host command suppor

1. support check_mem_survive, scan, connect, disconnect host command.

2. create a host_cmd.py to valid host commands

3. add uart_drv_rx_mutex/uart_drv_tx_mutex to lock uart tx/rx

4. add host_scan_filter_match_cb() to send device infomation to host.

5. add le_gap_disconnet()

6. freertos enable check stack overflow

7. freertos increase timer task stack

FreeRTOSConfig.h

@@ -80,7 +80,7 @@
 /* Hook function related definitions. */
 #define configUSE_IDLE_HOOK                                                       0
 #define configUSE_TICK_HOOK                                                       0
-#define configCHECK_FOR_STACK_OVERFLOW                                            0
+#define configCHECK_FOR_STACK_OVERFLOW                                            2
 #define configUSE_MALLOC_FAILED_HOOK                                              0
 
 /* Run time and task stats gathering related definitions. */
@@ -96,7 +96,7 @@
 #define configUSE_TIMERS                                                          1
 #define configTIMER_TASK_PRIORITY                                                 ( 2 )
 #define configTIMER_QUEUE_LENGTH                                                  32
-#define configTIMER_TASK_STACK_DEPTH                                              ( 80 )
+#define configTIMER_TASK_STACK_DEPTH                                              ( 256 )
 
 /* Tickless Idle configuration. */
 #define configEXPECTED_IDLE_TIME_BEFORE_SLEEP                                     2

host_tasks.c

