nrf51822---主从通信(1)

1.目的

   学习nrf51822主机和从机通信

2.分析

    2个设备,一个做主机一个做从机,相互通信   

3.平台:

协议栈版本:SDK10.0.0

编译软件:keil 5.12

硬件平台:nrf51822最小系统

例子:SDK 10.0.0\examples\ble_peripheral\ble_app_uart\pca10028\s110\arm4 从机例子

          SDK10.0\examples\ble_central_and_peripheral\experimental\ble_app_hrs_rscs_relay\pca10028\s130\arm4 做主机

      

4.步骤

   1.先把从机的程序下载到一个板子里面

   注意:a.32.769khz晶体的选型。b.SDK 以及softwaredevice的版本号

    2.来分析下主机的程序

   协议栈初始化,串口服务初始化,开始扫描参数初始化以及开始扫描

int main(void)
{
    uint32_t err_code;
    
    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, NULL);
    
    uart_init();
    buttons_leds_init();
    
    ble_stack_init();
    
    err_code = ble_db_discovery_init();
    APP_ERROR_CHECK(err_code);
    
    nus_c_init();

    // Start scanning for peripherals and initiate connection
    // with devices that advertise NUS UUID.
    scan_start();
    APPL_LOG("Scan started\r\n");
    for (;;)
    {
        power_manage();
    }
}


这里初始化回调函数,一个串口服务初始化

/**@brief Function for initializing the NUS Client.
 */
static void nus_c_init(void)
{
    uint32_t         err_code;
    ble_nus_c_init_t nus_c_init_t;
    
    nus_c_init_t.evt_handler = ble_nus_c_evt_handler;
    
    err_code = ble_nus_c_init(&m_ble_nus_c, &nus_c_init_t);
    APP_ERROR_CHECK(err_code);
}

这里是最终注册函数,看如下函数

sd_ble_uuid_vs_add(&nus_base_uuid, &p_ble_nus_c->uuid_type); 获得uuid的类型

 uuid的类型有 

/** @defgroup BLE_UUID_TYPES Types of UUID
 * @{ */
#define BLE_UUID_TYPE_UNKNOWN       0x00 /**< Invalid UUID type. */
#define BLE_UUID_TYPE_BLE           0x01 /**< Bluetooth SIG UUID (16-bit). */
#define BLE_UUID_TYPE_VENDOR_BEGIN  0x02 /**< Vendor UUID types start at this index (128-bit). */
/** @} */

  uart_uuid.type = p_ble_nus_c->uuid_type;  //串口服务的类型
  uart_uuid.uuid = BLE_UUID_NUS_SERVICE; //串口主服务的UUID


uint32_t ble_nus_c_init(ble_nus_c_t * p_ble_nus_c, ble_nus_c_init_t * p_ble_nus_c_init)
{
    uint32_t      err_code;
    ble_uuid_t    uart_uuid;
    ble_uuid128_t nus_base_uuid = NUS_BASE_UUID;
        
    if ((p_ble_nus_c == NULL) || (p_ble_nus_c_init == NULL))
    {
        return NRF_ERROR_NULL;
    }
    
    err_code = sd_ble_uuid_vs_add(&nus_base_uuid, &p_ble_nus_c->uuid_type);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }
    
    uart_uuid.type = p_ble_nus_c->uuid_type;
    uart_uuid.uuid = BLE_UUID_NUS_SERVICE;
    
    // save the pointer to the ble_uart_c_t struct locally
    mp_ble_nus_c = p_ble_nus_c;
    
    p_ble_nus_c->conn_handle   = BLE_CONN_HANDLE_INVALID;
    p_ble_nus_c->evt_handler   = p_ble_nus_c_init->evt_handler;
    p_ble_nus_c->nus_rx_handle = BLE_GATT_HANDLE_INVALID;
    p_ble_nus_c->nus_tx_handle = BLE_GATT_HANDLE_INVALID;
    
    return ble_db_discovery_evt_register(&uart_uuid, db_discover_evt_handler);
}

