#include "ble_comm.h" #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" #include "bsp_time.h" #include "system.h" #include "app_flash.h" // <<< Use Configuration Wizard in Context Menu >>>\r\n #define APP_ADV_INTERVAL 320 /**< 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 static char DEVICE_NAME[TARFET_LEN_MAX] = "SH"; #if USE_LADDR == 1 char BleReallyName[TARFET_LEN_MAX] = {0}; #endif #define MIN_CONN_INTERVAL MSEC_TO_UNITS(7.5, UNIT_1_25_MS) /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */ #define MAX_CONN_INTERVAL MSEC_TO_UNITS(1.25 * 1599, 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) #define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN static ble_uuid_t m_adv_uuids[] = { {BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}}; static unsigned char connect_to_client = 0; static Ble_receive_handler_t Rec_h = NULL; 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; ble_gap_conn_params_t slave_conn_params = {0}; static void nrf_qwr_error_handler(uint32_t nrf_error) //?óáDD′′í?ó2ù×÷ { APP_ERROR_HANDLER(nrf_error); } //′ó BLE ?óêüêy?Y static void nus_data_handler(ble_nus_evt_t *p_evt) { if (p_evt->type == BLE_NUS_EVT_RX_DATA) { Rec_h((unsigned char *)(p_evt->params.rx_data.p_data), p_evt->params.rx_data.length); } } static void services_init(void) //·t??3?ê??ˉ { 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 on_adv_evt(ble_adv_evt_t ble_adv_evt) //1?2￥ê??t { switch (ble_adv_evt) { case BLE_ADV_EVT_FAST: { BLE_PRINT("Fast advertising.\r\n"); } break; case BLE_ADV_EVT_IDLE: { BLE_PRINT("on_adv_evt->BLE_ADV_EVT_IDLE\r\n"); ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST); //?aê?1?2￥ APP_ERROR_CHECK(err_code); } break; default: // No implementation needed. break; } } static void advertising_init(void) { uint32_t err_code; ble_advertising_init_t init; int8_t txpower = 4; 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.advdata.p_tx_power_level = &txpower; 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 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); } void advertising_start(void) { ret_code_t err_code; err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST); //同时开始广播 DEBUG_LOG("advertising_start !\r\n"); if(NRF_ERROR_INVALID_STATE != err_code){ APP_ERROR_CHECK(err_code); } } void advertising_stop(void) { ret_code_t err_code; err_code = sd_ble_gap_adv_stop(m_advertising.adv_handle); //停止广播 DEBUG_LOG("advertising_stop !\r\n"); if(NRF_ERROR_INVALID_STATE != err_code){ APP_ERROR_CHECK(err_code); } } bool ble_evt_is_advertising_timeout(ble_evt_t const *p_ble_evt) { return (p_ble_evt->header.evt_id == BLE_GAP_EVT_ADV_SET_TERMINATED); } 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; } } } #define slave_connected_evt_num_max 16 static uint8_t slave_connected_evt_num = 0; static Ble_evt_cb ble_Slave_evt_cb[slave_connected_evt_num_max] = {0}; int Ble_Slave_Connectd_Evt_Regist(Ble_evt_cb cb) { for (int i = 0; i < slave_connected_evt_num_max; i++) { if (ble_Slave_evt_cb[i] == cb) return -1; if (ble_Slave_evt_cb[i] == 0) { slave_connected_evt_num++; ble_Slave_evt_cb[i] = cb; //??μ÷oˉêy return 0; } } DEBUG_LOG( "ble_evt_Regist -> too many!\n"); return -2; } void ble_slave_connected_evt_pcs(void) { for (int i = 0; i < slave_connected_evt_num; i++) { //DEBUG_LOG("time_cb[%d]=%d\n",i,time_cb[i]); if (ble_Slave_evt_cb[i]) { ble_Slave_evt_cb[i](); //??μ÷oˉêy } } } #define slave_disconn_evt_num_max 16 static uint8_t slave_disconn_evt_num = 0; static Ble_evt_cb ble_Slave_disconn_evt_cb[slave_disconn_evt_num_max] = {0}; int Ble_Slave_Disconn_Evt_Regist(Ble_evt_cb cb) { for (int i = 0; i < slave_disconn_evt_num_max; i++) { if (ble_Slave_disconn_evt_cb[i] == cb) return -1; if (ble_Slave_disconn_evt_cb[i] == 0) { slave_disconn_evt_num++; ble_Slave_disconn_evt_cb[i] = cb; //??μ÷oˉêy return 0; } } DEBUG_LOG( "Ble_Slave_Disconn_Evt_Regist -> too many!\r\n"); return -2; } void ble_slave_dicconn_evt_pcs(void) { for (int i = 0; i < slave_disconn_evt_num; i++) { //DEBUG_LOG("time_cb[%d]=%d\n",i,time_cb[i]); if (ble_Slave_disconn_evt_cb[i]) { ble_Slave_disconn_evt_cb[i](); //??μ÷oˉêy } } } unsigned char slave_update_conn_interval_request_sta = 0; static ble_gap_phys_t const phys = { .rx_phys = BLE_GAP_PHY_1MBPS, .tx_phys = BLE_GAP_PHY_1MBPS, }; static uint8_t _7_5ms_intervalFlag =0; uint8_t Slave_Get7_5ms_interval(void){ return _7_5ms_intervalFlag; } void on_ble_peripheral_evt(ble_evt_t const *p_ble_evt) //×÷?a′óéè±?μ?′|àí { 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:{ BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_CONNECTED\r\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句柄分配 err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_CONN,m_conn_handle,4); APP_ERROR_CHECK(err_code); connect_to_client = 1; ble_slave_connected_evt_pcs(); #if 1 BLE_PRINT("PHY update request."); err_code = sd_ble_gap_phy_update(p_gap_evt->conn_handle, &phys); APP_ERROR_CHECK(err_code); #endif BLE_PRINT("Connection 0x%x Received ble gap evt data length update request.", p_ble_evt->evt.gap_evt.conn_handle); ble_gap_data_length_params_t dlp = { .max_rx_time_us= BLE_GAP_DATA_LENGTH_AUTO, .max_tx_time_us= BLE_GAP_DATA_LENGTH_AUTO, .max_rx_octets = BLE_GAP_DATA_LENGTH_AUTO, .max_tx_octets = BLE_GAP_DATA_LENGTH_AUTO, }; err_code = sd_ble_gap_data_length_update(p_ble_evt->evt.gap_evt.conn_handle, &dlp, NULL); APP_ERROR_CHECK(err_code); sd_ble_gap_rssi_start(m_conn_handle, BLE_GAP_RSSI_THRESHOLD_INVALID, 0); } break; case BLE_GAP_EVT_DISCONNECTED: connect_to_client = 0; ble_slave_dicconn_evt_pcs(); sd_ble_gap_rssi_stop(m_conn_handle); _7_5ms_intervalFlag =0; BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_DISCONNECTED,reason:%d\r\n",p_gap_evt->params.disconnected.reason); break; case BLE_GAP_EVT_PHY_UPDATE_REQUEST: { BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_PHY_UPDATE_REQUEST\r\n"); 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. BLE_PRINT("on_ble_peripheral_evt -> BLE_GATTC_EVT_TIMEOUT\r\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. BLE_PRINT("on_ble_peripheral_evt -> BLE_GATTS_EVT_TIMEOUT\r\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: { BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_CONN_PARAM_UPDATE\r\n"); slave_update_conn_interval_request_sta = 0; memcpy(&slave_conn_params, &p_gap_evt->params.conn_param_update_request.conn_params, sizeof(ble_gap_conn_params_t)); BLE_PRINT("min_conn_interval : %d * 1.25 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.min_conn_interval); BLE_PRINT("max_conn_interval : %d * 1.25 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.max_conn_interval); BLE_PRINT("slave_latency : %d\r\n", p_gap_evt->params.conn_param_update_request.conn_params.slave_latency); BLE_PRINT("conn_sup_timeout : %d * 10 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.conn_sup_timeout); if(6 == p_gap_evt->params.conn_param_update_request.conn_params.min_conn_interval && 6 == p_gap_evt->params.conn_param_update_request.conn_params.max_conn_interval) _7_5ms_intervalFlag =1; else _7_5ms_intervalFlag =0; }BLE_PRINT("_7_5ms_intervalFlag : %d\r\n", _7_5ms_intervalFlag); break; case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST: { BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST\r\n"); ble_gap_conn_params_t params; params = p_gap_evt->params.conn_param_update_request.conn_params; err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle, ¶ms); BLE_PRINT("=====>BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST error:%d\r\n",err_code); APP_ERROR_CHECK(err_code); memcpy(&slave_conn_params, &p_gap_evt->params.conn_param_update_request.conn_params, sizeof(ble_gap_conn_params_t)); BLE_PRINT("min_conn_interval : %d * 1.25 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.min_conn_interval); BLE_PRINT("max_conn_interval : %d * 1.25 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.max_conn_interval); BLE_PRINT("slave_latency : %d\r\n", p_gap_evt->params.conn_param_update_request.conn_params.slave_latency); BLE_PRINT("conn_sup_timeout : %d * 10 ms\r\n", p_gap_evt->params.conn_param_update_request.conn_params.conn_sup_timeout); } break; case BLE_GAP_EVT_RSSI_CHANGED: BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_RSSI_CHANGED\r\n"); break; case BLE_GAP_EVT_DATA_LENGTH_UPDATE_REQUEST: { BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_DATA_LENGTH_UPDATE_REQUEST\r\n"); ble_gap_data_length_params_t const dlp = { .max_rx_octets = BLE_GAP_DATA_LENGTH_AUTO, .max_tx_octets = BLE_GAP_DATA_LENGTH_AUTO, }; err_code = sd_ble_gap_data_length_update(p_ble_evt->evt.gap_evt.conn_handle, &dlp, NULL); APP_ERROR_CHECK(err_code); } break; case BLE_GAP_EVT_DATA_LENGTH_UPDATE: { BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_DATA_LENGTH_UPDATE\r\n"); BLE_PRINT("max_rx_octets : %d \r\n", p_gap_evt->params.data_length_update.effective_params.max_rx_octets); BLE_PRINT("max_rx_time_us : %d \r\n", p_gap_evt->params.data_length_update.effective_params.max_rx_time_us); BLE_PRINT("max_tx_octets : %d \r\n", p_gap_evt->params.data_length_update.effective_params.max_tx_octets); BLE_PRINT("max_tx_time_us : %d \r\n", p_gap_evt->params.data_length_update.effective_params.max_tx_time_us); } break; case BLE_GAP_EVT_ADV_SET_TERMINATED: BLE_PRINT("on_ble_peripheral_evt -> BLE_GAP_EVT_ADV_SET_TERMINATED\r\n"); break; case BLE_GATTS_EVT_HVN_TX_COMPLETE: // BLE_PRINT("on_ble_peripheral_evt -> BLE_GATTS_EVT_HVN_TX_COMPLETE\r\n"); break; case BLE_GATTS_EVT_WRITE: //D′è?2ù×÷ò??-íê3é break; case BLE_GATTC_EVT_EXCHANGE_MTU_RSP: // err_code = sd_ble_gattc_exchange_mtu_request(p_ble_evt->evt.gattc_evt.conn_handle,247); // APP_ERROR_CHECK(err_code); BLE_PRINT("on_ble_peripheral_evt -> BLE_GATTC_EVT_EXCHANGE_MTU_RSP -> server_rx_mtu = %d\r\n",p_ble_evt->evt.gattc_evt.params.exchange_mtu_rsp.server_rx_mtu); break; case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST://?÷?ú?ò′ó?úéê??mtuê±μ?ê??t { sd_ble_gatts_exchange_mtu_reply(m_conn_handle, NRF_SDH_BLE_GATT_MAX_MTU_SIZE); BLE_PRINT("on_ble_peripheral_evt -> BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST -> client_rx_mtu=%d\r\n",p_ble_evt->evt.gatts_evt.params.exchange_mtu_request.client_rx_mtu); }break; default: BLE_PRINT("on_ble_peripheral_evt -> default : 0x%2x\r\n", p_ble_evt->header.evt_id); // No implementation needed. break; } } #if USE_LADDR == 1 ble_gap_addr_t m_my_addr; char set_adv_name = 0; #endif static void gap_params_init(void) //GAP3?ê??ˉ { uint32_t err_code; ble_gap_conn_params_t gap_conn_params; ble_gap_conn_sec_mode_t sec_mode; 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 (set_adv_name == 0) { BLE_PRINT("MAC [ %02X %02X %02X %02X %02X %02X ]\r\n", m_my_addr.addr[0], m_my_addr.addr[1], m_my_addr.addr[2], m_my_addr.addr[3], m_my_addr.addr[4], m_my_addr.addr[5]); sprintf(BleReallyName, "%s_%02X%02X", DEVICE_NAME, m_my_addr.addr[4], m_my_addr.addr[5]); err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)BleReallyName, strlen(DEVICE_NAME) + 5); } else { err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)BleReallyName, strlen(BleReallyName)); } BLE_PRINT(">>>>>>>name:%d,%s",set_adv_name,BleReallyName); #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); // err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_CONN,m_conn_handle,0); // APP_ERROR_CHECK(err_code); } #if USEFIFO RINGFRAME_DEF(sbc,ringframe_size_1024); static unsigned int TIME_GetTicks_ms; unsigned int send_bytes_client(unsigned char *bytes, uint16_t len) { unsigned short length = len; if (connect_to_client) { do { if(ringframe_in(&sbc,bytes,length)==0)return 0; }while(ringframe_throw(&sbc)==0); Process_SetHoldOn(send_bytes_client_pcs,1); TIME_GetTicks_ms=TIME_GetTicks(); return 0; } else { BLE_PRINT("send_bytes_client error. connect_to_client=0\r\n"); return 1; } } //作为从机时发送数据给主机 void send_bytes_client_pcs(void) { unsigned char sbuff[256]; unsigned char len=0; while(ringframe_peek(&sbc,sbuff,&len)==0) { unsigned short length = len; uint32_t flag = 0; flag = ble_nus_data_send(&m_nus, sbuff, &length, m_conn_handle); if(flag==0)ringframe_throw(&sbc); else { if((TIME_GetTicks()-TIME_GetTicks_ms>100)||(TIME_GetTicks_ms>TIME_GetTicks())) { Process_SetHoldOn(send_bytes_client_pcs,0); } return; } } Process_SetHoldOn(send_bytes_client_pcs,0); } #else unsigned int send_bytes_client(unsigned char *bytes, uint16_t len) { unsigned int rev=0; unsigned short length = len; if (connect_to_client){ rev=ble_nus_data_send(&m_nus, bytes, &length, m_conn_handle); return rev; } else{ BLE_PRINT("send_bytes_client error. connect_to_client=0\r\n"); return 1; } } //作为从机时发送数据给主机 void send_bytes_client_pcs(void) { } #endif extern void timer_init(void); extern void power_management_init(void); extern void ble_stack_init(void); extern void gatt_init(void); extern char ble_stack_init_sta; extern uint8_t app_Get_isHost(void); #if USEMACNAME && USE_LADDR != 1 ble_gap_addr_t mAddr; #endif void slave_init(Ble_receive_handler_t receive_handler) { static unsigned char init = 1; if (init) { if (receive_handler == NULL) { BLE_PRINT("slave_init -> param err \r\n"); return; } Rec_h = receive_handler; if (ble_stack_init_sta) { timer_init(); // power_management_init(); // ble_stack_init(); // gatt_init(); // ble_stack_init_sta = 0; } #if USEMACNAME && USE_LADDR != 1 if (!app_Get_isHost()) { sd_ble_gap_addr_get(&mAddr); memset(DEVICE_NAME, 0, TARFET_LEN_MAX); sprintf(DEVICE_NAME, "%02X%02X%02X%02X%02X%02X", mAddr.addr[5], mAddr.addr[4], mAddr.addr[3], mAddr.addr[2], mAddr.addr[1], mAddr.addr[0]); } #endif gap_params_init(); services_init(); advertising_init(); conn_params_init(); advertising_start(); init = 0; #if USE_LADDR BLE_PRINT("slave_init -> name [ %s ] \r\n", BleReallyName); #else BLE_PRINT("slave_init -> name [ %s ] \r\n", DEVICE_NAME); #endif } else { BLE_PRINT("slave_init -> err slave has init done \r\n"); } } unsigned char slave_isconnect(void) { return connect_to_client; } unsigned int slave_set_adv_name(char *name, int len) { #if USE_LADDR == 1 if (len > TARFET_LEN_MAX) return APP_ERR_OVERLENGTH; set_adv_name = 1; memset(BleReallyName, 0, TARFET_LEN_MAX); memcpy(BleReallyName, name, len); #else if (len > TARFET_LEN_MAX) return APP_ERR_OVERLENGTH; memset(DEVICE_NAME, 0, TARFET_LEN_MAX); memcpy(DEVICE_NAME, name, len); #endif return APP_SUCCESS; } void slave_get_advname_len(int *len) { *len = strlen(BleReallyName); } void slave_get_advname(char *name, int len) { memcpy(name,BleReallyName,len); } void slave_disconnect(void) { if (connect_to_client) sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); } unsigned int slave_update_conn_interval_request(float min_conn_interval, float max_conn_interval) { ret_code_t err_code; ble_gap_conn_params_t bgcp; if (slave_update_conn_interval_request_sta) return APP_ERR_BUSY; if (connect_to_client) { slave_update_conn_interval_request_sta = 1; if ((max_conn_interval > 1.25 * 1599) || (max_conn_interval < min_conn_interval)) return APP_ERR_PARAMERR; if (min_conn_interval < 7.5f) return APP_ERR_PARAMERR; bgcp.max_conn_interval = MSEC_TO_UNITS(max_conn_interval, UNIT_1_25_MS); bgcp.min_conn_interval = MSEC_TO_UNITS(min_conn_interval, UNIT_1_25_MS); bgcp.conn_sup_timeout = MSEC_TO_UNITS(4000, UNIT_10_MS); bgcp.slave_latency = 0; BLE_PRINT("slave_update_conn_interval_request -> %d \r\n", bgcp.max_conn_interval); err_code = sd_ble_gap_conn_param_update(m_conn_handle, &bgcp); APP_ERROR_CHECK(err_code); return err_code; } else { return APP_ERR_DISCONN; } } void slave_get_conn_params(ble_gap_conn_params_t *p) { p->conn_sup_timeout = slave_conn_params.conn_sup_timeout; p->max_conn_interval = slave_conn_params.max_conn_interval; p->min_conn_interval = slave_conn_params.min_conn_interval; p->slave_latency = slave_conn_params.slave_latency; } void slave_adv_init(void) { gap_params_init(); //ìí?óμ?GAP3?ê??ˉ conn_params_init(); //ìí?óμ?á??ó2?êy3?ê??ˉ advertising_init(); //ìí?ó1?2￥3?ê??ˉ } static signed char rssi = 0; signed char slave_get_rssi(void) { unsigned char channel; if (connect_to_client == 0) return 1; sd_ble_gap_rssi_get(m_conn_handle, &rssi, &channel); // BLE_PRINT("rssi= %d channel=%d\r\n", rssi, channel); return rssi; } #if DEBUGBLE #define led 13 #define tx 11 //1.1 #define rx 12 //#define LS -1611916254 //?a·￠°? //#define RS -889050188 //#define LS 97376119 //31 //#define RS 627878688 //32 #define LS -1087551583 //1.1 #define RS -957332282 //1.1 #define PS -1372482754 //usb unsigned char buff[255]; char start = 0; void host_r(unsigned char *p, int len) { BLE_PRINT("hr : %d,0x%x\r\n", len, p[0]); if (p[0] == 0xbb) { BLE_PRINT("hr -------------: 0xbb\r\n"); SEGGER_RTT_Write(0, &p[1], len); } if (p[0] == 0xcc) { BLE_PRINT("hr -------------: 0xcc\r\n"); } } #define TIMER_TICK 25 #define TCUN 1000 unsigned short cun = 0; unsigned short ts = 0; unsigned short rec[5] = {0}; unsigned short recrtc[5] = {0}; unsigned int rtc_cun = 0; void slave_r(unsigned char *p, int len) { if (p[0] == 0xaa) { cun++; ts = p[1]; ts = ts << 8; ts += p[2]; if (ts >= 1) { start = 1; rtc_cun = NRF_RTC2->COUNTER; } if (ts == TCUN) start = 0; if (start) { if (NRF_RTC2->COUNTER - rtc_cun < 1 * TIMER_TICK) recrtc[0]++; if ((NRF_RTC2->COUNTER - rtc_cun >= 1 * TIMER_TICK) && (NRF_RTC2->COUNTER - rtc_cun < 2 * TIMER_TICK)) recrtc[1]++; if ((NRF_RTC2->COUNTER - rtc_cun >= 2 * TIMER_TICK) && (NRF_RTC2->COUNTER - rtc_cun < 3 * TIMER_TICK)) recrtc[2]++; if ((NRF_RTC2->COUNTER - rtc_cun >= 3 * TIMER_TICK) && (NRF_RTC2->COUNTER - rtc_cun < 4 * TIMER_TICK)) recrtc[3]++; if (NRF_RTC2->COUNTER - rtc_cun > 4 * TIMER_TICK) recrtc[4]++; rtc_cun = NRF_RTC2->COUNTER; } BLE_PRINT("sr : %d\r\n", ts); } if (p[0] == 0xbb) { buff[0] = 0xbb; int leng = sprintf(((char *)&buff[1]), "0 :%d,%d\r\n1 :%d,%d\r\n2 :%d,%d\r\n3 :%d,%d\r\n4 :%d,%d\r\n", rec[0], recrtc[0], rec[1], recrtc[1], rec[2], recrtc[2], rec[3], recrtc[3], rec[4], recrtc[4]); send_bytes_server(buff, leng); } if (p[0] == 0xcc) { BLE_PRINT("sr -------------: 0xcc\r\n"); memset(rec, 0, 10); memset(recrtc, 0, 10); send_bytes_server(p, 3); } } #include "cli.h" nrf_radio_request_t radio_request_p; APP_TIMER_DEF(s_Timer); #define TEST_PERIOD APP_TIMER_TICKS(TIMER_TICK) unsigned short tims = 0; unsigned short stp = 0; void s_TimerCallback(void *arg) { if ((tims > 0) && (tims <= TCUN)) { buff[0] = 0xaa; buff[1] = tims >> 8; buff[2] = tims; send_bytes_client(buff, 100); BLE_PRINT("send : %d\r\n", tims); tims++; } if (start) { if (cun > 4) cun = 4; rec[cun]++; cun = 0; } //·￠êy?Y??ê??ú if (*NRF_FICR->DEVICEID == LS) //×ó±?D? { if (start) { buff[0] = 0xaa; buff[1] = stp >> 8; buff[2] = stp; send_bytes_client(buff, 100); } stp++; } // nrf_gpio_pin_toggle(rx); //nrf_gpio_pin_write(rx, 0); // BLE_PRINT("error= %d\r\n", sd_radio_request(&radio_request_p)); } void Radio_State(void) { switch (NRF_RADIO->STATE) { case RADIO_STATE_STATE_Disabled: BLE_PRINT("RADIO_STATE_STATE_Disabled\r\n"); break; case RADIO_STATE_STATE_RxRu: BLE_PRINT("RADIO_STATE_STATE_RxRu\r\n"); break; case RADIO_STATE_STATE_RxIdle: BLE_PRINT("RADIO_STATE_STATE_RxIdle\r\n"); break; case RADIO_STATE_STATE_Rx: BLE_PRINT("RADIO_STATE_STATE_Rx\r\n"); break; case RADIO_STATE_STATE_RxDisable: BLE_PRINT("RADIO_STATE_STATE_RxDisable\r\n"); break; case RADIO_STATE_STATE_TxRu: BLE_PRINT("RADIO_STATE_STATE_TxRu\r\n"); break; case RADIO_STATE_STATE_TxIdle: BLE_PRINT("RADIO_STATE_STATE_TxIdle\r\n"); break; case RADIO_STATE_STATE_Tx: BLE_PRINT("RADIO_STATE_STATE_Tx\r\n"); break; case RADIO_STATE_STATE_TxDisable: BLE_PRINT("RADIO_STATE_STATE_TxDisable\r\n"); break; } } void unoioo(void) { Ble_update_conn_interval(7.5,7.5); } void unoioo_s(void) { slave_update_conn_interval_request(30, 30); scan_start(); } void unoioo_s_d(void) { host_disconnect(); scan_start(); } void rtc_config(void) { NRF_RTC2->PRESCALER = 0; //??ò?oá????êy?÷?ó1,1024us NRF_RTC2->TASKS_START = 1; } #include "nrf_drv_timer.h" void radio_evt_conf(void); const nrf_drv_timer_t TIMER_RADIO = NRF_DRV_TIMER_INSTANCE(2); void timer_led_event_handler(nrf_timer_event_t event_type, void *p_context) { if (*NRF_FICR->DEVICEID == LS) //×ó±?D? { switch (event_type) { case NRF_TIMER_EVENT_COMPARE0: //320 sd_radio_request(&radio_request_p); NRF_PPI->CHEN &= (~(PPI_CHENCLR_CH0_Enabled << PPI_CHEN_CH0_Pos) | (PPI_CHENCLR_CH1_Enabled << PPI_CHEN_CH1_Pos)); break; case NRF_TIMER_EVENT_COMPARE1: //324 sd_radio_request(&radio_request_p); break; case NRF_TIMER_EVENT_COMPARE2: //328 sd_radio_request(&radio_request_p); break; case NRF_TIMER_EVENT_COMPARE3: //332 NRF_PPI->CHEN |= (PPI_CHENCLR_CH0_Enabled << PPI_CHEN_CH0_Pos) | (PPI_CHENCLR_CH1_Enabled << PPI_CHEN_CH1_Pos); break; default: //Do nothing. break; } } if (*NRF_FICR->DEVICEID == RS) //óò±?D? { switch (event_type) { case NRF_TIMER_EVENT_COMPARE0: //320 nrf_gpio_pin_write(tx, 1); break; case NRF_TIMER_EVENT_COMPARE1: //324 nrf_gpio_pin_write(tx, 0); break; case NRF_TIMER_EVENT_COMPARE2: //328 break; case NRF_TIMER_EVENT_COMPARE3: //332 break; default: //Do nothing. break; } } } void timer_config(void) { uint32_t time_us = 5000; //Time(in miliseconds) between consecutive compare events. uint32_t time_ticks; uint32_t err_code = NRF_SUCCESS; nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG; err_code = nrf_drv_timer_init(&TIMER_RADIO, &timer_cfg, timer_led_event_handler); APP_ERROR_CHECK(err_code); if (*NRF_FICR->DEVICEID == LS) //×ó±?D? { time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_RADIO, time_us); nrf_drv_timer_extended_compare(&TIMER_RADIO, NRF_TIMER_CC_CHANNEL0, time_ticks, 0, true); time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_RADIO, time_us + 10000); nrf_drv_timer_extended_compare(&TIMER_RADIO, NRF_TIMER_CC_CHANNEL1, time_ticks, 0, true); time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_RADIO, time_us + 20000); nrf_drv_timer_extended_compare(&TIMER_RADIO, NRF_TIMER_CC_CHANNEL2, time_ticks, 0, true); time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_RADIO, 29000); nrf_drv_timer_extended_compare(&TIMER_RADIO, NRF_TIMER_CC_CHANNEL3, time_ticks, NRF_TIMER_SHORT_COMPARE3_CLEAR_MASK, true); } if (*NRF_FICR->DEVICEID == RS) //óò±?D? { time_us = 1000; time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_RADIO, time_us); nrf_drv_timer_extended_compare(&TIMER_RADIO, NRF_TIMER_CC_CHANNEL0, time_ticks, 0, true); time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_RADIO, time_us + 9000 + 1); nrf_drv_timer_extended_compare(&TIMER_RADIO, NRF_TIMER_CC_CHANNEL1, time_ticks, NRF_TIMER_SHORT_COMPARE1_CLEAR_MASK, true); nrf_drv_timer_enable(&TIMER_RADIO); } // nrf_drv_timer_enable(&TIMER_RADIO); } void ppi_set(void) { NRF_PPI->CH[0].EEP = (unsigned int)(&NRF_TIMER0->EVENTS_COMPARE[0]); NRF_PPI->CH[0].TEP = (unsigned int)(&NRF_TIMER2->TASKS_START); NRF_PPI->CH[1].EEP = (unsigned int)(&NRF_TIMER2->EVENTS_COMPARE[3]); NRF_PPI->CH[1].TEP = (unsigned int)(&NRF_TIMER2->TASKS_SHUTDOWN); NRF_PPI->CHEN |= (PPI_CHENCLR_CH0_Enabled << PPI_CHEN_CH0_Pos) | (PPI_CHENCLR_CH1_Enabled << PPI_CHEN_CH1_Pos); } extern void USR_Init(void); extern void USR_Process(void); extern void TIME_Init(void); extern char Target_scan[]; unsigned char txbuff[300] = {0x0a, 0x03, 0, 0, 2, 3, 4, 5, 6, 0, 8, 9}; unsigned char rxbuff[300] = {0}; void radio_init_R(void) { NRF_RADIO->POWER = (RADIO_POWER_POWER_Enabled << RADIO_POWER_POWER_Pos); /* Start 16 MHz crystal oscillator */ NRF_CLOCK->EVENTS_HFCLKSTARTED = 0; NRF_CLOCK->TASKS_HFCLKSTART = 1; /* Wait for the external oscillator to start up */ while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0) { // Do nothing. } // Radio config NRF_RADIO->TXPOWER = (RADIO_TXPOWER_TXPOWER_0dBm << RADIO_TXPOWER_TXPOWER_Pos); NRF_RADIO->FREQUENCY = 7UL; // Frequency bin 7, 2407MHz NRF_RADIO->MODE = (RADIO_MODE_MODE_Nrf_1Mbit << RADIO_MODE_MODE_Pos); NRF_RADIO->PREFIX0 = 0xC3438303; NRF_RADIO->PREFIX1 = 0xE3630023; NRF_RADIO->BASE0 = 0x80C4A2E6; NRF_RADIO->BASE1 = 0x91D5B3F7; NRF_RADIO->TXADDRESS = 0x00UL; // Set device address 0 to use when transmitting NRF_RADIO->RXADDRESSES = 0x01UL; // Enable device address 0 to use to select which addresses to receive NRF_RADIO->PCNF0 = 0X00030006; NRF_RADIO->PCNF1 = 0X01040020; NRF_RADIO->CRCCNF = (RADIO_CRCCNF_LEN_Two << RADIO_CRCCNF_LEN_Pos); // Number of checksum bits NRF_RADIO->CRCINIT = 0xFFFFUL; // Initial value NRF_RADIO->CRCPOLY = 0x11021UL; // CRC poly: x^16 + x^12^x^5 + 1 NRF_RADIO->PACKETPTR = (uint32_t)&txbuff[0]; } #include "nrf_drv_rtc.h" const nrf_drv_rtc_t rtc = NRF_DRV_RTC_INSTANCE(0); /**< Declaring an instance of nrf_drv_rtc for RTC2. */ unsigned int countevt = 0; void radio_connect(void) { NRF_RTC0->CC[2] = NRF_RTC0->COUNTER; countevt = 1; nrf_drv_rtc_cc_set(&rtc, 0, NRF_RTC0->CC[2] + countevt * 0.009 * 32768, true); countevt++; } void RADIO_IRQHandler(void) { if (NRF_RADIO->EVENTS_READY && (NRF_RADIO->INTENSET & RADIO_INTENSET_READY_Msk)) { NRF_RADIO->EVENTS_READY = 0U; BLE_PRINT("a"); } if (NRF_RADIO->EVENTS_ADDRESS && (NRF_RADIO->INTENSET & RADIO_INTENSET_ADDRESS_Msk)) { NRF_RADIO->EVENTS_ADDRESS = 0U; BLE_PRINT("b"); } if (NRF_RADIO->EVENTS_PAYLOAD && (NRF_RADIO->INTENSET & RADIO_INTENSET_PAYLOAD_Msk)) { NRF_RADIO->EVENTS_PAYLOAD = 0U; BLE_PRINT("c"); } if (NRF_RADIO->EVENTS_END && (NRF_RADIO->INTENSET & RADIO_INTENSET_END_Msk)) { NRF_RADIO->EVENTS_END = 0U; // NRF_LOG_INFO("d"); if (NRF_RADIO->STATE >= 5UL) { NRF_RADIO->EVENTS_DISABLED = 0U; NRF_RADIO->TASKS_DISABLE = 1U; nrf_gpio_pin_write(tx, 0); // BLE_PRINT("Tx end\r\n"); } else { //ê?μ?êy?Yoó?è?D???a·￠?í?￡ê? NRF_RTC0->CC[2] = NRF_RTC0->COUNTER; NRF_RADIO->PACKETPTR = (unsigned int)txbuff; NRF_RADIO->SHORTS = RADIO_SHORTS_READY_START_Msk; nrf_gpio_pin_write(tx, 0); NRF_RADIO->EVENTS_DISABLED = 0U; NRF_RADIO->TASKS_DISABLE = 1U; while (NRF_RADIO->EVENTS_DISABLED == 0) ; NRF_RADIO->TASKS_TXEN = 1; nrf_gpio_pin_write(tx, 1); nrf_drv_rtc_cc_set(&rtc, 0, NRF_RTC0->CC[2] + 0.010 * 32768, true); nrf_drv_rtc_cc_set(&rtc, 1, NRF_RTC0->CC[2] + 0.018 * 32768, true); for (int i = 0; i < 50; i++) { BLE_PRINT("%x", rxbuff[i]); } BLE_PRINT("Rx\r\n", rxbuff[1]); } } if (NRF_RADIO->EVENTS_DISABLED && (NRF_RADIO->INTENSET & RADIO_INTENSET_DISABLED_Msk)) { NRF_RADIO->EVENTS_DISABLED = 0U; BLE_PRINT("e"); } if (NRF_RADIO->EVENTS_DEVMATCH && (NRF_RADIO->INTENSET & RADIO_INTENSET_DEVMATCH_Msk)) { NRF_RADIO->EVENTS_DEVMATCH = 0U; BLE_PRINT("f"); } if (NRF_RADIO->EVENTS_DEVMISS && (NRF_RADIO->INTENSET & RADIO_INTENSET_DEVMISS_Msk)) { NRF_RADIO->EVENTS_DEVMISS = 0U; BLE_PRINT("g"); } if (NRF_RADIO->EVENTS_RSSIEND && (NRF_RADIO->INTENSET & RADIO_INTENSET_RSSIEND_Msk)) { NRF_RADIO->EVENTS_RSSIEND = 0U; BLE_PRINT("h"); } if (NRF_RADIO->EVENTS_BCMATCH && (NRF_RADIO->INTENSET & RADIO_INTENSET_BCMATCH_Msk)) { NRF_RADIO->EVENTS_BCMATCH = 0U; BLE_PRINT("i"); } if (NRF_RADIO->EVENTS_CRCOK && (NRF_RADIO->INTENSET & RADIO_INTENSET_CRCOK_Msk)) { NRF_RADIO->EVENTS_CRCOK = 0U; BLE_PRINT("k"); } if (NRF_RADIO->EVENTS_CRCERROR && (NRF_RADIO->INTENSET & RADIO_INTENSET_CRCERROR_Msk)) { NRF_RADIO->EVENTS_CRCERROR = 0U; BLE_PRINT("l"); } NVIC_ClearPendingIRQ(RADIO_IRQn); } void radio_scan_start(void) { NRF_RADIO->SHORTS = 0; NRF_RADIO->SHORTS |= RADIO_SHORTS_DISABLED_RXEN_Msk; NRF_RADIO->SHORTS |= RADIO_SHORTS_READY_START_Msk; NRF_RADIO->SHORTS |= RADIO_SHORTS_END_START_Msk; NRF_RADIO->INTENSET |= RADIO_INTENSET_END_Msk; NRF_RADIO->TASKS_RXEN = 1; NRF_RADIO->EVENTS_READY = 0; while (NRF_RADIO->EVENTS_READY == 0) { } NRF_RADIO->TASKS_START = 1; NVIC_EnableIRQ(RADIO_IRQn); Radio_State(); } static void rtc_handler(nrf_drv_rtc_int_type_t int_type) { switch (int_type) { case NRFX_RTC_INT_COMPARE0: nrf_gpio_pin_write(tx, 1); NRF_RADIO->SHORTS = RADIO_SHORTS_READY_START_Msk; NRF_RADIO->PACKETPTR = (unsigned int)rxbuff; NRF_RADIO->TASKS_RXEN = 1U; break; case NRFX_RTC_INT_COMPARE1: Radio_State(); BLE_PRINT("NRFX_RTC_INT_COMPARE1\r\n"); break; case NRFX_RTC_INT_COMPARE2: break; case NRFX_RTC_INT_COMPARE3: break; case NRFX_RTC_INT_TICK: break; case NRFX_RTC_INT_OVERFLOW: nrf_drv_rtc_counter_clear(&rtc); break; } } /********************************************************** * oˉêy??×?￡ortc_config * oˉêy×÷ó?￡ortc?y?ˉ3?ê??ˉoíéè?? * oˉêy2?êy￡o?T * oˉêy·μ???μ￡o?T ***********************************************************/ void radio_rtc_config(void) { uint32_t err_code; NRF_CLOCK->LFCLKSRC = (CLOCK_LFCLKSRC_SRC_RC << CLOCK_LFCLKSRC_SRC_Pos); NRF_CLOCK->EVENTS_LFCLKSTARTED = 0; NRF_CLOCK->TASKS_LFCLKSTART = 1; while (NRF_CLOCK->EVENTS_LFCLKSTARTED == 0) { // Do nothing. } //Initialize RTC instance nrf_drv_rtc_config_t config = NRF_DRV_RTC_DEFAULT_CONFIG; config.prescaler = 0; //4095;????????=32768/(config.prescaler+1)Hz; err_code = nrf_drv_rtc_init(&rtc, &config, rtc_handler); APP_ERROR_CHECK(err_code); //Enable tick event & interrupt // nrf_drv_rtc_tick_enable(&rtc, true); //Set compare channel to trigger interrupt after COMPARE_COUNTERTIME seconds // err_code = nrf_drv_rtc_cc_set(&rtc, 0, 8, true); // APP_ERROR_CHECK(err_code); //Power on RTC instance nrf_drv_rtc_enable(&rtc); } int main(void) { unsigned int error = 0; unsigned int rtctemp = 0; unsigned int start = 0; unsigned int radio_dis_cun = 0; unsigned int radio_dis_cun_rtc = 0; nrf_gpio_cfg_output(led); nrf_gpio_pin_write(led, 1); nrf_gpio_cfg_output(tx); nrf_gpio_pin_write(tx, 0); nrf_gpio_cfg_output(8); nrf_gpio_pin_write(8, 0); nrf_gpio_cfg_output(rx); nrf_gpio_pin_write(rx, 0); BLE_PRINT("NRF_FICR->DEVICEID : %d\r\n", *NRF_FICR->DEVICEID); if (*NRF_FICR->DEVICEID == RS) //óò±?D? { #if 1 slave_init(host_r); #else radio_init_R(); radio_rtc_config(); radio_scan_start(); #endif BLE_PRINT("you \r\n"); } if (*NRF_FICR->DEVICEID == LS) //×ó±?D? { #if 0 Target_scan[0]=0xe3; //3132 Target_scan[1]=0x3f; Target_scan[2]=0xd9; Target_scan[3]=0x0d; Target_scan[4]=0x0e; Target_scan[5]=0xc6; sscanf("A1 A3 9D 04 E9 F4","%hhx %hhx %hhx %hhx %hhx %hhx",&Target_scan[0],&Target_scan[1],&Target_scan[2],&Target_scan[3],&Target_scan[4],&Target_scan[5]); // Target_scan[0]=0x3C; //?a·￠°? // Target_scan[1]=0x83; // Target_scan[2]=0xCF; // Target_scan[3]=0x49; // Target_scan[4]=0x50; // Target_scan[5]=0xE1; // #endif Ble_Host_Connectd_Evt_Regist(unoioo); Ble_Slave_Connectd_Evt_Regist(unoioo_s); Ble_Slave_Disconn_Evt_Regist(unoioo_s_d); // extern void radio_request_earliest(void); // Ble_Slave_Connectd_Evt_Regist(radio_request_earliest); slave_init(host_r); host_init(slave_r); // timer_config(); BLE_PRINT("zuo \r\n"); } if (*NRF_FICR->DEVICEID == PS) //ê??ú { #if 0 Target_scan[0] = 0x21; Target_scan[1] = 0x8a; Target_scan[2] = 0x4f; Target_scan[3] = 0x61; Target_scan[4] = 0xcb; Target_scan[5] = 0xe8; #endif host_set_scan_name("SH_13EC", 7); BLE_PRINT("shou \r\n"); host_init(slave_r); scan_start(); } rtc_config(); for (int i = 1; i < 200; i++) { buff[i] = i + 0x30; // txbuff[i]=i; } app_timer_create(&s_Timer, APP_TIMER_MODE_REPEATED, s_TimerCallback); app_timer_start(s_Timer, TEST_PERIOD, NULL); // ppi_set(); while (1) { cli_process(&clirtt); if (NRF_SUCCESS == sd_evt_get(&error)) { BLE_PRINT("shou \r\n"); } // if (*NRF_FICR->DEVICEID == LS) //×ó±?D? { if (NRF_RADIO->STATE == RADIO_STATE_STATE_Disabled) { nrf_gpio_pin_write(tx, 0); } else { nrf_gpio_pin_write(tx, 1); } } } } void host_init_pcs(cli_t *p_cli, unsigned short argc, char **argv) { host_init(slave_r); } CLI_CMD_REGISTER(host_init, "clear sereen", host_init_pcs); void hsb_pcs(cli_t *p_cli, unsigned short argc, char **argv) { send_bytes_server(buff, 200); } CLI_CMD_REGISTER(hsb, "clear sereen", hsb_pcs); void send_pcs(cli_t *p_cli, unsigned short argc, char **argv) { tims = 1; } CLI_CMD_REGISTER(send, "clear sereen", send_pcs); void scc_pcs(cli_t *p_cli, unsigned short argc, char **argv) { buff[0] = 0xcc; send_bytes_client(buff, 6); } CLI_CMD_REGISTER(scc, "clear sereen", scc_pcs); void sbb_pcs(cli_t *p_cli, unsigned short argc, char **argv) { buff[0] = 0xbb; send_bytes_client(buff, 6); } CLI_CMD_REGISTER(sbb, "clear sereen", sbb_pcs); void hcb_pcs(cli_t *p_cli, unsigned short argc, char **argv) { send_bytes_client(buff, 200); } CLI_CMD_REGISTER(hcb, "clear sereen", hcb_pcs); void slave_init_pcs(cli_t *p_cli, unsigned short argc, char **argv) { slave_init(host_r); } CLI_CMD_REGISTER(slave_init, "clear sereen", slave_init_pcs); void bleupdata_pcs(cli_t *p_cli, unsigned short argc, char **argv) { unsigned int error = 0; error = Ble_update_conn_interval(10, 10); cli_printf(p_cli, "err %d", error); } CLI_CMD_REGISTER(bleupdata10, "clear sereen", bleupdata_pcs); void bleupdata_1000pcs(cli_t *p_cli, unsigned short argc, char **argv) { unsigned int error = 0; error = Ble_update_conn_interval(1000, 1000); cli_printf(p_cli, "err %d", error); } CLI_CMD_REGISTER(bleupdata1000, "clear sereen", bleupdata_1000pcs); void slaveupdata_pcs(cli_t *p_cli, unsigned short argc, char **argv) { unsigned int error = slave_update_conn_interval_request(40, 40); cli_printf(p_cli, "err %d", error); } CLI_CMD_REGISTER(slaveupdata, "clear sereen", slaveupdata_pcs); void conn_pcs(cli_t *p_cli, unsigned short argc, char **argv) { if (argc == 1) { host_set_scan_name(argv[0], strlen(argv[0])); host_init(slave_r); } else cli_printf(p_cli, "err "); } CLI_CMD_REGISTER(conn, "clear sereen", conn_pcs); void scan_name_set_pcs(cli_t *p_cli, unsigned short argc, char **argv) { if (argc == 1) { host_set_scan_name(argv[0], strlen(argv[0])); } else cli_printf(p_cli, "err "); } CLI_CMD_REGISTER(scan_name_set, "clear sereen", scan_name_set_pcs); void systemreset_pcs(cli_t *p_cli, unsigned short argc, char **argv) { NVIC_SystemReset(); } CLI_CMD_REGISTER(systemreset, "clear sereen", systemreset_pcs); void scanstart_pcs(cli_t *p_cli, unsigned short argc, char **argv) { scan_start(); } CLI_CMD_REGISTER(scanstart, "clear sereen", scanstart_pcs); void slave_dec_pcs(cli_t *p_cli, unsigned short argc, char **argv) { slave_disconnect(); } CLI_CMD_REGISTER(slave_dec, "clear sereen", slave_dec_pcs); void host_dec_pcs(cli_t *p_cli, unsigned short argc, char **argv) { host_disconnect(); } CLI_CMD_REGISTER(host_dec, "clear sereen", host_dec_pcs); void getconn_pcs(cli_t *p_cli, unsigned short argc, char **argv) { BLE_PRINT("min_conn_interval : %d * 1.25 ms\r\n", slave_conn_params.min_conn_interval); BLE_PRINT("max_conn_interval : %d * 1.25 ms\r\n", slave_conn_params.max_conn_interval); BLE_PRINT("slave_latency : %d\r\n", slave_conn_params.slave_latency); BLE_PRINT("conn_sup_timeout : %d * 10 ms\r\n", slave_conn_params.conn_sup_timeout); extern ble_gap_conn_params_t host_conn_params; BLE_PRINT("min_conn_interval : %d * 1.25 ms\r\n", host_conn_params.min_conn_interval); BLE_PRINT("max_conn_interval : %d * 1.25 ms\r\n", host_conn_params.max_conn_interval); BLE_PRINT("slave_latency : %d\r\n", host_conn_params.slave_latency); BLE_PRINT("conn_sup_timeout : %d * 10 ms\r\n", host_conn_params.conn_sup_timeout); slave_set_adv_name("123456", 6); gap_params_init(); while (slave_isconnect() == 1) { } BLE_PRINT("123456555"); advertising_start(); BLE_PRINT("4554564"); } CLI_CMD_REGISTER(getconn, "clear sereen", getconn_pcs); void slave_get_rssi_pcs(cli_t *p_cli, unsigned short argc, char **argv) { slave_get_rssi(); } CLI_CMD_REGISTER(slave_get_rssi, "clear sereen", slave_get_rssi_pcs); void host_get_rssi_pcs(cli_t *p_cli, unsigned short argc, char **argv) { host_get_rssi(); } CLI_CMD_REGISTER(host_get_rssi, "clear sereen", host_get_rssi_pcs); int teg = 0; unsigned int rtccc = 0; void radio_evt_conf(void) { NRF_RADIO->POWER = (RADIO_POWER_POWER_Enabled << RADIO_POWER_POWER_Pos); /* Start 16 MHz crystal oscillator */ NRF_CLOCK->EVENTS_HFCLKSTARTED = 0; NRF_CLOCK->TASKS_HFCLKSTART = 1; txbuff[1] = NRF_RTC0->COUNTER; txbuff[2] = teg; /* Wait for the external oscillator to start up */ while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0) { // Do nothing. } // Radio config NRF_RADIO->TXPOWER = (RADIO_TXPOWER_TXPOWER_0dBm << RADIO_TXPOWER_TXPOWER_Pos); NRF_RADIO->FREQUENCY = 7UL; // Frequency bin 7, 2407MHz NRF_RADIO->MODE = (RADIO_MODE_MODE_Nrf_1Mbit << RADIO_MODE_MODE_Pos); NRF_RADIO->PREFIX0 = 0xC3438303; NRF_RADIO->PREFIX1 = 0xE3630023; NRF_RADIO->BASE0 = 0x80C4A2E6; NRF_RADIO->BASE1 = 0x91D5B3F7; NRF_RADIO->TXADDRESS = 0x00UL; // Set device address 0 to use when transmitting NRF_RADIO->RXADDRESSES = 0x01UL; // Enable device address 0 to use to select which addresses to receive NRF_RADIO->PCNF0 = 0X00030006; NRF_RADIO->PCNF1 = 0X01040020; NRF_RADIO->CRCCNF = (RADIO_CRCCNF_LEN_Two << RADIO_CRCCNF_LEN_Pos); // Number of checksum bits NRF_RADIO->CRCINIT = 0xFFFFUL; // Initial value NRF_RADIO->CRCPOLY = 0x11021UL; // CRC poly: x^16 + x^12^x^5 + 1 NRF_RADIO->SHORTS = RADIO_SHORTS_READY_START_Enabled << RADIO_SHORTS_READY_START_Pos //READYoó×??ˉ?aê??′DDSTART | RADIO_SHORTS_END_DISABLE_Enabled << RADIO_SHORTS_END_DISABLE_Pos; // Set payload pointer NRF_RADIO->PACKETPTR = (uint32_t)&txbuff[0]; NRF_RADIO->EVENTS_DISABLED = 0; //??3y±ê???? NRF_RADIO->TASKS_TXEN = 1; //?aê?oó?á?ú2?×??o2ù×÷ while (NRF_RADIO->EVENTS_END == 0) { //μè′y·￠?ííê3é } nrf_gpio_pin_write(rx, 0); NRF_RADIO->SHORTS = 0; NRF_RADIO->EVENTS_DISABLED = 0U; NRF_RADIO->TASKS_DISABLE = 1U; while (NRF_RADIO->EVENTS_DISABLED == 0) { //μè′y1?μ?radio } NRF_RADIO->EVENTS_READY = 0U; // Enable radio and wait for ready NRF_RADIO->TASKS_RXEN = 1U; NRF_RADIO->PACKETPTR = (uint32_t)&rxbuff[0]; while (NRF_RADIO->EVENTS_READY == 0U) { // wait } nrf_gpio_pin_write(rx, 1); NRF_RADIO->EVENTS_END = 0U; // Start listening and wait for address received event NRF_RADIO->TASKS_START = 1U; // Wait for end of packet or buttons state changed for (int j = 0; j < 5000; j++) { if (NRF_RADIO->EVENTS_END == 1) break; } if (NRF_RADIO->CRCSTATUS == 1U) { for (int i = 0; i < 50; i++) { BLE_PRINT("%x", rxbuff[i]); } BLE_PRINT("\r\n "); memset(rxbuff, 0, 60); } else { BLE_PRINT("E\r\n "); } } nrf_radio_signal_callback_return_param_t call_radio_return_val; nrf_radio_signal_callback_return_param_t *call_radio(unsigned char sig) { nrf_gpio_pin_write(rx, 1); radio_evt_conf(); nrf_gpio_pin_write(rx, 0); call_radio_return_val.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_REQUEST_AND_END; return &call_radio_return_val; } void radio_session_open(void) { BLE_PRINT("error= %d\r\n", sd_radio_session_open(call_radio)); } void radio_session_open_pcs(cli_t *p_cli, unsigned short argc, char **argv) { BLE_PRINT("error= %d\r\n", sd_radio_session_open(call_radio)); } CLI_CMD_REGISTER(radio_s_open, "clear sereen", radio_session_open_pcs); void radio_session_close_pcs(cli_t *p_cli, unsigned short argc, char **argv) { BLE_PRINT("error= %d\r\n", sd_radio_session_close()); } CLI_CMD_REGISTER(radio_s_close, "clear sereen", radio_session_close_pcs); void radio_request_earliest(void) { radio_session_open(); radio_request_p.request_type = NRF_RADIO_REQ_TYPE_EARLIEST; radio_request_p.params.earliest.hfclk = NRF_RADIO_HFCLK_CFG_NO_GUARANTEE; radio_request_p.params.earliest.length_us = 4000; radio_request_p.params.earliest.priority = NRF_RADIO_PRIORITY_NORMAL; radio_request_p.params.earliest.timeout_us = 2000; BLE_PRINT("radio_request_earliest= %d\r\n", sd_radio_request(&radio_request_p)); // // radio_request_p.request_type=NRF_RADIO_REQ_TYPE_NORMAL; // radio_request_p.params.normal.hfclk=NRF_RADIO_HFCLK_CFG_XTAL_GUARANTEED; // radio_request_p.params.normal.distance_us=10000; // radio_request_p.params.normal.length_us=5000; // radio_request_p.params.normal.priority=NRF_RADIO_PRIORITY_NORMAL; } void radio_request_e_pcs(cli_t *p_cli, unsigned short argc, char **argv) { radio_request_p.request_type = NRF_RADIO_REQ_TYPE_EARLIEST; radio_request_p.params.earliest.hfclk = NRF_RADIO_HFCLK_CFG_XTAL_GUARANTEED; radio_request_p.params.earliest.length_us = 5000; radio_request_p.params.earliest.priority = NRF_RADIO_PRIORITY_NORMAL; radio_request_p.params.earliest.timeout_us = 2000; BLE_PRINT("error= %d", sd_radio_request(&radio_request_p)); } CLI_CMD_REGISTER(radio_r_e, "clear sereen", radio_request_e_pcs); void radio_request_n_pcs(cli_t *p_cli, unsigned short argc, char **argv) { radio_request_p.request_type = NRF_RADIO_REQ_TYPE_NORMAL; BLE_PRINT("error= %d", sd_radio_request(&radio_request_p)); } CLI_CMD_REGISTER(radio_r_n, "clear sereen", radio_request_n_pcs); void Radio_State_pcs(cli_t *p_cli, unsigned short argc, char **argv) { Radio_State(); } CLI_CMD_REGISTER(Radio_State, "clear sereen", Radio_State_pcs); void s100_pcs(cli_t *p_cli, unsigned short argc, char **argv) { send_bytes_client(buff, 150); } CLI_CMD_REGISTER(s100, "clear sereen", s100_pcs); #endif