IoT-enabled wireless neural implant for chronic, programmable neuropharmacology and optogenetics.

1. /**
2. * Copyright (c) 2016 - 2019, Nordic Semiconductor ASA
3. *
4. * All rights reserved.
5. *
6. * Redistribution and use in source and binary forms, with or without modification,
7. * are permitted provided that the following conditions are met:
8. *
9. * 1. Redistributions of source code must retain the above copyright notice, this
10. * list of conditions and the following disclaimer.
11. *
12. * 2. Redistributions in binary form, except as embedded into a Nordic
13. * Semiconductor ASA integrated circuit in a product or a software update for
14. * such product, must reproduce the above copyright notice, this list of
15. * conditions and the following disclaimer in the documentation and/or other
16. * materials provided with the distribution.
17. *
18. * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
19. * contributors may be used to endorse or promote products derived from this
20. * software without specific prior written permission.
21. *
22. * 4. This software, with or without modification, must only be used with a
23. * Nordic Semiconductor ASA integrated circuit.
24. *
25. * 5. Any software provided in binary form under this license must not be reverse
26. * engineered, decompiled, modified and/or disassembled.
27. *
28. * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
29. * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
30. * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
31. * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
32. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
34. * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
37. * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38. *
39. */
41. #include "nordic_common.h"
42. #include "sdk_config.h"
43. #include <stdint.h>
44. #include <stdio.h>
45. #include <string.h>
47. #include "app_button.h"
48. #include "app_error.h"
49. #include "app_pwm.h"
50. #include "app_timer.h"
51. #include "app_uart.h"
52. #include "app_util_platform.h"
54. #include "ble.h"
55. #include "ble_advdata.h"
56. #include "ble_advertising.h"
57. #include "ble_conn_params.h"
58. #include "ble_cus.h"
59. #include "ble_cus_c.h"
60. #include "ble_err.h"
61. #include "ble_fs.h"
62. #include "ble_hci.h"
63. #include "ble_srv_common.h"
64. #include "boards.h"
65. #include "bsp_btn_ble.h"
67. #include "dht.h"
69. #include "nrf.h"
70. #include "nrf_ble_gatt.h"
71. #include "nrf_ble_qwr.h"
72. #include "nrf_ble_scan.h"
73. #include "nrf_delay.h"
74. #include "nrf_drv_gpiote.h"
75. #include "nrf_drv_ppi.h"
76. #include "nrf_drv_saadc.h"
77. #include "nrf_drv_timer.h"
78. #include "nrf_gpio.h"
79. #include "nrf_gpiote.h"
80. #include "nrf_log.h"
81. #include "nrf_log_ctrl.h"
82. #include "nrf_log_default_backends.h"
83. #include "nrf_pwr_mgmt.h"
84. #include "nrf_sdh.h"
85. #include "nrf_sdh_ble.h"
86. #include "nrf_uart.h"
88. #include "peer_manager_handler.h"
89. #include "pin_mapping.h"
91. #define DEVICE_NAME "RAPIDO"
93. /////////////////// Instances of Other Modules ///////////////////////////////
94. APP_PWM_INSTANCE(BLE_PWM1, 1); // Create the instance "BLE_PWM" using TIMER1.
96. APP_TIMER_DEF(m_app_timer);
98. /////////////// static variables //////////////////////////
99. static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
101. static uint8_t m_adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET; /**< Advertising handle used to identify an advertising set. */
102. static uint8_t m_enc_advdata[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< Buffer for storing an encoded advertising set. */
103. static uint8_t m_enc_scan_response_data[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< Buffer for storing an encoded scan data. */
104. static nrf_ppi_channel_t m_ppi_channel, ppi_channel_0, ppi_channel_1, ppi_channel_2, ppi_channel_3,
105. ppi_channel_4, ppi_channel_5, ppi_channel_6, ppi_channel_7; // ppi channels
107. static bool ble_pwm1_enable_flag = false;
109. uint32_t pwm1_frequency = 0;
111. uint8_t status_ack[8] = {'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'};
113. #define SAMPLES_IN_BUFFER 1
115. /////////////// static functions Decleration ////////////////
116. static void init_ble_pwm1(uint32_t pin, uint32_t freq, float dutyCycle);
118. static void deinit_ble_pwm1();
120. #define CONN_INTERVAL_DEFAULT (uint16_t)(MSEC_TO_UNITS(7.5, UNIT_1_25_MS)) /**< Default connection interval used at connection establishment by central side. */
122. #define MIN_CONN_INTERVAL MSEC_TO_UNITS(7.5, UNIT_1_25_MS) /**< Minimum acceptable connection interval (7.5 mseconds). */
123. #define MAX_CONN_INTERVAL MSEC_TO_UNITS(500, UNIT_1_25_MS) /**< Maximum acceptable connection interval (0.5 second). */
124. #define SLAVE_LATENCY 0 /**< Slave latency. */
125. #define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory time-out (4 seconds). */
127. #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(20000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (15 seconds). */
128. #define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (5 seconds). */
129. #define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */
131. #define TIMER_1_TIMEOUT_US_1 200
132. #define TIMER_1_TIMEOUT_US_2 400
133. #define TIMER_1_TIMEOUT_US_3 600
134. #define TIMER_1_TIMEOUT_US_4 800
135. #define TIMER_ADC_TIMEOUT_US 200
137. //================================================================
138. /** GPIO pin setup **/
141. // GPIO pins for real mode (EYSHSNZWZ)
142. int OUTPUT_LED = 4;
143. int OUTPUT_PUMP_LEFT_LV1 = 6; static bool pump_left_lv1_flag = false;
144. int OUTPUT_PUMP_LEFT_LV2 = 8; static bool pump_left_lv2_flag = false;
145. int OUTPUT_PUMP_LEFT_LV3 = 7; static bool pump_left_lv3_flag = false;
146. int OUTPUT_PUMP_RIGHT_LV1 = 5; static bool pump_right_lv1_flag = false;
147. int OUTPUT_PUMP_RIGHT_LV2 = 18; static bool pump_right_lv2_flag = false;
148. int OUTPUT_PUMP_RIGHT_LV3 = 20; static bool pump_right_lv3_flag = false;
150. /*
151. // GPIO pins for test mode (nRF52840-DK)
152. int OUTPUT_LED = 27;
153. int OUTPUT_PUMP_LEFT_LV1 = 26; static bool pump_left_lv1_flag = false;
154. int OUTPUT_PUMP_LEFT_LV2 = 4; static bool pump_left_lv2_flag = false;
155. int OUTPUT_PUMP_LEFT_LV3 = 28; static bool pump_left_lv3_flag = false;
156. int OUTPUT_PUMP_RIGHT_LV1 = 29; static bool pump_right_lv1_flag = false;
157. int OUTPUT_PUMP_RIGHT_LV2 = 30; static bool pump_right_lv2_flag = false;
158. int OUTPUT_PUMP_RIGHT_LV3 = 31; static bool pump_right_lv3_flag = false;
159. */
160. //================================================================
162. //================================================================
163. /** Frequency & Duty cycle **/
164. #define FREQ1 5
165. #define FREQ2 10
166. #define FREQ3 20
167. #define FREQ4 40
169. #define DUTY1 5
170. #define DUTY2 10
171. #define DUTY3 20
172. #define DUTY4 40
173. //================================================================
175. /** Variables required for pump actuation **/
176. static bool app_timer_flag = false;
178. uint16_t electrolysis_timer_sec = 0;
180. uint32_t pump_actuation_time = 0;
182. #define PUMP_INTERVAL APP_TIMER_TICKS(1000) // Tick every seconds
183. //================================================================
185. #define LESC_MITM_NC 0
187. /** @brief The maximum number of peripheral and central links combined. */
188. #define NRF_BLE_LINK_COUNT (NRF_SDH_BLE_PERIPHERAL_LINK_COUNT + NRF_SDH_BLE_CENTRAL_LINK_COUNT)
190. #define APP_BLE_CONN_CFG_TAG 1 /**< Tag that identifies the SoftDevice BLE configuration. */
192. #define CENTRAL_SCANNING_LED BSP_BOARD_LED_0
193. #define CENTRAL_CONNECTED_LED BSP_BOARD_LED_1
194. #define PERIPHERAL_ADVERTISING_LED BSP_BOARD_LED_2
195. #define PERIPHERAL_CONNECTED_LED BSP_BOARD_LED_3
197. #define SCAN_DURATION 0x0000
198. #define APP_ADV_INTERVAL 64 /**< Duration of the scanning in units of 10 milliseconds. If set to 0x0000, scanning continues until it is explicitly disabled. */
199. #define APP_ADV_DURATION 18000 /**< The advertising duration (180 seconds) in units of 10 milliseconds. */
201. #define SEC_PARAMS_BOND 1 /**< Perform bonding. */
202. #if LESC_MITM_NC
203. #define SEC_PARAMS_MITM 1 /**< Man In The Middle protection required. */
204. #define SEC_PARAMS_IO_CAPABILITIES BLE_GAP_IO_CAPS_DISPLAY_YESNO /**< Display Yes/No to force Numeric Comparison. */
205. #else
206. #define SEC_PARAMS_MITM 0 /**< Man In The Middle protection required. */
207. #define SEC_PARAMS_IO_CAPABILITIES BLE_GAP_IO_CAPS_NONE /**< No I/O caps. */
208. #endif
209. #define SEC_PARAMS_LESC 0 /**< LE Secure Connections pairing required. */
210. #define SEC_PARAMS_KEYPRESS 0 /**< Keypress notifications not required. */
211. #define SEC_PARAMS_OOB 0 /**< Out Of Band data not available. */
212. #define SEC_PARAMS_MIN_KEY_SIZE 7 /**< Minimum encryption key size in octets. */
213. #define SEC_PARAMS_MAX_KEY_SIZE 16 /**< Maximum encryption key size in octets. */
215. // #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
216. // #define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
217. #define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */
218. #define UART_INTERVAL APP_TIMER_TICKS(2000) /**< Uart measurement interval (ticks). */
219. #define UART_TX_BUF_SIZE 64 /**< UART TX buffer size. */
220. #define UART_RX_BUF_SIZE 32 /**< UART RX buffer size. */
222. #define APP_BLE_OBSERVER_PRIO 3
224. typedef struct {
225. bool is_connected;
226. ble_gap_addr_t address;
227. } conn_peer_t;
229. NRF_BLE_GQ_DEF(m_ble_gatt_queue, /**< BLE GATT Queue instance. */
230. NRF_SDH_BLE_CENTRAL_LINK_COUNT,
231. NRF_BLE_GQ_QUEUE_SIZE);
233. BLE_CUS_DEF(m_cus); /**< Heart Rate Service instance. */
234. BLE_CUS_C_DEF(m_cus_c); /**< Structure used to identify the Heart Rate client module. */
235. NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
236. NRF_BLE_QWRS_DEF(m_qwr, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< Context for the Queued Write module.*/
237. BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */
238. BLE_DB_DISCOVERY_DEF(m_db_disc); /**< Database discovery module instance. */
239. NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */
241. static uint16_t m_conn_handle_cus_c = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the HRS central application. */
242. static volatile uint16_t m_conn_handle_num_comp_central = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the central that needs a numeric comparison button press. */
243. static volatile uint16_t m_conn_handle_num_comp_peripheral = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the peripheral that needs a numeric comparison button press. */
245. static conn_peer_t m_connected_peers[NRF_BLE_LINK_COUNT]; /**< Array of connected peers. */
247. uint8_t uart_ble_data[2][6]; // 2 arrays of 3 analog values
248. uint8_t uart_array_check = 0x00;
249. static char *roles_str[] = {
250. "INVALID_ROLE",
251. "PERIPHERAL",
252. "CENTRAL",
253. };
255. static const char m_target_periph_name[] = "Nordic_Template";
257. static ble_uuid_t m_adv_uuids[] = {{CUSTOM_SERVICE_UUID, BLE_UUID_TYPE_VENDOR_BEGIN}};
260. // cus_c_error_handler()
261. static void cus_c_error_handler(uint32_t nrf_error) {
262. APP_ERROR_HANDLER(nrf_error);
263. }
266. // conn_params_error_handler()
267. static void conn_params_error_handler(uint32_t nrf_error) {
268. APP_ERROR_HANDLER(nrf_error);
269. }
272. // scan_start()
273. static void scan_start(void) {
274. ret_code_t err_code;
276. err_code = nrf_ble_scan_start(&m_scan);
277. APP_ERROR_CHECK(err_code);
279. NRF_LOG_INFO("Scanning Starting\n");
280. }
283. // scan_stop()
284. static void scan_stop(void) {
285. ret_code_t err_code;
287. nrf_ble_scan_stop();
288. NRF_LOG_INFO("Scanning Stopped\n");
289. }
292. // adv_scan_start()
293. static void adv_scan_start(void) {
294. ret_code_t err_code;
296. // Start advertising.
297. err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
298. APP_ERROR_CHECK(err_code);
300. NRF_LOG_INFO("Advertising");
301. }
304. // pm_evt_handler()
305. static void pm_evt_handler(pm_evt_t const *p_evt) {
306. pm_handler_on_pm_evt(p_evt);
307. pm_handler_flash_clean(p_evt);
309. switch (p_evt->evt_id) {
310. case PM_EVT_PEERS_DELETE_SUCCEEDED:
311. adv_scan_start();
312. break;
314. default:
315. break;
316. }
317. }
320. // filter_settings_change()
321. static void filter_settings_change(void) {
322. ret_code_t err_code;
324. err_code = nrf_ble_scan_all_filter_remove(&m_scan);
325. APP_ERROR_CHECK(err_code);
327. if (strlen(m_target_periph_name) != 0) {
328. err_code = nrf_ble_scan_filter_set(&m_scan,
329. SCAN_NAME_FILTER,
330. m_target_periph_name);
331. APP_ERROR_CHECK(err_code);
332. }
333. }
336. // cus_c_evt_handler()
337. static void cus_c_evt_handler(ble_cus_c_t *p_cus_c, ble_cus_c_evt_t *p_cus_c_evt) {
338. ret_code_t err_code;
340. switch (p_cus_c_evt->evt_type) {
341. case BLE_CUS_C_EVT_DISCOVERY_COMPLETE: {
342. if (m_conn_handle_cus_c == BLE_CONN_HANDLE_INVALID) {
343. ret_code_t err_code;
345. m_conn_handle_cus_c = p_cus_c_evt->conn_handle;
347. // We do not want to connect to two peripherals offering the same service, so when
348. // a UUID is matched, we check whether we are not already connected to a peer which
349. // offers the same service
350. filter_settings_change();
352. err_code = ble_cus_c_handles_assign(p_cus_c,
353. m_conn_handle_cus_c,
354. &p_cus_c_evt->params.peer_db);
355. APP_ERROR_CHECK(err_code);
357. // Heart rate service discovered. Enable notification of Heart Rate Measurement.
358. err_code = ble_cus_c_data_char_notif_enable(p_cus_c);
359. APP_ERROR_CHECK(err_code);
360. }
361. } break; // BLE_cus_C_EVT_DISCOVERY_COMPLETE
363. case BLE_CUS_C_EVT_DATA_NOTIFICATION: {
364. NRF_LOG_INFO("CENTRAL: Received Data len %d. Data is\n", p_cus_c_evt->params.data_char.length);
365. NRF_LOG_HEXDUMP_INFO(p_cus_c_evt->params.data_char.p_data, p_cus_c_evt->params.data_char.length);
367. for (uint8_t i = 0; i < p_cus_c_evt->params.data_char.length; i++) {
368. uart_ble_data[uart_array_check][i] = p_cus_c_evt->params.data_char.p_data[i];
369. NRF_LOG_INFO("uart_ble_data[%d][%d] = %d\n", uart_array_check, i, uart_ble_data[uart_array_check][i]);
370. }
372. uart_array_check ^= 0x01; // choose the altermative arrays next time
373. } break;
375. default:
376. break;
377. }
378. }
381. // is_already_connected()
382. static bool is_already_connected(ble_gap_addr_t const *p_connected_adr) {
383. for (uint32_t i = 0; i < NRF_BLE_LINK_COUNT; i++) {
384. if (m_connected_peers[i].is_connected) {
385. if (m_connected_peers[i].address.addr_type == p_connected_adr->addr_type) {
386. if (memcmp(m_connected_peers[i].address.addr,
387. p_connected_adr->addr,
388. sizeof(m_connected_peers[i].address.addr)) == 0) {
389. return true;
390. }
391. }
392. }
393. }
394. return false;
395. }
398. // on_match_request()
399. static void on_match_request(uint16_t conn_handle, uint8_t role) {
400. // Mark the appropriate conn_handle as pending. The rest is handled on button press.
401. NRF_LOG_INFO("Press Button 1 to confirm, Button 2 to reject");
402. if (role == BLE_GAP_ROLE_CENTRAL) {
403. m_conn_handle_num_comp_central = conn_handle;
404. } else if (role == BLE_GAP_ROLE_PERIPH) {
405. m_conn_handle_num_comp_peripheral = conn_handle;
406. }
407. }
410. // multi_qwr_conn_handle_assign()
411. static void multi_qwr_conn_handle_assign(uint16_t conn_handle) {
412. for (uint32_t i = 0; i < NRF_BLE_LINK_COUNT; i++) {
413. if (m_qwr[i].conn_handle == BLE_CONN_HANDLE_INVALID) {
414. ret_code_t err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr[i], conn_handle);
415. APP_ERROR_CHECK(err_code);
416. break;
417. }
418. }
419. }
422. // on_ble_evt()
423. static void on_ble_evt(uint16_t conn_handle, ble_evt_t const *p_ble_evt) {
424. char passkey[BLE_GAP_PASSKEY_LEN + 1];
425. uint16_t role = ble_conn_state_role(conn_handle);
427. switch (p_ble_evt->header.evt_id) {
428. case BLE_GAP_EVT_CONNECTED:
429. m_connected_peers[conn_handle].is_connected = true;
430. m_connected_peers[conn_handle].address = p_ble_evt->evt.gap_evt.params.connected.peer_addr;
431. multi_qwr_conn_handle_assign(conn_handle);
432. break;
434. case BLE_GAP_EVT_DISCONNECTED:
435. memset(&m_connected_peers[conn_handle], 0x00, sizeof(m_connected_peers[0]));
436. break;
438. case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
439. NRF_LOG_INFO("%s: BLE_GAP_EVT_SEC_PARAMS_REQUEST", nrf_log_push(roles_str[role]));
440. break;
442. case BLE_GAP_EVT_PASSKEY_DISPLAY:
443. memcpy(passkey, p_ble_evt->evt.gap_evt.params.passkey_display.passkey, BLE_GAP_PASSKEY_LEN);
444. passkey[BLE_GAP_PASSKEY_LEN] = 0x00;
446. NRF_LOG_INFO("%s: BLE_GAP_EVT_PASSKEY_DISPLAY: passkey=%s match_req=%d",
447. nrf_log_push(roles_str[role]),
448. nrf_log_push(passkey),
449. p_ble_evt->evt.gap_evt.params.passkey_display.match_request);
451. if (p_ble_evt->evt.gap_evt.params.passkey_display.match_request) {
452. on_match_request(conn_handle, role);
453. }
454. break;
456. case BLE_GAP_EVT_AUTH_KEY_REQUEST:
457. NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_KEY_REQUEST", nrf_log_push(roles_str[role]));
458. break;
460. case BLE_GAP_EVT_LESC_DHKEY_REQUEST:
461. NRF_LOG_INFO("%s: BLE_GAP_EVT_LESC_DHKEY_REQUEST", nrf_log_push(roles_str[role]));
462. break;
464. case BLE_GAP_EVT_AUTH_STATUS:
465. NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_STATUS: status=0x%x bond=0x%x lv4: %d kdist_own:0x%x kdist_peer:0x%x",
466. nrf_log_push(roles_str[role]),
467. p_ble_evt->evt.gap_evt.params.auth_status.auth_status,
468. p_ble_evt->evt.gap_evt.params.auth_status.bonded,
469. p_ble_evt->evt.gap_evt.params.auth_status.sm1_levels.lv4,
470. *((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_own),
471. *((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_peer));
472. break;
474. case BLE_GAP_EVT_PHY_UPDATE_REQUEST: {
475. NRF_LOG_DEBUG("PHY update request.");
476. ble_gap_phys_t const phys = {
477. .rx_phys = BLE_GAP_PHY_AUTO,
478. .tx_phys = BLE_GAP_PHY_AUTO,
479. };
480. ret_code_t err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
481. APP_ERROR_CHECK(err_code);
482. } break;
484. default:
485. break;
486. }
487. }
490. // on_ble_central_evt()
491. static void on_ble_central_evt(ble_evt_t const *p_ble_evt) {
492. ble_gap_evt_t const *p_gap_evt = &p_ble_evt->evt.gap_evt;
493. ret_code_t err_code;
495. switch (p_ble_evt->header.evt_id) {
496. // Upon connection, check which peripheral is connected (HR or RSC), initiate DB
497. // discovery, update LEDs status, and resume scanning, if necessary.
498. case BLE_GAP_EVT_CONNECTED: {
499. NRF_LOG_INFO("CENTRAL: Connected, handle: %d.", p_gap_evt->conn_handle);
500. // If no Heart Rate Sensor is currently connected, try to find them on this peripheral.
501. if (m_conn_handle_cus_c == BLE_CONN_HANDLE_INVALID) {
502. NRF_LOG_INFO("CENTRAL: Searching for cus on conn_handle 0x%x", p_gap_evt->conn_handle);
504. err_code = ble_db_discovery_start(&m_db_disc, p_gap_evt->conn_handle);
505. APP_ERROR_CHECK(err_code);
506. }
507. } break; // BLE_GAP_EVT_CONNECTED
509. // Upon disconnection, reset the connection handle of the peer that disconnected, update
510. // the status of LEDs, and start scanning again.
511. case BLE_GAP_EVT_DISCONNECTED: {
512. NRF_LOG_INFO("CENTRAL: Disconnected, handle: %d, reason: 0x%x",
513. p_gap_evt->conn_handle,
514. p_gap_evt->params.disconnected.reason);
516. if (p_gap_evt->conn_handle == m_conn_handle_cus_c) {
517. ble_uuid_t target_uuid = {.uuid = CUSTOM_SERVICE_UUID, .type = BLE_UUID_TYPE_VENDOR_BEGIN};
518. m_conn_handle_cus_c = BLE_CONN_HANDLE_INVALID;
520. err_code = nrf_ble_scan_filter_set(&m_scan,
521. SCAN_UUID_FILTER,
522. &target_uuid);
523. APP_ERROR_CHECK(err_code);
524. }
525. } break; // BLE_GAP_EVT_DISCONNECTED
527. case BLE_GAP_EVT_TIMEOUT: {
528. // Timeout for scanning is not specified, so only connection attemps can time out.
529. if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN) {
530. NRF_LOG_DEBUG("CENTRAL: Connection Request timed out.");
531. }
532. } break;
534. case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST: {
535. // Accept parameters requested by peer.
536. err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
537. &p_gap_evt->params.conn_param_update_request.conn_params);
538. APP_ERROR_CHECK(err_code);
539. } break;
541. case BLE_GATTC_EVT_TIMEOUT:
542. // Disconnect on GATT Client timeout event.
543. NRF_LOG_DEBUG("CENTRAL: GATT Client Timeout.");
544. err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
545. BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
546. APP_ERROR_CHECK(err_code);
547. break;
549. case BLE_GATTS_EVT_TIMEOUT:
550. // Disconnect on GATT Server timeout event.
551. NRF_LOG_DEBUG("CENTRAL: GATT Server Timeout.");
552. err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
553. BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
554. APP_ERROR_CHECK(err_code);
555. break;
557. default:
558. break;
559. }
560. }
563. // on_ble_peripheral_evt()
564. static void on_ble_peripheral_evt(ble_evt_t const *p_ble_evt) {
565. ret_code_t err_code;
566. switch (p_ble_evt->header.evt_id) {
567. case BLE_GAP_EVT_CONNECTED:
568. NRF_LOG_INFO("PERIPHERAL: Connected, handle %d.", p_ble_evt->evt.gap_evt.conn_handle);
569. break;
571. case BLE_GAP_EVT_DISCONNECTED:
572. NRF_LOG_INFO("PERIPHERAL: Disconnected, handle %d, reason 0x%x.",
573. p_ble_evt->evt.gap_evt.conn_handle,
574. p_ble_evt->evt.gap_evt.params.disconnected.reason);
576. // LED indication will be changed when advertising starts.
577. break;
579. case BLE_GATTC_EVT_TIMEOUT:
580. // Disconnect on GATT Client timeout event.
581. NRF_LOG_DEBUG("PERIPHERAL: GATT Client Timeout.");
582. err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
583. BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
584. APP_ERROR_CHECK(err_code);
585. break;
587. case BLE_GATTS_EVT_TIMEOUT:
588. // Disconnect on GATT Server timeout event.
589. NRF_LOG_DEBUG("PERIPHERAL: GATT Server Timeout.");
590. err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
591. BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
592. APP_ERROR_CHECK(err_code);
593. break;
595. default:
596. break;
597. }
598. }
601. // on_adv_evt()
602. static void on_adv_evt(ble_adv_evt_t ble_adv_evt) {
603. switch (ble_adv_evt) {
604. case BLE_ADV_EVT_FAST:
605. break;
607. case BLE_ADV_EVT_IDLE: {
608. ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
609. APP_ERROR_CHECK(err_code);
610. } break;
612. default:
613. break;
614. }
615. }
618. // ble_evt_handler()
619. static void ble_evt_handler(ble_evt_t const *p_ble_evt, void *p_context) {
620. uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
621. uint16_t role = ble_conn_state_role(conn_handle);
623. if ((p_ble_evt->header.evt_id == BLE_GAP_EVT_CONNECTED) && (is_already_connected(&p_ble_evt->evt.gap_evt.params.connected.peer_addr))) {
624. NRF_LOG_INFO("%s: Already connected to this device as %s (handle: %d), disconnecting.",
625. (role == BLE_GAP_ROLE_PERIPH) ? "PERIPHERAL" : "CENTRAL",
626. (role == BLE_GAP_ROLE_PERIPH) ? "CENTRAL" : "PERIPHERAL",
627. conn_handle);
629. (void)sd_ble_gap_disconnect(conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
631. // Do not process the event further.
632. return;
633. }
635. on_ble_evt(conn_handle, p_ble_evt);
637. if (role == BLE_GAP_ROLE_PERIPH) {
638. // Manages peripheral LEDs.
639. on_ble_peripheral_evt(p_ble_evt);
640. } else if ((role == BLE_GAP_ROLE_CENTRAL) || (p_ble_evt->header.evt_id == BLE_GAP_EVT_ADV_REPORT)) {
641. on_ble_central_evt(p_ble_evt);
642. }
643. }
646. // cus_c_init()
647. static void cus_c_init(void) {
648. ret_code_t err_code;
649. ble_cus_c_init_t cus_c_init_obj;
651. cus_c_init_obj.evt_handler = cus_c_evt_handler;
652. cus_c_init_obj.error_handler = cus_c_error_handler;
653. cus_c_init_obj.p_gatt_queue = &m_ble_gatt_queue;
655. err_code = ble_cus_c_init(&m_cus_c, &cus_c_init_obj);
656. APP_ERROR_CHECK(err_code);
657. }
660. // ble_stack_init()
661. static void ble_stack_init(void) {
662. ret_code_t err_code;
664. err_code = nrf_sdh_enable_request();
665. APP_ERROR_CHECK(err_code);
667. // Configure the BLE stack by using the default settings.
668. // Fetch the start address of the application RAM.
669. uint32_t ram_start = 0;
670. err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
671. APP_ERROR_CHECK(err_code);
673. // Enable BLE stack.
674. err_code = nrf_sdh_ble_enable(&ram_start);
675. APP_ERROR_CHECK(err_code);
677. // Register a handler for BLE events.
678. NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
679. }
682. // peer_manager_init()
683. static void peer_manager_init(void) {
684. ble_gap_sec_params_t sec_params;
685. ret_code_t err_code;
687. err_code = pm_init();
688. APP_ERROR_CHECK(err_code);
690. memset(&sec_params, 0, sizeof(ble_gap_sec_params_t));
692. // Security parameters to be used for all security procedures.
693. sec_params.bond = SEC_PARAMS_BOND;
694. sec_params.mitm = SEC_PARAMS_MITM;
695. sec_params.lesc = SEC_PARAMS_LESC;
696. sec_params.keypress = SEC_PARAMS_KEYPRESS;
697. sec_params.io_caps = SEC_PARAMS_IO_CAPABILITIES;
698. sec_params.oob = SEC_PARAMS_OOB;
699. sec_params.min_key_size = SEC_PARAMS_MIN_KEY_SIZE;
700. sec_params.max_key_size = SEC_PARAMS_MAX_KEY_SIZE;
701. sec_params.kdist_own.enc = 1;
702. sec_params.kdist_own.id = 1;
703. sec_params.kdist_peer.enc = 1;
704. sec_params.kdist_peer.id = 1;
706. err_code = pm_sec_params_set(&sec_params);
707. APP_ERROR_CHECK(err_code);
709. err_code = pm_register(pm_evt_handler);
710. APP_ERROR_CHECK(err_code);
711. }
714. // delete_bonds()
715. static void delete_bonds(void) {
716. ret_code_t err_code;
718. NRF_LOG_INFO("Erase bonds!");
720. err_code = pm_peers_delete();
721. APP_ERROR_CHECK(err_code);
722. }
725. // buttons_leds_init()
726. static void buttons_leds_init(bool *p_erase_bonds) {
727. ret_code_t err_code;
728. bsp_event_t startup_event;
730. *p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
731. }
734. // gap_params_init()
735. static void gap_params_init(void) {
736. ret_code_t err_code;
737. ble_gap_conn_params_t gap_conn_params;
738. ble_gap_conn_sec_mode_t sec_mode;
740. BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
742. err_code = sd_ble_gap_device_name_set(&sec_mode,
743. (const uint8_t *)DEVICE_NAME,
744. strlen(DEVICE_NAME));
745. APP_ERROR_CHECK(err_code);
747. memset(&gap_conn_params, 0, sizeof(gap_conn_params));
749. gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
750. gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
751. gap_conn_params.slave_latency = SLAVE_LATENCY;
752. gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT;
754. err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
755. APP_ERROR_CHECK(err_code);
756. }
759. // gatt_init()
760. static void gatt_init(void) {
761. ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
762. APP_ERROR_CHECK(err_code);
763. }
766. // conn_params_init()
767. static void conn_params_init(void) {
768. ret_code_t err_code;
769. ble_conn_params_init_t cp_init;
771. memset(&cp_init, 0, sizeof(cp_init));
773. cp_init.p_conn_params = NULL;
774. cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
775. cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
776. cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT;
777. cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID; // Start upon connection.
778. cp_init.disconnect_on_fail = true;
779. cp_init.evt_handler = NULL; // Ignore events.
780. cp_init.error_handler = conn_params_error_handler;
782. err_code = ble_conn_params_init(&cp_init);
783. APP_ERROR_CHECK(err_code);
784. }
787. // void_db_disc_handler()
788. static void db_disc_handler(ble_db_discovery_evt_t *p_evt) {
789. ble_cus_on_db_disc_evt(&m_cus_c, p_evt);
790. }
793. // db_discovery_init()
794. static void db_discovery_init(void) {
795. ble_db_discovery_init_t db_init;
797. memset(&db_init, 0, sizeof(db_init));
799. db_init.evt_handler = db_disc_handler;
800. db_init.p_gatt_queue = &m_ble_gatt_queue;
802. ret_code_t err_code = ble_db_discovery_init(&db_init);
803. APP_ERROR_CHECK(err_code);
804. }
807. // ble_pwm_ready_callback()
808. static void ble_pwm_ready_callback(uint32_t pwm_id) {
809. }
812. // freq_to_period_us()
813. static uint32_t freq_to_period_us(uint32_t freq) {
814. return (uint32_t)((1.0 / (float)freq) * 1000000);
815. }
818. // init_ble_pwm1()
819. static void init_ble_pwm1(uint32_t pin, uint32_t freq, float dutyCycle) {
821. ret_code_t err_code;
823. app_pwm_config_t out_cfg = APP_PWM_DEFAULT_CONFIG_1CH(freq_to_period_us(freq), pin); // period = 1/freq
825. // Switch the polarity of the second channel.
826. out_cfg.pin_polarity[0] = APP_PWM_POLARITY_ACTIVE_HIGH;
828. // Initialize and enable PWM.
829. err_code = app_pwm_init(&BLE_PWM1, &out_cfg, ble_pwm_ready_callback);
830. APP_ERROR_CHECK(err_code);
831. app_pwm_enable(&BLE_PWM1);
832. ble_pwm1_enable_flag = true;
833. pwm1_frequency = freq;
834. for (uint8_t i = 0; i < out_cfg.num_of_channels; i++) {
835. APP_ERROR_CHECK(app_pwm_channel_duty_set(&BLE_PWM1, i, dutyCycle));
836. }
837. }
840. // deinit_ble_pwm1()
841. static void deinit_ble_pwm1() {
842. app_pwm_disable(&BLE_PWM1);
844. APP_ERROR_CHECK(app_pwm_uninit(&BLE_PWM1));
845. ble_pwm1_enable_flag = false;
846. pwm1_frequency = 0;
847. }
850. // pump_all_off()
851. static void pump_all_off() {
852. if (app_timer_flag) {
853. ret_code_t err_code = app_timer_stop(m_app_timer);
854. app_timer_flag = false;
855. electrolysis_timer_sec = 0;
856. pump_actuation_time = 0;
857. }
859. if (pump_left_lv1_flag) { // Turn off left pump (Lv.1)
860. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV1);
861. nrf_gpio_pin_clear(OUTPUT_PUMP_LEFT_LV1);
862. pump_left_lv1_flag = false;
863. }
865. if (pump_left_lv2_flag) { // Turn off left pump (Lv.2)
866. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV2);
867. nrf_gpio_pin_clear(OUTPUT_PUMP_LEFT_LV2);
868. pump_left_lv2_flag = false;
869. }
871. if (pump_left_lv3_flag) { // Turn off left pump (Lv.3)
872. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV3);
873. nrf_gpio_pin_clear(OUTPUT_PUMP_LEFT_LV3);
874. pump_left_lv3_flag = false;
875. }
877. if (pump_right_lv1_flag) { // Turn off right pump (Lv.1)
878. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV1);
879. nrf_gpio_pin_clear(OUTPUT_PUMP_RIGHT_LV1);
880. pump_right_lv1_flag = false;
881. }
883. if (pump_right_lv2_flag) { // Turn off right pump (Lv.2)
884. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV2);
885. nrf_gpio_pin_clear(OUTPUT_PUMP_RIGHT_LV2);
886. pump_right_lv2_flag = false;
887. }
889. if (pump_right_lv3_flag) { // Turn off right pump (Lv.3)
890. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV3);
891. nrf_gpio_pin_clear(OUTPUT_PUMP_RIGHT_LV3);
892. pump_right_lv3_flag = false;
893. }
895. // Force full deinitialization of peripheral pins
896. nrf_gpio_cfg_input(OUTPUT_PUMP_LEFT_LV1, NRF_GPIO_PIN_NOPULL);
897. nrf_gpio_cfg_input(OUTPUT_PUMP_LEFT_LV2, NRF_GPIO_PIN_NOPULL);
898. nrf_gpio_cfg_input(OUTPUT_PUMP_LEFT_LV3, NRF_GPIO_PIN_NOPULL);
899. nrf_gpio_cfg_input(OUTPUT_PUMP_RIGHT_LV1, NRF_GPIO_PIN_NOPULL);
900. nrf_gpio_cfg_input(OUTPUT_PUMP_RIGHT_LV2, NRF_GPIO_PIN_NOPULL);
901. nrf_gpio_cfg_input(OUTPUT_PUMP_RIGHT_LV3, NRF_GPIO_PIN_NOPULL);
902. }
905. // on_cus_evt()
906. static void on_cus_evt(ble_cus_t *p_cus_service, ble_cus_evt_t *p_evt, uint8_t *p_data, uint8_t length) {
907. ret_code_t err_code;
908. uint8_t data[length];
910. switch (p_evt->evt_type) {
911. case BLE_CUS_EVT_NOTIFICATION_ENABLED:
912. break;
914. case BLE_CUS_EVT_NOTIFICATION_DISABLED:
915. break;
917. case BLE_CUS_EVT_CONNECTED:
918. break;
920. case BLE_CUS_EVT_DISCONNECTED:
921. break;
923. case BLE_CUS_EVT_WRITE:
924. memcpy(data, p_data, length);
925. // 'attr_char_value.max_len' has been modified in "ble_cus.c".
926. NRF_LOG_INFO("Data is %s and length is %d", (uint32_t)data, length);
928. if (data[0] == 'a') { // set PWM: LED, 5Hz, 10ms duty
929. if (ble_pwm1_enable_flag) { // If LED was already operating, turn off the LED.
930. deinit_ble_pwm1();
931. NRF_LOG_INFO("LED was already operating. Turning off the LED...");
933. } else {
934. init_ble_pwm1(OUTPUT_LED, FREQ1, DUTY1);
935. NRF_LOG_INFO("Operate LED in 5 Hz...");
936. }
938. ble_cus_custom_value_update(&m_cus, status_ack, sizeof(status_ack));
940. } else if (data[0] == 'b') { // set PWM: LED, 10Hz, 10ms duty
941. if (ble_pwm1_enable_flag) { // If LED was already operating, turn off the LED.
942. deinit_ble_pwm1();
943. NRF_LOG_INFO("LED was already operating. Turning off the LED...");
945. } else {
946. init_ble_pwm1(OUTPUT_LED, FREQ2, DUTY2);
947. NRF_LOG_INFO("Operate LED in 10 Hz...");
948. }
950. ble_cus_custom_value_update(&m_cus, status_ack, sizeof(status_ack));
952. } else if (data[0] == 'c') { // set PWM: LED, 20Hz, 10ms duty
953. if (ble_pwm1_enable_flag) { // If LED was already operating, turn off the LED.
954. deinit_ble_pwm1();
955. NRF_LOG_INFO("LED was already operating. Turning off the LED...");
957. } else {
958. init_ble_pwm1(OUTPUT_LED, FREQ3, DUTY3);
959. NRF_LOG_INFO("Operate LED in 20 Hz...");
960. }
962. ble_cus_custom_value_update(&m_cus, status_ack, sizeof(status_ack));
964. } else if (data[0] == 'd') { // set PWM: LED, 40Hz, 10ms duty
965. if (ble_pwm1_enable_flag) { // If LED was already operating, turn off the LED.
966. deinit_ble_pwm1();
967. NRF_LOG_INFO("LED was already operating. Turning off the LED...");
969. } else {
970. init_ble_pwm1(OUTPUT_LED, FREQ4, DUTY4);
971. NRF_LOG_INFO("Operate LED in 40 Hz...");
972. }
974. ble_cus_custom_value_update(&m_cus, status_ack, sizeof(status_ack));
976. } else if (data[0] == 'e') {
977. if ((data[1] == 'F') && (data[3] == 'f') && (data[4] == 'P') && (data[6] == 'p') && (data[7] == 'N') && (data[10] == 'n')) {
978. // Pump actuation: data = "eF_fP_pN__n"
979. // F: Target brain -> 1(=Left) / 2(=Right) / 3(=Both)
980. // P: Flow rate level -> 1(=Lv.1) / 2(=Lv.2) / 3(=Lv.3)
981. // N: Actuation time -> 01-99 sec
982. if (app_timer_flag) { // If pump was already actuating, turn off the pump.
983. pump_all_off();
984. NRF_LOG_INFO("Pump was already actuating. Turning off the pump(s)...");
986. } else if ((data[2] == '1') && (data[5] == '1')) { // Condition #1. Actuate left pump (Lv.1)
987. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
988. NRF_LOG_INFO("Left pump (Lv.1) actuation time is %d sec.", pump_actuation_time);
990. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
991. pump_all_off();
992. NRF_LOG_INFO("Turning off the pump(s)...");
994. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
995. electrolysis_timer_sec = 0;
996. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
997. app_timer_flag = true;
999. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV1);
1000. nrf_gpio_pin_set(OUTPUT_PUMP_LEFT_LV1);
1001. pump_left_lv1_flag = true;
1002. }
1004. } else if ((data[2] == '1') && (data[5] == '2')) { // Condition #2. Actuate left pump (Lv.2)
1005. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1006. NRF_LOG_INFO("Left pump (Lv.2) actuation time is %d sec.", pump_actuation_time);
1008. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1009. pump_all_off();
1010. NRF_LOG_INFO("Turning off the pump(s)...");
1012. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1013. electrolysis_timer_sec = 0;
1014. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1015. app_timer_flag = true;
1017. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV2);
1018. nrf_gpio_pin_set(OUTPUT_PUMP_LEFT_LV2);
1019. pump_left_lv2_flag = true;
1020. }
1022. } else if ((data[2] == '1') && (data[5] == '3')) { // Condition #3. Actuate left pump (Lv.3)
1023. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1024. NRF_LOG_INFO("Left pump (Lv.3) actuation time is %d sec.", pump_actuation_time);
1026. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1027. pump_all_off();
1028. NRF_LOG_INFO("Turning off the pump(s)...");
1030. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1031. electrolysis_timer_sec = 0;
1032. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1033. app_timer_flag = true;
1035. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV3);
1036. nrf_gpio_pin_set(OUTPUT_PUMP_LEFT_LV3);
1037. pump_left_lv3_flag = true;
1038. }
1040. } else if ((data[2] == '2') && (data[5] == '1')) { // Condition #4. Actuate right pump (Lv.1)
1041. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1042. NRF_LOG_INFO("Right pump (Lv.1) actuation time is %d sec.", pump_actuation_time);
1044. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1045. pump_all_off();
1046. NRF_LOG_INFO("Turning off the pump(s)...");
1048. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1049. electrolysis_timer_sec = 0;
1050. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1051. app_timer_flag = true;
1053. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV1);
1054. nrf_gpio_pin_set(OUTPUT_PUMP_RIGHT_LV1);
1055. pump_right_lv1_flag = true;
1056. }
1058. } else if ((data[2] == '2') && (data[5] == '2')) { // Condition #5. Actuate right pump (Lv.2)
1059. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1060. NRF_LOG_INFO("Right pump (Lv.2) actuation time is %d sec.", pump_actuation_time);
1062. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1063. pump_all_off();
1064. NRF_LOG_INFO("Turning off the pump(s)...");
1066. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1067. electrolysis_timer_sec = 0;
1068. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1069. app_timer_flag = true;
1071. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV2);
1072. nrf_gpio_pin_set(OUTPUT_PUMP_RIGHT_LV2);
1073. pump_right_lv2_flag = true;
1074. }
1076. } else if ((data[2] == '2') && (data[5] == '3')) { // Condition #6. Actuate right pump (Lv.3)
1077. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1078. NRF_LOG_INFO("Right pump (Lv.3) actuation time is %d sec.", pump_actuation_time);
1080. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1081. pump_all_off();
1082. NRF_LOG_INFO("Turning off the pump(s)...");
1084. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1085. electrolysis_timer_sec = 0;
1086. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1087. app_timer_flag = true;
1089. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV3);
1090. nrf_gpio_pin_set(OUTPUT_PUMP_RIGHT_LV3);
1091. pump_right_lv3_flag = true;
1092. }
1094. } else if ((data[2] == '3') && (data[5] == '1')) { // Condition #7. Actuate both pumps (Lv.1)
1095. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1096. NRF_LOG_INFO("Both pumps (Lv.1) actuation time is %d sec.", pump_actuation_time);
1098. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1099. pump_all_off();
1100. NRF_LOG_INFO("Turning off the pump(s)...");
1102. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1103. electrolysis_timer_sec = 0;
1104. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1105. app_timer_flag = true;
1107. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV1);
1108. nrf_gpio_pin_set(OUTPUT_PUMP_LEFT_LV1);
1109. pump_left_lv1_flag = true;
1111. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV1);
1112. nrf_gpio_pin_set(OUTPUT_PUMP_RIGHT_LV1);
1113. pump_right_lv1_flag = true;
1114. }
1116. } else if ((data[2] == '3') && (data[5] == '2')) { // Condition #8. Actuate both pumps (Lv.2)
1117. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1118. NRF_LOG_INFO("Both pumps (Lv.2) actuation time is %d sec.", pump_actuation_time);
1120. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1121. pump_all_off();
1122. NRF_LOG_INFO("Turning off the pump(s)...");
1124. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1125. electrolysis_timer_sec = 0;
1126. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1127. app_timer_flag = true;
1129. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV2);
1130. nrf_gpio_pin_set(OUTPUT_PUMP_LEFT_LV2);
1131. pump_left_lv2_flag = true;
1133. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV2);
1134. nrf_gpio_pin_set(OUTPUT_PUMP_RIGHT_LV2);
1135. pump_right_lv2_flag = true;
1136. }
1138. } else if ((data[2] == '3') && (data[5] == '3')) { // Condition #9. Actuate both pumps (Lv.3)
1139. pump_actuation_time = 10*(data[8] - '0') + 1*(data[9] - '0');
1140. NRF_LOG_INFO("Both pumps (Lv.3) actuation time is %d sec.", pump_actuation_time);
1142. if (pump_actuation_time == 0) { // If pump actuation time input is 0, turn off the pump.
1143. pump_all_off();
1144. NRF_LOG_INFO("Turning off the pump(s)...");
1146. } else if ((pump_actuation_time > 0) && (pump_actuation_time < 100)) { // Actuation time: 01-99 sec
1147. electrolysis_timer_sec = 0;
1148. err_code = app_timer_start(m_app_timer, PUMP_INTERVAL, NULL);
1149. app_timer_flag = true;
1151. nrf_gpio_cfg_output(OUTPUT_PUMP_LEFT_LV3);
1152. nrf_gpio_pin_set(OUTPUT_PUMP_LEFT_LV3);
1153. pump_left_lv3_flag = true;
1155. nrf_gpio_cfg_output(OUTPUT_PUMP_RIGHT_LV3);
1156. nrf_gpio_pin_set(OUTPUT_PUMP_RIGHT_LV3);
1157. pump_right_lv3_flag = true;
1158. }
1159. }
1161. } else { // If pump actuation command is abnormal, turn off the pump.
1162. pump_all_off();
1163. NRF_LOG_INFO("Non-identified command. Turning off the pump(s)...");
1164. }
1166. ble_cus_custom_value_update(&m_cus, status_ack, sizeof(status_ack));
1168. } else if (data[0] == 'q') { // Turn off the LED
1169. if (ble_pwm1_enable_flag) {
1170. deinit_ble_pwm1();
1171. }
1172. NRF_LOG_INFO("Turning off the LED...");
1174. ble_cus_custom_value_update(&m_cus, status_ack, sizeof(status_ack));
1176. } else if (data[0] == 'y') { // Turn off the pumps
1177. pump_all_off();
1178. NRF_LOG_INFO("Turning off the pump(s)...");
1180. ble_cus_custom_value_update(&m_cus, status_ack, sizeof(status_ack));
1182. } else if (data[0] == 'r') { // Reset
1183. sd_nvic_SystemReset();
1185. } else if (data[0] == 'z') { // Restart into bootloader
1186. err_code = sd_power_gpregret_clr(0, 0xffffffff);
1187. VERIFY_SUCCESS(err_code);
1189. err_code = sd_power_gpregret_set(0, 0xB1);
1190. VERIFY_SUCCESS(err_code);
1192. // Signal that DFU mode is to be enter to the power management module
1193. nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_DFU);
1194. }
1195. break;
1197. default:
1198. break;
1199. }
1200. }
1203. // services_init()
1204. static void services_init(void) {
1205. ret_code_t err_code;
1206. ble_cus_init_t cus_init = {0};
1208. // Initialize CUS Service init structure to zero.
1209. cus_init.evt_handler = on_cus_evt;
1211. BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cus_init.custom_value_char_attr_md.cccd_write_perm);
1212. BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cus_init.custom_value_char_attr_md.read_perm);
1213. BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cus_init.custom_value_char_attr_md.write_perm);
1215. err_code = ble_cus_init(&m_cus, &cus_init);
1216. APP_ERROR_CHECK(err_code);
1217. }
1220. // advertising_init()
1221. static void advertising_init(void) {
1222. ret_code_t err_code;
1223. ble_advertising_init_t init;
1225. memset(&init, 0, sizeof(init));
1227. init.advdata.name_type = BLE_ADVDATA_FULL_NAME;
1228. init.advdata.include_appearance = true;
1229. init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
1230. init.srdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
1231. init.srdata.uuids_complete.p_uuids = m_adv_uuids;
1233. init.config.ble_adv_fast_enabled = true;
1234. init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
1235. init.config.ble_adv_fast_timeout = APP_ADV_DURATION;
1237. init.evt_handler = on_adv_evt;
1239. err_code = ble_advertising_init(&m_advertising, &init);
1240. APP_ERROR_CHECK(err_code);
1242. ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
1243. }
1246. // saadc_event_handler()
1247. void saadc_event_handler(nrf_drv_saadc_evt_t const *p_event) {
1249. }
1252. // saadc_init()
1253. int saadc_init1() {
1254. // AIN0 = P0.02 (EYSHSNZWZ)
1255. // AIN1 = P0.03 (nRF52840-DK; A0) = P0.03 (EYSHSNZWZ)
1256. // AIN2 = P0.04 (nRF52840-DK; A1) = P0.04 (EYSHSNZWZ)
1257. // AIN3 = P0.05 (EYSHSNZWZ)
1258. // AIN4 = P0.28 (nRF52840-DK; A2) = P0.28 (EYSHSNZWZ)
1259. // AIN5 = P0.29 (nRF52840-DK; A3)
1260. // AIN6 = P0.30 (nRF52840-DK; A4)
1261. // AIN7 = P0.31 (nRF52840-DK; A5)
1262. int ret = nrf_drv_saadc_init(NULL, saadc_event_handler);
1263. if (ret)
1264. return ret;
1265. nrf_saadc_channel_config_t config =
1266. NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN1); // AIN1 = P0.03 (PIN 9 - TAIYOYUDEN)
1267. ret = nrf_drv_saadc_channel_init(0, &config);
1268. return ret;
1269. }
1272. // saadc_measure1()
1273. int saadc_measure1() {
1274. nrf_saadc_value_t value;
1275. nrf_drv_saadc_sample_convert(0, &value);
1276. return value;
1277. }
1280. // timer_handler()
1281. void timer_handler(nrf_timer_event_t event_type, void *p_context) {
1282. electrolysis_timer_sec = electrolysis_timer_sec + 1;
1283. }
1286. // log_init()
1287. static void log_init(void) {
1288. ret_code_t err_code = NRF_LOG_INIT(NULL);
1289. APP_ERROR_CHECK(err_code);
1291. NRF_LOG_DEFAULT_BACKENDS_INIT();
1292. }
1295. // timer_init()
1296. static void timer_init(void) {
1297. ret_code_t err_code;
1299. /* timer driver initialization */
1300. nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
1301. timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;
1302. }
1305. // power_management_init()
1306. static void power_management_init(void) {
1307. ret_code_t err_code;
1308. err_code = nrf_pwr_mgmt_init();
1309. APP_ERROR_CHECK(err_code);
1310. }
1313. // application_timers_start()
1314. static void application_timers_start(void) {
1316. }
1319. // advertising_start()
1320. static void advertising_start(bool erase_bonds) {
1321. if (erase_bonds == true) {
1322. delete_bonds();
1323. // Advertising is started by PM_EVT_PEERS_DELETED_SUCEEDED event
1324. } else {
1325. ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
1327. APP_ERROR_CHECK(err_code);
1328. }
1329. }
1332. // app_timer_handler()
1333. static void app_timer_handler(void * p_context) {
1334. electrolysis_timer_sec = electrolysis_timer_sec + 1;
1336. if (electrolysis_timer_sec == pump_actuation_time) {
1337. pump_all_off();
1338. }
1339. }
1342. // app_timers_init()
1343. static void app_timers_init(void) {
1344. // Initialize timer module, making it use the scheduler
1345. ret_code_t err_code;
1347. err_code = app_timer_init();
1348. APP_ERROR_CHECK(err_code);
1350. err_code = app_timer_create(&m_app_timer, APP_TIMER_MODE_REPEATED, app_timer_handler);
1351. APP_ERROR_CHECK(err_code);
1352. }
1355. // idle_state_handler()
1356. static void idle_state_handle(void) {
1357. ret_code_t err_code;
1359. if (NRF_LOG_PROCESS() == false) {
1360. nrf_pwr_mgmt_run();
1361. }
1362. }
1365. // main()
1366. int main(void) {
1367. bool erase_bonds;
1369. // Initialize.
1370. log_init(); //
1371. timer_init();
1372. buttons_leds_init(&erase_bonds);
1373. app_timers_init();
1374. power_management_init();
1375. ble_stack_init();
1376. gap_params_init();
1377. gatt_init();
1378. services_init();
1379. advertising_init();
1380. conn_params_init();
1381. peer_manager_init();
1383. // Start execution.
1384. NRF_LOG_INFO("Template example started.");
1385. application_timers_start();
1387. db_discovery_init();
1388. cus_c_init();
1390. // advertising_start(erase_bonds);
1391. // saadc_init0();
1392. saadc_init1();
1394. // Start execution.
1395. NRF_LOG_INFO("LE Secure Connections example started.");
1397. if (erase_bonds == true) {
1398. delete_bonds();
1399. // Scanning and advertising is started by PM_EVT_PEERS_DELETE_SUCEEDED.
1400. } else {
1401. adv_scan_start(); // "Advertising"
1402. }
1404. // Enter main loop.
1405. for (;;) {
1406. idle_state_handle();
1407. }
1408. }

main.c, under CC-BY-4.0 · at the source