串口服务回调函数可以看到对应的事件类型的处理,因为串口服务只有2个特征值,一个notify(通知) 和一个write and write no response(写并无返回)的属性

 这里在描述对应事件的时候就会产生对应的事件,比如扫描的时候发现了write and write no response(BLE_NUS_C_EVT_FOUND_NUS_TX_CHARACTERISTIC)的特征值就是跳到BLE_NUS_C_EVT_FOUND_NUS_TX_CHARACTERISTIC事件,

 扫描到notify(BLE_NUS_C_EVT_FOUND_NUS_RX_CHARACTERISTIC)的事件,主机要使能从机,这样才能接到从机主动发来的信息,

BLE_NUS_C_EVT_NUS_RX_EVT 事件是,当使能了从机,从机发送过来信息的时候产生的事件,

BLE_NUS_C_EVT_DISCONNECTED ,蓝牙断开事件,断开从新开始扫描

<pre name="code" class="cpp">/**@snippet [Handling events from the ble_nus_c module] */ 
static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, const ble_nus_c_evt_t * p_ble_nus_evt)
{
    uint32_t err_code;
    switch (p_ble_nus_evt->evt_type)
    {
        case BLE_NUS_C_EVT_FOUND_NUS_TX_CHARACTERISTIC:
            APPL_LOG("The device has the device TX characteristic\r\n");
            break;
        
        case BLE_NUS_C_EVT_FOUND_NUS_RX_CHARACTERISTIC:
            err_code = ble_nus_c_rx_notif_enable(p_ble_nus_c);
            APP_ERROR_CHECK(err_code);
            APPL_LOG("The device has the device RX characteristic\r\n");
            break;
                case BLE_NUS_C_EVT_NUS_RX_EVT:
            for (uint32_t i = 0; i < p_ble_nus_evt->data_len; i++)
            {
                while(app_uart_put( p_ble_nus_evt->p_data[i]) != NRF_SUCCESS);
            }
            break;
        
        case BLE_NUS_C_EVT_DISCONNECTED:
            APPL_LOG("NUS device disconnected\r\n");
            scan_start();
            break;
    }
}

开始扫描主要是扫描参数的设置。
<pre name="code" class="cpp">#define SCAN_INTERVAL           0x00A0                          /**< Determines scan interval in units of 0.625 millisecond. */
#define SCAN_WINDOW             0x0050                          /**< Determines scan window in units of 0.625 millisecond. */
#define SCAN_ACTIVE             1                               /**< If 1, performe active scanning (scan requests). */
#define SCAN_SELECTIVE          0                               /**< If 1, ignore unknown devices (non whitelisted). */
#define SCAN_TIMEOUT            0x0000    

/**
 * @brief Parameters used when scanning.
 */
static const ble_gap_scan_params_t m_scan_params = 
  {
    .active      = SCAN_ACTIVE,
    .selective   = SCAN_SELECTIVE,
    .p_whitelist = NULL,
    .interval    = SCAN_INTERVAL,
    .window      = SCAN_WINDOW,
    .timeout     = SCAN_TIMEOUT
  };

/**@brief Function to start scanning.
 */
static void scan_start(void)
{
    uint32_t err_code;
    
    err_code = sd_ble_gap_scan_start(&m_scan_params);
    APP_ERROR_CHECK(err_code);
    
    err_code = bsp_indication_set(BSP_INDICATE_SCANNING);
    APP_ERROR_CHECK(err_code);
}


开始扫描后如果发现了广播数据,就会产生广播报告事件。即BLE_GAP_EVT_ADV_REPORT事件,然后在通过is_uuid_present() 函数来找对应的是UUID以及类型,通过这2个特征来识别是不是要连接的从机,然后通过sd_ble_gap_connect来连接从机,连接是通过mac地址来连接的如下

err_code = sd_ble_gap_connect(&p_adv_report->peer_addr,
                                              &m_scan_params,
                                              &m_connection_param);

 当连接上了蓝牙产生,BLE_GAP_EVT_CONNECTED事件,在这里,

    开始发现服务和特征值:ble_db_discovery_start(&m_ble_db_discovery, p_ble_evt->evt.gap_evt.conn_handle);具体代码如下:

/**@brief Function for dispatching a BLE stack event to all modules with a BLE stack event handler.
 *
 * @details This function is called from the scheduler in the main loop after a BLE stack event has
 *  been received.
 *
 * @param[in]   p_ble_evt   Bluetooth stack event.
 */
