host.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  1. #include "ble_comm.h"
  2. #include "app_flash.h"
  3. #include "system.h"
  4. #if USENAMEFR
  5. char Target_scan[TARFET_LEN_MAX] = "SH_E9F4";
  6. #else
  7. char Target_scan[TARFET_LEN_MAX] = {0x01, 0xf9, 0x84, 0x6a, 0x83, 0xeb};
  8. #endif
  9. static Ble_receive_handler_t Rec_h = NULL;
  10. #define APP_BLE_OBSERVER_PRIO 3 /**< BLE observer priority of the application. There is no need to modify this value. */
  11. #define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN /**< UUID type for the Nordic UART Service (vendor specific). */
  12. #define ECHOBACK_BLE_UART_DATA 1 /**< Echo the UART data that is received over the Nordic UART Service (NUS) back to the sender. */
  13. BLE_NUS_C_DEF(m_ble_nus_c); /**< BLE Nordic UART Service (NUS) client instance. */
  14. NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
  15. BLE_DB_DISCOVERY_DEF(m_db_disc); /**< Database discovery module instance. */
  16. NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */
  17. NRF_BLE_GQ_DEF(m_ble_gatt_queue, /**< BLE GATT Queue instance. */
  18. NRF_SDH_BLE_CENTRAL_LINK_COUNT,
  19. NRF_BLE_GQ_QUEUE_SIZE);
  20. static uint16_t m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH; /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
  21. unsigned char connect_to_server = 0;
  22. ble_gap_conn_params_t host_conn_params = {0};
  23. static void db_disc_handler(ble_db_discovery_evt_t *p_evt)
  24. {
  25. ble_nus_c_on_db_disc_evt(&m_ble_nus_c, p_evt);
  26. }
  27. void timer_init(void)
  28. {
  29. ret_code_t err_code = app_timer_init();
  30. APP_ERROR_CHECK(err_code);
  31. }
  32. static void db_discovery_init(void)
  33. {
  34. ble_db_discovery_init_t db_init;
  35. memset(&db_init, 0, sizeof(ble_db_discovery_init_t));
  36. db_init.evt_handler = db_disc_handler;
  37. db_init.p_gatt_queue = &m_ble_gatt_queue;
  38. ret_code_t err_code = ble_db_discovery_init(&db_init);
  39. APP_ERROR_CHECK(err_code);
  40. }
  41. void power_management_init(void)
  42. {
  43. ret_code_t err_code;
  44. err_code = nrf_pwr_mgmt_init();
  45. APP_ERROR_CHECK(err_code);
  46. }
  47. static void gatt_evt_handler(nrf_ble_gatt_t *p_gatt, nrf_ble_gatt_evt_t const *p_evt)
  48. {
  49. if (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED)
  50. {
  51. BLE_PRINT("GATT MTU exchange completed.\r\r\n");
  52. m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
  53. BLE_PRINT("Ble NUS max data length set to 0x%X(%d)\r\r\n", m_ble_nus_max_data_len, m_ble_nus_max_data_len);
  54. }
  55. }
  56. void gatt_init(void)
  57. {
  58. ret_code_t err_code;
  59. err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
  60. APP_ERROR_CHECK(err_code);
  61. err_code = nrf_ble_gatt_att_mtu_central_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE);
  62. APP_ERROR_CHECK(err_code);
  63. err_code = nrf_ble_gatt_att_mtu_periph_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE);
  64. APP_ERROR_CHECK(err_code);
  65. }
  66. void scan_start(void)
  67. {
  68. ret_code_t ret;
  69. if(connect_to_server)return;
  70. ret = nrf_ble_scan_start(&m_scan);
  71. APP_ERROR_CHECK(ret);
  72. BLE_PRINT("scan_start -> scan_name <%s> \r\n", Target_scan);
  73. }
  74. void ST_scan_stop(void)
  75. {
  76. nrf_ble_scan_stop();
  77. BLE_PRINT("ST_scan_stop \r\n");
  78. }
  79. unsigned int ST_scan_start(void)
  80. {
  81. ret_code_t ret;
  82. ret = nrf_ble_scan_start(&m_scan);
  83. APP_ERROR_CHECK(ret);
  84. BLE_PRINT("ST_scan_start -> scan_name <%s> \r\n", Target_scan);
  85. if(ret != APP_SUCCESS)
  86. {
  87. return APP_ERROR_RESOURCES;
  88. }
  89. return APP_SUCCESS;
  90. }
  91. static void ble_nus_c_evt_handler(ble_nus_c_t *p_ble_nus_c, ble_nus_c_evt_t const *p_ble_nus_evt)
  92. {
  93. ret_code_t err_code;
  94. switch (p_ble_nus_evt->evt_type)
  95. {
  96. case BLE_NUS_C_EVT_DISCOVERY_COMPLETE:
  97. BLE_PRINT("Discovery complete.\r\n");
  98. err_code = ble_nus_c_handles_assign(p_ble_nus_c, p_ble_nus_evt->conn_handle, &p_ble_nus_evt->handles);
  99. APP_ERROR_CHECK(err_code);
  100. err_code = ble_nus_c_tx_notif_enable(p_ble_nus_c);
  101. APP_ERROR_CHECK(err_code);
  102. BLE_PRINT("Connected to device with Nordic UART Service.\r\n");
  103. break;
  104. case BLE_NUS_C_EVT_NUS_TX_EVT: //作为主机接收从机的数据
  105. Rec_h(p_ble_nus_evt->p_data, p_ble_nus_evt->data_len);
  106. break;
  107. case BLE_NUS_C_EVT_DISCONNECTED:
  108. BLE_PRINT("Disconnected.\r\n");
  109. #if DEBUGBLE
  110. scan_start();
  111. #endif
  112. break;
  113. }
  114. }
  115. static void nus_error_handler(uint32_t nrf_error)
  116. {
  117. if (nrf_error == NRF_ERROR_RESOURCES)
  118. return;
  119. if (nrf_error == NRF_ERROR_INVALID_STATE)
  120. return;
  121. APP_ERROR_HANDLER(nrf_error);
  122. }
  123. static void nus_c_init(void)
  124. {
  125. ret_code_t err_code;
  126. ble_nus_c_init_t init;
  127. init.evt_handler = ble_nus_c_evt_handler;
  128. init.error_handler = nus_error_handler;
  129. init.p_gatt_queue = &m_ble_gatt_queue;
  130. err_code = ble_nus_c_init(&m_ble_nus_c, &init);
  131. APP_ERROR_CHECK(err_code);
  132. }
  133. #define host_connected_evt_num_max 3
  134. static uint8_t host_connected_evt_num = 0;
  135. static Ble_evt_cb ble_host_connected_evt_cb[host_connected_evt_num_max] = {0};
  136. int Ble_Host_Connectd_Evt_Regist(Ble_evt_cb cb)
  137. {
  138. for (int i = 0; i < host_connected_evt_num_max; i++)
  139. {
  140. if (ble_host_connected_evt_cb[i] == cb)
  141. return -1;
  142. if (ble_host_connected_evt_cb[i] == 0)
  143. {
  144. host_connected_evt_num++;
  145. ble_host_connected_evt_cb[i] = cb; //回调函数
  146. return 0;
  147. }
  148. }
  149. DEBUG_LOG( "ble_evt_Regist -> too many!\n");
  150. return -2;
  151. }
  152. void ble_host_connected_evt_pcs(void)
  153. {
  154. for (int i = 0; i < host_connected_evt_num; i++)
  155. { //DEBUG_LOG("time_cb[%d]=%d\n",i,time_cb[i]);
  156. if (ble_host_connected_evt_cb[i])
  157. {
  158. ble_host_connected_evt_cb[i](); //回调函数
  159. }
  160. }
  161. }
  162. #define host_disconn_evt_num_max 16
  163. static uint8_t host_disconn_evt_num = 0;
  164. static Ble_evt_cb ble_Host_disconn_evt_cb[host_disconn_evt_num_max] = {0};
  165. int Ble_Host_Disconn_Evt_Regist(Ble_evt_cb cb)
  166. {
  167. for (int i = 0; i < host_disconn_evt_num_max; i++)
  168. {
  169. if (ble_Host_disconn_evt_cb[i] == cb)
  170. return -1;
  171. if (ble_Host_disconn_evt_cb[i] == 0)
  172. {
  173. host_disconn_evt_num++;
  174. ble_Host_disconn_evt_cb[i] = cb; //回调函数
  175. return 0;
  176. }
  177. }
  178. DEBUG_LOG( "Ble_Slave_Disconn_Evt_Regist -> too many!\r\n");
  179. return -2;
  180. }
  181. void ble_host_dicconn_evt_pcs(void)
  182. {
  183. for (int i = 0; i < host_disconn_evt_num; i++)
  184. { //DEBUG_LOG("time_cb[%d]=%d\n",i,time_cb[i]);
  185. if (ble_Host_disconn_evt_cb[i])
  186. {
  187. ble_Host_disconn_evt_cb[i](); //回调函数
  188. }
  189. }
  190. }
  191. bool advdata_name_find(uint8_t const * p_encoded_data,
  192. uint16_t data_len,
  193. char const * p_target_name)
  194. {
  195. return ble_advdata_name_find(p_encoded_data,data_len,p_target_name);
  196. }
  197. bool advdata_short_name_find(uint8_t const * p_encoded_data,
  198. uint16_t data_len,
  199. char const * p_target_name,
  200. uint8_t const short_name_min_len)
  201. {
  202. return ble_advdata_short_name_find(p_encoded_data,data_len,p_target_name,short_name_min_len);
  203. }
  204. #if BleNameHoldOn_ENANBLE
  205. uint8_t SaveFlashFlag_holdOn =0;
  206. #endif
  207. advdata_rep_handler_t _advdata_rep_callback = NULL;
  208. void advdata_report_Evt_Regist(advdata_rep_handler_t handler)
  209. {
  210. if(handler==NULL)
  211. {
  212. BLE_PRINT("advdata_report_Evt_Regist ERROR\r\n");
  213. }
  214. else
  215. {
  216. BLE_PRINT("advdata_report_Evt_Regist SUCCESS\r\n");
  217. _advdata_rep_callback=handler;
  218. }
  219. }
  220. static void on_ble_central_evt(ble_evt_t const *p_ble_evt, void *p_context) //作为主设备时的处理
  221. {
  222. ret_code_t err_code;
  223. ble_gap_evt_t const *p_gap_evt = &p_ble_evt->evt.gap_evt;
  224. switch (p_ble_evt->header.evt_id)
  225. {
  226. case BLE_GAP_EVT_CONNECTED:
  227. err_code = ble_nus_c_handles_assign(&m_ble_nus_c, p_ble_evt->evt.gap_evt.conn_handle, NULL);
  228. APP_ERROR_CHECK(err_code);
  229. BLE_PRINT("start discovery services\r\n"); //添加开始发现服务提示
  230. connect_to_server = 1;
  231. // start discovery of services. The NUS Client waits for a discovery result
  232. err_code = ble_db_discovery_start(&m_db_disc, p_ble_evt->evt.gap_evt.conn_handle);
  233. APP_ERROR_CHECK(err_code);
  234. ble_host_connected_evt_pcs();
  235. #if BleNameHoldOn_ENANBLE
  236. if(mFlash.isHost >0){
  237. uint8_t i =0;
  238. for(i=0;i<sizeof(mFlash.mClient.macAddr);i++){
  239. if(mFlash.mClient.macAddr[i] != 0xff)break;
  240. }
  241. if(sizeof(mFlash.mClient.macAddr) == i){
  242. for(i=0;i<sizeof(mFlash.mClient.macAddr);i++){
  243. mFlash.mClient.macAddr[i] = p_ble_evt->evt.gap_evt.params.connected.peer_addr.addr[5-i];
  244. }
  245. SaveFlashFlag_holdOn = 1;
  246. }
  247. }
  248. #endif
  249. sd_ble_gap_rssi_start(m_ble_nus_c.conn_handle, BLE_GAP_RSSI_THRESHOLD_INVALID, 0);
  250. break;
  251. case BLE_GAP_EVT_DISCONNECTED:
  252. connect_to_server = 0;
  253. BLE_PRINT("Disconnected. conn_handle: 0x%x, reason: 0x%x",
  254. p_gap_evt->conn_handle,
  255. p_gap_evt->params.disconnected.reason);
  256. BLE_PRINT("Disconnected to Server.\r\n");
  257. ble_host_dicconn_evt_pcs();
  258. sd_ble_gap_rssi_stop(m_ble_nus_c.conn_handle);
  259. break;
  260. case BLE_GAP_EVT_TIMEOUT:
  261. if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
  262. {
  263. BLE_PRINT("Connection Request timed out.\r\n");
  264. }
  265. break;
  266. case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
  267. // Pairing not supported.
  268. err_code = sd_ble_gap_sec_params_reply(p_ble_evt->evt.gap_evt.conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
  269. APP_ERROR_CHECK(err_code);
  270. BLE_PRINT("on_ble_central_evt -> BLE_GAP_EVT_SEC_PARAMS_REQUEST\r\n");
  271. break;
  272. case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
  273. {
  274. BLE_PRINT("Connection 0x%x PHY update request.", p_ble_evt->evt.gap_evt.conn_handle);
  275. ble_gap_phys_t const phys =
  276. {
  277. .rx_phys = BLE_GAP_PHY_AUTO,
  278. .tx_phys = BLE_GAP_PHY_AUTO,
  279. };
  280. err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
  281. APP_ERROR_CHECK(err_code);
  282. }
  283. break;
  284. case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
  285. // Accepting parameters requested by peer.
  286. err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
  287. &p_gap_evt->params.conn_param_update_request.conn_params); //主机接受从机连接参数更新连接参数
  288. APP_ERROR_CHECK(err_code);
  289. BLE_PRINT("on_ble_central_evt -> BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST\r\n");
  290. break;
  291. case BLE_GAP_EVT_CONN_PARAM_UPDATE:
  292. BLE_PRINT("on_ble_central_evt -> BLE_GAP_EVT_CONN_PARAM_UPDATE\r\n");
  293. memcpy(&host_conn_params, &p_gap_evt->params.conn_param_update_request.conn_params, sizeof(ble_gap_conn_params_t));
  294. BLE_PRINT("min_conn_interval : %d * 1.25 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.min_conn_interval);
  295. BLE_PRINT("max_conn_interval : %d * 1.25 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.max_conn_interval);
  296. BLE_PRINT("slave_latency : %d\r\n", p_gap_evt->params.conn_param_update_request.conn_params.slave_latency);
  297. BLE_PRINT("conn_sup_timeout : %d * 10 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.conn_sup_timeout);
  298. break;
  299. case BLE_GATTC_EVT_TIMEOUT:
  300. // Disconnect on GATT Client timeout event.
  301. BLE_PRINT("GATT Client Timeout.\r\n");
  302. err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
  303. BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
  304. APP_ERROR_CHECK(err_code);
  305. break;
  306. case BLE_GATTS_EVT_TIMEOUT:
  307. // Disconnect on GATT Server timeout event.
  308. BLE_PRINT("GATT Server Timeout.\r\n");
  309. err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
  310. BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
  311. APP_ERROR_CHECK(err_code);
  312. break;
  313. case BLE_GAP_EVT_ADV_REPORT:
  314. {
  315. if(p_gap_evt->params.adv_report.type.scan_response == 0)
  316. {
  317. if(_advdata_rep_callback != NULL)
  318. {
  319. _advdata_rep_callback(p_gap_evt->params.adv_report.data.p_data , p_gap_evt->params.adv_report.data.len ,p_gap_evt->params.adv_report.rssi);
  320. }
  321. // unsigned short parsed_name_len;
  322. // uint16_t offset = 0;
  323. // parsed_name_len = ble_advdata_search(p_gap_evt->params.adv_report.data.p_data,p_gap_evt->params.adv_report.data.len,&offset,BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME);
  324. // if(parsed_name_len>0)
  325. // {
  326. // printf( " RSSI:%d \tNAME :",p_gap_evt->params.adv_report.rssi);
  327. // for(int k=0;k<parsed_name_len;k++)
  328. // {
  329. // printf( "%c" ,p_gap_evt->params.adv_report.data.p_data[k+offset] );
  330. // }
  331. // printf( "\r\n");
  332. // }
  333. }
  334. }
  335. break;
  336. default:
  337. break;
  338. }
  339. }
  340. extern bool ble_evt_is_advertising_timeout(ble_evt_t const *p_ble_evt);
  341. extern void on_ble_peripheral_evt(ble_evt_t const *p_ble_evt); //作为从设备的处理
  342. static void ble_evt_handler(ble_evt_t const *p_ble_evt, void *p_context)
  343. {
  344. uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
  345. uint16_t role = ble_conn_state_role(conn_handle);
  346. // Based on the role this device plays in the connection, dispatch to the right handler.不同角色下所做的处理
  347. if (role == BLE_GAP_ROLE_PERIPH || ble_evt_is_advertising_timeout(p_ble_evt))
  348. {
  349. // ble_nus_on_ble_evt(p_ble_evt, &m_nus);
  350. on_ble_peripheral_evt(p_ble_evt);
  351. }
  352. else if ((role == BLE_GAP_ROLE_CENTRAL) || (p_ble_evt->header.evt_id == BLE_GAP_EVT_ADV_REPORT))
  353. {
  354. // ble_nus_c_on_ble_evt(p_ble_evt, &m_ble_nus_c);
  355. on_ble_central_evt(p_ble_evt, NULL);
  356. }
  357. else
  358. {
  359. BLE_PRINT("ble_evt_handler -> other\r\n");
  360. }
  361. }
  362. void ble_stack_init(void)
  363. {
  364. ret_code_t err_code;
  365. err_code = nrf_sdh_enable_request();
  366. APP_ERROR_CHECK(err_code);
  367. // Configure the BLE stack using the default settings.
  368. // Fetch the start address of the application RAM.
  369. uint32_t ram_start = 0;
  370. err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
  371. APP_ERROR_CHECK(err_code);
  372. // Enable BLE stack.
  373. err_code = nrf_sdh_ble_enable(&ram_start);
  374. APP_ERROR_CHECK(err_code);
  375. // Register a handler for BLE events.
  376. NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
  377. }
  378. #define PRINT_MAC 0
  379. /**@brief Function for handling Scanning Module events.
  380. */
  381. static void scan_evt_handler(scan_evt_t const *p_scan_evt)
  382. {
  383. switch (p_scan_evt->scan_evt_id)
  384. {
  385. case NRF_BLE_SCAN_EVT_CONNECTING_ERROR:
  386. {
  387. // ret_code_t err_code = p_scan_evt->params.connecting_err.err_code;
  388. // APP_ERROR_CHECK(err_code);
  389. BLE_PRINT("scan_evt_handler -> NRF_BLE_SCAN_EVT_CONNECTING_ERROR \r\n");
  390. }
  391. break;
  392. case NRF_BLE_SCAN_EVT_CONNECTED:
  393. {
  394. BLE_PRINT("scan_evt_handler -> NRF_BLE_SCAN_EVT_CONNECTED\r\n");
  395. #if PRINT_MAC
  396. ble_gap_evt_connected_t const *p_connected =
  397. p_scan_evt->params.connected.p_connected;
  398. // Scan is automatically stopped by the connection.
  399. BLE_PRINT("Connecting to Host %02x%02x %02x%02x %02x%02x\r\r\n",
  400. p_connected->peer_addr.addr[0],
  401. p_connected->peer_addr.addr[1],
  402. p_connected->peer_addr.addr[2],
  403. p_connected->peer_addr.addr[3],
  404. p_connected->peer_addr.addr[4],
  405. p_connected->peer_addr.addr[5]);
  406. #endif
  407. }
  408. break;
  409. case NRF_BLE_SCAN_EVT_SCAN_TIMEOUT:
  410. {
  411. BLE_PRINT("scan_evt_handler -> NRF_BLE_SCAN_EVT_SCAN_TIMEOUT -> Scan timed out.\r\n");
  412. scan_start();
  413. }
  414. break;
  415. }
  416. }
  417. unsigned int send_bytes_server(uint8_t *bytes, uint16_t len)
  418. {
  419. if (connect_to_server == 0)
  420. {
  421. BLE_PRINT("send_bytes_server -> APP_ERR_DISCONN\r\n");
  422. return APP_ERR_DISCONN;
  423. }
  424. if (len > m_ble_nus_max_data_len)
  425. {
  426. BLE_PRINT("send_bytes_server -> fail ->overlength\r\n");
  427. return APP_ERR_OVERLENGTH;
  428. }
  429. if (NRF_SUCCESS != ble_nus_c_string_send(&m_ble_nus_c, bytes, len))
  430. {
  431. BLE_PRINT("send_bytes_server -> fail\r\n");
  432. }
  433. return APP_SUCCESS;
  434. }
  435. static void scan_init(void)
  436. {
  437. ret_code_t err_code;
  438. nrf_ble_scan_init_t init_scan;
  439. memset(&init_scan, 0, sizeof(init_scan));
  440. init_scan.connect_if_match = true;
  441. init_scan.conn_cfg_tag = APP_BLE_CONN_CFG_TAG;
  442. err_code = nrf_ble_scan_init(&m_scan, &init_scan, scan_evt_handler);
  443. APP_ERROR_CHECK(err_code);
  444. #if USENAMEFR
  445. err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_NAME_FILTER, &Target_scan);
  446. APP_ERROR_CHECK(err_code);
  447. err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_NAME_FILTER, false);
  448. APP_ERROR_CHECK(err_code);
  449. BLE_PRINT("scan_init -> scan_name <%s> \r\n", Target_scan);
  450. #else
  451. err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_ADDR_FILTER, &Target_scan);
  452. APP_ERROR_CHECK(err_code);
  453. err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_ADDR_FILTER, false);
  454. APP_ERROR_CHECK(err_code);
  455. BLE_PRINT("scan_start -> scan_MAC [ %02X %02X %02X %02X %02X %02X ]\r\n", Target_scan[0], Target_scan[1], Target_scan[2], Target_scan[3], Target_scan[4], Target_scan[5]);
  456. #endif
  457. }
  458. unsigned char host_isconnect(void)
  459. {
  460. return connect_to_server;
  461. }
  462. char ble_stack_init_sta = 1;
  463. char host_init_sta = 0;
  464. void host_init(Ble_receive_handler_t receive_handler)
  465. {
  466. if (receive_handler == NULL)
  467. {
  468. BLE_PRINT("host_init -> param err \r\n");
  469. return;
  470. }
  471. Rec_h = receive_handler;
  472. if (ble_stack_init_sta)
  473. {
  474. timer_init(); //
  475. power_management_init(); //
  476. ble_stack_init(); //
  477. gatt_init(); //
  478. ble_stack_init_sta = 0;
  479. }
  480. db_discovery_init();
  481. nus_c_init();
  482. scan_init();
  483. host_init_sta=1;
  484. }
  485. void err(int err_num)
  486. {
  487. BLE_PRINT("APP ERROR -> %d \r\n", err_num);
  488. }
  489. unsigned int host_set_scan_name(char *name, int len)
  490. {
  491. unsigned int err_code;
  492. if (len > TARFET_LEN_MAX)
  493. return APP_ERR_OVERLENGTH;
  494. if(connect_to_server)
  495. return APP_ERR_CONNECTED;
  496. memset(Target_scan, 0, TARFET_LEN_MAX);
  497. if(host_init_sta)
  498. {
  499. memcpy(Target_scan, name, len);
  500. err_code =nrf_ble_scan_all_filter_remove(&m_scan);
  501. APP_ERROR_CHECK(err_code);
  502. #if USENAMEFR
  503. err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_NAME_FILTER, &Target_scan);
  504. APP_ERROR_CHECK(err_code);
  505. err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_NAME_FILTER, false);
  506. APP_ERROR_CHECK(err_code);
  507. BLE_PRINT("host_set_scan_name -> scan_name <%s> \r\n", Target_scan);
  508. #else
  509. err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_ADDR_FILTER, &Target_scan);
  510. APP_ERROR_CHECK(err_code);
  511. err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_ADDR_FILTER, false);
  512. APP_ERROR_CHECK(err_code);
  513. BLE_PRINT("host_set_scan_name -> scan_MAC [ %02X %02X %02X %02X %02X %02X ]\r\n", Target_scan[0], Target_scan[1], Target_scan[2], Target_scan[3], Target_scan[4], Target_scan[5]);
  514. #endif
  515. }
  516. else
  517. {
  518. memcpy(Target_scan, name, len);
  519. }
  520. return APP_SUCCESS;
  521. }
  522. unsigned int Ble_update_conn_interval(float min_conn_interval, float max_conn_interval)
  523. {
  524. ret_code_t err_code;
  525. ble_gap_conn_params_t bgcp;
  526. //主机接受从机连接参数更新连接参数
  527. if (connect_to_server)
  528. {
  529. if ((max_conn_interval > 1.25 * 1599) || (max_conn_interval < min_conn_interval))
  530. return APP_ERR_PARAMERR;
  531. if (min_conn_interval < 7.5f)
  532. return APP_ERR_PARAMERR;
  533. bgcp.max_conn_interval = MSEC_TO_UNITS(max_conn_interval, UNIT_1_25_MS);
  534. bgcp.min_conn_interval = MSEC_TO_UNITS(min_conn_interval, UNIT_1_25_MS);
  535. bgcp.conn_sup_timeout = MSEC_TO_UNITS(4000, UNIT_10_MS);
  536. bgcp.slave_latency = 0;
  537. err_code = sd_ble_gap_conn_param_update(m_ble_nus_c.conn_handle, &bgcp);
  538. if(err_code != NRF_ERROR_INVALID_STATE && err_code != NRF_ERROR_BUSY && err_code != NRF_SUCCESS){
  539. APP_ERROR_CHECK(err_code);
  540. }
  541. return err_code;
  542. }
  543. else
  544. {
  545. return APP_ERR_DISCONN;
  546. }
  547. }
  548. void host_disconnect(void)
  549. {
  550. if (connect_to_server)
  551. sd_ble_gap_disconnect(m_ble_nus_c.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
  552. }
  553. void host_get_conn_params(ble_gap_conn_params_t *p)
  554. {
  555. memcpy(p, &host_conn_params, sizeof(ble_gap_conn_params_t));
  556. }
  557. static signed char rssi = 0;
  558. signed char host_get_rssi(void)
  559. {
  560. unsigned char channel;
  561. if (connect_to_server == 0)
  562. return 1;
  563. sd_ble_gap_rssi_get(m_ble_nus_c.conn_handle, &rssi, &channel);
  564. ///BLE_PRINT("rssi= %d channel=%d\r\n", rssi, channel);
  565. return rssi;
  566. }