nrf51 S120 uart communitcaion

RE: nrf51 S120 uart communitcaion

Anders Strand — Wed, 04 Nov 2015 13:02:13 GMT

Ble central tutorial is now available here.

RE: nrf51 S120 uart communitcaion

lakshman — Mon, 12 Oct 2015 05:47:14 GMT

Dear Anders, Thank you very much for detailed answer. I was going through the The nan36 application note goes trough making a custom BLE peripheral application.Most of the function calls mentioned here with some explanation. Thanks for your support. Thanks and Regards Lakshman,PMP,PMI-RMP

RE: nrf51 S120 uart communitcaion

lakshman — Fri, 09 Oct 2015 01:40:56 GMT

Hi Anders, Thanks for your reply. Yes I understand gpiote stands for General Purpose Input Out Tasks & Events. What I read from forum is its kind of replacing nrf_drv_gpiote.c functionality.from your mail its clear I don't need to use it. Yes of course we use prinf to send data through UART. I didn't that question.

My question is where I can find discovery,connection,pairing,bonding,unbonding & disconnection function calls in your stack. I can see the events notification in device manager like static ret_code_t device_manager_event_handler(const dm_handle_t * p_handle, const dm_event_t * p_event, const ret_code_t event_result) { uint32_t err_code;

switch(p_event->event_id)
{
    case DM_EVT_CONNECTION:
    {   
        nrf_gpio_pin_set(CONNECTED_LED_PIN_NO);
    printf("Connected \r\n");
        m_dm_device_handle = (*p_handle);

        // Discover peer's services. 
         err_code = ble_db_discovery_start(&m_ble_db_discovery,
                                           p_event->event_param.p_gap_param->conn_handle);
        APP_ERROR_CHECK(err_code);

        m_peer_count++;
        if (m_peer_count < MAX_PEER_COUNT)
        {
            scan_start();
        }
        break;
    }
    
    case DM_EVT_DISCONNECTION:
    {
        memset(&m_ble_db_discovery, 0 , sizeof (m_ble_db_discovery));

        nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
        if (m_peer_count == MAX_PEER_COUNT)
        {
            scan_start();
        }
        m_peer_count--;
        break;
    }
    
    case DM_EVT_SECURITY_SETUP:
    {
        // Slave securtiy request received from peer, if from a non bonded device, 
        // initiate security setup, else, wait for encryption to complete.
        err_code = dm_security_setup_req(&m_dm_device_handle);
        APP_ERROR_CHECK(err_code);
        break;
    }
    case DM_EVT_SECURITY_SETUP_COMPLETE:
    {    
         // Heart rate service discovered. Enable notification of Heart Rate Measurement.
        err_code = ble_uart_c_rx_notif_enable(&m_ble_uart_c);
        APP_ERROR_CHECK(err_code);
        break;
    }
    
    case DM_EVT_LINK_SECURED:
        break;
        
    case DM_EVT_DEVICE_CONTEXT_LOADED:
        APP_ERROR_CHECK(event_result);
        break;
        
    case DM_EVT_DEVICE_CONTEXT_STORED:
        APP_ERROR_CHECK(event_result);
        break;
        
    case DM_EVT_DEVICE_CONTEXT_DELETED:
        APP_ERROR_CHECK(event_result);
        break;
        
    default:
        break;
}

return NRF_SUCCESS;

} But I don't see the function call to control it( something like Master control panel.we do discover,connect,disconnect,bond ..etc.,).

Thanks I am aware of documentation and devzone turtorials. I am going through it.

Really appreciate your support.

Thanks and Regards Lakshman,PMP,PMI-RMP

RE: nrf51 S120 uart communitcaion

Anders Strand — Thu, 08 Oct 2015 14:45:48 GMT

Hello.

You can safely drop gpiote. It stands for General Purpose Input Output Tasks & Events. It is used for linking gpio pins to various things.

The nan36 application note goes trough making a custom BLE peripheral application. This might not be directly relevant for your central application development, but it might give you some insights on how our system is built up.

If you want to send discovered device info to a computer, you can use uart. (printf is in many examples linked to the uart).

Other resources: Our documentation portal (Infocenter) .DevZone Tutorials

EDIT: Briefly on how to scan, connect, disconnect, discover services and bond as a central device using the ble_uart_c github example. This is an initial "brain-dump" to help you gain some understanding. This post might by edited and updated in the future. It will also soon be extended to a tutorial to be found in the tutorial section.

Scanning

Scanning is started by calling scan_start(). This functions sets up the scan parameters (interval, scan window length etc) and finally calls the softdevice function sd_ble_gap_scan_start(&m_scan_param); with these parameters.

Scan results (advertisement packets from nearby BLE devices) are arriving to the application as BLE events. These events comes in trough the ble_evt_dispatch(ble_evt_t * p_ble_evt) function which passes ble event on to any module that needs them. In this case, the module which is relevant is our application in main. Here we find theon_ble_evt(ble_evt_t * p_ble_evt) function. This function contains a large switch case based on event type. The case BLE_GAP_EVT_ADV_REPORT events contains advertisement packets from the scan. Use the adv_report_parse(uint8_t type, data_t * p_advdata, data_t * p_typedata) function to extract what data you want from the advertisement packet (henceforth advdata). This function puts the data you asked for in the provided p_typedatabuffer, and returns an error code based on whether or not the requested data was found. The different data types are defined in ble_gap.h.

Based on what you find in the advdata, you can decide if you want to connect or not.

Connecting

You connect by called this function: err_code = sd_ble_gap_connect(&p_gap_evt->params.adv_report.peer_addr,&m_scan_param,&m_connection_param);. If all goes well, you receive a BLE_GAP_EVT_CONNECTED ble event. As all events are, this ble event is passed to several modules trough ble_evt_dispatch(ble_evt_t * p_ble_evt). In on_ble_evt, no action is taken on the connected-event. In the rest of the event handlers called from ble_evt_dispatch, the event leads to various actions. In most of them, the connection handle is saved to the appropriate structure.

The device manager is the module responsible for handling our relationship with other devices, for example bonding and pairing.

Discovering services

In the Device Manager, the connection event is handled and a callback to the applications' device_manager_event_handler() is called. This is a common flow in our SDK: BLE event -> Module event handler -> Callback to application event handler for that module.

We see here that on the DM_EVT_CONNECTIONevent, the function ble_db_discovery_start is called. The db_discovery module is a module that handles service discovery for us. We first initialize it in main(), and then call this start function to start a discovery after connection.

When the db_discovery module has completed its service discovery, the module will call the db_discover_evt_handlerfunction inside ble_uart_c.c. This callback was registered in ble_uart_c_init() with the call ble_db_discovery_evt_register(&uart_uuid, db_discover_evt_handler); This event handler will notify our application through the uart_c_evt_handler() function inside main.c. The event will be BLE_UART_C_EVT_DISCOVERY_COMPLETE. Here we see an extended event flow: BLE event -> Module event handler ->Service event handler -> Callback to application event handler for that service. If you want to extract the data from the service discovery, look inside db_discover_evt_handler in ble_uart_c.c. The discovery result is within the ble_db_discovery_evt_t * variable p_evt.

Disconnecting

You can call the softdevice call sd_ble_gap_disconnect(uint16_t conn_handle, uint8_t hci_status_code));To disconnect from a device. The hci status codes can be found here.

Bonding

Bonding is the action of storing pairing keys in permanent storage. This is done by the Device Manager by calling the dm_security_setup_req() function.

Unbonding

This is something you do internally in your device. If you delete the device from the permanent storage, it is in practice "unbonded". The device manager module has a function dm_device_delete() which can be used for this purpose.