static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
{
    on_ble_evt(p_ble_evt);  
    bsp_btn_ble_on_ble_evt(p_ble_evt);
    ble_db_discovery_on_ble_evt(&m_ble_db_discovery, p_ble_evt);
    ble_nus_c_on_ble_evt(&m_ble_nus_c,p_ble_evt);
}


/**@brief Function for handling the Application's BLE Stack events.
 *
 * @param[in]   p_ble_evt   Bluetooth stack event.
 */
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
    uint32_t              err_code;
    const ble_gap_evt_t * p_gap_evt = &p_ble_evt->evt.gap_evt;	
    
    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_ADV_REPORT:
        {
            const ble_gap_evt_adv_report_t *p_adv_report = &p_gap_evt->params.adv_report;
                        
            if (is_uuid_present(&m_nus_uuid, p_adv_report))
            {

                err_code = sd_ble_gap_connect(&p_adv_report->peer_addr,
                                              &m_scan_params,
                                              &m_connection_param);
                
                if (err_code == NRF_SUCCESS)
                {                   // scan is automatically stopped by the connect
                                      
                    err_code = bsp_indication_set(BSP_INDICATE_IDLE);
                    APP_ERROR_CHECK(err_code);
                    APPL_LOG("Connecting to target %02x%02x%02x%02x%02x%02x\r\n",
                             p_adv_report->peer_addr.addr[0],
                             p_adv_report->peer_addr.addr[1],
                             p_adv_report->peer_addr.addr[2],
                             p_adv_report->peer_addr.addr[3],
                             p_adv_report->peer_addr.addr[4],
                             p_adv_report->peer_addr.addr[5]
                             );
                }
            }
            break;
        }       
        case BLE_GAP_EVT_CONNECTED:
            APPL_LOG("Connected to target\r\n");
            err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
            APP_ERROR_CHECK(err_code);
            
            m_ble_nus_c.conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            // start discovery of services. The NUS Client waits for a discovery result
            err_code = ble_db_discovery_start(&m_ble_db_discovery, p_ble_evt->evt.gap_evt.conn_handle);
            APP_ERROR_CHECK(err_code);
            break;      case BLE_GAP_EVT_TIMEOUT:
            if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_SCAN)
            {
                APPL_LOG("[APPL]: Scan timed out.\r\n");
                scan_start();
            }
            else if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
            {
                APPL_LOG("[APPL]: Connection Request timed out.\r\n");
            }
            break;           
        case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
            // Pairing not supported
            err_code = sd_ble_gap_sec_params_reply(p_ble_evt->evt.gap_evt.conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
            APP_ERROR_CHECK(err_code);
            break;
    
        case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
            // Accepting parameters requested by peer.
            err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
                                                    &p_gap_evt->params.conn_param_update_request.conn_params);
            APP_ERROR_CHECK(err_code);
            break;
           default:
            break;
    }
}

开始发现服务,也会产生对应的事件,代码如下:第一次扫描发现的是主服务:产生的是BLE_GATTC_EVT_PRIM_SRVC_DISC_RSP事件。表示找到了主服务

 

void ble_db_discovery_on_ble_evt(ble_db_discovery_t * const p_db_discovery,
                                 const ble_evt_t * const    p_ble_evt)
{
    if ((p_db_discovery == NULL) || (p_ble_evt == NULL))
    {
        // Null pointer provided. Return.
        return;
    }

    if (!m_initialized)
    {
        return;
    }
      switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
					SEGGER_RTT_printf(0,"BLE_GAP_EVT_CONNECTED\r\n");
            p_db_discovery->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            break;
        
        case BLE_GAP_EVT_DISCONNECTED:
            memset(p_db_discovery, 0, sizeof(ble_db_discovery_t));
            p_db_discovery->conn_handle = BLE_CONN_HANDLE_INVALID;
            break;

        case BLE_GATTC_EVT_PRIM_SRVC_DISC_RSP:  <strong>//找到了主服务</strong>
					SEGGER_RTT_printf(0,"BLE_GATTC_EVT_PRIM_SRVC_DISC_RSP\r\n");
            on_primary_srv_discovery_rsp(p_db_discovery, &(p_ble_evt->evt.gattc_evt));
            break;
        case BLE_GATTC_EVT_CHAR_DISC_RSP:
					 SEGGER_RTT_printf(0,"BLE_GATTC_EVT_CHAR_DISC_RSP\r\n");
            on_characteristic_discovery_rsp(p_db_discovery, &(p_ble_evt->evt.gattc_evt));
            break;

        case BLE_GATTC_EVT_DESC_DISC_RSP:
					SEGGER_RTT_printf(0,"BLE_GATTC_EVT_DESC_DISC_RSP\r\n");
					  //SEGGER_RTT_printf(0,"\r\np_ble_evt->header.evt_id=%d\r\n,p_ble_evt->header.evt_id");
            on_descriptor_discovery_rsp(p_db_discovery, &(p_ble_evt->evt.gattc_evt));
            break;

        default:
            break;
    }
}

