#include "ble_peripheral.h" #include "ble_conn_state.h" #include "peer_manager.h" #include "peer_manager_handler.h" //DFU需要引用的头文件 #if NRF_MODULE_ENABLED(BLE_DFU) #include "nrf_power.h" #include "nrf_bootloader_info.h" #include "ble_dfu.h" #include "nrf_sdm.h" #include "nrf_dfu_ble_svci_bond_sharing.h" #include "nrf_svci_async_function.h" #include "nrf_svci_async_handler.h" static void ble_dfu_evt_handler(ble_dfu_buttonless_evt_type_t event); #endif #if NRF_MODULE_ENABLED(BLE_MY_UARTS) #include "my_ble_uarts.h" #endif BLE_ADVERTISING_DEF(m_advertising); /**< ************** Advertising module instance. **************/ int8_t tx_power_level=NRF_BLE_ADVDATA_NOREG_TX_POWER; /**< *********************** ble发射功率 **********************/ uint32_t ble_adv_interval=NRF_BLE_ADV_NOREG_INTERVAL; /**< *********************ble蓝牙广播时间 *********************/ uint32_t ble_adv_duration=NRF_BLE_ADV_DURATION; static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< ************ Handle of the current connection. ***********/ static uint8_t m_enc_advdata[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< ****** Buffer for storing an encoded advertising set. ****/ static uint8_t m_enc_scan_response_data[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< ********* Buffer for storing an encoded scan data. *******/ bool ble_adv_stat=false; #if NRF_SEC_PARAM_BLE==1 static ble_gap_sec_params_t m_sec_params; static ble_gap_sec_keyset_t m_sec_keyset; static ble_gap_enc_key_t m_own_enc_key; static ble_gap_enc_key_t m_peer_enc_key; static ble_gap_sec_params_t m_sec_params_auth; #endif #if NRF_BLE_ADVDATA_WHITELIST_ENABLE==1 static pm_peer_id_t m_peer_id; static pm_peer_id_t m_whitelist_peers[NRF_BLE_ADVDATA_WHITELIST_MAX_COUNT]; /**< ******* List of peers currently in the whitelist. ********/ static uint32_t m_whitelist_peer_cnt; /**< ****** Number of peers currently in the whitelist. *******/ #endif extern uint8_t m_addl_adv_manuf_data[]; static void advertising_start(void); /**@brief Struct that contains pointers to the encoded advertising data. */ static ble_gap_adv_data_t m_adv_data = { .adv_data = { .p_data = m_enc_advdata, .len = BLE_GAP_ADV_SET_DATA_SIZE_MAX }, .scan_rsp_data = { .p_data = m_enc_scan_response_data, .len = BLE_GAP_ADV_SET_DATA_SIZE_MAX } }; static ble_peripheral_s ble_per_s= { .dfu_func=NULL, .dfu_stat=false, }; // 添加私有服务时，需更改NRF_SDH_BLE_VS_UUID_COUNT static ble_uuid_t owned_adv_uuids[] = /**< ******** Universally unique service identifiers. *********/ { #if WECHAT_SERVER_ENABLED==1 {BLE_UUID_WECHAT_SERVICE, BLE_UUID_TYPE_BLE}, #else #if OWNED_SERVER_ENABLED==1 {BLE_UUID_OWNED_BASE, BLE_UUID_TYPE_BLE}, #endif #endif #if NRF_MODULE_ENABLED(BLE_MY_UARTS) {BLE_UUID_UARTS_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN}, #endif }; /**@brief Function for the Noreg GAP initialization. * * @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the * device including the device name, appearance, and the preferred connection parameters. */ static void gap_params_init(void) { ret_code_t err_code; ble_gap_conn_params_t gap_conn_params; ble_gap_conn_sec_mode_t sec_mode; #if NRF_SEC_PARAM_BLE==1 ble_opt_t passkey_opt; uint8_t passkey[] = "12345678"; #endif BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode); err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)BLE_DEVICE_NAME, strlen(BLE_DEVICE_NAME)); APP_ERROR_CHECK(err_code); memset(&gap_conn_params, 0, sizeof(gap_conn_params)); gap_conn_params.min_conn_interval = NRF_BLE_MIN_CONN_INTERVAL; gap_conn_params.max_conn_interval = NRF_BLE_MAX_CONN_INTERVAL; gap_conn_params.slave_latency = NRF_BLE_CONN_SLAVE_LATENCY; gap_conn_params.conn_sup_timeout = NRF_BLE_CONN_SUP_TIMEOUT; err_code = sd_ble_gap_ppcp_set(&gap_conn_params); APP_ERROR_CHECK(err_code); #if NRF_SEC_PARAM_BLE==1 passkey_opt.gap_opt.passkey.p_passkey = passkey; err_code = sd_ble_opt_set(BLE_GAP_OPT_PASSKEY, &passkey_opt); APP_ERROR_CHECK(err_code); #endif } //ble_gap_addr_t whitelist_addrs_gap[1]; /**@brief Function for handling Queued Write Module errors. * * @details A pointer to this function will be passed to each service which may need to inform the * application about an error. * * @param[in] nrf_error Error code containing information about what went wrong. */ static void nrf_qwr_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } #if NRF_BLE_ADVDATA_WHITELIST_ENABLE==1 /**@brief Function for setting filtered whitelist. * * @param[in] skip Filter passed to @ref pm_peer_id_list. */ static void whitelist_set(pm_peer_id_list_skip_t skip) { pm_peer_id_t peer_ids[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; uint32_t peer_id_count = BLE_GAP_WHITELIST_ADDR_MAX_COUNT; ret_code_t err_code = pm_peer_id_list(peer_ids, &peer_id_count, PM_PEER_ID_INVALID, skip); APP_ERROR_CHECK(err_code); NRF_LOG_INFO("\tm_whitelist_peer_cnt %d, MAX_PEERS_WLIST %d", peer_id_count + 1, BLE_GAP_WHITELIST_ADDR_MAX_COUNT); err_code = pm_whitelist_set(peer_ids, peer_id_count); APP_ERROR_CHECK(err_code); } #endif #if NRF_SEC_PARAM_BLE==1 /**@brief Function for setting filtered device identities. * * @param[in] skip Filter passed to @ref pm_peer_id_list. */ static void identities_set(pm_peer_id_list_skip_t skip) { pm_peer_id_t peer_ids[BLE_GAP_DEVICE_IDENTITIES_MAX_COUNT]; uint32_t peer_id_count = BLE_GAP_DEVICE_IDENTITIES_MAX_COUNT; ret_code_t err_code = pm_peer_id_list(peer_ids, &peer_id_count, PM_PEER_ID_INVALID, skip); APP_ERROR_CHECK(err_code); err_code = pm_device_identities_list_set(peer_ids, peer_id_count); APP_ERROR_CHECK(err_code); } #endif /**@brief Function for handling advertising events. * * @details This function will be called for advertising events which are passed to the application. * * @param[in] ble_adv_evt Advertising event. */ static void on_adv_evt(ble_adv_evt_t ble_adv_evt) { uint32_t err_code; switch (ble_adv_evt) { case BLE_ADV_EVT_FAST: NRF_LOG_INFO("Fast advertising"); break; #if NRF_BLE_ADVDATA_WHITELIST_ENABLE==1 case BLE_ADV_EVT_FAST_WHITELIST: NRF_LOG_INFO("Fast advertising with WhiteList"); break; case BLE_ADV_EVT_SLOW_WHITELIST: NRF_LOG_INFO("Slow advertising with WhiteList"); break; #endif case BLE_ADV_EVT_SLOW: NRF_LOG_INFO("Slow advertising"); break; case BLE_ADV_EVT_IDLE: NRF_LOG_INFO("Enter BLE Idle"); ble_adv_stat=false; break; #if NRF_BLE_ADVDATA_WHITELIST_ENABLE==1 case BLE_ADV_EVT_WHITELIST_REQUEST: { ble_gap_addr_t whitelist_addrs[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; ble_gap_irk_t whitelist_irks[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; uint32_t addr_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT; uint32_t irk_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT; err_code = pm_whitelist_get(whitelist_addrs, &addr_cnt, whitelist_irks, &irk_cnt); APP_ERROR_CHECK(err_code); NRF_LOG_DEBUG("pm_whitelist_get returns %d addr in whitelist and %d irk whitelist", addr_cnt, irk_cnt); // Set the correct identities list (no excluding peers with no Central Address Resolution). identities_set(PM_PEER_ID_LIST_SKIP_NO_IRK); // Apply the whitelist. err_code = ble_advertising_whitelist_reply(&m_advertising, whitelist_addrs, addr_cnt, whitelist_irks, irk_cnt); APP_ERROR_CHECK(err_code); break; } #endif default: break; } } #if NRF_SEC_PARAM_BLE==1 /**@brief Fetch the list of peer manager peer IDs. * * @param[inout] p_peers The buffer where to store the list of peer IDs. * @param[inout] p_size In: The size of the @p p_peers buffer. * Out: The number of peers copied in the buffer. */ static void peer_list_get(pm_peer_id_t * p_peers, uint32_t * p_size) { pm_peer_id_t peer_id; uint32_t peers_to_copy; peers_to_copy = (*p_size < NRF_BLE_ADVDATA_WHITELIST_MAX_COUNT) ? *p_size : NRF_BLE_ADVDATA_WHITELIST_MAX_COUNT; peer_id = pm_next_peer_id_get(PM_PEER_ID_INVALID); *p_size = 0; while ((peer_id != PM_PEER_ID_INVALID) && (peers_to_copy--)) { p_peers[(*p_size)++] = peer_id; peer_id = pm_next_peer_id_get(peer_id); } } /**@brief Clear bond information from persistent storage. */ static void delete_bonds(void) { ret_code_t err_code; NRF_LOG_INFO("Erase bonds!"); err_code = pm_peers_delete(); APP_ERROR_CHECK(err_code); } /**@brief Function for handling Peer Manager events. * * @param[in] p_evt Peer Manager event. */ static void pm_evt_handler(pm_evt_t const * p_evt) { ret_code_t err_code; pm_handler_on_pm_evt(p_evt); pm_handler_flash_clean(p_evt); switch (p_evt->evt_id) { case PM_EVT_CONN_SEC_SUCCEEDED: { m_peer_id = p_evt->peer_id; // Discover peer's services. err_code = ble_db_discovery_start(&m_ble_db_discovery, p_evt->conn_handle); APP_ERROR_CHECK(err_code); } break; case PM_EVT_PEERS_DELETE_SUCCEEDED: { advertising_start(); } break; case PM_EVT_CONN_SEC_CONFIG_REQ: { pm_conn_sec_config_t pm_conn; pm_conn.allow_repairing=true; pm_conn_sec_config_reply(p_evt->conn_handle,&pm_conn); break; } case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED: { // Note: You should check on what kind of white list policy your application should use. if ( p_evt->params.peer_data_update_succeeded.flash_changed && (p_evt->params.peer_data_update_succeeded.data_id == PM_PEER_DATA_ID_BONDING)) { NRF_LOG_INFO("New Bond, add the peer to the whitelist if possible"); // Note: You should check on what kind of white list policy your application should use. whitelist_set(PM_PEER_ID_LIST_SKIP_NO_ID_ADDR); } } break; default: break; } } #endif extern uint8_t bat_percent;//电池电量 extern uint8_t dev_reg_stat;//设备激活状态 #include "user_config.h" //广播初始化 uint32_t advertising_init(void) { ret_code_t ret; ble_advdata_t advdata; ble_advdata_t srdata; uint8_t adv_server_count=0; memset(&advdata, 0, sizeof(advdata)); memset(&srdata, 0, sizeof(srdata)); //设备名称类型 advdata.name_type = NRF_BLE_ADVDATA_NAME_TYPE; //是否包含外观 advdata.include_appearance = NRF_BLE_ADVDATA_INCLUDE_APPEARANCE; //Flag:一般可发现模式，不支持BR/EDR advdata.flags = NRF_BLE_ADVDATA_FLAGS; //发射功率等级 advdata.p_tx_power_level = &tx_power_level; ble_advdata_manuf_data_t manuf_data; //制造商ID，0x0059是Nordic的ID manuf_data.company_identifier = NRF_BLE_ADVDATA_COMPANY_ID; manuf_data.data.size = sizeof(ble_adv_manuf_data); //指向制造商自定义的数据 ble_adv_manuf_data adv_manuf_data={ .m_addr={0}, .product_type=NRF_DEV_PRODUCT, .dev_version=(NRF_BLE_ADV_DEV_VERSION_MAIN<<4)| NRF_BLE_ADV_DEV_VERSION_SLAVE, .dev_reg_stat=(NRF_DEV_TYPE<<4) | dev_reg_stat, .bat_percent=bat_percent }; //#ifdef user_config_param memcpy(adv_manuf_data.m_addr,m_addl_adv_manuf_data,BLE_GAP_ADDR_LEN); //#else // memcpy(adv_manuf_data.m_addr,m_addl_adv_manuf_data,BLE_GAP_ADDR_LEN); //#endif manuf_data.data.p_data = (uint8_t *)&adv_manuf_data; // manuf_data.data.size = BLE_GAP_ADDR_LEN; // manuf_data.data.p_data = m_addl_adv_manuf_data; NRF_LOG_INFO("mac addr."); NRF_LOG_HEXDUMP_INFO(manuf_data.data.p_data, manuf_data.data.size); advdata.p_manuf_specific_data=&manuf_data; // memcpy(&advdata.p_manuf_specific_data,&manuf_data,sizeof(ble_advdata_manuf_data_t)); #if NRF_BLE_ADVDATA_INCLUDE_BAT == 1 //定义服务数据结构体 ble_advdata_service_data_t service_data; //电池电量服务UUID 0x180F service_data.service_uuid = BLE_UUID_BATTERY_SERVICE; service_data.data.size = sizeof(bat_percent); service_data.data.p_data = &bat_percent; //广播数据中加入服务数据 advdata.p_service_data_array=&service_data; adv_server_count++; #endif //服务数据数量设置 advdata.service_data_count = adv_server_count; srdata.uuids_complete.uuid_cnt = sizeof(owned_adv_uuids) / sizeof(owned_adv_uuids[0]); srdata.uuids_complete.p_uuids = owned_adv_uuids; #if NRF_BLE_ADVDATA_WHITELIST_ENABLE==1 m_advertising.adv_modes_config.ble_adv_whitelist_enabled = true; #endif if(ble_adv_duration==0) { m_advertising.adv_modes_config.ble_adv_slow_interval = ble_adv_interval; m_advertising.adv_modes_config.ble_adv_slow_enabled = true; m_advertising.adv_modes_config.ble_adv_slow_timeout = ble_adv_duration; m_advertising.adv_modes_config.ble_adv_on_disconnect_disabled = false; } else{ m_advertising.adv_modes_config.ble_adv_slow_enabled = true; m_advertising.adv_modes_config.ble_adv_slow_interval = ble_adv_interval; m_advertising.adv_modes_config.ble_adv_slow_timeout = ble_adv_duration; m_advertising.adv_modes_config.ble_adv_fast_enabled = true; m_advertising.adv_modes_config.ble_adv_fast_interval = ble_adv_interval; m_advertising.adv_modes_config.ble_adv_fast_timeout = ble_adv_duration; m_advertising.adv_modes_config.ble_adv_on_disconnect_disabled = true; } m_advertising.adv_mode_current = BLE_ADV_MODE_IDLE; m_advertising.conn_cfg_tag = BLE_CONN_CFG_TAG_DEFAULT; m_advertising.evt_handler = on_adv_evt; m_advertising.error_handler = nrf_qwr_error_handler; m_advertising.current_slave_link_conn_handle = BLE_CONN_HANDLE_INVALID; m_advertising.p_adv_data = &m_advertising.adv_data; memset(&m_advertising.peer_address, 0, sizeof(m_advertising.peer_address)); // Copy advertising data. if (!m_advertising.initialized) { m_advertising.adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET; } m_advertising.adv_data.adv_data.p_data = m_advertising.enc_advdata; if (m_advertising.adv_modes_config.ble_adv_extended_enabled == true) { #ifdef BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_CONNECTABLE_MAX_SUPPORTED m_advertising.adv_data.adv_data.len = BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_CONNECTABLE_MAX_SUPPORTED; #else m_advertising.adv_data.adv_data.len = BLE_GAP_ADV_SET_DATA_SIZE_MAX; #endif // BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_CONNECTABLE_MAX_SUPPORTED } else { m_advertising.adv_data.adv_data.len = BLE_GAP_ADV_SET_DATA_SIZE_MAX; } ret = ble_advdata_encode(&advdata, m_advertising.enc_advdata, &m_advertising.adv_data.adv_data.len); VERIFY_SUCCESS(ret); m_advertising.adv_data.scan_rsp_data.p_data = m_advertising.enc_scan_rsp_data; if (m_advertising.adv_modes_config.ble_adv_extended_enabled == true) { #ifdef BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_CONNECTABLE_MAX_SUPPORTED m_advertising.adv_data.scan_rsp_data.len = BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_CONNECTABLE_MAX_SUPPORTED; #else m_advertising.adv_data.scan_rsp_data.len = BLE_GAP_ADV_SET_DATA_SIZE_MAX; #endif // BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_CONNECTABLE_MAX_SUPPORTED } else { m_advertising.adv_data.scan_rsp_data.len = BLE_GAP_ADV_SET_DATA_SIZE_MAX; } ret = ble_advdata_encode(&srdata,m_advertising.adv_data.scan_rsp_data.p_data,&m_advertising.adv_data.scan_rsp_data.len); VERIFY_SUCCESS(ret); // Configure a initial advertising configuration. The advertising data and and advertising // parameters will be changed later when we call @ref ble_advertising_start, but must be set // to legal values here to define an advertising handle. m_advertising.adv_params.primary_phy = BLE_GAP_PHY_1MBPS; m_advertising.adv_params.duration = ble_adv_duration; m_advertising.adv_params.properties.type = BLE_GAP_ADV_TYPE_CONNECTABLE_SCANNABLE_UNDIRECTED; m_advertising.adv_params.p_peer_addr = NULL; m_advertising.adv_params.filter_policy = BLE_GAP_ADV_FP_ANY; m_advertising.adv_params.interval = ble_adv_interval; ret = sd_ble_gap_adv_set_configure(&m_advertising.adv_handle, NULL, &m_advertising.adv_params); VERIFY_SUCCESS(ret); m_advertising.initialized = true; ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG); return ret; } /**@brief Function for handling the Connection Parameters Module. * * @details This function will be called for all events in the Connection Parameters Module that * are passed to the application. * * @note All this function does is to disconnect. This could have been done by simply * setting the disconnect_on_fail config parameter, but instead we use the event * handler mechanism to demonstrate its use. * * @param[in] p_evt Event received from the Connection Parameters Module. */ static void on_conn_params_evt(ble_conn_params_evt_t * p_evt) { ret_code_t err_code; if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED) { err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE); APP_ERROR_CHECK(err_code); } } /**@brief Function for handling a Connection Parameters error. * * @param[in] nrf_error Error code containing information about what went wrong. */ static void conn_params_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } //连接参数协商模块初始化 static void conn_params_init(void) { ret_code_t err_code; //定义连接参数协商模块初始化结构体 ble_conn_params_init_t cp_init; memset(&cp_init, 0, sizeof(cp_init)); //设置为NULL，从主机获取连接参数 cp_init.p_conn_params = NULL; //连接或启动通知到首次发起连接参数更新请求之间的时间设置为5秒 cp_init.first_conn_params_update_delay = NRF_BLE_FIRST_CONN_PARAMS_UPDATE_DELAY; //每次调用sd_ble_gap_conn_param_update()函数发起连接参数更新请求的之间的间隔时间设置为：30秒 cp_init.next_conn_params_update_delay = NRF_BLE_NEXT_CONN_PARAMS_UPDATE_DELAY; //放弃连接参数协商前尝试连接参数协商的最大次数设置为：3次 cp_init.max_conn_params_update_count = NRF_BLE_MAX_CONN_PARAMS_UPDATE_COUNT; //连接参数更新从连接事件开始计时 cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID; //连接参数更新失败断开连接 cp_init.disconnect_on_fail = NRF_BLE_CONN_UPDATE_FAIL_DISCONNECT; //注册连接参数更新事件句柄 cp_init.evt_handler = on_conn_params_evt; //注册连接参数更新错误事件句柄 cp_init.error_handler = conn_params_error_handler; //调用库函数（以连接参数更新初始化结构体为输入参数）初始化连接参数协商模块 err_code = ble_conn_params_init(&cp_init); APP_ERROR_CHECK(err_code); } /**@brief Function for starting advertising. */ static void advertising_start(void) { ret_code_t err_code; #if NRF_BLE_ADVDATA_WHITELIST_ENABLE==1 whitelist_set(PM_PEER_ID_LIST_SKIP_NO_ID_ADDR); #endif if(ble_adv_duration==NRF_BLE_ADV_DURATION) { err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_SLOW); } else{ err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST); } APP_ERROR_CHECK(err_code); err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_ADV,m_advertising.adv_handle,tx_power_level); APP_ERROR_CHECK(err_code); } static void advertising_stop(void) { ret_code_t err_code; err_code = sd_ble_gap_adv_stop(m_advertising.adv_handle); if(err_code != NRF_SUCCESS && err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } } #if NRF_SEC_PARAM_BLE==1 static void sec_params_init(void) { memset(&m_sec_params, 0, sizeof(ble_gap_sec_params_t)); // Security parameters to be used for all security procedures. m_sec_params.bond = NRF_SEC_PARAM_BOND; m_sec_params.mitm = NRF_SEC_PARAM_MITM; m_sec_params.lesc = NRF_SEC_PARAM_LESC; m_sec_params.keypress = NRF_SEC_PARAM_KEYPRESS; m_sec_params.io_caps = NRF_SEC_PARAM_IO_CAPABILITIES; m_sec_params.oob = NRF_SEC_PARAM_OOB; m_sec_params.min_key_size = NRF_SEC_PARAM_MIN_KEY_SIZE; m_sec_params.max_key_size = NRF_SEC_PARAM_MAX_KEY_SIZE; m_sec_params.kdist_own.enc = 1; m_sec_params.kdist_own.id = 0; m_sec_params.kdist_own.sign = 0; m_sec_params.kdist_peer.enc = 1; m_sec_params.kdist_peer.id = 0; m_sec_params.kdist_peer.sign = 0; m_sec_keyset.keys_own.p_enc_key = &m_own_enc_key; m_sec_keyset.keys_own.p_id_key = NULL; m_sec_keyset.keys_own.p_pk = NULL; m_sec_keyset.keys_own.p_sign_key = NULL; m_sec_keyset.keys_peer.p_enc_key = &m_peer_enc_key; m_sec_keyset.keys_peer.p_id_key = NULL; m_sec_keyset.keys_peer.p_pk = NULL; m_sec_keyset.keys_peer.p_sign_key = NULL; } /**@brief Function for the Peer Manager initialization. */ static void peer_manager_init(void) { ret_code_t err_code; err_code = pm_init(); APP_ERROR_CHECK(err_code); sec_params_init(); err_code = pm_sec_params_set(&m_sec_params); APP_ERROR_CHECK(err_code); err_code = pm_register(pm_evt_handler); APP_ERROR_CHECK(err_code); } #endif //蓝牙事件处理函数 void ble_peripheral_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context) { ret_code_t err_code; ble_owned_t * p_owned = (ble_owned_t *)p_context; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: NRF_LOG_INFO("maindev connected!"); // ble_timers_start(30000); m_conn_handle = p_ble_evt->evt.gattc_evt.conn_handle; // err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, p_ble_evt->evt.gattc_evt.conn_handle); // APP_ERROR_CHECK(err_code); #if NRF_SEC_PARAM_BLE==1 m_sec_params_auth.bond = 0; m_sec_params_auth.mitm = 1; sd_ble_gap_authenticate(m_conn_handle, &m_sec_params_auth);//向中心设备发送配对请求 #endif break; case BLE_GAP_EVT_DISCONNECTED: NRF_LOG_INFO("maindev disconnected!"); ble_adv_stat=false; if(ble_adv_duration==NRF_BLE_ADV_DURATION) { Peripheral_Start(); } break; case BLE_GAP_EVT_PHY_UPDATE_REQUEST: { NRF_LOG_INFO("PHY update request."); ble_gap_phys_t const phys = { .rx_phys = BLE_GAP_PHY_AUTO, .tx_phys = BLE_GAP_PHY_AUTO, }; err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys); APP_ERROR_CHECK(err_code); } break; case BLE_GAP_EVT_ADV_SET_TERMINATED: NRF_LOG_INFO("adv timeout!"); ble_adv_stat=false; if(ble_adv_duration == 0) { Peripheral_Start(); } break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: // No system attributes have been stored. err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0); APP_ERROR_CHECK(err_code); NRF_LOG_INFO("GATTS_EVT_SYS_ATTR_MISSING."); break; case BLE_GATTC_EVT_TIMEOUT: // Disconnect on GATT Client timeout event. NRF_LOG_INFO("GATT Client Timeout."); err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_TIMEOUT: // Disconnect on GATT Server timeout event. NRF_LOG_INFO("GATT Server Timeout."); err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); break; #if NRF_SEC_PARAM_BLE==1 case BLE_GAP_EVT_SEC_PARAMS_REQUEST: sec_params_init(); err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_SUCCESS, &m_sec_params, &m_sec_keyset); APP_ERROR_CHECK(err_code); break; #endif case BLE_GAP_EVT_PASSKEY_DISPLAY: NRF_LOG_INFO("passkey: %s\n",p_ble_evt->evt.gap_evt.params.passkey_display.passkey); break; #if NRF_SEC_PARAM_BLE==1 case BLE_GAP_EVT_SEC_INFO_REQUEST: sd_ble_gap_sec_info_reply(m_conn_handle, &(m_own_enc_key.enc_info), NULL, NULL); //  sec_params_display(); NRF_LOG_INFO("BLE_GAP_EVT_SEC_INFO_REQUEST\n"); break; case BLE_GAP_EVT_KEY_PRESSED: NRF_LOG_INFO("BLE_GAP_EVT_KEY_PRESSED\n"); break; case BLE_GAP_EVT_AUTH_KEY_REQUEST: NRF_LOG_INFO("BLE_GAP_EVT_AUTH_KEY_REQUEST\n"); break; case BLE_GAP_EVT_AUTH_STATUS: if(p_ble_evt->evt.gap_evt.params.auth_status.auth_status == BLE_GAP_SEC_STATUS_SUCCESS) { NRF_LOG_INFO("pair success\n"); // sec_params_display(); } else { NRF_LOG_INFO("pair error\n"); err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); } break; #endif default: // No implementation needed. break; } } void Ble_Peripheral_Init(set_dfu_func func,uint16_t **conn_handle) { ret_code_t err_code; ble_per_s.dfu_func=func; *conn_handle=&m_conn_handle; gap_params_init(); advertising_init(); conn_params_init(); #if NRF_SEC_PARAM_BLE==1 peer_manager_init(); #endif // Start execution. // NRF_LOG_INFO("Blinky example started."); advertising_start(); } void set_ble_tx_power_level(int8_t rssi) { tx_power_level=rssi; } void set_ble_adv_interval(uint32_t time) { ble_adv_interval=time; } void Peripheral_Start(void) { // if(ble_per_s.dfu_stat==true) // { // return; // } advertising_stop(); advertising_init(); advertising_start(); ble_adv_stat=true; } void Peripheral_Stop(void) { advertising_stop(); ble_adv_stat=false; } void user_ble_advertising_modes_config_set(ble_adv_modes_config_t const * const p_adv_modes_config) { ble_advertising_modes_config_set(&m_advertising, p_adv_modes_config); } #if NRF_MODULE_ENABLED(BLE_DFU) /**@snippet [Handling the data received over BLE] */ //检查是否准备好关机 bool m_ready_for_reset=true; //关机准备处理程序。在关闭过程中，将以1秒的间隔调用此函数，直到函数返回true。当函数返回true时，表示应用程序已准备好复位为DFU模式 static bool app_shutdown_handler(nrf_pwr_mgmt_evt_t event) { switch (event) { case NRF_PWR_MGMT_EVT_PREPARE_DFU: NRF_LOG_INFO("Power management wants to reset to DFU mode."); // YOUR_JOB: Get ready to reset into DFU mode // // If you aren't finished with any ongoing tasks, return "false" to // signal to the system that reset is impossible at this stage. // // Here is an example using a variable to delay resetting the device. // if (m_ready_for_reset==false) { return false; } // uint32_t err_code; // err_code = sd_softdevice_disable(); // APP_ERROR_CHECK(err_code); // err_code = app_timer_stop_all(); // APP_ERROR_CHECK(err_code); break; default: // YOUR_JOB: Implement any of the other events available from the power management module: // -NRF_PWR_MGMT_EVT_PREPARE_SYSOFF // -NRF_PWR_MGMT_EVT_PREPARE_WAKEUP // -NRF_PWR_MGMT_EVT_PREPARE_RESET return true; } NRF_LOG_INFO("Power management allowed to reset to DFU mode."); return true; } //注册优先级为0的应用程序关闭处理程序 NRF_PWR_MGMT_HANDLER_REGISTER(app_shutdown_handler, 0); //SoftDevice状态监视者 static void buttonless_dfu_sdh_state_observer(nrf_sdh_state_evt_t state, void * p_context) { if (state == NRF_SDH_EVT_STATE_DISABLED) { //表明Softdevice在复位之前已经禁用，告之bootloader启动时应跳过CRC nrf_power_gpregret2_set(BOOTLOADER_DFU_SKIP_CRC); //进入system off. nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF); } } //注册SoftDevice状态监视者，用于SoftDevice状态改变或者即将改变时接收SoftDevice事件 NRF_SDH_STATE_OBSERVER(m_buttonless_dfu_state_obs, 0) = { .handler = buttonless_dfu_sdh_state_observer, }; //获取广播模式、间隔和超时时间 static void advertising_config_get(ble_adv_modes_config_t * p_config) { memset(p_config, 0, sizeof(ble_adv_modes_config_t)); p_config->ble_adv_slow_enabled = false; p_config->ble_adv_slow_interval = NRF_BLE_ADV_INTERVAL; p_config->ble_adv_slow_timeout = NRF_BLE_ADV_DURATION; } //断开当前连接，设备准备进入bootloader之前，需要先断开连接 static void disconnect(uint16_t conn_handle, void * p_context) { UNUSED_PARAMETER(p_context); //断开当前连接 ret_code_t err_code = sd_ble_gap_disconnect(conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); if (err_code != NRF_SUCCESS) { NRF_LOG_WARNING("Failed to disconnect connection. Connection handle: %d Error: %d", conn_handle, err_code); } else { NRF_LOG_DEBUG("Disconnected connection handle %d", conn_handle); } } //DFU事件处理函数。如果需要在DFU事件中执行操作，可以在相应的事件里面加入处理代码 static void ble_dfu_evt_handler(ble_dfu_buttonless_evt_type_t event) { switch (event) { //该事件指示设备正在准备进入bootloader case BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE: { if(ble_per_s.dfu_func!=NULL) { ble_per_s.dfu_func(true); } // ble_per_s.dfu_stat=true; NRF_LOG_INFO("Device is preparing to enter bootloader mode."); //防止设备在断开连接时广播 ble_adv_modes_config_t config; advertising_config_get(&config); //连接断开后设备不自动进行广播 config.ble_adv_on_disconnect_disabled = true; //修改广播配置 ble_advertising_modes_config_set(&m_advertising, &config); //断开当前已经连接的所有其他绑定设备。在设备固件更新成功（或中止）后，需要在启动时接收服务更改指示 uint32_t conn_count = ble_conn_state_for_each_connected(disconnect, NULL); NRF_LOG_INFO("Disconnected %d links.", conn_count); break; } //该事件指示函数返回后设备即进入bootloader case BLE_DFU_EVT_BOOTLOADER_ENTER: //如果应用程序有数据需要保存到Flash，通过app_shutdown_handler返回flase以延迟复位，从而保证数据正确写入到Flash NRF_LOG_INFO("Device will enter bootloader mode."); break; //该事件指示进入bootloader失败 case BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED: //进入bootloader失败，应用程序需要采取纠正措施来处理问题 NRF_LOG_ERROR("Request to enter bootloader mode failed asynchroneously."); if(ble_per_s.dfu_func!=NULL) { ble_per_s.dfu_func(true); } else{ NVIC_SystemReset(); } break; //该事件指示发送响应失败 case BLE_DFU_EVT_RESPONSE_SEND_ERROR: NRF_LOG_ERROR("Request to send a response to client failed."); //发送响应失败，应用程序需要采取纠正措施来处理问题 APP_ERROR_CHECK(false); break; default: NRF_LOG_ERROR("Unknown event from ble_dfu_buttonless."); break; } } void dfu_service_init(void) { ret_code_t err_code; #if NRF_MODULE_ENABLED(BLE_DFU) //初始化DFU服务 //定义DFU服务初始化结构体 ble_dfu_buttonless_init_t dfus_init = {0}; // Initialize the async SVCI interface to bootloader before any interrupts are enabled. err_code = ble_dfu_buttonless_async_svci_init(); APP_ERROR_CHECK(err_code); dfus_init.evt_handler = ble_dfu_evt_handler; err_code = ble_dfu_buttonless_init(&dfus_init); APP_ERROR_CHECK(err_code); #endif } #endif