@@ -5,9 +5,15 @@ extern "C"
 {
 #endif
 
+#include "ble_advdata.h"
+
 #include "nrf_ble_gatt.h"
 #include "nrf_ble_scan.h"
 
+#include "nrf_sdh.h"
+#include "nrf_sdh_ble.h"
+#include "nrf_sdh_freertos.h"
+
 #include "nrf_log.h"
 #include "nrf_log_ctrl.h"
 #include "nrf_log_default_backends.h"
@@ -96,39 +102,137 @@ typedef union
 
 static MessageBufferHandle_t host_cmd_msg;
 
-void on_connect(host_cmd_connect_t *p_cmd)
+static void survive_ack(void)
+{
+    uint8_t ack[] = { 0x04, 0x00, 0x01, 0x03 };
+    uart_drv_tx(ack, sizeof(ack));
+}
+
+void on_survive(host_cmd_survive_t *p_cmd)
+{
+    survive_ack();
+}
+
+static void connect_ack(void)
+{
+    uint8_t ack[] = { 0x04, 0x00, 0x04, 0x2E, 0x50, 0x30, 0x04 };
+    uart_drv_tx(ack, sizeof(ack));
+}
+
+static void on_connect(host_cmd_connect_t *p_cmd)
 {
     extern void le_scan_stop(void);
     extern void le_gap_connet(ble_gap_addr_t * p_peer_addr, nrf_ble_scan_t * p_scan);
     extern const nrf_ble_scan_t *le_scan_obj(void);
 
-    le_scan_stop();
-
     ble_gap_addr_t gap_addr;
     gap_addr.addr_type    = BLE_GAP_ADDR_TYPE_RANDOM_STATIC;
     gap_addr.addr_id_peer = 0;
-    memcpy(gap_addr.addr, p_cmd->addr, sizeof((gap_addr.addr)));
+    for (int i = 0; i < COUNTOF(gap_addr.addr); i++)
+    {
+        gap_addr.addr[i] = p_cmd->addr[COUNTOF(gap_addr.addr) - i - 1];
+    }
     le_gap_connet((void *)&gap_addr, (void *)le_scan_obj());
 
     char rsp_buf[64];
     sprintf(rsp_buf, "%s(%02X:%02X:%02X:%02X:%02X:%02X)\r\n", __FUNCTION__, gap_addr.addr[5], gap_addr.addr[4], gap_addr.addr[3], gap_addr.addr[2], gap_addr.addr[1], gap_addr.addr[0]);
     NRF_LOG_INFO("%s", rsp_buf);
-
-    p_cmd->opcode = CMD_NULL;
-    p_cmd->len    = 0;
 }
 
-void on_scan(host_cmd_scan_t *p_cmd)
+static void disconnect_ack(void)
+{
+    uint8_t ack[] = { 0x04, 0x00, 0x01, 0x03 };
+    uart_drv_tx(ack, sizeof(ack));
+}
+
+static void on_disconnect(host_cmd_disconnect_t *p_cmd)
+{
+    extern void le_gap_disconnet(uint16_t);
+    le_gap_disconnet(0);
+}
+
+static void on_scan(host_cmd_scan_t *p_cmd)
 {
     extern void le_scan_start(void);
     le_scan_start();
+}
 
-    char rsp_buf[64];
-    sprintf(rsp_buf, "%s() \r\n", __FUNCTION__);
-    uart_drv_tx(rsp_buf, strlen(rsp_buf));
+typedef struct
+{
+    const uint16_t company_identifier;
+    struct
+    {
+        const uint8_t company_code[5];
+        const uint8_t hw_ver[4];
+        const uint16_t battery_level;
+    } __PACKED data;
+} manu_spec_data_t;
 
-    p_cmd->opcode = CMD_NULL;
-    p_cmd->len    = 0;
+void host_scan_filter_match_cb(
+    void *p_manu_spec_data,
+    uint32_t manu_spec_data_len,
+    char *p_device_name,
+    uint32_t device_name_len,
+    ble_gap_addr_t const *peer_addr,
+    int16_t rssi)
+{
+
+    typedef struct
+    {
+        uint16_t hci_packet_event;
+        uint8_t len;
+        uint8_t addr[6];
+        uint8_t product_module[4];
+        uint32_t hw_ver;
+        uint8_t buid_time[2];
+        uint8_t parameter[3];
+        uint16_t bat_volt;
+        uint8_t dev_name[11];
+    } __PACKED host_scan_rsp_t;
+
+    volatile host_scan_rsp_t host_scan_rsp = {
+        .hci_packet_event = 0x0004,
+        .product_module   = { 'B', 'P', 'H', 'S' },
+        .parameter        = { 'B', 'A', 'T' },
+        .buid_time        = { 0x17, 0x06 },
+    };
+
+    char peer_addr_str[(2 + 1) * BLE_GAP_ADDR_LEN + 1] = { 0 };
+    if (peer_addr)
+    {
+        for (int i = 0; i < BLE_GAP_ADDR_LEN; i++)
+        {
+            host_scan_rsp.addr[i] = peer_addr->addr[(BLE_GAP_ADDR_LEN - 1) - i];
+        }
+        sprintf(peer_addr_str, "%02X:%02X:%02X:%02X:%02X:%02X", host_scan_rsp.addr[0], host_scan_rsp.addr[1], host_scan_rsp.addr[2], host_scan_rsp.addr[3], host_scan_rsp.addr[4], host_scan_rsp.addr[5]);
+    }
+    if (p_manu_spec_data)
+    {
+        manu_spec_data_t *p = p_manu_spec_data;
+        memcpy((void *)&host_scan_rsp.hw_ver, &p->data.hw_ver[0], sizeof(p->data.hw_ver));
+        uint16_t voltage       = p->data.battery_level * 37;
+        host_scan_rsp.bat_volt = __REVSH(voltage);
+    }
+
+    host_scan_rsp.len = offsetof(host_scan_rsp_t, dev_name) - offsetof(host_scan_rsp_t, addr);
+    if (p_device_name)
+    {
+        uint32_t len;
+        len = sizeof(host_scan_rsp.dev_name);
+        len = len > device_name_len ? device_name_len : len;
+        memcpy((void *)host_scan_rsp.dev_name, p_device_name, len);
+        host_scan_rsp.len += len;
+    }
+
+    NRF_LOG_INFO("Found: %s [%s, %s, %08X, %d, %ddb]",
+                 host_scan_rsp.dev_name,
+                 peer_addr_str,
+                 host_scan_rsp.product_module,
+                 __REV(host_scan_rsp.hw_ver),
+                 __REVSH(host_scan_rsp.bat_volt),
+                 rssi);
+    uint32_t tx_len = offsetof(host_scan_rsp_t, addr) + host_scan_rsp.len;
+    uart_drv_tx((void *)&host_scan_rsp, offsetof(host_scan_rsp_t, addr) + host_scan_rsp.len);
 }
 
 static void host_cmd_exec_task(void *p_arg)
@@ -136,16 +240,24 @@ static void host_cmd_exec_task(void *p_arg)
     for (;;)
     {
         static uint8_t buf[256] = { 0 };
+        host_command_t *p_cmd   = (void *)buf;
 
-        size_t recv = xMessageBufferReceive(host_cmd_msg, buf, sizeof(buf), pdMS_TO_TICKS(25));
+        p_cmd->raw.opcode = CMD_NULL;
+        p_cmd->raw.len    = 0;
 
-        host_command_t *p_cmd = (void *)buf;
+        size_t recv = xMessageBufferReceive(host_cmd_msg, buf, sizeof(buf), portMAX_DELAY);
 
         switch (p_cmd->raw.opcode)
         {
+            case CMD_SURVIVE:
+                on_survive(&p_cmd->survive);
+                break;
             case CMD_CONNECT:
                 on_connect(&p_cmd->connect);
                 break;
+            case CMD_DISCONNECT:
+                on_disconnect(&p_cmd->disconnect);
+                break;
             case CMD_SCAN:
                 on_scan(&p_cmd->scan);
                 break;
@@ -170,35 +282,61 @@ static void host_cmd_recv_task(void *p_arg)
 
             taskENTER_CRITICAL();
 
-            switch (p_cmd->raw.opcode)
+            if (p_cmd->raw.payload[p_cmd->raw.len] == CMD_SUFFIX)
             {
-                case CMD_CONNECT:
-                    if (p_cmd->raw.payload[p_cmd->raw.len] == CMD_SUFFIX)
-                    {
+                switch (p_cmd->raw.opcode)
+                {
+                    case CMD_SURVIVE:
+                        xMessageBufferSend(host_cmd_msg, p_cmd, sizeof(host_cmd_survive_t), pdMS_TO_TICKS(0));
+                        offset += sizeof(host_cmd_survive_t);
+                        break;
+                    case CMD_CONNECT:
                         xMessageBufferSend(host_cmd_msg, p_cmd, sizeof(host_cmd_connect_t), pdMS_TO_TICKS(0));
                         offset += sizeof(host_cmd_connect_t);
-                    }
-                    break;
-                case CMD_SCAN:
-                    if (p_cmd->raw.payload[p_cmd->raw.len] == CMD_SUFFIX)
-                    {
+                        break;
+                    case CMD_DISCONNECT:
+                        xMessageBufferSend(host_cmd_msg, p_cmd, sizeof(host_cmd_disconnect_t), pdMS_TO_TICKS(0));
+                        offset += sizeof(host_cmd_disconnect_t);
+                        break;
+                    case CMD_SCAN:
                         xMessageBufferSend(host_cmd_msg, p_cmd, sizeof(host_cmd_scan_t), pdMS_TO_TICKS(0));
                         offset += sizeof(host_cmd_scan_t);
-                    }
-                    break;
-                default:
-                    offset++;
-                    break;
+                        break;
+                    default:
+                        offset++;
+                        break;
+                }
+            }
+            else
+            {
+                offset++;
             }
-
             taskEXIT_CRITICAL();
         }
     }
 }
 