这里是发现主服务之后的处理,找特征值:characteristics_discover(p_db_discovery);

static void on_primary_srv_discovery_rsp(ble_db_discovery_t * const    p_db_discovery,
                                         const ble_gattc_evt_t * const p_ble_gattc_evt)
{
    if (p_ble_gattc_evt->gatt_status == BLE_GATT_STATUS_SUCCESS)
    {
        uint32_t err_code;
        const ble_gattc_evt_prim_srvc_disc_rsp_t * p_prim_srvc_disc_rsp_evt;
        ble_gatt_db_srv_t                        * p_srv_being_discovered;

        p_srv_being_discovered = &(p_db_discovery->services[p_db_discovery->curr_srv_ind]);

        p_prim_srvc_disc_rsp_evt = &(p_ble_gattc_evt->params.prim_srvc_disc_rsp);

        p_srv_being_discovered->srv_uuid     = p_prim_srvc_disc_rsp_evt->services[0].uuid;
        p_srv_being_discovered->handle_range = p_prim_srvc_disc_rsp_evt->services[0].handle_range;

        err_code = characteristics_discover(p_db_discovery);       
        if (err_code != NRF_SUCCESS)
        {
            p_db_discovery->discovery_in_progress = false;
            
            // Error with discovering the service.
            // Indicate the error to the registered user application.
            discovery_error_evt_trigger(p_db_discovery, err_code);
        }
    }
    else
    {
        // Trigger Service Not Found event to the application.
        discovery_complete_evt_trigger(p_db_discovery, false);
   
        on_srv_disc_completion(p_db_discovery);
    }
}



找到特征值后会产生BLE_GATTC_EVT_CHAR_DISC_RSP事件,然后会处理,on_characteristic_discovery_rsp()函数,该函数注意2点,是否全部找到了特征值,如果没有找到继续找,如果找到了,这找描述符。

  if (
            !is_char_discovery_reqd(p_db_discovery, p_last_known_char) ||
            (p_srv_being_discovered->char_count == BLE_GATT_DB_MAX_CHARS)
           )
        {  
            perform_desc_discov = true;
        }

   判断是否找全了特征值,或者是否超出了设置的特征值的数量,BLE_GATT_DB_MAX_CHARS是预定义的一个特征值的个数,意思就是,假如一个服务里面有超过BLE_GATT_DB_MAX_CHARS特征值,则认为是全部找到了。可以在项目中适当的改变这个值的大小。

  当全部找到了特征值,则descriptors_discover(p_db_discovery, &raise_discov_complete); 找描述符

