obd_iso15765/BleCanBoxCode/NRF51802/examples/ble_peripheral/ble_app_z5x/main.c

#include <stdint.h>
#include <string.h>
#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
#define PC_BLE_TEST                     0

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;

#if PC_BLE_TEST
static uint8_t g_s_send_start[] = {0x10, 0x10};
static uint8_t g_s_send_stop[] = {0x10, 0x11};
static uint8_t g_s_send_ble_timer_handle = 0xFF;
#endif //PC_BLE_TEST

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);
}

#if PC_BLE_TEST
uint8_t get_rtc_rng(void)
{
    static uint8_t num;

    srand(timer_get_os_tick() + num);
    num += 1;
    if(num > 3)
    {
        num = 0;
    }
    return (rand()%100);
}

static void send_ble_timer_callback(void)
{
    uint8_t send_buf[6] = {0};
    for(int i=0; i<6; i++)
    {
        send_buf[i] = get_rtc_rng();
    }
    DLOG("%d,%d,%d,%d,%d,%d", send_buf[0], send_buf[1], send_buf[2], send_buf[3], send_buf[4], send_buf[5]);
    Hal_BleSendDatas(send_buf, 6);
}
#endif //PC_BLE_TEST

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);
#if PC_BLE_TEST
    if(!memcmp(p_data, g_s_send_start, sizeof(g_s_send_start)))
    {
        //启动timer开始发送.
        g_s_send_ble_timer_handle = timer_register(send_ble_timer_callback, 500);

    }
    if(!memcmp(p_data, g_s_send_stop, sizeof(g_s_send_stop)))
    {
        //关闭发送timer
        timer_unregister(&g_s_send_ble_timer_handle);
    }
    else
    {
#endif //PC_BLE_TEST
        spis_transfer_data(BLE_CMD_TRANSFER, p_data, length);
#if PC_BLE_TEST
    }
#endif //PC_BLE_TEST
}

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();
#if PC_BLE_TEST
            timer_unregister(&g_s_send_ble_timer_handle);
#endif //PC_BLE_TEST
            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);
}