+static void host_tasks_handler(ble_evt_t const *p_ble_evt, void *p_context)
+{
+    ret_code_t err_code;
+    switch (p_ble_evt->header.evt_id)
+    {
+        case BLE_GAP_EVT_CONNECTED:
+            connect_ack();
+            break;
+        case BLE_GAP_EVT_DISCONNECTED:
+            disconnect_ack();
+            break;
+        default:
+            break;
+    }
+}
+
 void host_tasks_init(void)
 {
     host_cmd_msg = xMessageBufferCreate(1024);
     xTaskCreate(host_cmd_recv_task, "cmd_recv", 128, NULL, 5, NULL);
-    xTaskCreate(host_cmd_exec_task, "cmd_exec", 128, NULL, 2, NULL);
+    xTaskCreate(host_cmd_exec_task, "cmd_exec", 512, NULL, 2, NULL);
+    // Register a handler for BLE events.
+    NRF_SDH_BLE_OBSERVER(m_tasks_observer, 3, host_tasks_handler, NULL);
 }

le_eis_c.c

@@ -57,24 +57,26 @@ static void on_disconnected(ble_eis_c_t *p_ble_eis_c, ble_evt_t const *p_ble_evt
     p_ble_eis_c->event_char_handle          = BLE_GATT_HANDLE_INVALID;
 }
 
