Nordic Semiconductor nRF5 AirFuel SDK  version 2.2.0
pru.c
Go to the documentation of this file.
1 /* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved.
2  *
3  * The information contained herein is property of Nordic Semiconductor ASA.
4  * Terms and conditions of usage are described in detail in NORDIC
5  * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
6  *
7  * Licensees are granted free, non-transferable use of the information. NO
8  * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
9  * the file.
10  *
11  */
12 
15 #include <stdint.h>
16 #include <string.h>
17 #include "nordic_common.h"
18 #include "nrf_assert.h"
19 #include "pru.h"
20 #include "pru_sensors.h"
21 #include "pru_hw_config.h"
22 #include "pru_test_mux.h"
23 #include "pru_sm.h"
24 #include "pru_adv.h"
25 #include "pru_config.h"
26 #include "ble_hci.h"
27 #ifdef PRU_PSTORAGE_ENABLE
28 #include "pru_pstorage.h"
29 #endif
30 
31 
32 /******************************************************************************/
35 /******************************************************************************/
36 
37 static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
39 APP_TIMER_DEF(m_pru_sensors_timer_single_shot_id);
40 APP_TIMER_DEF(m_p_pru_sensors_timer_id);
41 static uint32_t m_vrect_high_duration_ms;
43 static bool m_adv_allowed = false;
45 static bool m_advertising;
48 /******************************************************************************
49  * Static functions
50  ******************************************************************************/
51 
57 static void m_advertising_start(void)
58 {
59  uint32_t err_code;
60  ble_gap_adv_params_t adv_params;
61 
62  err_code = pru_advdata_set(&m_wpts);
63  APP_ERROR_CHECK(err_code);
64 
65  memset(&adv_params, 0, sizeof(adv_params));
66 
67  // We always use indirect advertising
68  adv_params.type = BLE_GAP_ADV_TYPE_ADV_IND;
69  adv_params.p_peer_addr = NULL;
70  adv_params.fp = BLE_GAP_ADV_FP_ANY;
71  adv_params.interval = PRU_ADV_INTERVAL;
72  adv_params.timeout = BLE_GAP_ADV_TIMEOUT_LIMITED_MAX;
73 
74  err_code = sd_ble_gap_adv_start(&adv_params);
75  m_advertising = true;
76 
77  if(err_code != NRF_ERROR_INVALID_STATE && err_code != NRF_ERROR_BUSY)
78  {
79  APP_ERROR_CHECK(err_code);
80  }
81 }
82 
83 #ifdef PRU_PSTORAGE_ENABLE
84 
90 static void m_sys_evt_dispatch(uint32_t event)
91 {
93 }
94 #endif
95 
101 static void m_gap_params_init(void)
102 {
103  uint32_t err_code;
104  ble_gap_conn_params_t gap_conn_params;
105  ble_gap_conn_sec_mode_t sec_mode;
106 
107  BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&sec_mode);
108  err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)PRU_ADV_DEVICE_NAME, strlen(PRU_ADV_DEVICE_NAME));
109  APP_ERROR_CHECK(err_code);
110 
111  err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_UNKNOWN);
112  APP_ERROR_CHECK(err_code);
113 
114  err_code = sd_ble_gap_tx_power_set(PRU_TX_POWER_LEVEL);
115  APP_ERROR_CHECK(err_code);
116 
117  memset(&gap_conn_params, 0, sizeof(gap_conn_params));
118 
119  gap_conn_params.min_conn_interval = PRU_MIN_CONN_INTERVAL;
120  gap_conn_params.max_conn_interval = PRU_MAX_CONN_INTERVAL;
121  gap_conn_params.slave_latency = PRU_SLAVE_LATENCY;
122  gap_conn_params.conn_sup_timeout = PRU_CONN_SUP_TIMEOUT;
123 
124  err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
125  APP_ERROR_CHECK(err_code);
126 }
127 
128 
133 {
134  uint32_t err_code;
135 
136  switch(evt)
137  {
139  if(m_state_variables.current_state == PRU_SM_STATE_BOOT || m_state_variables.current_state == PRU_SM_STATE_NULL)
140  {
143 
146  }
147  break;
148 
150  m_adv_allowed = false;
151  if(m_state_variables.current_state == PRU_SM_STATE_PRU_ON)
152  {
153  err_code = pru_tmux_vout_enable_set(false);
154  APP_ERROR_CHECK(err_code);
155  ASSERT(m_advertising);
156  (void) sd_ble_gap_adv_stop(); // We do not care about the return code.
157  m_advertising = false;
158  }
159  break;
160 
162  if(m_state_variables.current_state == PRU_SM_STATE_SYSTEM_ERROR && pru_sensors_data_get()->vrect >= PRU_VRECT_UVLO && !m_advertising)
164  break;
165 
166  default:
167  break;
168  }
169 }
170 
176 {
177  uint32_t err_code;
178 
179  m_handle_event(evt);
180 
181  (void)pru_sm_execute(evt, &m_state_variables);
182 
183  if(m_state_variables.current_state != m_state_variables.prev_state)
184  {
185  switch(m_state_variables.current_state)
186  {
187  case PRU_SM_STATE_COUNT:
188  break;
189 
190  case PRU_SM_STATE_NULL:
191  if (m_advertising)
192  {
193  (void) sd_ble_gap_adv_stop(); // We do not care about the return code.
194  m_advertising = false;
195  }
196  err_code = sd_ble_gap_disconnect(m_wpts.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
197 
198  if(err_code != NRF_ERROR_INVALID_STATE && err_code != BLE_ERROR_INVALID_CONN_HANDLE && err_code != BLE_ERROR_NOT_ENABLED)
199  APP_ERROR_CHECK(err_code);
200 
201  err_code = pru_tmux_vout_enable_set(false);
202  APP_ERROR_CHECK(err_code);
203  break;
204 
205  case PRU_SM_STATE_BOOT:
206  err_code = pru_tmux_vout_enable_set(false);
207  APP_ERROR_CHECK(err_code);
208 
210  break;
211 
212  case PRU_SM_STATE_PRU_ON:
213  err_code = pru_tmux_vout_enable_set(true);
214  APP_ERROR_CHECK(err_code);
215  break;
216 
217  case PRU_SM_STATE_SYSTEM_ERROR:
218  err_code = pru_tmux_vout_enable_set(false);
219  APP_ERROR_CHECK(err_code);
220  break;
221  }
222  }
223 
224  // Notify application of state machine signal
225  // To avoid application from setting softdevice in illegal state before we need it,
226  // invoke at the end of the handling.
227  if(m_app_sm_evt_handler != NULL)
228  m_app_sm_evt_handler(evt, &m_state_variables);
229 
230 }
231 
239 static void m_wpts_evt_handler(ble_wpts_t * p_wpts, ble_wpts_evt_t * p_evt)
240 {
241  uint32_t err_code;
242 
243  switch(p_evt->evt_type)
244  {
246  // Handle PRU Control Command
248  {
250  APP_ERROR_CHECK(err_code);
251  }
253  break;
254 
255  default:
256  break;
257  }
258 
259 #ifdef DEBUG_OUT_ENABLE
260  wpts_test_evt_handle_cb(p_wpts, p_evt);
261 #endif //DEBUG_OUT_ENABLE
262 }
263 
264 
271 static void on_ble_evt(ble_evt_t * p_ble_evt)
272 {
273  uint32_t err_code = NRF_SUCCESS;
274 
275  switch (p_ble_evt->header.evt_id)
276  {
277  case BLE_GAP_EVT_TIMEOUT:
278  if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING)
280  break;
281 
282  case BLE_GATTS_EVT_SYS_ATTR_MISSING:
283  err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
284  APP_ERROR_CHECK(err_code);
285  break;
286 
287  case BLE_GAP_EVT_CONNECTED:
288  m_wpts.reboot_bit = 1;
289  m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
290  break;
291 
292  case BLE_GAP_EVT_DISCONNECTED:
293  m_conn_handle = BLE_CONN_HANDLE_INVALID;
294  m_advertising = false;
295  m_on_sm_event(PRU_SM_SIGNAL_DISCONNECTED); // Treat disconnect in same way as power removed.
296  break;
297 
298  case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
299  {
300  ble_gap_sec_params_t sec_params;
301 
302  memset(&sec_params, 0, sizeof(ble_gap_sec_params_t));
303  sec_params.bond = 0; // No bonding
304  sec_params.io_caps = BLE_GAP_IO_CAPS_NONE; // No IO capabilities
305  sec_params.min_key_size = PRU_SEC_MIN_KEYSIZE; // Min allowed key size
306  sec_params.max_key_size = PRU_SEC_MAX_KEYSIZE; // Max allowed key size
307  sec_params.mitm = 0; // No man in the middle protection
308  sec_params.oob = 0; // No out of band data available
309 
310  err_code = sd_ble_gap_sec_params_reply(p_ble_evt->evt.gap_evt.conn_handle, BLE_GAP_SEC_STATUS_SUCCESS, &sec_params, NULL);
311  }
312  break;
313 
314  case BLE_GAP_EVT_AUTH_STATUS:
315  ASSERT(p_ble_evt->evt.gap_evt.params.auth_status.auth_status == BLE_GAP_SEC_STATUS_SUCCESS);
316  break;
317 
318  default:
319  break;
320  }
321 
322  APP_ERROR_CHECK(err_code);
323 }
324 
327 static void m_ble_wpts_init(void)
328 {
329  uint32_t err_code;
330  ble_wpts_init_t wpts_init;
331 
332  // Initialize PRU Service
333  memset(&wpts_init, 0, sizeof(wpts_init));
334  memset(&m_wpts, 0, sizeof(ble_wpts_t));
335 
336  wpts_init.evt_handler = m_wpts_evt_handler;
337 
338  // Here the sec level for the WPT Service can be changed/increased.
339  PRU_SECURITY(&wpts_init.wpts_attr_md.read_perm);
340  PRU_SECURITY(&wpts_init.wpts_attr_md.write_perm);
341 
342  // Configure PRU Static Parameters.
344  wpts_init.pru_static.delta_r1 = PRU_DELTA_R1;
355  wpts_init.pru_static.prect_max = PRU_PRECT_MAX;
358  wpts_init.pru_static.vrect_set = PRU_VRECT_SET;
359 
360  err_code = ble_wpts_init(&m_wpts, &wpts_init);
361  APP_ERROR_CHECK(err_code);
362 }
363 
364 
375 static uint32_t m_ble_wpts_pru_dynamic_set(ble_wpts_t * p_wpts, const pru_sensor_data_t * p_pru_sensor_data)
376 {
377  pru_dynamic_t pru_dynamic;
378 
379  memset(&pru_dynamic,0,sizeof(pru_dynamic_t));
380 
387 
388  pru_dynamic.vrect = p_pru_sensor_data ->vrect;
389  pru_dynamic.irect = p_pru_sensor_data ->irect;
390  pru_dynamic.vout = p_pru_sensor_data ->vout;
391  pru_dynamic.iout = p_pru_sensor_data ->iout;
392  pru_dynamic.temperature = p_pru_sensor_data ->temperature;
393  pru_dynamic.vrect_min_dyn = PRU_VRECT_MIN;
394  pru_dynamic.vrect_set_dyn = PRU_VRECT_SET;
395  pru_dynamic.vrect_high_dyn = PRU_VRECT_HIGH;
396  pru_dynamic.alerts.pru_over_voltage = p_pru_sensor_data ->over_voltage;
397  pru_dynamic.alerts.pru_over_current = p_pru_sensor_data ->over_current;
398  pru_dynamic.alerts.pru_over_temperature = p_pru_sensor_data ->over_temperature;
399  pru_dynamic.alerts.charge_complete = p_pru_sensor_data ->charge_complete;
400  pru_dynamic.alerts.wired_charge_detect = p_pru_sensor_data ->wired_charge_detect;
401  pru_dynamic.alerts.pru_self_protection = 0;
402  pru_dynamic.adjust_power_response = p_pru_sensor_data -> power_adjusted;
403  pru_dynamic.pru_charge_port = p_pru_sensor_data->charge_port;
405 
406  return ble_wpts_pru_dynamic_set(p_wpts, &pru_dynamic);
407 }
408 
409 
417 static void m_sensors_timer_handler(void * p_context)
418 {
419  uint32_t err_code;
420  pru_alert_t alerts;
421  bool new_alert_occured = false;
422 
423  UNUSED_PARAMETER(p_context);
425 
426  err_code = m_ble_wpts_pru_dynamic_set(&m_wpts, pru_sensors_data_get());
427  APP_ERROR_CHECK(err_code);
428  err_code = pru_sensor_alerts_get(&new_alert_occured, &alerts);
429  APP_ERROR_CHECK(err_code);
430  if(new_alert_occured)
431  {
432  err_code = ble_wpts_alert_send(&m_wpts, &alerts);
433  // If not disconnected or CCCD not yet received.
434  if((err_code != BLE_ERROR_INVALID_CONN_HANDLE) && (err_code != NRF_ERROR_INVALID_STATE) && (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING))
435  {
436  APP_ERROR_CHECK(err_code);
437  }
438  }
440 }
441 
445 {
446  uint32_t err_code;
447  err_code = app_timer_start(m_pru_sensors_timer_single_shot_id, APP_TIMER_MIN_TIMEOUT_TICKS, NULL);
448  APP_ERROR_CHECK(err_code);
449 }
450 
453 static void m_sensors_timer_start(uint16_t period_ms)
454 {
455  uint32_t err_code;
456  err_code = app_timer_start(m_p_pru_sensors_timer_id, APP_TIMER_TICKS(period_ms, APP_TIMER_PRESCALER), NULL);
457  APP_ERROR_CHECK(err_code);
458 }
459 
462 static void m_timers_init(void)
463 {
464  uint32_t err_code;
465 
466  err_code = app_timer_create(&m_p_pru_sensors_timer_id, APP_TIMER_MODE_REPEATED, m_sensors_timer_handler);
467  APP_ERROR_CHECK(err_code);
468  err_code = app_timer_create(&m_pru_sensors_timer_single_shot_id, APP_TIMER_MODE_SINGLE_SHOT, m_sensors_timer_handler);
469 
470  APP_ERROR_CHECK(err_code);
471 }
472 
475 /******************************************************************************/
478 /******************************************************************************/
479 
481 {
482  m_app_sm_evt_handler = sm_handler;
483  m_timers_init();
485 }
486 
487 void pru_start(void)
488 {
489  uint32_t err_code;
490 
491  m_conn_handle = BLE_CONN_HANDLE_INVALID;
492 
494  m_ble_wpts_init();
495 
496  m_wpts.reboot_bit = 0; // We have just rebooted
497 
498  err_code = tmux_init(); // Initializes HAL as well
499  APP_ERROR_CHECK(err_code);
500 
502 
503  err_code = m_ble_wpts_pru_dynamic_set(&m_wpts, pru_sensors_data_get());
504  APP_ERROR_CHECK(err_code);
505 
508 }
509 
510 void pru_on_ble_evt(ble_evt_t * p_ble_evt)
511 {
512  on_ble_evt(p_ble_evt);
513  ble_wpts_on_ble_evt(&m_wpts, p_ble_evt);
514 }
515 
516 #ifdef DFU_SUPPORT
517 
518 void terminate(void)
519 {
520  // No action needed to tear down the PRU application.
521 }
522 
523 bool dfu_check(void)
524 {
525  const pru_sensor_data_t * sensor_data;
526  sensor_data = pru_sensors_data_get();
527  return sensor_data->vrect == 0;
528 }
529 
530 #endif // DFU_SUPPORT
531 
uint16_t irect
Definition: wpt.h:168
State machine state variables.
Definition: pru_sm.h:55
#define PRU_POWER_CONTROL_ALG_PREFERENCE
Definition: pru_config.h:39
uint8_t info_ccp_connected_mode
Definition: wpt.h:105
void pru_on_ble_evt(ble_evt_t *p_ble_evt)
Handle BLE event.
Definition: pru.c:510
uint8_t info_adj_power_capability
Definition: wpt.h:104
APP_TIMER_DEF(m_pru_sensors_timer_single_shot_id)
uint8_t charge_port
Definition: pru_sensors.h:38
static bool m_adv_allowed
Definition: pru.c:43
pru_alert_bits_t alerts
Definition: wpt.h:175
ble_wpts_evt_handler_t evt_handler
Definition: ble_wpts.h:65
#define PRU_CONN_SUP_TIMEOUT
Definition: pru_config.h:31
#define BLE_WPTS_PRU_INFO_PTU_TEST_MODE_DISABLED_VAL
uint8_t wired_charge_detect
Definition: wpt.h:139
uint8_t pru_category
Definition: wpt.h:92
#define PRU_VRECT_MIN
Definition: pru_hw_config.h:25
static uint32_t m_ble_wpts_pru_dynamic_set(ble_wpts_t *p_wpts, const pru_sensor_data_t *p_pru_sensor_data)
Set PRU dynamic data.
Definition: pru.c:375
bool dfu_check(void)
Needs to be implemented by application. Check if it is OK to jump to the DFU application.
Definition: pru.c:523
uint16_t vout
Definition: wpt.h:169
uint8_t over_voltage
Definition: pru_sensors.h:33
uint8_t adjust_power_response
Definition: wpt.h:177
int16_t temperature
Definition: pru_sensors.h:32
#define PRU_SEPARATE_BTLE_RADIO_SUPORTED
Definition: pru_hw_config.h:41
#define PRU_SECURITY
Definition: pru_config.h:36
#define PRU_VRECT_HIGH
Definition: pru_hw_config.h:27
#define BLE_WPTS_PRU_DYNAMIC_OPTION_VRECT_MIN_DYN_BITPOS
uint8_t protocol_rev
Definition: wpt.h:91
#define PRU_SEC_MIN_KEYSIZE
Definition: pru_config.h:37
uint16_t vrect
Definition: wpt.h:167
uint8_t info_pc_alg_pref
Definition: wpt.h:103
void pru_sensors_gen_evts(void)
Generate PRU state machine events from sensor data.
Definition: pru_sensors.c:190
void pru_init(app_sm_evt_handler_t sm_handler)
Initialize PRU. This function must be called before any other PRU function can be called...
Definition: pru.c:480
static void m_sys_evt_dispatch(uint32_t event)
Dispatches a System stack event to flash storage module.
Definition: pru.c:90
uint16_t vrect_set_dyn
Definition: wpt.h:173
uint8_t enable_pru_output
Definition: wpt.h:81
#define BLE_WPTS_PRU_DYNAMIC_OPTION_IOUT_BITPOS
int16_t temperature
Definition: wpt.h:171
#define PRU_SENSORS_TIMER_PERIOD_MS
Definition: pru_hw_config.h:39
#define PRU_ADV_INTERVAL
Definition: pru_config.h:24
void pru_sensors_read_all(void)
Read PRU sensors.
Definition: pru_sensors.c:51
uint16_t iout
Definition: wpt.h:170
PRU Alert Parameter structure.
Definition: wpt.h:145
uint16_t conn_handle
Definition: ble_wpts.h:80
static uint32_t m_vrect_high_duration_ms
Definition: pru.c:41
uint16_t vrect_high_dyn
Definition: wpt.h:174
uint32_t ble_wpts_init(ble_wpts_t *p_wpts, const ble_wpts_init_t *p_wpts_init)
Initialize the WPT Service.
Definition: ble_wpts.c:642
uint8_t fw_revision
Definition: wpt.h:94
void pru_sensors_init(pru_sm_handler_t pru_sm_handler)
Initialize sensors and read default values.
Definition: pru_sensors.c:42
#define BLE_WPTS_PRU_DYNAMIC_OPTION_VRECT_SET_DYN_BITPOS
static void m_gap_params_init(void)
GAP initialization.
Definition: pru.c:101
#define PRU_DELTA_R1_VALID
Definition: pru_hw_config.h:31
#define PRU_TX_POWER_LEVEL
Definition: pru_hw_config.h:38
static void m_timers_init(void)
Instanicate timers used in this file.
Definition: pru.c:462
uint8_t over_temperature
Definition: pru_sensors.h:35
#define PRU_CHARGE_COMPLETE_ADV_WAIT_TIME_MS
Definition: pru_config.h:33
pru_static_t pru_static
Definition: ble_wpts.h:66
uint32_t ble_wpts_pru_dynamic_set(ble_wpts_t *p_wpts, pru_dynamic_t *p_pru_dynamic)
Sets value of the PRU Dynamic Parameter characteristic.
Definition: ble_wpts.c:790
const pru_sensor_data_t * pru_sensors_data_get(void)
Get the latest data from the PRU sensors.
Definition: pru_sensors.c:146
Definition of PRU reporting data.
Definition: pru_sensors.h:26
ptu_tester_command_t tester_command
Definition: wpt.h:180
#define PRU_CCP_ADJUST_POWER_CAPABILITY
Definition: pru_hw_config.h:42
uint16_t vrect_min_dyn
Definition: wpt.h:172
#define PRU_FW_REVISION
Definition: pru_config.h:27
static void m_sensors_timer_handler(void *p_context)
Sensors measurement timer timeout handler.
Definition: pru.c:417
#define PRU_SEC_MAX_KEYSIZE
Definition: pru_config.h:38
void wpts_test_evt_handle_cb(ble_wpts_t *p_wpts, ble_wpts_evt_t *p_evt)
Override weak wpts_test_evt_handle_cb()
Definition: pru_debug.c:77
static void m_on_sm_event(pru_sm_signal_type_t evt)
Forward events to the PRU state machine. Also handles the resulting request event.
Definition: pru.c:175
uint8_t info_sep_btle_radio
Definition: wpt.h:102
uint8_t option_fields_r1_valid
Definition: wpt.h:100
pru_sm_state_t prev_state
Definition: pru_sm.h:57
uint16_t vrect_high_static
Definition: wpt.h:97
void pru_pstorage_sys_evt_handler(uint32_t event)
Handles system callbacks.
Definition: pru_pstorage.c:51
pru_sm_state_t current_state
Definition: pru_sm.h:58
uint32_t pru_tmux_vout_enable_set(bool enable)
Test wrapper for pru_hal_vout_enable_set().
Definition: pru_test_mux.c:107
#define PRU_ADV_DEVICE_NAME
Definition: pru_config.h:23
ble_wpts_evt_type_t evt_type
Definition: ble_wpts.h:43
#define BLE_WPTS_PRU_DYNAMIC_OPTION_VOUT_BITPOS
PRU Dynamic Parameter characteristic Option field.
static void m_ble_wpts_init(void)
Initialize the WPT Service.
Definition: pru.c:327
uint8_t hw_revision
Definition: wpt.h:93
void(* app_sm_evt_handler_t)(pru_sm_signal_type_t signal, const pru_sm_state_vars_t *p_state_vars)
Definition: pru.h:29
uint32_t ble_wpts_alert_send(ble_wpts_t *p_wpts, pru_alert_t *p_alert)
Sends PRU alert if notification has been enabled.
Definition: ble_wpts.c:703
uint8_t pru_charge_port
Definition: wpt.h:176
uint32_t pru_advdata_set(ble_wpts_t *p_wpts)
Advertising functionality initialization.
Definition: pru_adv.c:27
static bool m_advertising
Definition: pru.c:45
#define PRU_VRECT_SET
Definition: pru_hw_config.h:26
uint8_t pru_over_voltage
Definition: wpt.h:134
uint8_t charge_complete
Definition: pru_sensors.h:39
WPT Service event.
Definition: ble_wpts.h:41
#define BLE_WPTS_PRU_DYNAMIC_OPTION_VRECT_HIGH_DYN_BITPOS
static void m_sensors_timer_trigger()
Start timer for reading sensors one time.
Definition: pru.c:444
void terminate(void)
Needs to be implemented by application. Perform all requried actions before jump to DFU application c...
Definition: pru.c:518
#define PRU_NFC_RECEIVER_SUPPORTED
Definition: pru_hw_config.h:40
uint8_t pru_over_current
Definition: wpt.h:135
#define PRU_DELTA_R1
Definition: pru_hw_config.h:32
static void on_ble_evt(ble_evt_t *p_ble_evt)
BLE stack GAP event handler.
Definition: pru.c:271
uint8_t pru_over_temperature
Definition: wpt.h:136
#define PRU_CCP_CONNECT_MODE_SUPPORTED
Definition: pru_config.h:40
#define PRU_SLAVE_LATENCY
Definition: pru_config.h:30
uint16_t delta_r1
Definition: wpt.h:99
#define APP_TIMER_PRESCALER
Definition: pru.h:33
static void m_wpts_evt_handler(ble_wpts_t *p_wpts, ble_wpts_evt_t *p_evt)
WPT Service event handler.
Definition: pru.c:239
#define PRU_MAX_CONN_INTERVAL
Definition: pru_config.h:29
#define PRU_PRECT_MAX
Definition: pru_hw_config.h:43
#define PRU_HW_REVISION
Definition: pru_config.h:26
union ble_wpts_evt_t::@0 data
WPT Service init structure.
Definition: ble_wpts.h:63
pru_sm_signal_type_t
PRU state machine signal type.
Definition: pru_sm.h:36
uint8_t info_nfc_receiver
Definition: wpt.h:101
uint8_t reboot_bit
Definition: ble_wpts.h:81
uint16_t vrect_min_static
Definition: wpt.h:96
uint8_t wired_charge_detect
Definition: pru_sensors.h:37
static void m_advertising_start(void)
Start advertising.
Definition: pru.c:57
uint8_t optional_fields
Definition: wpt.h:166
pru_control_t pru_control
Definition: ble_wpts.h:46
#define BLE_WPTS_PRU_DYNAMIC_OPTION_TEMPERATURE_BITPOS
uint16_t vrect_set
Definition: wpt.h:98
#define PRU_VRECT_UVLO
Definition: pru_hw_config.h:24
void ble_wpts_on_ble_evt(ble_wpts_t *p_wpts, ble_evt_t *p_ble_evt)
WPT Service BLE stack event handler.
Definition: ble_wpts.c:196
pru_sm_state_t pru_sm_execute(pru_sm_signal_type_t sig, pru_sm_state_vars_t *p_state)
Execute state machine.
Definition: pru_sm.c:71
uint8_t over_current
Definition: pru_sensors.h:34
static pru_sm_state_vars_t m_state_variables
Definition: pru.c:42
uint8_t info_ptu_test_mode
Definition: wpt.h:106
void pru_start(void)
Enable the PRU profile. When enabled sensor reading and signal generation will be enabled...
Definition: pru.c:487
uint8_t pru_self_protection
Definition: wpt.h:137
uint32_t tmux_init(void)
Initialize the PTU's test multiplexer.
Definition: pru_test_mux.c:53
#define PRU_CATEGORY
Definition: pru_hw_config.h:34
static ble_wpts_t m_wpts
Definition: pru.c:38
ble_srv_security_mode_t wpts_attr_md
Definition: ble_wpts.h:67
WPT Service status structure.
Definition: ble_wpts.h:71
static void m_sensors_timer_start(uint16_t period_ms)
Start timer for reading sensors periodically.
Definition: pru.c:453
uint32_t pru_sensor_alerts_get(bool *new_alert_occured, pru_alert_t *p_pru_alert)
Extract alerts from the latest data read from PRU sensors.
Definition: pru_sensors.c:151
static void m_handle_event(pru_sm_signal_type_t evt)
Handle PRU SM events that require profile handling.
Definition: pru.c:132
#define PRU_PROTOCOL_REVISION
Definition: pru_config.h:25
ctl_adj_power_t adj_power
Definition: wpt.h:83
uint32_t pru_tmux_adj_power_set(ctl_adj_power_t adj_setting)
Test wrapper for pru_hal_adj_power_set().
Definition: pru_test_mux.c:112
#define PRU_MIN_CONN_INTERVAL
Definition: pru_config.h:28
uint8_t charge_complete
Definition: wpt.h:138
static app_sm_evt_handler_t m_app_sm_evt_handler
Definition: pru.c:44
static uint16_t m_conn_handle
Definition: pru.c:37
PRU Dynamic Parameter structure.
Definition: wpt.h:164
uint8_t prect_max
Definition: wpt.h:95