Nordic Semiconductor nRF5 AirFuel SDK  version 2.2.0
ble_app_hrs.c
Go to the documentation of this file.
1 /* Copyright (c) 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 <stdlib.h>
16 #include "app_profile.h"
17 #include <stdint.h>
18 #include <string.h>
19 #include "nordic_common.h"
20 #include "nrf.h"
21 #include "app_error.h"
22 #include "ble.h"
23 #include "ble_hci.h"
24 #include "ble_srv_common.h"
25 #include "ble_advdata.h"
26 #include "ble_advertising.h"
27 #include "ble_bas.h"
28 #include "ble_hrs.h"
29 #include "ble_dis.h"
30 #include "ble_conn_params.h"
31 #include "boards.h"
32 #include "sensorsim.h"
33 #include "softdevice_handler.h"
34 #include "app_timer.h"
35 #include "device_manager.h"
36 #include "pstorage.h"
37 #include "app_trace.h"
38 #include "bsp.h"
39 #include "nrf_delay.h"
40 #include "bsp_btn_ble.h"
41 #include "app_gpiote.h"
42 
43 #define IS_SRVC_CHANGED_CHARACT_PRESENT 1
45 #define DEVICE_NAME "Nordic_HRM"
46 #define MANUFACTURER_NAME "NordicSemiconductor"
47 #define APP_ADV_INTERVAL 300
48 #define APP_ADV_TIMEOUT_IN_SECONDS 180
50 #define APP_TIMER_PRESCALER 0
51 #define APP_PROFILE_MAX_TIMERS (4+BSP_APP_TIMERS_NUMBER)
52 #define APP_TIMER_OP_QUEUE_SIZE 4
54 #define BATTERY_LEVEL_MEAS_INTERVAL APP_TIMER_TICKS(2000, APP_TIMER_PRESCALER)
55 #define MIN_BATTERY_LEVEL 81
56 #define MAX_BATTERY_LEVEL 100
57 #define BATTERY_LEVEL_INCREMENT 1
59 #define HEART_RATE_MEAS_INTERVAL APP_TIMER_TICKS(1000, APP_TIMER_PRESCALER)
60 #define MIN_HEART_RATE 140
61 #define MAX_HEART_RATE 300
62 #define HEART_RATE_INCREMENT 10
64 #define RR_INTERVAL_INTERVAL APP_TIMER_TICKS(300, APP_TIMER_PRESCALER)
65 #define MIN_RR_INTERVAL 100
66 #define MAX_RR_INTERVAL 500
67 #define RR_INTERVAL_INCREMENT 1
69 #define SENSOR_CONTACT_DETECTED_INTERVAL APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER)
71 #define MIN_CONN_INTERVAL MSEC_TO_UNITS(400, UNIT_1_25_MS)
72 #define MAX_CONN_INTERVAL MSEC_TO_UNITS(650, UNIT_1_25_MS)
73 #define SLAVE_LATENCY 0
74 #define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS)
76 #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER)
77 #define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER)
78 #define MAX_CONN_PARAMS_UPDATE_COUNT 3
80 #define SEC_PARAM_BOND 1
81 #define SEC_PARAM_MITM 0
82 #define SEC_PARAM_IO_CAPABILITIES BLE_GAP_IO_CAPS_NONE
83 #define SEC_PARAM_OOB 0
84 #define SEC_PARAM_MIN_KEY_SIZE 7
85 #define SEC_PARAM_MAX_KEY_SIZE 16
87 #define DEAD_BEEF 0xDEADBEEF
89 static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
90 static ble_bas_t m_bas;
91 static ble_hrs_t m_hrs;
92 static bool m_rr_interval_enabled = true;
94 static sensorsim_cfg_t m_battery_sim_cfg;
95 static sensorsim_state_t m_battery_sim_state;
96 static sensorsim_cfg_t m_heart_rate_sim_cfg;
97 static sensorsim_state_t m_heart_rate_sim_state;
98 static sensorsim_cfg_t m_rr_interval_sim_cfg;
99 static sensorsim_state_t m_rr_interval_sim_state;
101 APP_TIMER_DEF(m_battery_timer_id);
102 APP_TIMER_DEF(m_heart_rate_timer_id);
103 APP_TIMER_DEF(m_rr_interval_timer_id);
104 APP_TIMER_DEF(m_sensor_contact_timer_id);
106 static dm_application_instance_t m_app_handle;
108 static ble_uuid_t m_adv_uuids[] = {{BLE_UUID_HEART_RATE_SERVICE, BLE_UUID_TYPE_BLE},
109  {BLE_UUID_BATTERY_SERVICE, BLE_UUID_TYPE_BLE},
110  {BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE}};
115 static void battery_level_update(void)
116 {
117  uint32_t err_code;
118  uint8_t battery_level;
119 
120  battery_level = (uint8_t)sensorsim_measure(&m_battery_sim_state, &m_battery_sim_cfg);
121 
122  err_code = ble_bas_battery_level_update(&m_bas, battery_level);
123  if ((err_code != NRF_SUCCESS) &&
124  (err_code != NRF_ERROR_INVALID_STATE) &&
125  (err_code != BLE_ERROR_NO_TX_PACKETS) &&
126  (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
127  )
128  {
129  APP_ERROR_HANDLER(err_code);
130  }
131 }
132 
133 
141 static void battery_level_meas_timeout_handler(void * p_context)
142 {
143  UNUSED_PARAMETER(p_context);
145 }
146 
147 
156 static void heart_rate_meas_timeout_handler(void * p_context)
157 {
158  static uint32_t cnt = 0;
159  uint32_t err_code;
160  uint16_t heart_rate;
161 
162  UNUSED_PARAMETER(p_context);
163 
164  heart_rate = (uint16_t)sensorsim_measure(&m_heart_rate_sim_state, &m_heart_rate_sim_cfg);
165 
166  cnt++;
167  err_code = ble_hrs_heart_rate_measurement_send(&m_hrs, heart_rate);
168  if ((err_code != NRF_SUCCESS) &&
169  (err_code != NRF_ERROR_INVALID_STATE) &&
170  (err_code != BLE_ERROR_NO_TX_PACKETS) &&
171  (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
172  )
173  {
174  APP_ERROR_HANDLER(err_code);
175  }
176 
177  // Disable RR Interval recording every third heart rate measurement.
178  // NOTE: An application will normally not do this. It is done here just for testing generation
179  // of messages without RR Interval measurements.
180  m_rr_interval_enabled = ((cnt % 3) != 0);
181 }
182 
183 
191 static void rr_interval_timeout_handler(void * p_context)
192 {
193  UNUSED_PARAMETER(p_context);
194 
196  {
197  uint16_t rr_interval;
198 
199  rr_interval = (uint16_t)sensorsim_measure(&m_rr_interval_sim_state,
201  ble_hrs_rr_interval_add(&m_hrs, rr_interval);
202  }
203 }
204 
205 
213 static void sensor_contact_detected_timeout_handler(void * p_context)
214 {
215  static bool sensor_contact_detected = false;
216 
217  UNUSED_PARAMETER(p_context);
218 
219  sensor_contact_detected = !sensor_contact_detected;
220  ble_hrs_sensor_contact_detected_update(&m_hrs, sensor_contact_detected);
221 }
222 
223 
228 static void timers_init(void)
229 {
230  uint32_t err_code;
231 
232  // Create timers.
233  err_code = app_timer_create(&m_battery_timer_id,
234  APP_TIMER_MODE_REPEATED,
236  APP_ERROR_CHECK(err_code);
237 
238  err_code = app_timer_create(&m_heart_rate_timer_id,
239  APP_TIMER_MODE_REPEATED,
241  APP_ERROR_CHECK(err_code);
242 
243  err_code = app_timer_create(&m_rr_interval_timer_id,
244  APP_TIMER_MODE_REPEATED,
246  APP_ERROR_CHECK(err_code);
247 
248  err_code = app_timer_create(&m_sensor_contact_timer_id,
249  APP_TIMER_MODE_REPEATED,
251  APP_ERROR_CHECK(err_code);
252 }
253 
254 
260 static void gap_params_init(void)
261 {
262  uint32_t err_code;
263  ble_gap_conn_params_t gap_conn_params;
264  ble_gap_conn_sec_mode_t sec_mode;
265 
266  BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
267 
268  err_code = sd_ble_gap_device_name_set(&sec_mode,
269  (const uint8_t *)DEVICE_NAME,
270  strlen(DEVICE_NAME));
271  APP_ERROR_CHECK(err_code);
272 
273  err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_HEART_RATE_SENSOR_HEART_RATE_BELT);
274  APP_ERROR_CHECK(err_code);
275 
276  memset(&gap_conn_params, 0, sizeof(gap_conn_params));
277 
278  gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
279  gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
280  gap_conn_params.slave_latency = SLAVE_LATENCY;
281  gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT;
282 
283  err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
284  APP_ERROR_CHECK(err_code);
285 }
286 
289 static void advertising_stop(void)
290 {
291  uint32_t err_code;
292 
293  err_code = sd_ble_gap_adv_stop();
294  APP_ERROR_CHECK(err_code);
295 
296  err_code = bsp_indication_set(BSP_INDICATE_IDLE);
297  APP_ERROR_CHECK(err_code);
298 }
299 
302 static void reset_prepare(void)
303 {
304  uint32_t err_code;
305 
306  if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
307  {
308  // Disconnect from peer.
309  err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
310 
311  if(err_code != BLE_ERROR_INVALID_CONN_HANDLE)
312  APP_ERROR_CHECK(err_code);
313 
314  err_code = bsp_indication_set(BSP_INDICATE_IDLE);
315  APP_ERROR_CHECK(err_code);
316  }
317  else
318  {
319  // If not connected, the device will be advertising. Hence stop the advertising.
321  }
322 
323  err_code = ble_conn_params_stop();
324  APP_ERROR_CHECK(err_code);
325 }
326 
327 
332 static void services_init(void)
333 {
334  uint32_t err_code;
335  ble_hrs_init_t hrs_init;
336  ble_bas_init_t bas_init;
337  ble_dis_init_t dis_init;
338  uint8_t body_sensor_location;
339 
340  // Initialize Heart Rate Service.
341  body_sensor_location = BLE_HRS_BODY_SENSOR_LOCATION_FINGER;
342 
343  memset(&hrs_init, 0, sizeof(hrs_init));
344 
345  hrs_init.evt_handler = NULL;
346  hrs_init.is_sensor_contact_supported = true;
347  hrs_init.p_body_sensor_location = &body_sensor_location;
348 
349  // Here the sec level for the Heart Rate Service can be changed/increased.
350  BLE_GAP_CONN_SEC_MODE_SET_OPEN(&hrs_init.hrs_hrm_attr_md.cccd_write_perm);
351  BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&hrs_init.hrs_hrm_attr_md.read_perm);
352  BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&hrs_init.hrs_hrm_attr_md.write_perm);
353 
354  BLE_GAP_CONN_SEC_MODE_SET_OPEN(&hrs_init.hrs_bsl_attr_md.read_perm);
355  BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&hrs_init.hrs_bsl_attr_md.write_perm);
356 
357  err_code = ble_hrs_init(&m_hrs, &hrs_init);
358  APP_ERROR_CHECK(err_code);
359 
360  // Initialize Battery Service.
361  memset(&bas_init, 0, sizeof(bas_init));
362 
363  // Here the sec level for the Battery Service can be changed/increased.
364  BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.cccd_write_perm);
365  BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.read_perm);
366  BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&bas_init.battery_level_char_attr_md.write_perm);
367 
368  BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_report_read_perm);
369 
370  bas_init.evt_handler = NULL;
371  bas_init.support_notification = true;
372  bas_init.p_report_ref = NULL;
373  bas_init.initial_batt_level = 100;
374 
375  err_code = ble_bas_init(&m_bas, &bas_init);
376  APP_ERROR_CHECK(err_code);
377 
378  // Initialize Device Information Service.
379  memset(&dis_init, 0, sizeof(dis_init));
380 
381  ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, (char *)MANUFACTURER_NAME);
382 
383  BLE_GAP_CONN_SEC_MODE_SET_OPEN(&dis_init.dis_attr_md.read_perm);
384  BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&dis_init.dis_attr_md.write_perm);
385 
386  err_code = ble_dis_init(&dis_init);
387  APP_ERROR_CHECK(err_code);
388 }
389 
390 
391 
394 static void sensor_simulator_init(void)
395 {
399  m_battery_sim_cfg.start_at_max = true;
400 
401  sensorsim_init(&m_battery_sim_state, &m_battery_sim_cfg);
402 
406  m_heart_rate_sim_cfg.start_at_max = false;
407 
408  sensorsim_init(&m_heart_rate_sim_state, &m_heart_rate_sim_cfg);
409 
413  m_rr_interval_sim_cfg.start_at_max = false;
414 
416 }
417 
418 
421 static void application_timers_start(void)
422 {
423  uint32_t err_code;
424 
425  // Start application timers.
426  err_code = app_timer_start(m_battery_timer_id, BATTERY_LEVEL_MEAS_INTERVAL, NULL);
427  APP_ERROR_CHECK(err_code);
428 
429  err_code = app_timer_start(m_heart_rate_timer_id, HEART_RATE_MEAS_INTERVAL, NULL);
430  APP_ERROR_CHECK(err_code);
431 
432  err_code = app_timer_start(m_rr_interval_timer_id, RR_INTERVAL_INTERVAL, NULL);
433  APP_ERROR_CHECK(err_code);
434 
435  err_code = app_timer_start(m_sensor_contact_timer_id, SENSOR_CONTACT_DETECTED_INTERVAL, NULL);
436  APP_ERROR_CHECK(err_code);
437 }
438 
439 
450 static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
451 {
452  uint32_t err_code;
453 
454  if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
455  {
456  err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
457  APP_ERROR_CHECK(err_code);
458  }
459 }
460 
461 
466 static void conn_params_error_handler(uint32_t nrf_error)
467 {
468  APP_ERROR_HANDLER(nrf_error);
469 }
470 
471 
474 static void conn_params_init(void)
475 {
476  uint32_t err_code;
477  ble_conn_params_init_t cp_init;
478 
479  memset(&cp_init, 0, sizeof(cp_init));
480 
481  cp_init.p_conn_params = NULL;
482  cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
483  cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
484  cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT;
485  cp_init.start_on_notify_cccd_handle = m_hrs.hrm_handles.cccd_handle;
486  cp_init.disconnect_on_fail = false;
487  cp_init.evt_handler = on_conn_params_evt;
488  cp_init.error_handler = conn_params_error_handler;
489 
490  err_code = ble_conn_params_init(&cp_init);
491  APP_ERROR_CHECK(err_code);
492 }
493 
494 
499 static void sleep_mode_enter(void)
500 {
501  uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
502  APP_ERROR_CHECK(err_code);
503 
504  // Prepare wakeup buttons.
505  err_code = bsp_btn_ble_sleep_mode_prepare();
506  APP_ERROR_CHECK(err_code);
507 
508  // Go to system-off mode (this function will not return; wakeup will cause a reset).
509  err_code = sd_power_system_off();
510  APP_ERROR_CHECK(err_code);
511 }
512 
513 
520 static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
521 {
522  uint32_t err_code;
523 
524  switch (ble_adv_evt)
525  {
526  case BLE_ADV_EVT_FAST:
527  err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
528  APP_ERROR_CHECK(err_code);
529  break;
530  case BLE_ADV_EVT_IDLE:
532  break;
533  default:
534  break;
535  }
536 }
537 
538 
543 static void on_ble_evt(ble_evt_t * p_ble_evt)
544 {
545  uint32_t err_code;
546 
547  switch (p_ble_evt->header.evt_id)
548  {
549  case BLE_GAP_EVT_CONNECTED:
550  err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
551  APP_ERROR_CHECK(err_code);
552  m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
553  break;
554 
555  case BLE_GAP_EVT_DISCONNECTED:
556  m_conn_handle = BLE_CONN_HANDLE_INVALID;
557  break;
558 
559  default:
560  // No implementation needed.
561  break;
562  }
563 }
564 
565 
573 static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
574 {
575  dm_ble_evt_handler(p_ble_evt);
576  ble_hrs_on_ble_evt(&m_hrs, p_ble_evt);
577  ble_bas_on_ble_evt(&m_bas, p_ble_evt);
578  ble_conn_params_on_ble_evt(p_ble_evt);
579  bsp_btn_ble_on_ble_evt(p_ble_evt);
580  on_ble_evt(p_ble_evt);
581  ble_advertising_on_ble_evt(p_ble_evt);
582 }
583 
584 
592 static void sys_evt_dispatch(uint32_t sys_evt)
593 {
594  pstorage_sys_event_handler(sys_evt);
595  ble_advertising_on_sys_evt(sys_evt);
596 }
597 
598 
599 
604 void bsp_event_handler(bsp_event_t event)
605 {
606  uint32_t err_code;
607  switch (event)
608  {
609  case BSP_EVENT_SLEEP:
611  break;
612 
613  case BSP_EVENT_DISCONNECT:
614  err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
615  if (err_code != NRF_ERROR_INVALID_STATE)
616  {
617  APP_ERROR_CHECK(err_code);
618  }
619  break;
620 
621  case BSP_EVENT_WHITELIST_OFF:
622  err_code = ble_advertising_restart_without_whitelist();
623  if (err_code != NRF_ERROR_INVALID_STATE)
624  {
625  APP_ERROR_CHECK(err_code);
626  }
627  break;
628 
629  default:
630  break;
631  }
632 }
633 
634 
642 static uint32_t device_manager_evt_handler(dm_handle_t const * p_handle,
643  dm_event_t const * p_event,
644  ret_code_t event_result)
645 {
646  APP_ERROR_CHECK(event_result);
647 
648  return NRF_SUCCESS;
649 }
650 
651 
657 static void device_manager_init(bool erase_bonds)
658 {
659  uint32_t err_code;
660  dm_init_param_t init_param = {.clear_persistent_data = erase_bonds};
661  dm_application_param_t register_param;
662 
663  // Initialize persistent storage module.
664  err_code = pstorage_init();
665  APP_ERROR_CHECK(err_code);
666 
667  err_code = dm_init(&init_param);
668  APP_ERROR_CHECK(err_code);
669 
670  memset(&register_param.sec_param, 0, sizeof(ble_gap_sec_params_t));
671 
672  register_param.sec_param.bond = SEC_PARAM_BOND;
673  register_param.sec_param.mitm = SEC_PARAM_MITM;
674  register_param.sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES;
675  register_param.sec_param.oob = SEC_PARAM_OOB;
676  register_param.sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
677  register_param.sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
678  register_param.evt_handler = device_manager_evt_handler;
679  register_param.service_type = DM_PROTOCOL_CNTXT_GATT_SRVR_ID;
680 
681  err_code = dm_register(&m_app_handle, &register_param);
682  APP_ERROR_CHECK(err_code);
683 }
684 
685 
688 static void advertising_init(void)
689 {
690  uint32_t err_code;
691  ble_advdata_t advdata;
692 
693  // Build advertising data struct to pass into @ref ble_advertising_init.
694  memset(&advdata, 0, sizeof(advdata));
695 
696  advdata.name_type = BLE_ADVDATA_FULL_NAME;
697  advdata.include_appearance = true;
698  advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
699  advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
700  advdata.uuids_complete.p_uuids = m_adv_uuids;
701 
702  ble_adv_modes_config_t options = {0};
703  options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
704  options.ble_adv_fast_interval = APP_ADV_INTERVAL;
705  options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;
706 
707  err_code = ble_advertising_init(&advdata, NULL, &options, on_adv_evt, NULL);
708  APP_ERROR_CHECK(err_code);
709 }
710 
711 
712 /*********************
713  API Implementation
714 *********************/
715 
717 {
718  // Initialize.
719  timers_init();
720  device_manager_init(true);
723 
724 }
725 
726 void app_profile_on_ble_evt(ble_evt_t * p_ble_evt)
727 {
728  ble_evt_dispatch(p_ble_evt);
729 }
730 
731 void app_profile_on_sys_evt(uint32_t sys_evt)
732 {
733  sys_evt_dispatch(sys_evt);
734 }
735 
737 {
738  uint32_t err_code;
739 
740  gap_params_init();
742  services_init();
743 
744  // Start execution.
747 
748  err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
749  APP_ERROR_CHECK(err_code);
750 }
751 
753 {
754  reset_prepare();
755 }
static void conn_params_init(void)
Function for initializing the Connection Parameters module.
Definition: ble_app_hrs.c:474
static uint16_t m_conn_handle
Definition: ble_app_hrs.c:89
static sensorsim_cfg_t m_rr_interval_sim_cfg
Definition: ble_app_hrs.c:98
static bool m_rr_interval_enabled
Definition: ble_app_hrs.c:92
static void sensor_contact_detected_timeout_handler(void *p_context)
Function for handling the Sensor Contact Detected timer timeout.
Definition: ble_app_hrs.c:213
static ble_bas_t m_bas
Definition: ble_app_hrs.c:90
static void rr_interval_timeout_handler(void *p_context)
Function for handling the RR interval timer timeout.
Definition: ble_app_hrs.c:191
#define DEVICE_NAME
Definition: ble_app_hrs.c:45
static sensorsim_state_t m_rr_interval_sim_state
Definition: ble_app_hrs.c:99
#define SEC_PARAM_MITM
Definition: ble_app_hrs.c:81
static void advertising_stop(void)
Function for stopping advertising.
Definition: ble_app_hrs.c:289
#define HEART_RATE_MEAS_INTERVAL
Definition: ble_app_hrs.c:59
#define MAX_CONN_PARAMS_UPDATE_COUNT
Definition: ble_app_hrs.c:78
static ble_hrs_t m_hrs
Definition: ble_app_hrs.c:91
#define MIN_HEART_RATE
Definition: ble_app_hrs.c:60
#define SEC_PARAM_MAX_KEY_SIZE
Definition: ble_app_hrs.c:85
#define RR_INTERVAL_INCREMENT
Definition: ble_app_hrs.c:67
static ble_uuid_t m_adv_uuids[]
Definition: ble_app_hrs.c:108
static void on_ble_evt(ble_evt_t *p_ble_evt)
Function for handling the Application's BLE Stack events.
Definition: ble_app_hrs.c:543
static void conn_params_error_handler(uint32_t nrf_error)
Function for handling a Connection Parameters error.
Definition: ble_app_hrs.c:466
void app_profile_start(void)
Start profile. Is called every time profile is activated.
Definition: ble_app_hrs.c:736
static sensorsim_cfg_t m_heart_rate_sim_cfg
Definition: ble_app_hrs.c:96
static void services_init(void)
Function for initializing services that will be used by the application.
Definition: ble_app_hrs.c:332
#define MIN_RR_INTERVAL
Definition: ble_app_hrs.c:65
#define MANUFACTURER_NAME
Definition: ble_app_hrs.c:46
static void sys_evt_dispatch(uint32_t sys_evt)
Function for dispatching a system event to interested modules.
Definition: ble_app_hrs.c:592
#define MAX_CONN_INTERVAL
Definition: ble_app_hrs.c:72
#define SEC_PARAM_IO_CAPABILITIES
Definition: ble_app_hrs.c:82
void app_profile_init(void)
Initialize profile. Is only called once.
Definition: ble_app_hrs.c:716
#define NEXT_CONN_PARAMS_UPDATE_DELAY
Definition: ble_app_hrs.c:77
#define SLAVE_LATENCY
Definition: ble_app_hrs.c:73
#define SEC_PARAM_MIN_KEY_SIZE
Definition: ble_app_hrs.c:84
static void timers_init(void)
Function for the Timer initialization.
Definition: ble_app_hrs.c:228
static void ble_evt_dispatch(ble_evt_t *p_ble_evt)
Function for dispatching a BLE stack event to all modules with a BLE stack event handler.
Definition: ble_app_hrs.c:573
#define BATTERY_LEVEL_MEAS_INTERVAL
Definition: ble_app_hrs.c:54
void app_profile_on_sys_evt(uint32_t sys_evt)
Handle system event.
Definition: ble_app_hrs.c:731
void bsp_event_handler(bsp_event_t event)
Function for handling events from the BSP module.
Definition: ble_app_hrs.c:604
static void advertising_init(void)
Function for initializing the Advertising functionality.
Definition: ble_app_hrs.c:688
#define FIRST_CONN_PARAMS_UPDATE_DELAY
Definition: ble_app_hrs.c:76
#define MAX_RR_INTERVAL
Definition: ble_app_hrs.c:66
#define RR_INTERVAL_INTERVAL
Definition: ble_app_hrs.c:64
static sensorsim_cfg_t m_battery_sim_cfg
Definition: ble_app_hrs.c:94
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
Function for handling advertising events.
Definition: ble_app_hrs.c:520
static void device_manager_init(bool erase_bonds)
Function for the Device Manager initialization.
Definition: ble_app_hrs.c:657
#define MIN_CONN_INTERVAL
Definition: ble_app_hrs.c:71
static void sleep_mode_enter(void)
Function for putting the chip into sleep mode.
Definition: ble_app_hrs.c:499
static dm_application_instance_t m_app_handle
Definition: ble_app_hrs.c:106
static void on_conn_params_evt(ble_conn_params_evt_t *p_evt)
Function for handling the Connection Parameters Module.
Definition: ble_app_hrs.c:450
#define SEC_PARAM_BOND
Definition: ble_app_hrs.c:80
static sensorsim_state_t m_heart_rate_sim_state
Definition: ble_app_hrs.c:97
#define CONN_SUP_TIMEOUT
Definition: ble_app_hrs.c:74
#define MAX_HEART_RATE
Definition: ble_app_hrs.c:61
static void reset_prepare(void)
Function for preparing for system reset.
Definition: ble_app_hrs.c:302
#define MAX_BATTERY_LEVEL
Definition: ble_app_hrs.c:56
#define MIN_BATTERY_LEVEL
Definition: ble_app_hrs.c:55
static sensorsim_state_t m_battery_sim_state
Definition: ble_app_hrs.c:95
static uint32_t device_manager_evt_handler(dm_handle_t const *p_handle, dm_event_t const *p_event, ret_code_t event_result)
Function for handling the Device Manager events.
Definition: ble_app_hrs.c:642
#define BATTERY_LEVEL_INCREMENT
Definition: ble_app_hrs.c:57
#define SEC_PARAM_OOB
Definition: ble_app_hrs.c:83
#define APP_ADV_INTERVAL
Definition: ble_app_hrs.c:47
void app_profile_stop(void)
Stop profile. Note: Needs to set the softdevice in a state where it is ok to initialize PRU profile...
Definition: ble_app_hrs.c:752
static void sensor_simulator_init(void)
Function for initializing the sensor simulators.
Definition: ble_app_hrs.c:394
static void application_timers_start(void)
Function for starting application timers.
Definition: ble_app_hrs.c:421
static void battery_level_update(void)
Function for performing battery measurement and updating the Battery Level characteristic in Battery ...
Definition: ble_app_hrs.c:115
static void battery_level_meas_timeout_handler(void *p_context)
Function for handling the Battery measurement timer timeout.
Definition: ble_app_hrs.c:141
#define HEART_RATE_INCREMENT
Definition: ble_app_hrs.c:62
static void gap_params_init(void)
Function for the GAP initialization.
Definition: ble_app_hrs.c:260
static void heart_rate_meas_timeout_handler(void *p_context)
Function for handling the Heart rate measurement timer timeout.
Definition: ble_app_hrs.c:156
void app_profile_on_ble_evt(ble_evt_t *p_ble_evt)
Handle BLE event.
Definition: ble_app_hrs.c:726
#define APP_ADV_TIMEOUT_IN_SECONDS
Definition: ble_app_hrs.c:48
#define SENSOR_CONTACT_DETECTED_INTERVAL
Definition: ble_app_hrs.c:69