+static uint32_t hvx_cnt     = 0;
+static TickType_t hvx_begin = 0;
 static void on_connected(ble_eis_c_t *p_ble_eis_c, ble_evt_t const *p_ble_evt)
 {
+    hvx_cnt   = 0;
+    hvx_begin = 0;
 }
 
 static void on_hvx(ble_eis_c_t *p_ble_eis_c, ble_evt_t const *p_ble_evt)
 {
-    static int idx    = 0;
-    static uint begin = 0;
-    idx++;
-    if (begin == 0)
+    hvx_cnt++;
+    if (hvx_begin == 0)
     {
-        begin = xTaskGetTickCount();
+        hvx_begin = xTaskGetTickCount();
     }
     else
     {
         static char str[64];
-        float kb       = 8 * idx * 240 / 1024.0;
-        float timespan = (xTaskGetTickCount() - begin) / 1000.0;
+        float kb       = 8 * hvx_cnt * 240 / 1024.0;
+        float timespan = (xTaskGetTickCount() - hvx_begin) / 1000.0;
         snprintf(str, sizeof(str), "%s(): %.2fkbps", __FUNCTION__, kb / timespan);
         NRF_LOG_INFO("%s", str);
     }
@@ -88,20 +90,22 @@ ret_code_t le_eis_ccdc_configure(uint16_t conn_handle, uint16_t char_handle, boo
 {
     if (conn_handle == BLE_CONN_HANDLE_INVALID)
     {
+        __BKPT(255);
         return NRF_ERROR_INVALID_PARAM;
     }
 
     if (char_handle == BLE_GATT_HANDLE_INVALID)
     {
+        __BKPT(255);
         return NRF_ERROR_INVALID_PARAM;
     }
 
-    NRF_LOG_INFO("Configuring CCCD. CCCD Handle = 0x%04X, Connection Handle = 0x%04X",
+    NRF_LOG_INFO("Configuring CCCD Handle = 0x%04X, Connection Handle = 0x%04X",
                  char_handle + 1,
                  conn_handle);
 
     nrf_ble_gq_req_t cccd_req;
-    uint16_t cccd_val = notification_enable ? BLE_GATT_HVX_NOTIFICATION : 0;
+    uint16_t cccd_val = notification_enable ? BLE_GATT_HVX_NOTIFICATION : BLE_GATT_HVX_INVALID;
     uint8_t cccd[BLE_CCCD_VALUE_LEN];
 
     cccd[0] = LSB_16(cccd_val);
@@ -110,14 +114,14 @@ ret_code_t le_eis_ccdc_configure(uint16_t conn_handle, uint16_t char_handle, boo
     memset(&cccd_req, 0, sizeof(nrf_ble_gq_req_t));
 
     cccd_req.type                        = NRF_BLE_GQ_REQ_GATTC_WRITE;
-    cccd_req.params.gattc_write.handle   = m_eis_c.regular_data_char_handle + 1;
+    cccd_req.params.gattc_write.handle   = char_handle + 1;
     cccd_req.params.gattc_write.len      = BLE_CCCD_VALUE_LEN;
     cccd_req.params.gattc_write.offset   = 0;
     cccd_req.params.gattc_write.p_value  = cccd;
     cccd_req.params.gattc_write.write_op = BLE_GATT_OP_WRITE_REQ;
 
     extern nrf_ble_gq_t *le_gap_queue(void);
-    return nrf_ble_gq_item_add(le_gap_queue(), &cccd_req, m_eis_c.conn_handle);
+    return nrf_ble_gq_item_add(le_gap_queue(), &cccd_req, conn_handle);
 }
 
 static void le_eis_c_evt_handler(ble_evt_t const *p_ble_evt, void *p_context)
@@ -220,21 +224,13 @@ static void le_eis_c_evt_handler(ble_evt_t const *p_ble_evt, void *p_context)
 
 void le_eis_c_cccd_timer_cb(TimerHandle_t xTimer)
 {
-    static int cnt = 0;
-    if (cnt++ < 10)
-    {
-
-        NRF_LOG_INFO("Configuring CCCD Countdow: %d", 11 - cnt);
-    }
-    else
-    {
-        le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.regular_data_char_handle, true);
-        le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.low_freq_data_char_handle, true);
-        le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.auxiliary_data_char_handle, true);
-        le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.status_char_handle, true);
-        le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.event_char_handle, true);
-        xTimerStop(xTimer, pdMS_TO_TICKS(0));
-    }
+    xTimerStop(xTimer, pdMS_TO_TICKS(0));
+    le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.regular_data_char_handle, true);
+    le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.low_freq_data_char_handle, true);
+    le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.auxiliary_data_char_handle, true);
+    le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.status_char_handle, true);
+    le_eis_ccdc_configure(m_eis_c.conn_handle, m_eis_c.event_char_handle, true);
+    NRF_LOG_INFO("Enable notifications. ");
 }
 
 static TimerHandle_t le_eis_c_cccd_timer = NULL;