static void on_characteristic_discovery_rsp(ble_db_discovery_t * const    p_db_discovery,
                             const ble_gattc_evt_t * const                p_ble_gattc_evt)
{
    uint32_t                 err_code;
    ble_gatt_db_srv_t      * p_srv_being_discovered;
    bool                     perform_desc_discov = false;    

    p_srv_being_discovered = &(p_db_discovery->services[p_db_discovery->curr_srv_ind]);

    if (p_ble_gattc_evt->gatt_status == BLE_GATT_STATUS_SUCCESS)
    {
        const ble_gattc_evt_char_disc_rsp_t * p_char_disc_rsp_evt;

        p_char_disc_rsp_evt = &(p_ble_gattc_evt->params.char_disc_rsp);

        // Find out the number of characteristics that were previously discovered (in earlier
        // characteristic discovery responses, if any).
        uint8_t num_chars_prev_disc = p_srv_being_discovered->char_count;
               // Find out the number of characteristics that are currently discovered (in the
        // characteristic discovery response being handled).
        uint8_t num_chars_curr_disc = p_char_disc_rsp_evt->count;

        // Check if the total number of discovered characteristics are supported by this module.
        if ((num_chars_prev_disc + num_chars_curr_disc) <= BLE_GATT_DB_MAX_CHARS)
        {
            // Update the characteristics count.
            p_srv_being_discovered->char_count += num_chars_curr_disc;
        }
        else
        {            // The number of characteristics discovered at the peer is more than the supported
            // maximum. This module will store only the characteristics found up to this point.
            p_srv_being_discovered->char_count = BLE_GATT_DB_MAX_CHARS;
        }

        uint32_t i;
        uint32_t j;

        for (i = num_chars_prev_disc, j = 0; i < p_srv_being_discovered->char_count; i++, j++)
        {
            p_srv_being_discovered->charateristics[i].characteristic =
                p_char_disc_rsp_evt->chars[j];

            p_srv_being_discovered->charateristics[i].cccd_handle = BLE_GATT_HANDLE_INVALID;
        }
              ble_gattc_char_t * p_last_known_char;
        
        p_last_known_char = &(p_srv_being_discovered->charateristics[i - 1].characteristic);

        // If no more characteristic discovery is required, or if the maximum number of supported
        // characteristic per service has been reached, descriptor discovery will be performed.
        if (
            !is_char_discovery_reqd(p_db_discovery, p_last_known_char) ||
            (p_srv_being_discovered->char_count == BLE_GATT_DB_MAX_CHARS)
           )
        {  
            perform_desc_discov = true;
        }
        else
        {
            // Update the current characteristic index.
            p_db_discovery->curr_char_ind = p_srv_being_discovered->char_count;
            // Perform another round of characteristic discovery.
            err_code = characteristics_discover(p_db_discovery); <strong> //找特征值</strong>

            if (err_code != NRF_SUCCESS)
            {
                p_db_discovery->discovery_in_progress = false;

                discovery_error_evt_trigger(p_db_discovery, err_code);
                 
                return;
            }
        }
    }
    else
    {       // The previous characteristic discovery resulted in no characteristics.
        // descriptor discovery should be performed.
        perform_desc_discov = true;
    }

    if (perform_desc_discov)
    {
        bool raise_discov_complete;

        p_db_discovery->curr_char_ind = 0;

        err_code = descriptors_discover(p_db_discovery, &raise_discov_complete); <strong>//找描述符</strong>

        if (err_code != NRF_SUCCESS)
        {
            p_db_discovery->discovery_in_progress = false;

            discovery_error_evt_trigger(p_db_discovery, err_code);
          
            return;
        }     if (raise_discov_complete)
        {
            // No more characteristics and descriptors need to be discovered. Discovery is complete.
            // Send a discovery complete event to the user application.
            DB_LOG("[DB]: Discovery of service with UUID 0x%x completed with success for Connection"
                   " handle %d\r\n", p_srv_being_discovered->srv_uuid.uuid,
                   p_db_discovery->conn_handle);

            discovery_complete_evt_trigger(p_db_discovery, true);
             
            on_srv_disc_completion(p_db_discovery);
        }
    }
}

找到了描述符则会产生BLE_GATTC_EVT_DESC_DISC_RSP事件,如果没有找全 则descriptors_discover(p_db_discovery, &raise_discov_complete);,再次发现描述符,并再次产生BLE_GATTC_EVT_DESC_DISC_RSP事件,如果全部找到了则 discovery_complete_evt_trigger(p_db_discovery, true);


/**@brief     Function for handling descriptor discovery response.
 *
 * @param[in] p_db_discovery    Pointer to the DB Discovery structure.
 * @param[in] p_ble_gattc_evt   Pointer to the GATT Client event.
 */
