#include "main.h" #include "bsp_time.h" #include "hal_ble_client.h" #include "hal_ble_host.h" static uint8_t isHostConnet = 0; //本机主机 static uint8_t isClientConnet = 0; //本机从机 //#if IS_HOST // char my_name[] = "long_S0"; //#else // char my_name[] = "long_SS0"; //#endif #define APP_BLE_CONN_CFG_TAG 1 /**< Tag that refers to the BLE stack configuration set with @ref sd_ble_cfg_set. The default tag is @ref BLE_CONN_CFG_TAG_DEFAULT. */ #define APP_BLE_OBSERVER_PRIO 3 /**< BLE observer priority of the application. There is no need to modify this value. */ #define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN /**< UUID type for the Nordic UART Service (vendor specific). */ #define ECHOBACK_BLE_UART_DATA 1 /**< Echo the UART data that is received over the Nordic UART Service (NUS) back to the sender. */ BLE_NUS_C_DEF(m_ble_nus_c); /**< BLE Nordic UART Service (NUS) client instance. */ NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */ BLE_DB_DISCOVERY_DEF(m_db_disc); /**< Database discovery module instance. */ NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */ NRF_BLE_GQ_DEF(m_ble_gatt_queue, /**< BLE GATT Queue instance. */ NRF_SDH_BLE_CENTRAL_LINK_COUNT, NRF_BLE_GQ_QUEUE_SIZE); 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. */ /**@brief Function for handling asserts in the SoftDevice. * * @details This function is called in case of an assert in the SoftDevice. * * @warning This handler is only an example and is not meant for the final product. You need to analyze * how your product is supposed to react in case of assert. * @warning On assert from the SoftDevice, the system can only recover on reset. * * @param[in] line_num Line number of the failing assert call. * @param[in] p_file_name File name of the failing assert call. */ void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name) { app_error_handler(0xDEADBEEF, line_num, p_file_name); } /**@brief Function for handling the Nordic UART Service Client errors. * * @param[in] nrf_error Error code containing information about what went wrong. */ static void nus_error_handler(uint32_t nrf_error) { //APP_ERROR_HANDLER(nrf_error); } /**@brief Function to start scanning. */ static void scan_start(void) { ret_code_t ret; ret = nrf_ble_scan_start(&m_scan); APP_ERROR_CHECK(ret); ret = bsp_indication_set(BSP_INDICATE_SCANNING); APP_ERROR_CHECK(ret); // SEGGER_RTT_printf(0,"scan_start -> scan_name <%s> \n",HOST_NAME); } /**@brief Function to stop scanning. */ //static void scan_stop(void) //{ // nrf_ble_scan_stop(); //} #define PRINT_MAC 0 /**@brief Function for handling Scanning Module events. */ static void scan_evt_handler(scan_evt_t const * p_scan_evt) { ret_code_t err_code; switch(p_scan_evt->scan_evt_id) { case NRF_BLE_SCAN_EVT_CONNECTING_ERROR: { err_code = p_scan_evt->params.connecting_err.err_code; APP_ERROR_CHECK(err_code); SEGGER_RTT_printf(0,"scan_evt_handler -> NRF_BLE_SCAN_EVT_CONNECTING_ERROR \n"); } break; case NRF_BLE_SCAN_EVT_CONNECTED: { SEGGER_RTT_printf(0,"scan_evt_handler -> NRF_BLE_SCAN_EVT_CONNECTED\n"); ble_gap_evt_connected_t const * p_connected = p_scan_evt->params.connected.p_connected; // Scan is automatically stopped by the connection. SEGGER_RTT_printf(0,"mac:%02x %02x %02x %02x %02x %02x\r\n", p_connected->peer_addr.addr[5], p_connected->peer_addr.addr[4], p_connected->peer_addr.addr[3], p_connected->peer_addr.addr[2], p_connected->peer_addr.addr[1], p_connected->peer_addr.addr[0] ); } break; case NRF_BLE_SCAN_EVT_SCAN_TIMEOUT: { SEGGER_RTT_printf(0,"scan_evt_handler -> NRF_BLE_SCAN_EVT_SCAN_TIMEOUT -> Scan timed out.\n"); scan_start(); } break; case NRF_BLE_SCAN_EVT_FILTER_MATCH: { SEGGER_RTT_printf(0,"scan_evt_handler -> NRF_BLE_SCAN_EVT_FILTER_MATCH\n"); } break; case NRF_BLE_SCAN_EVT_WHITELIST_REQUEST: { SEGGER_RTT_printf(0,"scan_evt_handler -> NRF_BLE_SCAN_EVT_WHITELIST_REQUEST\n"); } break; case NRF_BLE_SCAN_EVT_WHITELIST_ADV_REPORT: { SEGGER_RTT_printf(0,"scan_evt_handler -> NRF_BLE_SCAN_EVT_WHITELIST_ADV_REPORT\n"); } break; case NRF_BLE_SCAN_EVT_NOT_FOUND: { // SEGGER_RTT_printf(0,"scan_evt_handler -> NRF_BLE_SCAN_EVT_NOT_FOUND"); } break; default:SEGGER_RTT_printf(0,"scan_evt_handler -> default:%d \n",p_scan_evt->scan_evt_id); break; } } /**@brief Function for initializing the scanning and setting the filters. */ static void scan_init(void) { ret_code_t err_code; nrf_ble_scan_init_t init_scan; memset(&init_scan, 0, sizeof(init_scan)); init_scan.connect_if_match = true; init_scan.conn_cfg_tag = APP_BLE_CONN_CFG_TAG; err_code = nrf_ble_scan_init(&m_scan, &init_scan, scan_evt_handler); APP_ERROR_CHECK(err_code); err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_NAME_FILTER, HOST_NAME); APP_ERROR_CHECK(err_code); err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_NAME_FILTER, false); APP_ERROR_CHECK(err_code); } /**@brief Function for handling database discovery events. * * @details This function is a callback function to handle events from the database discovery module. * Depending on the UUIDs that are discovered, this function forwards the events * to their respective services. * * @param[in] p_event Pointer to the database discovery event. */ static void db_disc_handler(ble_db_discovery_evt_t * p_evt) { ble_nus_c_on_db_disc_evt(&m_ble_nus_c, p_evt); } /**@brief Function for handling app_uart events. * * @details This function receives a single character from the app_uart module and appends it to * a string. The string is sent over BLE when the last character received is a * 'new line' '\n' (hex 0x0A) or if the string reaches the maximum data length. */ //void uart_event_handle(app_uart_evt_t * p_event) //{ // unsigned char byte; // switch (p_event->evt_type) // { // /**@snippet [Handling data from UART] */ // case APP_UART_DATA_READY: // app_uart_get(&byte); // break; // /**@snippet [Handling data from UART] */ // case APP_UART_COMMUNICATION_ERROR: // //APP_ERROR_HANDLER(p_event->data.error_communication); // break; // case APP_UART_FIFO_ERROR: // //APP_ERROR_HANDLER(p_event->data.error_code); // break; // default: // break; // } //} /**@brief Callback handling Nordic UART Service (NUS) client events. * * @details This function is called to notify the application of NUS client events. * * @param[in] p_ble_nus_c NUS client handle. This identifies the NUS client. * @param[in] p_ble_nus_evt Pointer to the NUS client event. */ /**@snippet [Handling events from the ble_nus_c module] */ 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) { ret_code_t err_code; switch (p_ble_nus_evt->evt_type) { case BLE_NUS_C_EVT_DISCOVERY_COMPLETE: printf("Discovery complete.\n"); err_code = ble_nus_c_handles_assign(p_ble_nus_c, p_ble_nus_evt->conn_handle, &p_ble_nus_evt->handles); APP_ERROR_CHECK(err_code); err_code = ble_nus_c_tx_notif_enable(p_ble_nus_c); APP_ERROR_CHECK(err_code); printf("Connected to device with Nordic UART Service.\n"); break; case BLE_NUS_C_EVT_NUS_TX_EVT://作为主机接收从机的数据 BLE_Host_Push(p_ble_nus_evt->p_data, p_ble_nus_evt->data_len); //ble_receive_from_server(p_ble_nus_evt->p_data, p_ble_nus_evt->data_len); break; case BLE_NUS_C_EVT_DISCONNECTED: printf("Disconnected.\n"); scan_start(); break; } } /**@snippet [Handling events from the ble_nus_c module] */ int send_bytes_server(uint8_t * bytes, uint16_t len) { if(isHostConnet==0) return -1; if(NRF_SUCCESS != ble_nus_c_string_send(&m_ble_nus_c,bytes,len)) { SEGGER_RTT_printf(0,"send_bytes_server -> fail\r\n"); return -1; } return 0; } /** * @brief Function for handling shutdown events. * * @param[in] event Shutdown type. */ static bool shutdown_handler(nrf_pwr_mgmt_evt_t event) { ret_code_t err_code; err_code = bsp_indication_set(BSP_INDICATE_IDLE); APP_ERROR_CHECK(err_code); switch (event) { case NRF_PWR_MGMT_EVT_PREPARE_WAKEUP: // Prepare wakeup buttons. err_code = bsp_btn_ble_sleep_mode_prepare(); APP_ERROR_CHECK(err_code); break; default: break; } return true; } NRF_PWR_MGMT_HANDLER_REGISTER(shutdown_handler, APP_SHUTDOWN_HANDLER_PRIORITY); /**@brief Function for handling BLE events. * * @param[in] p_ble_evt Bluetooth stack event. * @param[in] p_context Unused. */ static void on_ble_central_evt(ble_evt_t const * p_ble_evt, void * p_context)//作为主设备时的处理 { ret_code_t err_code; ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: err_code = ble_nus_c_handles_assign(&m_ble_nus_c, p_ble_evt->evt.gap_evt.conn_handle, NULL); APP_ERROR_CHECK(err_code); err_code = bsp_indication_set(BSP_INDICATE_CONNECTED); APP_ERROR_CHECK(err_code); SEGGER_RTT_printf(0,"start discovery services\n");//添加开始发现服务提示 APP_ERROR_CHECK(err_code); // start discovery of services. The NUS Client waits for a discovery result err_code = ble_db_discovery_start(&m_db_disc, p_ble_evt->evt.gap_evt.conn_handle); APP_ERROR_CHECK(err_code); isHostConnet = 1; break; case BLE_GAP_EVT_DISCONNECTED: isHostConnet = 0; SEGGER_RTT_printf(0,"Disconnected. conn_handle: 0x%x, reason: 0x%x", p_gap_evt->conn_handle, p_gap_evt->params.disconnected.reason); printf("Disconnected to Server.\n"); break; case BLE_GAP_EVT_TIMEOUT: if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN) { SEGGER_RTT_printf(0,"Connection Request timed out.\n"); } break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: // Pairing not supported. 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); APP_ERROR_CHECK(err_code); SEGGER_RTT_printf(0,"on_ble_central_evt -> BLE_GAP_EVT_SEC_PARAMS_REQUEST\n"); break; case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST: // Accepting parameters requested by peer. err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle, &p_gap_evt->params.conn_param_update_request.conn_params);//主机接受从机连接参数更新连接参数 APP_ERROR_CHECK(err_code); SEGGER_RTT_printf(0,"on_ble_central_evt -> BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST\n"); break; case BLE_GAP_EVT_CONN_PARAM_UPDATE: SEGGER_RTT_printf(0,"on_ble_central_evt -> BLE_GAP_EVT_CONN_PARAM_UPDATE\n"); SEGGER_RTT_printf(0,"min_conn_interval : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.min_conn_interval); SEGGER_RTT_printf(0,"max_conn_interval : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.max_conn_interval); SEGGER_RTT_printf(0,"slave_latency : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.slave_latency); SEGGER_RTT_printf(0,"conn_sup_timeout : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.conn_sup_timeout); break; case BLE_GAP_EVT_PHY_UPDATE_REQUEST: { NRF_LOG_DEBUG("PHY update request.\n"); 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_GATTC_EVT_TIMEOUT: // Disconnect on GATT Client timeout event. NRF_LOG_DEBUG("GATT Client Timeout.\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; case BLE_GATTS_EVT_TIMEOUT: // Disconnect on GATT Server timeout event. NRF_LOG_DEBUG("GATT Server Timeout.\n"); 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; default: break; } } /**@brief Function for handling events from the GATT library. */ void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt) { if (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED) { printf("ATT MTU exchange completed.\r\n"); m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH; printf("Ble NUS max data length set to 0x%X(%d)\r\n", m_ble_nus_max_data_len, m_ble_nus_max_data_len); } } /**@brief Function for initializing the GATT library. */ void gatt_init(void) { ret_code_t err_code; err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler); APP_ERROR_CHECK(err_code); err_code = nrf_ble_gatt_att_mtu_central_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE); APP_ERROR_CHECK(err_code); } /**@brief Function for handling events from the BSP module. * * @param[in] event Event generated by button press. */ void bsp_event_handler(bsp_event_t event) { ret_code_t err_code; switch (event) { case BSP_EVENT_SLEEP: nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF); break; case BSP_EVENT_DISCONNECT: err_code = sd_ble_gap_disconnect(m_ble_nus_c.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); if (err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } break; default: break; } } /**@brief Function for initializing the UART. */ //static void uart_init(void) //{ // #ifdef USE_REGISTER_UART // bsp_uart_init(ble_receive_from_uart); // #else // ret_code_t err_code; // app_uart_comm_params_t const comm_params = // { // .rx_pin_no = PIN_RXD_BLE, // .tx_pin_no = PIN_TXD_BLE, // .rts_pin_no = RTS_PIN_NUMBER, // .cts_pin_no = CTS_PIN_NUMBER, // .flow_control = APP_UART_FLOW_CONTROL_DISABLED, // .use_parity = false, // .baud_rate = UART_BAUDRATE_BAUDRATE_Baud115200 // }; // APP_UART_FIFO_INIT(&comm_params, // UART_RX_BUF_SIZE, // UART_TX_BUF_SIZE, // uart_event_handle, // APP_IRQ_PRIORITY_LOWEST, // err_code); // APP_ERROR_CHECK(err_code); // #endif //} /**@brief Function for initializing the Nordic UART Service (NUS) client. */ static void nus_c_init(void) { ret_code_t err_code; ble_nus_c_init_t init; init.evt_handler = ble_nus_c_evt_handler; init.error_handler = nus_error_handler; init.p_gatt_queue = &m_ble_gatt_queue; err_code = ble_nus_c_init(&m_ble_nus_c, &init); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing buttons and leds. */ //static void buttons_leds_init(void) //{ // ret_code_t err_code; // bsp_event_t startup_event; // err_code = bsp_init(BSP_INIT_LEDS, bsp_event_handler); // APP_ERROR_CHECK(err_code); // err_code = bsp_btn_ble_init(NULL, &startup_event); // APP_ERROR_CHECK(err_code); //} /**@brief Function for initializing the timer. */ static void timer_init(void) { ret_code_t err_code = app_timer_init(); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing the nrf log module. */ //static void log_init(void) //{ // ret_code_t err_code = NRF_LOG_INIT(NULL); // APP_ERROR_CHECK(err_code); // NRF_LOG_DEFAULT_BACKENDS_INIT(); //} /**@brief Function for initializing power management. */ static void power_management_init(void) { ret_code_t err_code; err_code = nrf_pwr_mgmt_init(); APP_ERROR_CHECK(err_code); } /** @brief Function for initializing the database discovery module. */ static void db_discovery_init(void) { ble_db_discovery_init_t db_init; memset(&db_init, 0, sizeof(ble_db_discovery_init_t)); db_init.evt_handler = db_disc_handler; db_init.p_gatt_queue = &m_ble_gatt_queue; ret_code_t err_code = ble_db_discovery_init(&db_init); APP_ERROR_CHECK(err_code); } /**@brief Function for handling the idle state (main loop). * * @details Handles any pending log operations, then sleeps until the next event occurs. */ //static void idle_state_handle(void) //{ // if (NRF_LOG_PROCESS() == false) // { // nrf_pwr_mgmt_run(); // } //} //********************************* 从机初始化 *********************************// #include "ble_advertising.h" #include "ble_conn_params.h" #include "nrf_ble_qwr.h" #include "nrf_fstorage.h" #include "nrf_soc.h" #include "ble_nus.h" #define APP_ADV_INTERVAL 300 /**< The advertising interval (in units of 0.625 ms). This value corresponds to 187.5 ms. */ #define APP_ADV_DURATION 18000 /**< The advertising duration (180 seconds) in units of 10 milliseconds. */ #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(1000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */ #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 (30 seconds). */ #define MAX_CONN_PARAMS_UPDATE_COUNT 1 //#if IS_HOST // #define DEVICE_NAME "00_test" //#else // #define DEVICE_NAME "long_S0" //#endif //#define DEVICE_NAME "00_test" #define MIN_CONN_INTERVAL MSEC_TO_UNITS(20, UNIT_1_25_MS) /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */ #define MAX_CONN_INTERVAL MSEC_TO_UNITS(75, UNIT_1_25_MS) /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */ #define SLAVE_LATENCY 0 /**< Slave latency. */ #define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifier. */ { {BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE} }; BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT); BLE_ADVERTISING_DEF(m_advertising); NRF_BLE_QWRS_DEF(m_qwr, NRF_SDH_BLE_TOTAL_LINK_COUNT); uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; static void on_adv_evt(ble_adv_evt_t ble_adv_evt)//广播事件 { switch (ble_adv_evt) { case BLE_ADV_EVT_FAST: { SEGGER_RTT_printf(0,"Fast advertising.\n"); } break; case BLE_ADV_EVT_IDLE: { SEGGER_RTT_printf(0,"on_adv_evt->BLE_ADV_EVT_IDLE\n"); ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);//开始广播 APP_ERROR_CHECK(err_code); } break; default: // No implementation needed. break; } } static void multi_qwr_conn_handle_assign(uint16_t conn_handle) { for (uint32_t i = 0; i < NRF_SDH_BLE_TOTAL_LINK_COUNT; i++) { if (m_qwr[i].conn_handle == BLE_CONN_HANDLE_INVALID) { ret_code_t err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr[i], conn_handle); APP_ERROR_CHECK(err_code); break; } } } static void on_ble_peripheral_evt(ble_evt_t const * p_ble_evt)//作为从设备的处理 { ret_code_t err_code; ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GAP_EVT_CONNECTED\n"); m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle; multi_qwr_conn_handle_assign(p_ble_evt->evt.gap_evt.conn_handle);//QWR句柄分配 isClientConnet = 1; break; case BLE_GAP_EVT_DISCONNECTED: isClientConnet = 0; SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GAP_EVT_DISCONNECTED\n"); break; case BLE_GAP_EVT_PHY_UPDATE_REQUEST: { SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GAP_EVT_PHY_UPDATE_REQUEST\n"); 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_GATTC_EVT_TIMEOUT: // Disconnect on GATT Client timeout event. SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GATTC_EVT_TIMEOUT\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; case BLE_GATTS_EVT_TIMEOUT: // Disconnect on GATT Server timeout event. SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GATTS_EVT_TIMEOUT\n"); 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; case BLE_GAP_EVT_CONN_PARAM_UPDATE: SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GAP_EVT_CONN_PARAM_UPDATE\n"); SEGGER_RTT_printf(0,"min_conn_interval : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.min_conn_interval); SEGGER_RTT_printf(0,"max_conn_interval : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.max_conn_interval); SEGGER_RTT_printf(0,"slave_latency : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.slave_latency); SEGGER_RTT_printf(0,"conn_sup_timeout : %d\n",p_gap_evt->params.conn_param_update_request.conn_params.conn_sup_timeout); break; case BLE_GATTC_EVT_EXCHANGE_MTU_RSP: SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GATTC_EVT_EXCHANGE_MTU_RSP\n"); break; case BLE_GAP_EVT_DATA_LENGTH_UPDATE: SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GAP_EVT_DATA_LENGTH_UPDATE\n"); break; case BLE_GAP_EVT_ADV_SET_TERMINATED: SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> BLE_GAP_EVT_ADV_SET_TERMINATED\n"); break; case BLE_GATTS_EVT_HVN_TX_COMPLETE: NRF_LOG_DEBUG("on_ble_peripheral_evt -> BLE_GATTS_EVT_HVN_TX_COMPLETE\n"); break; case BLE_GATTS_EVT_WRITE: NRF_LOG_DEBUG("on_ble_peripheral_evt -> BLE_GATTS_EVT_WRITE\n"); break; default:SEGGER_RTT_printf(0,"on_ble_peripheral_evt -> default : 0x%2x\n",p_ble_evt->header.evt_id); // No implementation needed. break; } } 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)); cp_init.p_conn_params = NULL; cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY; cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY; cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT; cp_init.start_on_notify_cccd_handle = BLE_CONN_HANDLE_INVALID; // Start upon connection. cp_init.disconnect_on_fail = true; cp_init.evt_handler = NULL; // Ignore events. cp_init.error_handler = conn_params_error_handler; err_code = ble_conn_params_init(&cp_init); APP_ERROR_CHECK(err_code); } static void nrf_qwr_error_handler(uint32_t nrf_error)//队列写错误操作 { APP_ERROR_HANDLER(nrf_error); } //从 BLE 接受数据 static void nus_data_handler(ble_nus_evt_t * p_evt) { if (p_evt->type == BLE_NUS_EVT_RX_DATA) { BLE_Client_Push((unsigned char*)(p_evt->params.rx_data.p_data), p_evt->params.rx_data.length); } } void ble_nus_send_buff(uint8_t *p,uint16_t len) { if(isClientConnet==0) return; ble_nus_data_send(&m_nus, p, &len, m_conn_handle); } static void services_init(void)//服务初始化 { uint32_t err_code; ble_nus_init_t nus_init; nrf_ble_qwr_init_t qwr_init = {0}; // Initialize Queued Write Module. qwr_init.error_handler = nrf_qwr_error_handler; for (uint32_t i = 0; i < NRF_SDH_BLE_TOTAL_LINK_COUNT; i++) { err_code = nrf_ble_qwr_init(&m_qwr[i], &qwr_init); APP_ERROR_CHECK(err_code); } // Initialize NUS. memset(&nus_init, 0, sizeof(nus_init)); nus_init.data_handler = nus_data_handler; err_code = ble_nus_init(&m_nus, &nus_init); APP_ERROR_CHECK(err_code); } static void gap_params_init(void)//GAP初始化 { uint32_t err_code; ble_gap_conn_params_t gap_conn_params; ble_gap_conn_sec_mode_t sec_mode; #if USE_LADDR == 1 ble_gap_addr_t m_my_addr; char BleReallyName[30]={0}; #endif BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode); #if USE_LADDR == 1 err_code = sd_ble_gap_addr_get(&m_my_addr); APP_ERROR_CHECK(err_code); #if PROJECT_SLECT == 8 sprintf(BleReallyName,"%s_L%02X%02X",DEVICE_NAME,m_my_addr.addr[1],m_my_addr.addr[0]); #endif #if PROJECT_SLECT == 9 sprintf(BleReallyName,"%s_R%02X%02X",DEVICE_NAME,m_my_addr.addr[1],m_my_addr.addr[0]); #endif err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *) BleReallyName, strlen(DEVICE_NAME)+7); #else err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *) DEVICE_NAME, strlen(DEVICE_NAME)); #endif APP_ERROR_CHECK(err_code); memset(&gap_conn_params, 0, sizeof(gap_conn_params)); gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL; gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL; gap_conn_params.slave_latency = SLAVE_LATENCY; gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT; err_code = sd_ble_gap_ppcp_set(&gap_conn_params); APP_ERROR_CHECK(err_code); } static void advertising_init(void) { uint32_t err_code; ble_advertising_init_t init; memset(&init, 0, sizeof(init)); init.advdata.name_type = BLE_ADVDATA_FULL_NAME; init.advdata.include_appearance = false; init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE; init.srdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]); init.srdata.uuids_complete.p_uuids = m_adv_uuids; init.config.ble_adv_fast_enabled = true; init.config.ble_adv_fast_interval = APP_ADV_INTERVAL; init.config.ble_adv_fast_timeout = APP_ADV_DURATION; init.evt_handler = on_adv_evt; err_code = ble_advertising_init(&m_advertising, &init); APP_ERROR_CHECK(err_code); ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG); } //static void adv_scan_start(void) //{ //#if BLESLAVE // ret_code_t err_code; //#endif // //check if there are no flash operations in progress // if (!nrf_fstorage_is_busy(NULL)) // { // // Start scanning for peripherals and initiate connection to devices which // // advertise Heart Rate or Running speed and cadence UUIDs. //#if BLEHOST // scan_start();//开始扫描 //#endif // // Start advertising. //#if BLESLAVE // err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);//同时开始广播 // APP_ERROR_CHECK(err_code); //#endif // } //} void advertising_start(void) { #if BLESLAVE ret_code_t err_code; err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);//同时开始广播 APP_ERROR_CHECK(err_code); #endif } void senduart(unsigned char* bytes,int len) { for(int i=0;iheader.evt_id == BLE_GAP_EVT_ADV_SET_TERMINATED); } /**@brief Function for handling BLE events. * * @param[in] p_ble_evt Bluetooth stack event. * @param[in] p_context Unused. */ static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) { uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle; uint16_t role = ble_conn_state_role(conn_handle); // Based on the role this device plays in the connection, dispatch to the right handler.不同角色下所做的处理 if (role == BLE_GAP_ROLE_PERIPH || ble_evt_is_advertising_timeout(p_ble_evt)) { // ble_nus_on_ble_evt(p_ble_evt, &m_nus); on_ble_peripheral_evt(p_ble_evt); } else if ((role == BLE_GAP_ROLE_CENTRAL) || (p_ble_evt->header.evt_id == BLE_GAP_EVT_ADV_REPORT)) { // ble_nus_c_on_ble_evt(p_ble_evt, &m_ble_nus_c); on_ble_central_evt(p_ble_evt,NULL); } else { SEGGER_RTT_printf(0,"ble_evt_handler -> other\n"); } } /**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. */ static void ble_stack_init(void) { ret_code_t err_code; err_code = nrf_sdh_enable_request(); APP_ERROR_CHECK(err_code); // Configure the BLE stack using the default settings. // Fetch the start address of the application RAM. uint32_t ram_start = 0; err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start); APP_ERROR_CHECK(err_code); // Enable BLE stack. err_code = nrf_sdh_ble_enable(&ram_start); APP_ERROR_CHECK(err_code); // Register a handler for BLE events. NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL); } uint8_t BLE_Client_Isconneted(void) { return isClientConnet; } uint8_t BLE_Host_Isconneted(void) { return isHostConnet; } int8_t sd_ble_gap_rssi_get_user(void) { int8_t rssi =0; unsigned char pch_chan=0; sd_ble_gap_rssi_get(m_ble_nus_c.conn_handle, &rssi,&pch_chan); return rssi; } extern void PRE_Init(void); extern void USR_Init(void); extern void USR_Process(void); int main(void) { // log_init(); PRE_Init(); //用户初始化 timer_init(); TIME_Init(); // uart_init(); db_discovery_init(); power_management_init(); ble_stack_init(); gatt_init(); nus_c_init(); scan_init(); scan_start();//开始扫描 SEGGER_RTT_printf(0,"Uart BLE_Host started.\r\n"); Advertising_Config(); ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST); SEGGER_RTT_printf(0,"Uart BLE_Slave started.\r\n"); USR_Init(); //用户初始化 while (1) { USR_Process(); } }