le_gap.c

@@ -42,6 +42,11 @@ void le_gap_connet(ble_gap_addr_t *p_peer_addr, nrf_ble_scan_t *p_scan)
     APP_ERROR_CHECK(err_code);
 }
 
+void le_gap_disconnet(uint16_t conn_handle)
+{
+    ret_code_t err_code = sd_ble_gap_disconnect(conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
+}
+
 void le_gap_phy_update(uint16_t conn_handle)
 {
     NRF_LOG_INFO("Send PHY update request.");

le_scan.c

@@ -32,77 +32,49 @@ NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */
 
 #define MAX_DEV_NAME_LEN ((BLE_GAP_ADV_SET_DATA_SIZE_MAX + 1) - AD_DATA_OFFSET)
 
-typedef struct
-{
-    const uint16_t company_identifier;
-    struct
-    {
-        const uint8_t company_code[5];
-        const uint8_t hw_ver[4];
-        const uint16_t bat_volt;
-    } __PACKED data;
-} manu_spec_data_t;
-
-static void found_device_cb(manu_spec_data_t *p_manu_spec_data, char *p_device_name, ble_gap_addr_t const *peer_addr, int16_t rssi)
-{
-    char company_code[6] = { 0, 0, 0, 0, 0, 0 };
-    uint32_t hw_ver      = 0;
-    uint16_t bat_volt    = 0;
-    if (p_manu_spec_data)
-    {
-        memcpy(company_code, &p_manu_spec_data->data.company_code[0], sizeof(p_manu_spec_data->data.company_code));
-        memcpy(&hw_ver, &p_manu_spec_data->data.hw_ver[0], sizeof(p_manu_spec_data->data.hw_ver));
-        memcpy(&bat_volt, &p_manu_spec_data->data.bat_volt, sizeof(p_manu_spec_data->data.bat_volt));
-        hw_ver = __REV(hw_ver);
-    }
-
-    char peer_addr_str[(2 + 1) * BLE_GAP_ADDR_LEN + 1];
-    if (peer_addr)
-    {
-        sprintf(peer_addr_str, "%02X:%02X:%02X:%02X:%02X:%02X", peer_addr->addr[5], peer_addr->addr[4], peer_addr->addr[3], peer_addr->addr[2], peer_addr->addr[1], peer_addr->addr[0]);
-    }
-
-    NRF_LOG_INFO("Found: %s [%s, %s, 0x%08X, %d, %ddb]",
-                 p_device_name,
-                 peer_addr_str,
-                 company_code,
-                 hw_ver,
-                 bat_volt,
-                 rssi);
-}
-
 static void on_adv_report(ble_gap_evt_adv_report_t const *p_adv_report)
 {
     // Initialize advertisement report for parsing.
     ret_code_t err_code;
-    uint16_t field_len     = 0;
     uint16_t offset        = 0;
     void *p_manu_spec_data = NULL;
     char dev_name[MAX_DEV_NAME_LEN];
     memset(dev_name, 0x00, MAX_DEV_NAME_LEN);
 
     // Search for advertising manufacturer spec data
-    field_len = ble_advdata_search(p_adv_report->data.p_data,
-                                   p_adv_report->data.len,
-                                   &offset,
-                                   BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA);
-    if (field_len)
+    uint32_t manu_spec_data_len = ble_advdata_search(p_adv_report->data.p_data,
+                                                     p_adv_report->data.len,
+                                                     &offset,
+                                                     BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA);
+    if (manu_spec_data_len)
     {
         p_manu_spec_data = &p_adv_report->data.p_data[offset];
     }
 
     // Search for advertising names.
-    field_len = ble_advdata_search(p_adv_report->data.p_data,
-                                   p_adv_report->data.len,
-                                   &offset,
-                                   BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME);
-    if (field_len)
+    uint32_t device_name_len = ble_advdata_search(p_adv_report->data.p_data,
+                                                  p_adv_report->data.len,
+                                                  &offset,
+                                                  BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME);
+    if (device_name_len)
     {
         uint8_t *p = (uint8_t *)p_adv_report->data.p_data;
-        memcpy(dev_name, &p[offset], field_len);
+        memcpy(dev_name, &p[offset], device_name_len);
     }
-
-    found_device_cb(p_manu_spec_data, dev_name, &p_adv_report->peer_addr, p_adv_report->rssi);
+    extern void host_scan_filter_match_cb(
+        void *p_manu_spec_data,
+        uint32_t manu_spec_data_len,
+        char *p_device_name,
+        uint32_t device_name_len,
+        ble_gap_addr_t const *peer_addr,
+        int16_t rssi);
+    host_scan_filter_match_cb(
+        p_manu_spec_data,
+        manu_spec_data_len,
+        dev_name,
+        device_name_len,
+        &p_adv_report->peer_addr,
+        p_adv_report->rssi);
 }
 
 static void scan_evt_handler(scan_evt_t const *p_scan_evt)

main.c

@@ -57,7 +57,6 @@ static void le_evt_handler(ble_evt_t const *p_ble_evt, void *p_context)
             break;
         case BLE_GAP_EVT_DISCONNECTED:
             NRF_LOG_INFO("Disconnected from peer.");
-            le_scan_start();
             break;
         case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
             le_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle);
@@ -145,3 +144,8 @@ int main(void)
         __BKPT(255);
     }
 }