static void on_descriptor_discovery_rsp(ble_db_discovery_t * const    p_db_discovery,
                                        const ble_gattc_evt_t * const p_ble_gattc_evt)
{
    const ble_gattc_evt_desc_disc_rsp_t * p_desc_disc_rsp_evt;
    ble_gatt_db_srv_t                   * p_srv_being_discovered;

    p_srv_being_discovered = &(p_db_discovery->services[p_db_discovery->curr_srv_ind]);

    p_desc_disc_rsp_evt = &(p_ble_gattc_evt->params.desc_disc_rsp);

    ble_gatt_db_char_t * p_char_being_discovered =
        &(p_srv_being_discovered->charateristics[p_db_discovery->curr_char_ind]);
    if (p_ble_gattc_evt->gatt_status == BLE_GATT_STATUS_SUCCESS)
    {
        // The descriptor was found at the peer.
        // If the descriptor was a CCCD, then the cccd_handle needs to be populated.

        uint32_t i;

        // Loop through all the descriptors to find the CCCD.
        for (i = 0; i < p_desc_disc_rsp_evt->count; i++)
        {
            if (
                p_desc_disc_rsp_evt->descs[i].uuid.uuid ==
                BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG
               )
            {                p_char_being_discovered->cccd_handle = p_desc_disc_rsp_evt->descs[i].handle;

                break;
            }
        }
    }

    bool raise_discov_complete = false;

    if ((p_db_discovery->curr_char_ind + 1) == p_srv_being_discovered->char_count)
    {
        // No more characteristics and descriptors need to be discovered. Discovery is complete.
        // Send a discovery complete event to the user application.

        raise_discov_complete = true;
    }
    else
    {
        // Begin discovery of descriptors for the next characteristic.
        uint32_t err_code;
        p_db_discovery->curr_char_ind++;

        err_code = descriptors_discover(p_db_discovery, &raise_discov_complete);

        if (err_code != NRF_SUCCESS)
        {
            p_db_discovery->discovery_in_progress = false;

            // Error with discovering the service.
            // Indicate the error to the registered user application.
            discovery_error_evt_trigger(p_db_discovery, err_code);
    
            return;
        }
    }
    if (raise_discov_complete)
    {
        DB_LOG("[DB]: Discovery of service with UUID 0x%x completed with success for Connection"
               "handle %d\r\n", p_srv_being_discovered->srv_uuid.uuid,
               p_db_discovery->conn_handle);
        SEGGER_RTT_printf(0,"Discovery\r\n");
        discovery_complete_evt_trigger(p_db_discovery, true);

        on_srv_disc_completion(p_db_discovery);
    }
}



现在来具体分析下这个函数:

首先找到对应的回调函数p_evt_handler = registered_handler_get(&(p_srv_being_discovered->srv_uuid));

 nus_c_init(); --->  ble_nus_c_init(&m_ble_nus_c, &nus_c_init_t);-->ble_db_discovery_evt_register(&uart_uuid, db_discover_evt_handler);--->registered_handler_set(p_uuid, evt_handler);

static uint32_t registered_handler_set(const ble_uuid_t * const       p_srv_uuid,
                                       ble_db_discovery_evt_handler_t p_evt_handler)
{
    if (m_num_of_handlers_reg < DB_DISCOVERY_MAX_USERS)
    {
        m_registered_handlers[m_num_of_handlers_reg].srv_uuid    = *p_srv_uuid;
        m_registered_handlers[m_num_of_handlers_reg].evt_handler = p_evt_handler;


        m_num_of_handlers_reg++;


        return NRF_SUCCESS;
    }
    else
    {
        return NRF_ERROR_NO_MEM;
    }
}

通过一层一层,把串口的服务的类型 和回调函数复制给了m_registered_handlers结构体保存期来了,如果还有其他的服务也可以按照同样步骤添加。

最后把static void db_discover_evt_handler(ble_db_discovery_evt_t * p_evt)函数地址保存在m_registered_handlers里面了

再看

static ble_db_discovery_evt_handler_t registered_handler_get(ble_uuid_t * p_srv_uuid)
{
    uint32_t i;


    for (i = 0; i < m_num_of_handlers_reg; i++)
    {
        if (BLE_UUID_EQ(&(m_registered_handlers[i].srv_uuid), p_srv_uuid))
        {
            return (m_registered_handlers[i].evt_handler);
        }
    }


    return NULL;
}

