#include #include #include "nordic_common.h" #include "nrf_drv_spis.h" #include "nrf.h" #include "ble_hci.h" #include "ble_advdata.h" #include "ble_advertising.h" #include "ble_conn_params.h" #include "softdevice_handler.h" #include "app_timer.h" #include "ble_nus.h" #include "app_uart.h" #include "app_util_platform.h" #include "pstorage.h" #include "type.h" #include "queue.h" #include "ver.h" #include "spi.h" #include "flash.h" #include "nrf_delay.h" #include "main.h" #include "ble.h" #include "ble_db_discovery.h" #include "ble_conn_state.h" #include "dtm.h" #include "bsp.h" #include "proc.h" #include "led.h" #include "timer.h" #include "sys_lib.h" #include "wdg.h" #define CENTRAL_LINK_COUNT 0 /**< Number of central links used by the application. When changing this number remember to adjust the RAM settings*/ #define PERIPHERAL_LINK_COUNT 1 /**< Number of peripheral links used by the application. When changing this number remember to adjust the RAM settings*/ #define APP_ADV_TIMEOUT_IN_SECONDS 0 /**< The advertising timeout (in units of seconds). */ #define APP_TIMER_PRESCALER 0 /**< Value of the RTC1 PRESCALER register. */ #define APP_TIMER_OP_QUEUE_SIZE 4 /**< Size of timer operation queues. */ #define MIN_CONN_INTERVAL MSEC_TO_UNITS(16, UNIT_1_25_MS) /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */ #define MAX_CONN_INTERVAL MSEC_TO_UNITS(50, 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) /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */ #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER) /**< 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(30000, APP_TIMER_PRESCALER) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */ #define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */ #define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */ #define COMPANY_IDENTIFIER 0x0013 #define TX_POWER_LEVEL 4 #define APP_USER_DATA_LENGTH 60 #define BLE_ADV_NAME_DEFAULT "13dog" #define TIMER_GAP 1 //定时器最小定时间隔为1ms #define TICK_TIMER_INTERVAL APP_TIMER_TICKS(TIMER_GAP, APP_TIMER_PRESCALER) #define BLE_MAC_ADDR_LEN 6 static ble_nus_t m_nus; /**< Structure to identify the Nordic UART Service. */ uint16_t g_s_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */ static ble_uuid_t m_adv_uuids[] = {{BLE_UUID_NUS_SERVICE, BLE_UUID_TYPE_BLE}}; /**< Universally unique service identifier. */ uint16_t g_s_ble_adv_interval = 320; //蓝牙广播间隔 static uint8_t g_s_led_timer_handle = 0xFF; static uint8_t g_s_report_ver_timer_handle = 0xFF; APP_TIMER_DEF(tick_check_timer_handle); queue_list_t g_s_app_msg_send_list; queue_list_t g_s_spi_msg_send_list; queue_list_t g_s_spi_msg_recv_list; static void led_timer_start(void); static void led_timer_stop(void); static void report_ver_timer_stop(void); /*user data store in flash,the sequence must can't change,structure is: little endian except mac address 4 Bytes 32 Bytes 4 Bytes 4 Bytes 8 Bytes 8 Bytes _____________|________________|______________|______________|____________|____________| | | | | | FILE_SIZE ADV_INFO ADV_INTERVAL OTA_FLAG NAME MAC */ __align(4) uint8_t user_data_in_flash[APP_USER_DATA_LENGTH] = { 0x70,0x3E,0,0, 0xE4, 0xE2, 0x47, 0x6B, 0xA7, 0x5A, 0x01, 0x60, 0x01, 0x01, 0x10,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0x40,0x01,0x00,0x00, 0,0,0,0, '1', '3', 'd', 'o', 'g', 0, 0, 0, 0x24, 0xF1, 0x50, 0x12, 0x34, 0x56, 0, 0 }; /********************************************/ uint8_t adv_change_flag; uint8_t adv_interval_change_flag; uint8_t reboot_reason[20]; uint8_t dtm_flag; static void print_log_timer_callback() { static uint32_t run_second; run_second += 5; DLOG("ble run seconds:%ds", run_second); if(60*60*24*7 == run_second) { run_second = 0; } } static void report_ver_timer_callback() { DLOG("report ver now"); spis_version_report(); } static void led_toggle_timer_callback() { led_toggle(LED_GREEN); } void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name) { app_error_handler(DEAD_BEEF, line_num, p_file_name); } static void gap_params_init(void) { uint32_t err_code; ble_gap_conn_params_t gap_conn_params; ble_gap_conn_sec_mode_t sec_mode; int len = strlen((const char *)&user_data_in_flash[ADV_NEME_OFFSET]); len = (len>8) ? 8 : len; BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode); DLOG("set ble name:%s", &user_data_in_flash[ADV_NEME_OFFSET]); err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)&user_data_in_flash[ADV_NEME_OFFSET], len); 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(TX_POWER_LEVEL); APP_ERROR_CHECK(err_code); } static void nus_data_handler(ble_nus_t * p_nus, uint8_t * p_data, uint16_t length) { DLOG("ble_rx_data:%s,len:%d", SYS_LibHex2Str(p_data, length), length); spis_transfer_data(BLE_CMD_TRANSFER, p_data, length); } static void services_init(void) { uint32_t err_code; ble_nus_init_t nus_init; 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_conn_params_evt(ble_conn_params_evt_t * p_evt) { uint32_t err_code; if(p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED) { err_code = sd_ble_gap_disconnect(g_s_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE); APP_ERROR_CHECK(err_code); } } static void conn_params_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } static void conn_params_init(void) { uint32_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_GATT_HANDLE_INVALID; cp_init.disconnect_on_fail = false; 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); } static void on_adv_evt(ble_adv_evt_t ble_adv_evt) { switch (ble_adv_evt) { case BLE_ADV_EVT_FAST: break; case BLE_ADV_EVT_IDLE: break; default: break; } } static void on_ble_evt(ble_evt_t * p_ble_evt) { uint32_t err_code; uint8_t mac[10]; const 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: DLOG("ble connected,handle:%d", p_gap_evt->conn_handle); led_timer_stop(); g_s_conn_handle = p_ble_evt->evt.gap_evt.conn_handle; memset(mac, 0, 10); mac[0] = 0; mac[1] = TAG_DL_MAC; mac[2] = 0; mac[3] = 6; mac[4] = p_ble_evt->evt.gap_evt.params.connected.peer_addr.addr[5]; mac[5] = p_ble_evt->evt.gap_evt.params.connected.peer_addr.addr[4]; mac[6] = p_ble_evt->evt.gap_evt.params.connected.peer_addr.addr[3]; mac[7] = p_ble_evt->evt.gap_evt.params.connected.peer_addr.addr[2]; mac[8] = p_ble_evt->evt.gap_evt.params.connected.peer_addr.addr[1]; mac[9] = p_ble_evt->evt.gap_evt.params.connected.peer_addr.addr[0]; spis_transfer_data(BLE_CMD_CONNECT, mac, 10); break; case BLE_GAP_EVT_DISCONNECTED: DLOG("ble disconnected,handle:%d,reason:0x%x", p_gap_evt->conn_handle, p_gap_evt->params.disconnected.reason); led_timer_start(); g_s_conn_handle = BLE_CONN_HANDLE_INVALID; spis_transfer_data(BLE_CMD_DISCONNECT, NULL, 0); break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: err_code = sd_ble_gap_sec_params_reply(g_s_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: err_code = sd_ble_gatts_sys_attr_set(g_s_conn_handle, NULL, 0, 0); APP_ERROR_CHECK(err_code); break; case BLE_EVT_TX_COMPLETE: break; case BLE_GAP_EVT_ADV_REPORT: break; case BLE_GAP_EVT_TIMEOUT: break; default: break; } } static void ble_evt_dispatch(ble_evt_t * p_ble_evt) { ble_conn_params_on_ble_evt(p_ble_evt); ble_nus_on_ble_evt(&m_nus, p_ble_evt); on_ble_evt(p_ble_evt); ble_advertising_on_ble_evt(p_ble_evt); } static void sys_evt_dispatch(uint32_t sys_evt) { pstorage_sys_event_handler(sys_evt); ble_advertising_on_sys_evt(sys_evt); } static void ble_stack_init(void) { uint32_t err_code; nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC; // Initialize SoftDevice. SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL); ble_enable_params_t ble_enable_params; err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT,&ble_enable_params); APP_ERROR_CHECK(err_code); //Check the ram settings against the used number of links CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT); // Enable BLE stack. ble_enable_params.common_enable_params.vs_uuid_count = 3; err_code = softdevice_enable(&ble_enable_params); APP_ERROR_CHECK(err_code); // Subscribe for BLE events. err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch); APP_ERROR_CHECK(err_code); err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch); APP_ERROR_CHECK(err_code); } void advertising_init() { uint32_t err_code; ble_advdata_t advdata; ble_advdata_t scanrsp; ble_advdata_manuf_data_t adv_manuf_specific_data; uint8_t ble_mac_addr[BLE_MAC_ADDR_LEN]; memcpy(ble_mac_addr, &user_data_in_flash[BLE_MAC_OFFSET], BLE_MAC_ADDR_LEN); adv_manuf_specific_data.company_identifier = COMPANY_IDENTIFIER; adv_manuf_specific_data.data.p_data = ble_mac_addr; adv_manuf_specific_data.data.size = sizeof(ble_mac_addr); memset(&advdata, 0, sizeof(advdata)); advdata.name_type = BLE_ADVDATA_FULL_NAME; advdata.include_appearance = false; advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE; advdata.p_manuf_specific_data = &adv_manuf_specific_data; memset(&scanrsp, 0, sizeof(scanrsp)); scanrsp.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]); scanrsp.uuids_complete.p_uuids = m_adv_uuids; ble_adv_modes_config_t options = {0}; options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED; options.ble_adv_fast_interval = g_s_ble_adv_interval; options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS; DLOG("set ble adv interval:%d", g_s_ble_adv_interval); err_code = ble_advertising_init(&advdata, &scanrsp, &options, on_adv_evt, NULL); APP_ERROR_CHECK(err_code); if(NRF_SUCCESS == err_code) { DLOG("ble advertising success"); } else { DLOG("ble advertising fail"); } } void Hal_BleSendDatas(uint8_t* data, uint8_t len) { uint8_t i = 0; uint8_t row = len / 20; uint8_t col = len % 20; uint32_t err_code; if(g_s_conn_handle == BLE_CONN_HANDLE_INVALID) { DLOG("ble disconnected"); return; } DLOG("ble_tx_data:%s,len:%d", SYS_LibHex2Str(data, len), len); while(i < row) { err_code = ble_nus_string_send(&m_nus, &data[i*20], 20); i++; if (err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } } if(col > 0) { err_code = ble_nus_string_send(&m_nus, &data[i*20], col); if (err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } } } int ble_configure_all(uint8_t* data, uint16_t len) { uint16_t change = 0, ret; uint8_t name_mac[16]; uint32_t interval; report_ver_timer_stop(); NRF_LOG_PRINTF("rx ble cfg,len:%d,data:", len); SYS_LibPrintHex(data, len); memset(name_mac, 0, 16); spi_tlv_get_value(TAG_DL_ADV_NAME, data, len, name_mac); spi_tlv_get_value(TAG_DL_MAC, data, len, &name_mac[8]); DLOG("ble cfg mac:%X%X%X%X%X%X", name_mac[8],name_mac[9],name_mac[10],name_mac[11],name_mac[12],name_mac[13]); DLOG("ble cfg name:%s, len:%d", name_mac, strlen(name_mac)); if(memcmp(name_mac, &user_data_in_flash[ADV_NEME_OFFSET], ADV_NAME_LEN+BLE_MAC_LEN) != 0) { ret = appdata_flash_update(name_mac,ADV_NAME_LEN+BLE_MAC_LEN,ADV_NEME_OFFSET); if(ret != NRF_SUCCESS) { NRF_LOG_PRINTF("appdata_flash_update name failed[%d]\r\n", ret); return -1; } else { change++; nrf_delay_ms(100); } } ret = spi_tlv_get_value(TAG_DL_ADV_INTERVAL, data, len, &interval); DLOG("ble cfg adv_interval:%d", interval); if(ret > 0) { if(memcmp(&interval, &user_data_in_flash[ADV_INTERVAL_OFFSET], ADV_INTERVAL_LEN) != 0) { ret = appdata_flash_update((uint8_t*)&interval,ADV_INTERVAL_LEN,ADV_INTERVAL_OFFSET); if(ret != NRF_SUCCESS) { NRF_LOG_PRINTF("appdata_flash_update interval failed[%d]\r\n", ret); return -2; } else { change++; nrf_delay_ms(100); } } } if(change > 0) { NVIC_SystemReset(); } return 0; } void ble_mac_init(uint8_t* ble_mac_addr, uint8_t len) { ble_gap_addr_t device_addr; device_addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC; device_addr.addr[5] = ble_mac_addr[0]; device_addr.addr[4] = ble_mac_addr[1]; device_addr.addr[3] = ble_mac_addr[2]; device_addr.addr[2] = ble_mac_addr[3]; device_addr.addr[1] = ble_mac_addr[4]; device_addr.addr[0] = ble_mac_addr[5]; DLOG("set ble mac addr:%s", SYS_LibHex2Str(ble_mac_addr, 6)); sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &device_addr); } static void tick_check_timer_callback(void* params) { timer_tick_check(); } static void timer_init() { uint32_t err_code; err_code = app_timer_create(&tick_check_timer_handle, APP_TIMER_MODE_REPEATED, tick_check_timer_callback); APP_ERROR_CHECK(err_code); err_code = app_timer_start(tick_check_timer_handle, TICK_TIMER_INTERVAL, NULL); APP_ERROR_CHECK(err_code); } static void led_timer_start(void) { g_s_led_timer_handle = timer_register(led_toggle_timer_callback, 200); } static void led_timer_stop(void) { timer_unregister(&g_s_led_timer_handle); } static void report_ver_timer_stop(void) { timer_unregister(&g_s_report_ver_timer_handle); } void ble_send_process(uint8_t* data, uint8_t len) { queue_in(&g_s_app_msg_send_list, data, len); } void spi_send_process(uint8_t* data, uint8_t len) { queue_in(&g_s_spi_msg_send_list, data, len); } int main(void) { uint32_t err_code; APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, false); queue_init(&g_s_app_msg_send_list); queue_init(&g_s_spi_msg_send_list); queue_init(&g_s_spi_msg_recv_list); NRF_LOG_INIT(); led_init(); led_off(LED_GREEN); spis_process_callback_register(ble_send_process, spi_send_process); wdg_init(); wdg_feed(); spis_init(); ble_stack_init(); appdata_flash_init(); appdata_flash_load(user_data_in_flash,APP_USER_DATA_LENGTH,FILE_SIZE_OFFSET); DLOG("VER:[%02X],Build:%s %s",get_version(),__DATE__,__TIME__); if((user_data_in_flash[ADV_INTERVAL_OFFSET] != 0xFF) && (user_data_in_flash[ADV_INTERVAL_OFFSET+1] != 0xFF)) { g_s_ble_adv_interval = (((uint16_t)user_data_in_flash[ADV_INTERVAL_OFFSET+1] << 8) | user_data_in_flash[ADV_INTERVAL_OFFSET]); if(g_s_ble_adv_interval > 1000) g_s_ble_adv_interval = 320; } if(user_data_in_flash[ADV_NEME_OFFSET] == 0xFF) { memset(&user_data_in_flash[ADV_NEME_OFFSET], 0, ADV_NAME_LEN); strcpy((char*)&user_data_in_flash[ADV_NEME_OFFSET], "13dog"); } timer_init(); ble_mac_init(&user_data_in_flash[BLE_MAC_OFFSET], BLE_MAC_LEN); gap_params_init(); services_init(); advertising_init(); conn_params_init(); err_code = ble_advertising_start(BLE_ADV_MODE_FAST); APP_ERROR_CHECK(err_code); led_timer_start(); timer_register(print_log_timer_callback, 5000); g_s_report_ver_timer_handle = timer_register(report_ver_timer_callback, 2000); do { QUEUE_MSG_PROCESS(&g_s_spi_msg_recv_list,spis_process_data); // if(dtm_flag == 1) // { // break; // } QUEUE_MSG_PROCESS(&g_s_app_msg_send_list,Hal_BleSendDatas); QUEUE_MSG_PROCESS(&g_s_spi_msg_send_list,spis_send_data); } while(1); // dtm_process_data(&g_s_spi_msg_send_list, &g_s_spi_msg_recv_list); }