+
+void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName)
+{
+    __BKPT(255);
+}

scripts/host_cmd.py

@@ -0,0 +1,79 @@
+import serial
+import os
+import time
+
+
+def survive_cmd(ser):
+    send = [0x0A, 0x01, 0xF1]
+    ser.write(send)
+    read = ser.read(4)
+    print("recv: "+" ".join("%02X" % b for b in read))
+
+def scan_cmd(ser, is_raw_data = True):
+    send = [0x03, 0x01, 0xF1]
+    ser.write(send)
+    peer_addr = [] 
+    for i in range(10):
+        hci_packet_event = ser.read(2)
+        if int.from_bytes(hci_packet_event, "little") != 0x0004:
+            continue
+        len = ser.read(1)
+        payload = ser.read(int.from_bytes(len, "little"))
+        peer_addr = payload[0:6]
+        if is_raw_data:
+            print(
+                "recv: "
+                + " ".join("0x%02X" % b for b in hci_packet_event)
+                + " "
+                + " ".join("0x%02X" % b for b in len)
+                + " "
+                + " ".join("0x%02X" % b for b in payload)
+            )
+        else:
+            print("-" * 100)
+            print("  peer address: " + ":".join("%02X" % b for b in payload[0:6]))
+            print("product module: " + str(payload[6:10], "utf-8"))
+            print("    hw version: " + " ".join("%02X" % b for b in payload[10:14]))
+            print("    build time: " + " ".join("%02X" % b for b in payload[14:16]))
+            print("    Parameter1: " + str(payload[16:19], "utf-8"))
+            print("  battery volt: " + str(int.from_bytes(payload[19:21], "big")/1000.0) + "V")
+            print("   device name: " + str(payload[21:], "utf-8"))            
+    return peer_addr
+
+def connect(ser, peer_addr = []):
+    send = [0x05, 0x08, 0x00]
+    send += peer_addr
+    send += [0xF1]
+    ser.write(send)
+    read = ser.read(7)
+    print("recv: "+" ".join("%02X" % b for b in read))
+
+def disconnect(ser):
+    send = [0x08, 0x01, 0xF1]
+    ser.write(send)
+    read = ser.read(4)
+    print("recv: "+" ".join("%02X" % b for b in read))
+
+
+def main():
+    # set comport
+    ser = serial.Serial("COM12", 57600, 8)
+
+    # send survive cmd
+    survive_cmd(ser)        
+
+    # send scan cmd
+    peer_addr = scan_cmd(ser, False)
+    
+    # send connect cmd with peer addr
+    connect(ser, peer_addr)
+    time.sleep(10)
+
+    # send disconnect cmd
+    disconnect(ser)
+
+    ser.close()
+
+
+if __name__ == "__main__":
+    main()