这里就是把输入的UUID的类型和m_registered_handlers保存的UUID的类型对比,如果一样则返回它对应的回调函数。

然后在m_pending_user_evts结构体赋值。因为is_srv_found == true

     if (is_srv_found)
            {
                m_pending_user_evts[m_pending_usr_evt_index].evt.evt_type =
                    BLE_DB_DISCOVERY_COMPLETE;


                m_pending_user_evts[m_pending_usr_evt_index].evt.params.discovered_db =
                    *p_srv_being_discovered;
            }

最后执行, pending_user_evts_send();

/**@brief Function for sending all pending discovery events to the corresponding user modules.
 */
static void pending_user_evts_send(void)
{
    uint32_t i;


    for (i = 0; i < m_num_of_handlers_reg; i++)
    {
        // Pass the event to the corresponding event handler.
        m_pending_user_evts[i].evt_handler(&(m_pending_user_evts[i].evt));
    }
    
    m_pending_usr_evt_index = 0;
}

在discovery_complete_evt_trigger里面

    p_evt_handler = registered_handler_get(&(p_srv_being_discovered->srv_uuid));   ------>  m_pending_user_evts[m_pending_usr_evt_index].evt_handler         = p_evt_handler; // 把回调函数赋值给m_pending_user_evts对应的地址。

   m_pending_user_evts[m_pending_usr_evt_index].evt.evt_type =   BLE_DB_DISCOVERY_COMPLETE;

这样就执行了db_discover_evt_handler(ble_db_discovery_evt_t * p_evt)函数


static void discovery_complete_evt_trigger(ble_db_discovery_t * const p_db_discovery,
                                           bool                       is_srv_found)
{
    ble_db_discovery_evt_handler_t p_evt_handler;
    ble_gatt_db_srv_t            * p_srv_being_discovered;

    p_srv_being_discovered = &(p_db_discovery->services[p_db_discovery->curr_srv_ind]);

    p_evt_handler = registered_handler_get(&(p_srv_being_discovered->srv_uuid));

    if (p_evt_handler != NULL)
    {
        if (m_pending_usr_evt_index < DB_DISCOVERY_MAX_USERS)
        {           // Insert an event into the pending event list.
            m_pending_user_evts[m_pending_usr_evt_index].evt.conn_handle =
                p_db_discovery->conn_handle;

            if (is_srv_found)
            {
                m_pending_user_evts[m_pending_usr_evt_index].evt.evt_type =
                    BLE_DB_DISCOVERY_COMPLETE;

                m_pending_user_evts[m_pending_usr_evt_index].evt.params.discovered_db =
                    *p_srv_being_discovered;
            }
            else
            {              m_pending_user_evts[m_pending_usr_evt_index].evt.evt_type =
                    BLE_DB_DISCOVERY_SRV_NOT_FOUND;
            }
            m_pending_user_evts[m_pending_usr_evt_index].evt_handler = p_evt_handler;

            m_pending_usr_evt_index++;

            if (m_pending_usr_evt_index == m_num_of_handlers_reg)
            {
                // All registered modules have pending events. Send all pending events to the user
                // modules.
                pending_user_evts_send();
            }
            else
            {
                // Too many events pending. Do nothing. (Ideally this should not happen.)
            }
        }
    }
}

这里会把发现的特征值全部过一遍,然后执行对应的处理。执行对应的回调

经过 nus_c_init()---> ble_nus_c_init(); 执行 ,把 ble_nus_c_evt_handler函数地址赋值给了mp_ble_nus_c.evt_handler

所以mp_ble_nus_c->evt_handler 就是 ble_nus_c_evt_handler。

p_evt就发现一个服务的全部信息的结构体,比如主服务的UUID,特征值的UUID一个权限,handle,发现特征值的个数(p_evt->params.discovered_db.char_count)等等,因为串口有2个特征值,write和notify 对应BLE_UUID_NUS_TX_CHARACTERISTIC和BLE_UUID_NUS_RX_CHARACTERISTIC 2个UUID,所以只要在找到对应的uuid,并保存下handle就好了。(假如提前并不知道对方的属性呢?)

 注意:为什么这里要保存handle,因为当主机发送要发数据给从机的时候,比如有好几个特征值,要往某个特定的UUID发送数据,就必须知道地址,而handle就是类是地址,每个特征值对应的地址,当主机连上从机后,知道了handle就可以往特定的权限的UUID通信了。

