How to send message from two slave to one master in nRF52

I hope to send a message from two slave to one master using nRF52 through bluetooth.

I send a message from a slave to a master with ble_app_uart_c and ble_app_uart. And I also connected two slave and one master with ble_app_multilink_central and peripheral. But I can't combine and apply that two case.

So please tell me how to send a message in multilink code, or how to use ble_app_uart as multilink.

I also found some information on internet, but I can't understand with them.

Parents
  • Yes,  on_ble_evt() is the same as ble_evt_handler(). 

    The steps above is based on SDK 12 or 13.

    From SDK 14.0.0, ble_evt_dispatch() was replaced by NRF_SDH_BLE_OBSERVER().

  • On the newest status, I've got 1 Error in Keil:

     error:  #167: argument of type "ble_nus_c_t (*)[8]" is incompatible with parameter of type "ble_nus_c_t *"

    The line is: ret_val = ble_nus_c_string_send(&m_ble_nus_c, data_array, index);

    Thats my code: 

    /**
     * Copyright (c) 2014 - 2017, Nordic Semiconductor ASA
     * 
     * All rights reserved.
     * 
     * Redistribution and use in source and binary forms, with or without modification,
     * are permitted provided that the following conditions are met:
     * 
     * 1. Redistributions of source code must retain the above copyright notice, this
     *    list of conditions and the following disclaimer.
     * 
     * 2. Redistributions in binary form, except as embedded into a Nordic
     *    Semiconductor ASA integrated circuit in a product or a software update for
     *    such product, must reproduce the above copyright notice, this list of
     *    conditions and the following disclaimer in the documentation and/or other
     *    materials provided with the distribution.
     * 
     * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
     *    contributors may be used to endorse or promote products derived from this
     *    software without specific prior written permission.
     * 
     * 4. This software, with or without modification, must only be used with a
     *    Nordic Semiconductor ASA integrated circuit.
     * 
     * 5. Any software provided in binary form under this license must not be reverse
     *    engineered, decompiled, modified and/or disassembled.
     * 
     * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
     * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
     * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
     * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
     * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
     * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     * 
     */
    /**
     * @brief BLE LED Button Service central and client application main file.
     *
     * This example can be a central for up to 8 peripherals.
     * The peripheral is called ble_app_blinky and can be found in the ble_peripheral
     * folder.
     */
    
    #include <stdint.h>
    #include <stdio.h>
    #include <string.h>
    #include "nordic_common.h"
    #include "softdevice_handler.h"
    #include "app_timer.h"
    #include "boards.h"
    #include "bsp.h"
    #include "bsp_btn_ble.h"
    #include "ble.h"
    #include "ble_hci.h"
    #include "app_uart.h"
    #include "ble_advdata.h"
    #include "ble_advertising.h"
    #include "ble_conn_params.h"
    #include "ble_db_discovery.h"
    #include "ble_lbs_c.h"
    #include "ble_conn_state.h"
    #include "nrf_ble_gatt.h"
    #include "app_uart.h"
    #include "ble_nus_c.h"
    
    #define NRF_LOG_MODULE_NAME "APP"
    #include "nrf_log.h"
    #include "nrf_log_ctrl.h"
    
    
    #define CENTRAL_LINK_COUNT        8                                             /**< Number of central links used by the application. When changing this number remember to adjust the RAM settings*/
    #define PERIPHERAL_LINK_COUNT     0                                             /**< Number of peripheral links used by the application. When changing this number remember to adjust the RAM settings*/
    #define TOTAL_LINK_COUNT          CENTRAL_LINK_COUNT + PERIPHERAL_LINK_COUNT    /**< Total number of links used by the application. */
    #define CONN_CFG_TAG              1                                             /**< A tag that refers to the BLE stack configuration we set with @ref sd_ble_cfg_set. Default tag is @ref BLE_CONN_CFG_TAG_DEFAULT. */
    
    #define CENTRAL_SCANNING_LED      BSP_BOARD_LED_0
    #define CENTRAL_CONNECTED_LED     BSP_BOARD_LED_1
    
    #define UART_TX_BUF_SIZE        256                                     /**< UART TX buffer size. */
    #define UART_RX_BUF_SIZE        256                                     /**< UART RX buffer size. */
    
    #define NUS_SERVICE_UUID_TYPE   BLE_UUID_TYPE_VENDOR_BEGIN              /**< UUID type for the Nordic UART Service (vendor specific). */
    
    
    #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_TIMEOUT              0x0000                                        /**< Timout when scanning. 0x0000 disables timeout. */
    
    #define MIN_CONNECTION_INTERVAL   MSEC_TO_UNITS(7.5, UNIT_1_25_MS)              /**< Determines minimum connection interval in milliseconds. */
    #define MAX_CONNECTION_INTERVAL   MSEC_TO_UNITS(30, UNIT_1_25_MS)               /**< Determines maximum connection interval in milliseconds. */
    #define SLAVE_LATENCY             0                                             /**< Determines slave latency in terms of connection events. */
    #define SUPERVISION_TIMEOUT       MSEC_TO_UNITS(4000, UNIT_10_MS)               /**< Determines supervision time-out in units of 10 milliseconds. */
    
    #define UUID16_SIZE             2                                       /**< Size of 16 bit UUID */
    #define UUID32_SIZE             4                                       /**< Size of 32 bit UUID */
    #define UUID128_SIZE            16                                      /**< Size of 128 bit UUID */
    
    #define ECHOBACK_BLE_UART_DATA  1                                       /**< Echo the UART data that is received over the Nordic UART Service back to the sender. */
    
    #define LEDBUTTON_LED             BSP_BOARD_LED_2                               /**< LED to indicate a change of state of the the Button characteristic on the peer. */
    
    #define LEDBUTTON_BUTTON_PIN      BSP_BUTTON_0                                  /**< Button that will write to the LED characteristic of the peer. */
    #define BUTTON_DETECTION_DELAY    APP_TIMER_TICKS(50)                           /**< Delay from a GPIOTE event until a button is reported as pushed (in number of timer ticks). */
    
    static ble_nus_c_t              m_ble_nus_c[TOTAL_LINK_COUNT];                            /**< Instance of NUS service. Must be passed to all NUS_C API calls. */
    static nrf_ble_gatt_t           m_gatt;                                 /**< GATT module instance. */
    static uint16_t                 m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH; /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
    
    
    
    static char const m_target_periph_name[] = "Nordic_Blinky";                     /**< Name of the device we try to connect to. This name is searched for in the scan report data*/
    
    /** @brief Scan parameters requested for scanning and connection. */
    static ble_gap_scan_params_t const m_scan_params =
    {
        .active   = 0,
        .interval = SCAN_INTERVAL,
        .window   = SCAN_WINDOW,
        .timeout  = SCAN_TIMEOUT,
    
        #if (NRF_SD_BLE_API_VERSION <= 2)
            .selective   = 0,
            .p_whitelist = NULL,
        #endif
    
        #if (NRF_SD_BLE_API_VERSION >= 3)
            .use_whitelist  = 0,
            .adv_dir_report = 0,
        #endif
    };
    
    /**@brief Connection parameters requested for connection. */
    static ble_gap_conn_params_t const m_connection_param =
    {
        (uint16_t)MIN_CONNECTION_INTERVAL,
        (uint16_t)MAX_CONNECTION_INTERVAL,
        (uint16_t)SLAVE_LATENCY,
        (uint16_t)SUPERVISION_TIMEOUT
    };
    
    static ble_lbs_c_t        m_ble_lbs_c[TOTAL_LINK_COUNT];           /**< Main structures used by the LED Button client module. */
    static uint8_t            m_ble_lbs_c_count;                       /**< Keeps track of how many instances of LED Button client module have been initialized. >*/
    static ble_db_discovery_t m_ble_db_discovery[TOTAL_LINK_COUNT];    /**< list of DB structures used by the database discovery module. */
    static nrf_ble_gatt_t     m_gatt;                                  /**< GATT module instance. */
    
    
    /**@brief Function to handle asserts in the SoftDevice.
     *
     * @details This function will be called in case of an assert in the SoftDevice.
     *
     * @warning This handler is an example only and does not fit a final product. You need to analyze
     *          how your product is supposed to react in case of Assert.
     * @warning On assert from the SoftDevice, the system can only recover on reset.
     *
     * @param[in] line_num     Line number of the failing ASSERT call.
     * @param[in] p_file_name  File name of the failing ASSERT call.
     */
    void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
    {
        app_error_handler(0xDEADBEEF, line_num, p_file_name);
    }
    
    
    /**@brief Function for the LEDs initialization.
     *
     * @details Initializes all LEDs used by the application.
     */
    static void leds_init(void)
    {
        bsp_board_leds_init();
    }
    
    
    /**@brief NUS uuid. */
    static ble_uuid_t const m_nus_uuid =
    {
        .uuid = BLE_UUID_NUS_SERVICE,
        .type = NUS_SERVICE_UUID_TYPE
    };
    
    /**@brief Function to start scanning.
     */
    static void scan_start(void)
    {
        ret_code_t ret;
    
        (void) sd_ble_gap_scan_stop();
    
        NRF_LOG_INFO("Start scanning for device name %s.\r\n", (uint32_t)m_target_periph_name);
        ret = sd_ble_gap_scan_start(&m_scan_params);
        APP_ERROR_CHECK(ret);
    
        ret = bsp_indication_set(BSP_INDICATE_SCANNING);
        APP_ERROR_CHECK(ret);
    }
    
    /**
     * @brief Parses advertisement data, providing length and location of the field in case
     *        matching data is found.
     *
     * @param[in]  type       Type of data to be looked for in advertisement data.
     * @param[in]  p_advdata  Advertisement report length and pointer to report.
     * @param[out] p_typedata If data type requested is found in the data report, type data length and
     *                        pointer to data will be populated here.
     *
     * @retval NRF_SUCCESS if the data type is found in the report.
     * @retval NRF_ERROR_NOT_FOUND if the data type could not be found.
     */
    static uint32_t adv_report_parse(uint8_t type, uint8_array_t * p_advdata, uint8_array_t * p_typedata)
    {
        uint32_t  index = 0;
        uint8_t * p_data;
    
        p_data = p_advdata->p_data;
    
        while (index < p_advdata->size)
        {
            uint8_t field_length = p_data[index];
            uint8_t field_type   = p_data[index + 1];
    
            if (field_type == type)
            {
                p_typedata->p_data = &p_data[index + 2];
                p_typedata->size   = field_length - 1;
                return NRF_SUCCESS;
            }
            index += field_length + 1;
        }
        return NRF_ERROR_NOT_FOUND;
    }
    
    /**@brief   Function for handling app_uart events.
     *
     * @details This function will receive a single character from the app_uart module and append it to
     *          a string. The string will be be sent over BLE when the last character received was a
     *          'new line' '\n' (hex 0x0A) or if the string has reached the maximum data length.
     */
    void uart_event_handle(app_uart_evt_t * p_event)
    {
        static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
        static uint16_t index = 0;
        uint32_t ret_val;
    
        switch (p_event->evt_type)
        {
            /**@snippet [Handling data from UART] */
            case APP_UART_DATA_READY:
                UNUSED_VARIABLE(app_uart_get(&data_array[index]));
                index++;
    
                if ((data_array[index - 1] == '\n') || (index >= (m_ble_nus_max_data_len)))
                {
                    NRF_LOG_DEBUG("Ready to send data over BLE NUS\r\n");
                    NRF_LOG_HEXDUMP_DEBUG(data_array, index);
    
                    do
                    {
                        ret_val = ble_nus_c_string_send(&m_ble_nus_c, data_array, index);
                        if ( (ret_val != NRF_ERROR_INVALID_STATE) && (ret_val != NRF_ERROR_BUSY) )
                        {
                            APP_ERROR_CHECK(ret_val);
                        }
                    } while (ret_val == NRF_ERROR_BUSY);
    
                    index = 0;
                }
                break;
    
            /**@snippet [Handling data from UART] */
            case APP_UART_COMMUNICATION_ERROR:
                NRF_LOG_ERROR("Communication error occurred while handling UART.\r\n");
                APP_ERROR_HANDLER(p_event->data.error_communication);
                break;
    
            case APP_UART_FIFO_ERROR:
                NRF_LOG_ERROR("Error occurred in FIFO module used by UART.\r\n");
                APP_ERROR_HANDLER(p_event->data.error_code);
                break;
    
            default:
                break;
        }
    }
    
    /**@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)
    {
        ret_code_t err_code;
    
        switch (p_ble_nus_evt->evt_type)
        {
            case BLE_NUS_C_EVT_DISCOVERY_COMPLETE:
                NRF_LOG_INFO("Discovery complete.\r\n");
                err_code = ble_nus_c_handles_assign(p_ble_nus_c, p_ble_nus_evt->conn_handle, &p_ble_nus_evt->handles);
                APP_ERROR_CHECK(err_code);
    
                err_code = ble_nus_c_tx_notif_enable(p_ble_nus_c);
                APP_ERROR_CHECK(err_code);
                printf("Connected to device with Nordic UART Service.\r\n");
                break;
    
            case BLE_NUS_C_EVT_NUS_TX_EVT:
                ble_nus_chars_received_uart_print(p_ble_nus_evt->p_data, p_ble_nus_evt->data_len);
                break;
    
            case BLE_NUS_C_EVT_DISCONNECTED:
                NRF_LOG_INFO("Disconnected.\r\n");
                scan_start();
                break;
        }
    }
    
    
    
    
    
    /**@brief Handles events coming from the LED Button central module.
     *
     * @param[in] p_lbs_c     The instance of LBS_C that triggered the event.
     * @param[in] p_lbs_c_evt The LBS_C event.
     */
    static void lbs_c_evt_handler(ble_lbs_c_t * p_lbs_c, ble_lbs_c_evt_t * p_lbs_c_evt)
    {
        switch (p_lbs_c_evt->evt_type)
        {
            case BLE_LBS_C_EVT_DISCOVERY_COMPLETE:
            {
                ret_code_t err_code;
    
                NRF_LOG_INFO("LED Button service discovered on conn_handle 0x%x\r\n",
                        p_lbs_c_evt->conn_handle);
    
                err_code = app_button_enable();
                APP_ERROR_CHECK(err_code);
    
                // LED Button service discovered. Enable notification of Button.
                err_code = ble_lbs_c_button_notif_enable(p_lbs_c);
                APP_ERROR_CHECK(err_code);
            } break; // BLE_LBS_C_EVT_DISCOVERY_COMPLETE
    
            case BLE_LBS_C_EVT_BUTTON_NOTIFICATION:
            {
                NRF_LOG_INFO("Link 0x%x, Button state changed on peer to 0x%x\r\n",
                               p_lbs_c_evt->conn_handle,
                               p_lbs_c_evt->params.button.button_state);
                if (p_lbs_c_evt->params.button.button_state)
                {
                    bsp_board_led_on(LEDBUTTON_LED);
                }
                else
                {
                    bsp_board_led_off(LEDBUTTON_LED);
                }
            } break; // BLE_LBS_C_EVT_BUTTON_NOTIFICATION
    
            default:
                // No implementation needed.
                break;
        }
    }
    
    /**@brief Function for handling the advertising report BLE event.
     *
     * @param[in] p_ble_evt  Bluetooth stack event.
     */
    static void on_adv_report(ble_evt_t const * p_ble_evt)
    {
        uint32_t      err_code;
        uint8_array_t adv_data;
        uint8_array_t dev_name;
        bool          do_connect = false;
    
        // For readibility.
        ble_gap_evt_t  const * p_gap_evt  = &p_ble_evt->evt.gap_evt;
        ble_gap_addr_t const * peer_addr  = &p_gap_evt->params.adv_report.peer_addr;
    
        // Prepare advertisement report for parsing.
        adv_data.p_data = (uint8_t *)p_gap_evt->params.adv_report.data;
        adv_data.size   = p_gap_evt->params.adv_report.dlen;
    
        // Search for advertising names.
        bool found_name = false;
        err_code = adv_report_parse(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME,
                                    &adv_data,
                                    &dev_name);
        if (err_code != NRF_SUCCESS)
        {
            // Look for the short local name if it was not found as complete.
            err_code = adv_report_parse(BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME, &adv_data, &dev_name);
            if (err_code != NRF_SUCCESS)
            {
                // If we can't parse the data, then exit.
                return;
            }
            else
            {
                found_name = true;
            }
        }
        else
        {
            found_name = true;
        }
    
        if (found_name)
        {
            if (strlen(m_target_periph_name) != 0)
            {
                if (memcmp(m_target_periph_name, dev_name.p_data, dev_name.size) == 0)
                {
                    do_connect = true;
                }
            }
        }
    
        if (do_connect)
        {
            // Initiate connection.
            err_code = sd_ble_gap_connect(peer_addr,
                                          &m_scan_params, &m_connection_param,
                                          CONN_CFG_TAG);
            if (err_code != NRF_SUCCESS)
            {
                NRF_LOG_ERROR("Connection Request Failed, reason %d\r\n", err_code);
            }
        }
    }
    
    static bool is_uuid_present(ble_uuid_t               const * p_target_uuid,
                                ble_gap_evt_adv_report_t const * p_adv_report)
    {
        ret_code_t   err_code;
        ble_uuid_t   extracted_uuid;
        uint16_t     index  = 0;
        uint8_t    * p_data = (uint8_t *)p_adv_report->data;
    
        while (index < p_adv_report->dlen)
        {
            uint8_t field_length = p_data[index];
            uint8_t field_type   = p_data[index + 1];
    
            if (   (field_type == BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_MORE_AVAILABLE)
                || (field_type == BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_COMPLETE))
            {
                for (uint32_t i = 0; i < (field_length / UUID16_SIZE); i++)
                {
                    err_code = sd_ble_uuid_decode(UUID16_SIZE,
                                                  &p_data[i * UUID16_SIZE + index + 2],
                                                  &extracted_uuid);
    
                    if (err_code == NRF_SUCCESS)
                    {
                        if ((extracted_uuid.uuid == p_target_uuid->uuid)
                            && (extracted_uuid.type == p_target_uuid->type))
                        {
                            return true;
                        }
                    }
                }
            }
            else if (   (field_type == BLE_GAP_AD_TYPE_32BIT_SERVICE_UUID_MORE_AVAILABLE)
                     || (field_type == BLE_GAP_AD_TYPE_32BIT_SERVICE_UUID_COMPLETE))
            {
                for (uint32_t i = 0; i < (field_length / UUID32_SIZE); i++)
                {
                    err_code = sd_ble_uuid_decode(UUID32_SIZE,
                                                  &p_data[i * UUID32_SIZE + index + 2],
                                                  &extracted_uuid);
    
                    if (err_code == NRF_SUCCESS)
                    {
                        if (   (extracted_uuid.uuid == p_target_uuid->uuid)
                            && (extracted_uuid.type == p_target_uuid->type))
                        {
                            return true;
                        }
                    }
                }
            }
    
            else if (   (field_type == BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_MORE_AVAILABLE)
                     || (field_type == BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_COMPLETE))
            {
                err_code = sd_ble_uuid_decode(UUID128_SIZE, &p_data[index + 2], &extracted_uuid);
                if (err_code == NRF_SUCCESS)
                {
                    if (   (extracted_uuid.uuid == p_target_uuid->uuid)
                        && (extracted_uuid.type == p_target_uuid->type))
                    {
                        return true;
                    }
                }
            }
            index += field_length + 1;
        }
        return false;
    }
    
    /**@brief Function for handling BLE Stack events concerning central applications.
     *
     * @details This function keeps the connection handles of central applications up-to-date. It
     *          parses scanning reports, initiating a connection attempt to peripherals when a
     *          target UUID is found, and manages connection parameter update requests. Additionally,
     *          it updates the status of LEDs used to report central applications activity.
     *
     * @note Since this function updates connection handles, @ref BLE_GAP_EVT_DISCONNECTED events
     *       should be dispatched to the target application before invoking this function.
     *
     * @param[in] p_ble_evt  Bluetooth stack event.
     */
    static void on_ble_evt(ble_evt_t const * p_ble_evt)
    {
        ret_code_t err_code;
    
        // For readability.
        ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt;
    
        switch (p_ble_evt->header.evt_id)
        {
            // Upon connection, check which peripheral has connected, initiate DB
            // discovery, update LEDs status and resume scanning if necessary.
            case BLE_GAP_EVT_CONNECTED:
            {
    					NRF_LOG_INFO("Connected to target\r\n");
                err_code = ble_nus_c_handles_assign(m_ble_nus_c, p_ble_evt->evt.gap_evt.conn_handle, NULL);
                APP_ERROR_CHECK(err_code);
    
                err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
                APP_ERROR_CHECK(err_code);
    
                // 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);
    					
                NRF_LOG_INFO("Connection 0x%x established, starting DB discovery.\r\n",
                             p_gap_evt->conn_handle);
    
                APP_ERROR_CHECK_BOOL(p_gap_evt->conn_handle < TOTAL_LINK_COUNT);
    
                err_code = ble_lbs_c_handles_assign(&m_ble_lbs_c[p_gap_evt->conn_handle],
                                                    p_gap_evt->conn_handle,
                                                    NULL);
                APP_ERROR_CHECK(err_code);
    
                memset(&m_ble_db_discovery[p_gap_evt->conn_handle], 0x00, sizeof(ble_db_discovery_t));
                err_code = ble_db_discovery_start(&m_ble_db_discovery[p_gap_evt->conn_handle],
                                                  p_gap_evt->conn_handle);
                if (err_code != NRF_ERROR_BUSY)
                {
                    APP_ERROR_CHECK(err_code);
                }
    
                // Update LEDs status, and check if we should be looking for more
                // peripherals to connect to.
                bsp_board_led_on(CENTRAL_CONNECTED_LED);
                if (ble_conn_state_n_centrals() == CENTRAL_LINK_COUNT)
                {
                    bsp_board_led_off(CENTRAL_SCANNING_LED);
                }
                else
                {
                    // Resume scanning.
                    bsp_board_led_on(CENTRAL_SCANNING_LED);
                    scan_start();
                }
            } break; // BLE_GAP_EVT_CONNECTED
    
            // Upon disconnection, reset the connection handle of the peer which disconnected, update
            // the LEDs status and start scanning again.
            case BLE_GAP_EVT_DISCONNECTED:
            {
                NRF_LOG_INFO("LBS central link 0x%x disconnected (reason: 0x%x)\r\n",
                             p_gap_evt->conn_handle,
                             p_gap_evt->params.disconnected.reason);
    
                if (ble_conn_state_n_centrals() == 0)
                {
                    err_code = app_button_disable();
                    APP_ERROR_CHECK(err_code);
    
                    // Turn off connection indication LED
                    bsp_board_led_off(CENTRAL_CONNECTED_LED);
                }
    
                // Start scanning
                scan_start();
    
                // Turn on LED for indicating scanning
                bsp_board_led_on(CENTRAL_SCANNING_LED);
    
            } break;
    
            case BLE_GAP_EVT_ADV_REPORT:
                on_adv_report(p_ble_evt);
    				
    				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,
                                                  CONN_CFG_TAG);
    
                    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);
                        NRF_LOG_INFO("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_TIMEOUT:
            {
                if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_SCAN)
                {
                    NRF_LOG_INFO("Scan timed out.\r\n");
                    scan_start();
                }
                else if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
                {
                    NRF_LOG_INFO("Connection Request timed out.\r\n");
                }
            } break;
    
            case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
            {
                NRF_LOG_DEBUG("BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST.\r\n");
                // Accept 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;
    
    				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; // BLE_GAP_EVT_SEC_PARAMS_REQUEST
    				
            case BLE_GATTC_EVT_TIMEOUT:
            {
                // Disconnect on GATT Client timeout event.
                NRF_LOG_DEBUG("GATT Client Timeout.\r\n");
                err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
                                                 BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
                APP_ERROR_CHECK(err_code);
            } break;
    
            case BLE_GATTS_EVT_TIMEOUT:
            {
                // Disconnect on GATT Server timeout event.
                NRF_LOG_DEBUG("GATT Server Timeout.\r\n");
                err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
                                                 BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
                APP_ERROR_CHECK(err_code);
            } break;
    
            default:
                // No implementation needed.
                break;
        }
    }
    
    
    /**@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)
    {
        uint16_t conn_handle;
        conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
    
        ble_conn_state_on_ble_evt(p_ble_evt);
        on_ble_evt(p_ble_evt);
    
        // Make sure taht an invalid connection handle are not passed since
        // our array of modules is bound to TOTAL_LINK_COUNT.
        if (conn_handle < TOTAL_LINK_COUNT)
        {
            ble_db_discovery_on_ble_evt(&m_ble_db_discovery[conn_handle], p_ble_evt);
            ble_lbs_c_on_ble_evt(&m_ble_lbs_c[conn_handle], p_ble_evt);
        }
    
        nrf_ble_gatt_on_ble_evt(&m_gatt, p_ble_evt);
    		ble_nus_c_on_ble_evt(m_ble_nus_c,p_ble_evt);
    }
    
    
    
    /**@brief LED Button collector initialization.
     */
    static void lbs_c_init(void)
    {
        ret_code_t       err_code;
        ble_lbs_c_init_t lbs_c_init_obj;
    
        lbs_c_init_obj.evt_handler = lbs_c_evt_handler;
    
        for (m_ble_lbs_c_count = 0; m_ble_lbs_c_count < TOTAL_LINK_COUNT; m_ble_lbs_c_count++)
        {
            err_code = ble_lbs_c_init(&m_ble_lbs_c[m_ble_lbs_c_count], &lbs_c_init_obj);
            APP_ERROR_CHECK(err_code);
        }
        m_ble_lbs_c_count = 0;
    }
    
    
    /**@brief Function for initializing the BLE stack.
     *
     * @details Initializes the SoftDevice and the BLE event interrupts.
     */
    static void ble_stack_init(void)
    {
        ret_code_t err_code;
    
        nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
    
        // Initialize the SoftDevice handler module.
        SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);
    
        // Fetch the start address of the application RAM.
        uint32_t ram_start = 0;
        err_code = softdevice_app_ram_start_get(&ram_start);
        APP_ERROR_CHECK(err_code);
    
        // Overwrite some of the default configurations for the BLE stack.
        ble_cfg_t ble_cfg;
    
        // Configure the maximum number of connections.
        memset(&ble_cfg, 0, sizeof(ble_cfg));
        ble_cfg.gap_cfg.role_count_cfg.periph_role_count  = PERIPHERAL_LINK_COUNT;
        ble_cfg.gap_cfg.role_count_cfg.central_role_count = CENTRAL_LINK_COUNT;
        ble_cfg.gap_cfg.role_count_cfg.central_sec_count  = 1;
        err_code = sd_ble_cfg_set(BLE_GAP_CFG_ROLE_COUNT, &ble_cfg, ram_start);
        APP_ERROR_CHECK(err_code);
    
        memset(&ble_cfg, 0, sizeof(ble_cfg));
        ble_cfg.conn_cfg.params.gap_conn_cfg.conn_count     = PERIPHERAL_LINK_COUNT + CENTRAL_LINK_COUNT;
        ble_cfg.conn_cfg.params.gap_conn_cfg.event_length   = BLE_GAP_EVENT_LENGTH_DEFAULT;
        ble_cfg.conn_cfg.conn_cfg_tag                       = CONN_CFG_TAG;
        err_code = sd_ble_cfg_set(BLE_CONN_CFG_GAP, &ble_cfg, ram_start);
        APP_ERROR_CHECK(err_code);
    
        // Enable BLE stack.
        err_code = softdevice_enable(&ram_start);
        APP_ERROR_CHECK(err_code);
    
        // Register with the SoftDevice handler module for BLE events.
        err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for writing to the LED characteristic of all connected clients.
     *
     * @details Based on if the button is pressed or released, this function writes a high or low
     *          LED status to the server.
     *
     * @param[in] button_action The button action (press/release).
     *            Determines if the LEDs of the servers will be ON or OFF.
     *
     * @return If successful NRF_SUCCESS is returned. Otherwise, the error code from @ref ble_lbs_led_status_send.
     */
    static ret_code_t led_status_send_to_all(uint8_t button_action)
    {
        ret_code_t err_code;
    
        for (uint32_t i = 0; i < CENTRAL_LINK_COUNT; i++)
        {
            err_code = ble_lbs_led_status_send(&m_ble_lbs_c[i], button_action);
            if (err_code != NRF_SUCCESS &&
                err_code != BLE_ERROR_INVALID_CONN_HANDLE &&
                err_code != NRF_ERROR_INVALID_STATE)
            {
                return err_code;
            }
        }
            return NRF_SUCCESS;
    }
    
    
    /**@brief Function for handling events from the button handler module.
     *
     * @param[in] pin_no        The pin that the event applies to.
     * @param[in] button_action The button action (press/release).
     */
    static void button_event_handler(uint8_t pin_no, uint8_t button_action)
    {
        ret_code_t err_code;
    
        switch (pin_no)
        {
            case LEDBUTTON_BUTTON_PIN:
                err_code = led_status_send_to_all(button_action);
                if (err_code == NRF_SUCCESS)
                {
                    NRF_LOG_INFO("LBS write LED state %d\r\n", button_action);
                }
                break;
    
            default:
                APP_ERROR_HANDLER(pin_no);
                break;
        }
    }
    
    
    /**@brief Function for initializing the button handler module.
     */
    static void buttons_init(void)
    {
        ret_code_t err_code;
    
       //The array must be static because a pointer to it will be saved in the button handler module.
        static app_button_cfg_t buttons[] =
        {
            {LEDBUTTON_BUTTON_PIN, false, BUTTON_PULL, button_event_handler}
        };
    
        err_code = app_button_init(buttons, sizeof(buttons) / sizeof(buttons[0]),
                                   BUTTON_DETECTION_DELAY);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for handling database discovery events.
     *
     * @details This function is callback function to handle events from the database discovery module.
     *          Depending on the UUIDs that are discovered, this function should forward the events
     *          to their respective services.
     *
     * @param[in] p_event  Pointer to the database discovery event.
     */
    static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
    {
        NRF_LOG_DEBUG("call to ble_lbs_on_db_disc_evt for instance %d and link 0x%x!\r\n",
                      p_evt->conn_handle,
                      p_evt->conn_handle);
    
        ble_lbs_on_db_disc_evt(&m_ble_lbs_c[p_evt->conn_handle], p_evt);
    }
    
    
    /** @brief Database discovery initialization.
     */
    static void db_discovery_init(void)
    {
        ret_code_t err_code = ble_db_discovery_init(db_disc_handler);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /** @brief Function to sleep until a BLE event is received by the application.
     */
    static void power_manage(void)
    {
        ret_code_t err_code = sd_app_evt_wait();
        APP_ERROR_CHECK(err_code);
    }
    
    
    /** @brief Function for initializing the log module.
     */
    static void log_init(void)
    {
        ret_code_t err_code = NRF_LOG_INIT(NULL);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /** @brief Function for initializing the timer.
     */
    static void timer_init(void)
    {
        ret_code_t err_code = app_timer_init();
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for initializing the GATT module.
     */
    static void gatt_init(void)
    {
        ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for initializing the NUS Client. */
    static void nus_c_init(void)
    {
        ret_code_t       err_code;
        ble_nus_c_init_t init;
    
        init.evt_handler = ble_nus_c_evt_handler;
    
    	
    		for (m_ble_lbs_c_count = 0; m_ble_lbs_c_count < TOTAL_LINK_COUNT; m_ble_lbs_c_count++)
        {
            err_code = ble_nus_c_init(&m_ble_nus_c[m_ble_lbs_c_count], &init);
            APP_ERROR_CHECK(err_code);
        }
        m_ble_lbs_c_count = 0;
    }
    
    /**@brief Function for initializing the UART. */
    static void uart_init(void)
    {
        ret_code_t err_code;
    
        const app_uart_comm_params_t comm_params =
          {
            .rx_pin_no    = RX_PIN_NUMBER,
            .tx_pin_no    = TX_PIN_NUMBER,
            .rts_pin_no   = RTS_PIN_NUMBER,
            .cts_pin_no   = CTS_PIN_NUMBER,
            .flow_control = APP_UART_FLOW_CONTROL_DISABLED,
            .use_parity   = false,
            .baud_rate    = UART_BAUDRATE_BAUDRATE_Baud115200
          };
    
        APP_UART_FIFO_INIT(&comm_params,
                           UART_RX_BUF_SIZE,
                           UART_TX_BUF_SIZE,
                           uart_event_handle,
                           APP_IRQ_PRIORITY_LOWEST,
                           err_code);
    
        APP_ERROR_CHECK(err_code);
    }
    
    int main(void)
    {
        log_init();
    		uart_init();
        timer_init();
        leds_init();
        buttons_init();
        ble_stack_init();
        gatt_init();
        db_discovery_init();
        //lbs_c_init();
        ble_conn_state_init();
    		nus_c_init();
    	
        NRF_LOG_INFO("Multilink example started.\r\n");
    
        // Start scanning for peripherals and initiate connection to devices which
        // advertise.
        scan_start();
    
        // Turn on the LED to signal scanning.
        bsp_board_led_on(CENTRAL_SCANNING_LED);
    
        for (;;)
        {
            if (NRF_LOG_PROCESS() == false)
            {
                // Wait for BLE events.
                power_manage();
            }
        }
    }
    

    I don't understand this error 100%, is it because it can't match the pointers? 

    Thanks for your help :)

  • Hi 

    I am trying same thing here with nRF52840-DK Boards.

    Code attached above is built and connecting to other peripheral board as well. Thank you for sharing it.

    My Question is that To connect let say 4 to 5 peripheral sensor to one central device which method will be more efficient, Bluetooth mesh or by adding here in same example number of sensor.   

  • Hello Vipul2988,

    Vipul2988 said:
    Code attached above is built and connecting to other peripheral board as well. Thank you for sharing it.

    No problem at all, I am happy to hear that it is working!

    Vipul2988 said:
    My Question is that To connect let say 4 to 5 peripheral sensor to one central device which method will be more efficient, Bluetooth mesh or by adding here in same example number of sensor.   

    That depends a little on what you mean by efficient - do you mean in terms of latency or power consumption, etc?
    In general, for 4-5 sensors, the answer is very likely to use the multilink example. The Bluetooth mesh protocol requires the radio to be listening almost constantly, and thus its power consumption is a lot higher than that of BLE linked devices. Furthermore, the throughput through the mesh network is also a lot less than through BLE connections.
    If you elaborate on your requirements and constraints I can be more specific, but for 4-5 peripheral sensor devices sending data to a central the BLE connections will most likely be your best option.

    Best regards,
    Karl

  • Hi ,

    Thank you for your quick response.

    Efficient in terms of Latency I am talking about, though our application is not critical in which we want all sensor reading within 500ms to 1 second.

    also you provided good information for power efficiency point of view as well, that really helps.

    In addition, we have already BLE application is running in nRF52840 Customized board with internal Sensor data values, We want to expand the capability of our application/Device via adding external BLE compatible sensors. 

    I got my answer but want to know more if you have any PRONS and CONS related to our application using mesh vs. Multilink BLE connection. 

  • Vipul2988 said:
    Thank you for your quick response.

    No problem at all, I am happy to help!

    Vipul2988 said:
    Efficient in terms of Latency I am talking about, though our application is not critical in which we want all sensor reading within 500ms to 1 second.

    Thank you for clarifying - this requirement should be fulfilled by either of the protocols, but I would still recommend the BLE multilink approach due to the number of devices and power consumption of BT Mesh.

    Vipul2988 said:
    In addition, we have already BLE application is running in nRF52840 Customized board with internal Sensor data values, We want to expand the capability of our application/Device via adding external BLE compatible sensors. 

    Thank you for elaborating, this makes your project much easier to understand and advice.
    If you only intend to have 4-5 peripheral devices, within BLE connection range, then I would suggest pursuing this with BLE multilink network topology.
    If you need this to be scalable, i.e suddenly adding more sensors and devices to it later, you might instead want to look at using Mesh topology.

    Vipul2988 said:
    I got my answer but want to know more if you have any PRONS and CONS related to our application using mesh vs. Multilink BLE connection. 

    If you want to discuss more in details the differences between BT Mesh and a multilink central, I would prefer it if you could open a new ticket on this separately, since it diverges from the original topic of this ticket. This keeps the forum tidy, and makes it easier for other forum-goers to find the answer if they have a similar question in the future.

    Best regards,
    Karl

Reply Children
Related