uart_drv.c

@@ -26,6 +26,8 @@ extern "C"
 
 static SemaphoreHandle_t uart_drv_tx_sem;
 static SemaphoreHandle_t uart_drv_rx_sem;
+static SemaphoreHandle_t uart_drv_tx_mutex;
+static SemaphoreHandle_t uart_drv_rx_mutex;
 
 uint32_t uart_drv_rx(void *p_data, uint16_t len)
 {
@@ -33,6 +35,7 @@ uint32_t uart_drv_rx(void *p_data, uint16_t len)
     {
         __BKPT(255);
     }
+    xSemaphoreTake(uart_drv_rx_mutex, portMAX_DELAY);
     nrf_uarte_rx_buffer_set(HOST_UART, p_data, len);
     nrf_uarte_event_clear(HOST_UART, NRF_UARTE_EVENT_RXTO);
     nrf_uarte_event_clear(HOST_UART, NRF_UARTE_EVENT_ENDRX);
@@ -44,7 +47,9 @@ uint32_t uart_drv_rx(void *p_data, uint16_t len)
     } while (xSemaphoreTake(uart_drv_rx_sem, pdMS_TO_TICKS(3)));
     nrf_uarte_task_trigger(HOST_UART, NRF_UARTE_TASK_STOPRX);
     xSemaphoreTake(uart_drv_rx_sem, portMAX_DELAY);
-    return nrf_uarte_rx_amount_get(HOST_UART);
+    uint32_t recv_bytes = nrf_uarte_rx_amount_get(HOST_UART);
+    xSemaphoreGive(uart_drv_rx_mutex);
+    return recv_bytes;
 }
 
 void uart_drv_tx(void *p_data, uint16_t len)
@@ -53,16 +58,20 @@ void uart_drv_tx(void *p_data, uint16_t len)
     {
         __BKPT(255);
     }
+    xSemaphoreTake(uart_drv_tx_mutex, portMAX_DELAY);
     HOST_UART->TXD.PTR    = (uint32_t)p_data;
     HOST_UART->TXD.MAXCNT = len;
     nrf_uarte_task_trigger(HOST_UART, NRF_UARTE_TASK_STARTTX);
     xSemaphoreTake(uart_drv_tx_sem, portMAX_DELAY);
+    xSemaphoreGive(uart_drv_tx_mutex);
 }
 
 void uart_drv_init(void)
 {
-    uart_drv_rx_sem     = xSemaphoreCreateBinary();
-    uart_drv_tx_sem = xSemaphoreCreateBinary();
+    uart_drv_rx_sem   = xSemaphoreCreateBinary();
+    uart_drv_tx_sem   = xSemaphoreCreateBinary();
+    uart_drv_rx_mutex = xSemaphoreCreateMutex();
+    uart_drv_tx_mutex = xSemaphoreCreateMutex();
 
     nrf_gpio_cfg_output(HOST_uart_drv_tx_PIN);
     nrf_gpio_cfg_input(HOST_UART_RX_PIN, NRF_GPIO_PIN_NOPULL);