static void db_discover_evt_handler(ble_db_discovery_evt_t * p_evt)
{
    // Check if the NUS was discovered.
    if (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE &&
        p_evt->params.discovered_db.srv_uuid.uuid == BLE_UUID_NUS_SERVICE &&
        p_evt->params.discovered_db.srv_uuid.type == mp_ble_nus_c->uuid_type)
    {

        uint32_t i;
       
        for (i = 0; i < p_evt->params.discovered_db.char_count; i++)
        {
            if (p_evt->params.discovered_db.charateristics[i].characteristic.uuid.uuid 
                == BLE_UUID_NUS_TX_CHARACTERISTIC)
            {
                mp_ble_nus_c->nus_tx_handle =
                    p_evt->params.discovered_db.charateristics[i].characteristic.handle_value;
                
                if (mp_ble_nus_c->evt_handler != NULL)                {
                    ble_nus_c_evt_t nus_c_evt;
                    
                    nus_c_evt.evt_type = BLE_NUS_C_EVT_FOUND_NUS_TX_CHARACTERISTIC;
                    mp_ble_nus_c->evt_handler(mp_ble_nus_c, &nus_c_evt);
                }
            }
            else if (p_evt->params.discovered_db.charateristics[i].characteristic.uuid.uuid 
                        == BLE_UUID_NUS_RX_CHARACTERISTIC)
            {
                mp_ble_nus_c->nus_rx_handle =
                    p_evt->params.discovered_db.charateristics[i].characteristic.handle_value;
                mp_ble_nus_c->nus_rx_cccd_handle =
                    p_evt->params.discovered_db.charateristics[i].cccd_handle;  

                if (mp_ble_nus_c->evt_handler != NULL)                {
                    ble_nus_c_evt_t nus_c_evt;
                
                    nus_c_evt.evt_type = BLE_NUS_C_EVT_FOUND_NUS_RX_CHARACTERISTIC;
                    mp_ble_nus_c->evt_handler(mp_ble_nus_c, &nus_c_evt);
                }
            }
        }
    }
}


接下看对应的事件会对应对的case 事件。这里看 BLE_NUS_C_EVT_FOUND_NUS_RX_CHARACTERISTIC 事件。这事件表示特征值的属性为notify 所以要使能监听才能收到数据,使能操作ble_nus_c_rx_notif_enable(p_ble_nus_c);

BLE_NUS_C_EVT_NUS_RX_EVT为接收从机发送数据事件。

/**@snippet [Handling events from the ble_nus_c module] */ 
static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, const ble_nus_c_evt_t * p_ble_nus_evt)
{
    uint32_t err_code;
    switch (p_ble_nus_evt->evt_type)
    {
        case BLE_NUS_C_EVT_FOUND_NUS_TX_CHARACTERISTIC:
            APPL_LOG("The device has the device TX characteristic\r\n");
            break;
        
        case BLE_NUS_C_EVT_FOUND_NUS_RX_CHARACTERISTIC:
            err_code = ble_nus_c_rx_notif_enable(p_ble_nus_c);
            APP_ERROR_CHECK(err_code);
            APPL_LOG("The device has the device RX characteristic\r\n");
            break;       
        case BLE_NUS_C_EVT_NUS_RX_EVT:
            for (uint32_t i = 0; i < p_ble_nus_evt->data_len; i++)
            {
                while(app_uart_put( p_ble_nus_evt->p_data[i]) != NRF_SUCCESS);
            }
            break;
        
        case BLE_NUS_C_EVT_DISCONNECTED:
            APPL_LOG("NUS device disconnected\r\n");
            scan_start();
            break;
    }
}


好了 到现在大概分析完了程序执行的流程。。。。。。上一张图对应ble_db_discovery_on_ble_evt()函数,执行流程

nrf51822---主从通信(1)_第1张图片

你可能感兴趣的:(nrf51822---主从通信(1))