multilink [ble_app_uart] - [ble_app_multilink_central](3)

[yokokawa]

OS ：Windows7
HARD :(Taiyo Yuden)EBSHSN Series Evaluation Board
CPU :(Nordic) nRF52832 / ARM Cortex-M4F 32 bit processor 28-pin Land Grid Array / 15GPIOs / SWD
Soft Ver:nRF5_SDK_15.0.0_a53641a

Using [ble_app_multilink_central] and [ble_app_uart_c], I created a program that performs multi-link UART communication, but immediately after the first peripheral was linked
Error 0x011 will be issued.
Please tell me the possible causes.
Thanking you in advance.



    

        Fullscreen
        main.c
        Download
    
    
/*---------------------------------------------------------------------------*/
/* multilink uart process            										 */ 
/*---------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdint.h>
#include "nordic_common.h"
#include "ble_db_discovery.h"
#include "app_timer.h"
#include "bsp_btn_ble.h"
#include "ble.h"
#include "ble_hci.h"
#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#include "ble_advdata.h"
#include "nrf_ble_gatt.h"
#include "nrf_pwr_mgmt.h"
/*-< multi setting >-*/
#include <string.h>
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "ble_conn_state.h"
/*-< uart setting >-*/
#include <stdbool.h>
#include "app_error.h"
#include "app_uart.h"
#include "app_util.h"
#include "ble_gap.h"
#include "nrf_sdh_soc.h"
#include "ble_nus_c.h"
/*-< log setting >-*/
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

/*------------------------------------------------------------------------------*/
#define APP_BLE_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 APP_BLE_OBSERVER_PRIO   3                                       /**< Application's BLE observer priority. You shoulnd't need to modify this value. */
#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_DURATION           0x0000                                  /**< Timout when scanning. 0x0000 disables timeout. */
#define MIN_CONNECTION_INTERVAL MSEC_TO_UNITS(20, UNIT_1_25_MS)         /**< Determines minimum connection interval in millisecond. */
#define MAX_CONNECTION_INTERVAL MSEC_TO_UNITS(75, UNIT_1_25_MS)         /**< Determines maximum connection interval in millisecond. */
#define SLAVE_LATENCY           0                                       /**< Determines slave latency in counts of connection events. */
#define SUPERVISION_TIMEOUT     MSEC_TO_UNITS(4000, UNIT_10_MS)         /**< Determines supervision time-out in units of 10 millisecond. */
/*-< uart setting >-*/
#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 ECHOBACK_BLE_UART_DATA  0                                       /**< Echo the UART data that is received over the Nordic UART Service back to the sender. */

/*------------------------------------------------------------------------------*/
NRF_BLE_GATT_DEF(m_gatt);                                          		/**< GATT module instance. */
BLE_NUS_C_ARRAY_DEF(m_ble_nus_c, NRF_SDH_BLE_CENTRAL_LINK_COUNT);		/**< BLE NUS service client instance. */
BLE_DB_DISCOVERY_ARRAY_DEF(m_db_disc,  NRF_SDH_BLE_CENTRAL_LINK_COUNT);	/**< DB discovery module instance. */

/*------------------------------------------------------------------------------*/
static char const m_target_periph_name[] = "Nordic_UART";				/**< Name of the device we try to connect to. This name is searched for in the scan report data*/
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. */
/**@brief NUS uuid. */
#if 0
static ble_uuid_t const m_nus_uuid = {
    .uuid = BLE_UUID_NUS_SERVICE,
    .type = NUS_SERVICE_UUID_TYPE
};
#endif

static uint8_t m_scan_buffer_data[BLE_GAP_SCAN_BUFFER_MIN]; /**< buffer where advertising reports will be stored by the SoftDevice. */

/**@brief Pointer to the buffer where advertising reports will be stored by the SoftDevice. */
static ble_data_t m_scan_buffer =
{
    m_scan_buffer_data,
    BLE_GAP_SCAN_BUFFER_MIN
};

/** @brief Parameters used when scanning. */
static ble_gap_scan_params_t const m_scan_params =
{
    .active   = 0,
    .interval = SCAN_INTERVAL,
    .window   = SCAN_WINDOW,
    .timeout          = SCAN_DURATION,
    .scan_phys        = BLE_GAP_PHY_1MBPS,
    .filter_policy    = BLE_GAP_SCAN_FP_ACCEPT_ALL,
};

/**@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
};

/**@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 to start scanning. */
static void scan_start(void)
{
    ret_code_t ret;

    (void) sd_ble_gap_scan_stop();			/* multlink function */

    NRF_LOG_INFO("Start scanning for device name %s.", (uint32_t)m_target_periph_name);
    ret = sd_ble_gap_scan_start(&m_scan_params, &m_scan_buffer);
    APP_ERROR_CHECK(ret);
    // Turn on the LED to signal scanning.
//    bsp_board_led_on(CENTRAL_SCANNING_LED);
}

/**@brief Function for handling characters received by the Nordic UART Service.
 *
 * @details This function takes a list of characters of length data_len and prints the characters out on UART.
 *          If @ref ECHOBACK_BLE_UART_DATA is set, the data is sent back to sender.
 */
static void ble_nus_chars_received_uart_print(uint8_t * p_data, uint16_t data_len)
{
    ret_code_t ret_val;

    NRF_LOG_DEBUG("Receiving data.");
    NRF_LOG_HEXDUMP_DEBUG(p_data, data_len);

    for (uint32_t i = 0; i < data_len; i++)
    {
         do
        {
            ret_val = app_uart_put(p_data[i]);
            if ((ret_val != NRF_SUCCESS) && (ret_val != NRF_ERROR_BUSY))
            {
                NRF_LOG_ERROR("app_uart_put failed for index 0x%04x.", i);
                APP_ERROR_CHECK(ret_val);
            }
        } while (ret_val == NRF_ERROR_BUSY);
    }
    if (p_data[data_len-1] == '\r')
    {
        while (app_uart_put('\n') == NRF_ERROR_BUSY);
    }
/*-< Echo Back Proc >-*/		
    if (ECHOBACK_BLE_UART_DATA)
    {
		for (uint32_t i = 0; i< NRF_SDH_BLE_CENTRAL_LINK_COUNT; i++)
		{
			// Send data back to peripheral.
			do
			{
				ret_val = ble_nus_c_string_send(&m_ble_nus_c[i], p_data, data_len);
				if ((ret_val != NRF_SUCCESS) && (ret_val != NRF_ERROR_BUSY))
				{
					NRF_LOG_ERROR("Failed sending NUS message. Error 0x%x. ", ret_val);
					APP_ERROR_CHECK(ret_val);
				}
			} while (ret_val == NRF_ERROR_BUSY);
		}
	}
}

/**@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");
                NRF_LOG_HEXDUMP_DEBUG(data_array, index);

				for (uint32_t i = 0; i< NRF_SDH_BLE_CENTRAL_LINK_COUNT; i++)
				{
					do
					{
						ret_val = ble_nus_c_string_send(&m_ble_nus_c[i], 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.");
            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.");
            APP_ERROR_HANDLER(p_event->data.error_code);
            break;

        default:
            break;
    }
}

/**@brief Callback handling NUS Client events.
 *
 * @details This function is called to notify the application of NUS client events.
 *
 * @param[in]   p_ble_nus_c   NUS Client Handle. This identifies the NUS client
 * @param[in]   p_ble_nus_evt Pointer to the NUS Client event.
 */

/**@snippet [Handling events from the ble_nus_c module] */
static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, ble_nus_c_evt_t const * p_ble_nus_evt)
{
    ret_code_t err_code;

    switch (p_ble_nus_evt->evt_type)
    {
        case BLE_NUS_C_EVT_DISCOVERY_COMPLETE:

			err_code = app_button_enable();
            APP_ERROR_CHECK(err_code);
		
            NRF_LOG_INFO("Discovery complete.");
            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);
            NRF_LOG_INFO("Connected to device with Nordic UART Service.");
            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.");
			scan_start();
			break;
        default:
            // No implementation needed.
            break;
	}
}
/**@snippet [Handling events from the ble_nus_c module] */


/**@brief Function for handling the advertising report BLE event.
 *
 * @param[in] p_adv_report  Advertising report from the SoftDevice.
 */
static void on_adv_report(ble_gap_evt_adv_report_t const * p_adv_report)
{
    ret_code_t err_code;
	
    if (ble_advdata_name_find(p_adv_report->data.p_data,
								p_adv_report->data.len, m_target_periph_name))
    {
        // Name is a match, initiate connection.
        err_code = sd_ble_gap_connect(&p_adv_report->peer_addr,
                                      &m_scan_params,
                                      &m_connection_param,
                                      APP_BLE_CONN_CFG_TAG);
        if (err_code != NRF_SUCCESS)
        {
            NRF_LOG_ERROR("Connection Request Failed, reason %d", err_code);
        }
    }
    else
    {
        err_code = sd_ble_gap_scan_start(NULL, &m_scan_buffer);
        APP_ERROR_CHECK(err_code);
    }
}


/**@brief Function for handling BLE events.
 *
 * @param[in]   p_ble_evt   Bluetooth stack event.
 * @param[in]   p_context   Unused.
 */
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    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("Connection 0x%x established, starting DB discovery.",
                         p_gap_evt->conn_handle);

            APP_ERROR_CHECK_BOOL(p_gap_evt->conn_handle < NRF_SDH_BLE_CENTRAL_LINK_COUNT);

			err_code = ble_nus_c_handles_assign(&m_ble_nus_c[p_gap_evt->conn_handle], 
												p_ble_evt->evt.gap_evt.conn_handle, NULL);
            APP_ERROR_CHECK(err_code);
            err_code = ble_db_discovery_start(&m_db_disc[p_gap_evt->conn_handle],
												p_ble_evt->evt.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.
            if (ble_conn_state_central_conn_count() != NRF_SDH_BLE_CENTRAL_LINK_COUNT)
            {
                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)",
                         p_gap_evt->conn_handle,
                         p_gap_evt->params.disconnected.reason);

            if (ble_conn_state_central_conn_count() == 0)
            {
                err_code = app_button_disable();
                APP_ERROR_CHECK(err_code);
            }

            // Start scanning
            scan_start();
        } break;

        case BLE_GAP_EVT_ADV_REPORT:
            on_adv_report(&p_gap_evt->params.adv_report);
            break;

        case BLE_GAP_EVT_TIMEOUT:
        {
            // We have not specified a timeout for scanning, so only connection attemps can timeout.
            if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
            {
                NRF_LOG_DEBUG("Connection request timed out.");
            }
        } break;

        case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
        {
            NRF_LOG_DEBUG("BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST.");
            // 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_PHY_UPDATE_REQUEST:
        {
            NRF_LOG_DEBUG("PHY update request.");
            ble_gap_phys_t const phys =
            {
                .rx_phys = BLE_GAP_PHY_AUTO,
                .tx_phys = BLE_GAP_PHY_AUTO,
            };
            err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
            APP_ERROR_CHECK(err_code);
        } break;

        case BLE_GATTC_EVT_TIMEOUT:
        {
            // Disconnect on GATT Client timeout event.
            NRF_LOG_DEBUG("GATT Client Timeout.");
            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.");
            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;
    }
}

static void nus_c_init(void)
{
    ret_code_t       err_code;
    ble_nus_c_init_t nus_c_init_obj;

    nus_c_init_obj.evt_handler = ble_nus_c_evt_handler;

     for (uint32_t i = 0; i < NRF_SDH_BLE_CENTRAL_LINK_COUNT; i++)
    {
		err_code = ble_nus_c_init(&m_ble_nus_c[i], &nus_c_init_obj);
		APP_ERROR_CHECK(err_code);
	}
}

/**@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;

    err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.
    uint32_t ram_start = 0;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    // Enable BLE stack.
    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    // Register a handler for BLE events.
    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}

/**@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!",
                  p_evt->conn_handle,
                  p_evt->conn_handle);
    ble_nus_c_on_db_disc_evt(&m_ble_nus_c[p_evt->conn_handle], p_evt);		/* BLE uart */
}


/** @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 for initializing the UART. */
static void uart_init(void)
{
    ret_code_t err_code;

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

/**@brief Function for initializing power management.
 */
static void power_management_init(void)
{
    ret_code_t err_code;
    err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}

/**@brief Function for handling the idle state (main loop).
 *
 * @details Handle any pending log operation(s), then sleep until the next event occurs.
 */
static void idle_state_handle(void)
{
    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}


/** @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);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}


/** @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 handling events from the GATT library. */
void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt)
{
    if (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED)
    {
        NRF_LOG_INFO("ATT MTU exchange completed.");

        m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
        NRF_LOG_INFO("Ble NUS max data length set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len);
    }
}

/**@brief Function for initializing the GATT module.
 */
static void gatt_init(void)
{
    ret_code_t err_code;

    err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_ble_gatt_att_mtu_central_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE);
    APP_ERROR_CHECK(err_code);
}

int main(void)
{
/*-< Initialize. >-*/
    log_init();
    timer_init();
    power_management_init();
    ble_stack_init();
    gatt_init();
    db_discovery_init();
    ble_conn_state_init();
/*-< uart config >-*/
    uart_init();
    nus_c_init();
	
/*-< Start execution. >-*/
    NRF_LOG_INFO("Multilink example started.");
    scan_start();

    for (;;)
    {
        idle_state_handle();
    }
}

[AndreasF]

Hi.

This error happend because you use the two API's app_button_enable() and app_button_disable() without initializing the app_button API.

When you find the device Nordic_UART your code goes to the BLE_NUS_C_EVT_DISCOVERY_COMPLETE case in line 243 and calls app_button_enable(), which is not initialized and the error occurs.

If you want to use this API call you should call the app_button_init(), maybe like this:

#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          BSP_BUTTON_0                          /**< Button that will write to the LED characteristic of the peer. */
#define BUTTON_DETECTION_DELAY    APP_TIMER_TICKS(50)      




/**@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:
            APP_ERROR_HANDLER(pin_no);
            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, false, BUTTON_PULL, button_event_handler}
    };

    err_code = app_button_init(buttons, ARRAY_SIZE(buttons), BUTTON_DETECTION_DELAY);
    APP_ERROR_CHECK(err_code);
}

int main(void)
{
/*-< Initialize. >-*/
    log_init();
    timer_init();
    buttons_init();
    power_management_init();
    ble_stack_init();
    gatt_init();
    db_discovery_init();
    ble_conn_state_init();
/*-< uart config >-*/
    uart_init();
    nus_c_init();
	
/*-< Start execution. >-*/
    NRF_LOG_INFO("Multilink example started.");
    scan_start();

    for (;;)
    {
        idle_state_handle();
    }
}

If not, remove this on line 245 and 246:

            err_code = app_button_enable();
            APP_ERROR_CHECK(err_code);

And remove this on line 353 and 354:

                err_code = app_button_disable();
                APP_ERROR_CHECK(err_code);

Best regards.

Andreas

[yokokawa]

1) Button detection is unnecessary, so I deleted "app_button_enable ()" "app_button_disable ()", but it did not improve.
2) I created the one with the button detection enabled and checked the operation, but I did not improve it.
3) Since the timing at which an error occurs is after detecting a peripheral, I think that it is related to communication operation or communication setting, is there any problem?
4) In the current situation, debugging was performed with a program with button detection, but since 0x08 error occurred in "error_error_handler_bare-> error_info-> err_cord" in error setting,
We are restricting the function and debugging is done only with necessary multi-connection UART communication.
Attach register information at error occurrence.

Thank you.

[AndreasF]

Hi.

I'm not able to recreate this error, my project, both with and without buttons run fine, as you can see below:

Without buttons in the code:

With buttons in the code:

Can you try to run my project when I have buttons included and when I dont have buttons included?

Download here: my two projects.zip

Both project must be placed in the ble_central folder, with the following path:

nRF5_SDK_15.0.0_a53641a\examples\ble_central

Best regards.

Andreas

[yokokawa]

With a program confirmed by Andreas, only one peripheral can be connected.
When setting to connect two peripherals, error 0x011 will be generated.
Change point of "sdk_config.h"
 1)#define BLE_ADVERTISING_ENABLED 1
 2)#define APP_USBD_CONFIG_EVENT_QUEUE_SIZE 64
 3)#define NRF_FSTORAGE_ENABLED 1
 4)#define NRF_SDH_BLE_CENTRAL_LINK_COUNT 2 
 5)#define NRF_SDH_BLE_TOTAL_LINK_COUNT 2 

Attach "sdk_config.h" file.
0576.sdk_config.h

Thanking you in advance.

[Additional notes]
 • An error occurs when waiting for the second peripheral to be detected.
 · If two peripherals are connected, an error will not occur. 

[AndreasF]

Hi again.

yokokawa said:

When setting to connect two peripherals, error 0x011 will be generated.

 Where did you get this error? Can you debug and see where this error occurs?

 

yokokawa said:

When setting to connect two peripherals, error 0x011 will be generated.

yokokawa said:

· If two peripherals are connected, an error will not occur. 

 I'm a bit confused by this, "When setting to connect peripherals, error 0x011 will be generated", but "if two peripherals are connected, an error will not occur."

Can you please explain more?

Best regards.

Andreas

[yokokawa]

【Reply】
1. After connecting one peripheral to the central, an error has occurred after executing "scan_start ()" with "BLE_GAP_EVT_CONNECTED:" in "ble_evt_handler ()" for the next peripheral detection.
Note: Because we are using "EBSHSN Series Evaluation Board (Taiyo Yuden)", we can not confirm LOG because SWO is not connected to J-Link.

2. Describe the operation when using the attached "sdk_config.h".
 1) ERROR will not occur if only Central is started.
 2) If one peripheral is started after starting central, an error will occur.
 3) Starting Central after starting one peripheral will result in an error.
 4) After starting two peripherals, if you start Central, it will operate normally.

  * It seems that an error occurs during detection of the second peripheral after Central has recognized one peripheral.

Thanking you in advance.sdk_config.zip

[AndreasF]

Hi.

I am not able to recreate your error.

Can you please provide me with your whole project so I can try?

If you wish, I can make this ticket private so that you can share your project.

Best regards,

Andreas

[yokokawa]

【Reply】
1) I was developing in the environment under the keil environment, but I decided that Mr. Andreas' development environment is Segger and confirmed it in the Segger environment.
"RAM start" and "Maximum RAM" appear to be incorrect, but please do not know how to set it.
Attachment: Debug Terminal_01.png
2) I will attach my current development environment.
Attachment: Yokokawa_project_181210.zip
Thanking you in advance.

Yokokawa_project_181210.zip

[AndreasF]

Hi again.

Segger Embedded Studio uses Section Placement Macros for defining the RAM and FLASH memory. RAM_START is the macro used for the RAM start address and FLASH_START is the macro used for the FLASH start address. You can easily configure the values in Segger Embedded Studio doing the following steps:

1. Open your project in Segger Embedded Studio
2. Right click on the Project folder
3. Select Edit Options...
4. Select the Common configuration
5. Click on Linker
6. Double click on Section Placement Macros
7. Edit the value RAM_START to 0x20003730, and click OK, and Click OK on the Options window

Best regards,

Andreas

[yokokawa]

【Reply】
1) The occurrence of error 0x011 (17) in program execution could not be improved.
2) When one peripheral is used, an error has occurred in [err_code = ble_nus_c_tx_notif_enable (p_ble_nus_c)] (3) of [ble_nus_c_evt_handler ()].
3) I think that it is caused by executing [err_code = ble_nus_c_tx_notif_enable (p_ble_nus_c)] (3) twice when one peripheral is connected, but since we do not know how to improve it, do it for each peripheral connection Please tell me how to do it or how it will not result in an error.
4) Attach log (1) of one peripheral connection and log (2) of connection of two peripherals.

(1)Debug Terminal_02.png
(2)Debug Terminal_03.png
(3)Error occurrence line.txt

Fullscreen Error occurrence line.txt Download

static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, ble_nus_c_evt_t const * p_ble_nus_evt)
{
    ret_code_t err_code;

    switch (p_ble_nus_evt->evt_type)
    {
        case BLE_NUS_C_EVT_DISCOVERY_COMPLETE:

	        err_code = app_button_enable();
            APP_ERROR_CHECK(err_code);
		
            NRF_LOG_INFO("Discovery complete.");
            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);	<----------　  <<< Error occurrence line  >>>
			
            NRF_LOG_INFO("Connected to device with Nordic UART Service.");
            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.");
			scan_start();
			break;
        default:
            // No implementation needed.
            break;
	}
}

Thanking you in advance.

[AndreasF]

Hi.

This is because of the API sd_ble_gattc_write():

/**@brief Perform a Write (Characteristic Value or Descriptor, with or without response, signed or not, long or reliable) procedure.
 *
 * @details This function can perform all write procedures described in GATT.
 *
 * @note    Only one write with response procedure can be ongoing per connection at a time.
 *          If the application tries to write with response while another write with response procedure is ongoing,
 *          the function call will return @ref NRF_ERROR_BUSY.
 *          A @ref BLE_GATTC_EVT_WRITE_RSP event will be issued as soon as the write response arrives from the peer.
 *
 * @note    The number of Write without Response that can be queued is configured by @ref ble_gattc_conn_cfg_t::write_cmd_tx_queue_size
 *          When the queue is full, the function call will return @ref NRF_ERROR_RESOURCES.
 *          A @ref BLE_GATTC_EVT_WRITE_CMD_TX_COMPLETE event will be issued as soon as the transmission of the write without response is complete.
 *
 * @note    The application can keep track of the available queue element count for writes without responses by following the procedure below:
 *          - Store initial queue element count in a variable.
 *          - Decrement the variable, which stores the currently available queue element count, by one when a call to this function returns @ref NRF_SUCCESS.
 *          - Increment the variable, which stores the current available queue element count, by the count variable in @ref BLE_GATTC_EVT_WRITE_CMD_TX_COMPLETE event.
 *
 * @events
 * @event{@ref BLE_GATTC_EVT_WRITE_CMD_TX_COMPLETE, Write without response transmission complete.}
 * @event{@ref BLE_GATTC_EVT_WRITE_RSP, Write response received from the peer.}
 * @endevents
 *
 * @mscs
 * @mmsc{@ref BLE_GATTC_VALUE_WRITE_WITHOUT_RESP_MSC}
 * @mmsc{@ref BLE_GATTC_VALUE_WRITE_MSC}
 * @mmsc{@ref BLE_GATTC_VALUE_LONG_WRITE_MSC}
 * @mmsc{@ref BLE_GATTC_VALUE_RELIABLE_WRITE_MSC}
 * @endmscs
 *
 * @param[in] conn_handle The connection handle identifying the connection to perform this procedure on.
 * @param[in] p_write_params A pointer to a write parameters structure.
 *
 * @retval ::NRF_SUCCESS Successfully started the Write procedure.
 * @retval ::BLE_ERROR_INVALID_CONN_HANDLE Invalid Connection Handle.
 * @retval ::NRF_ERROR_INVALID_STATE Invalid Connection State.
 * @retval ::NRF_ERROR_INVALID_ADDR Invalid pointer supplied.
 * @retval ::NRF_ERROR_INVALID_PARAM Invalid parameter(s) supplied.
 * @retval ::NRF_ERROR_DATA_SIZE Invalid data size(s) supplied.
 * @retval ::NRF_ERROR_BUSY For write with response, procedure already in progress. Wait for a @ref BLE_GATTC_EVT_WRITE_RSP event and retry.
 * @retval ::NRF_ERROR_RESOURCES Too many writes without responses queued.
 *                               Wait for a @ref BLE_GATTC_EVT_WRITE_CMD_TX_COMPLETE event and retry.
 * @retval ::NRF_ERROR_TIMEOUT There has been a GATT procedure timeout. No new GATT procedure can be performed without reestablishing the connection.
 */
SVCALL(SD_BLE_GATTC_WRITE, uint32_t, sd_ble_gattc_write(uint16_t conn_handle, ble_gattc_write_params_t const *p_write_params));

Try to modify your ble_nus_c_evt_handler() like this:

/**@brief Callback handling NUS Client events.
 *
 * @details This function is called to notify the application of NUS client events.
 *
 * @param[in]   p_ble_nus_c   NUS Client Handle. This identifies the NUS client
 * @param[in]   p_ble_nus_evt Pointer to the NUS Client event.
 */
 
/**@snippet [Handling events from the ble_nus_c module] */
static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, ble_nus_c_evt_t const * p_ble_nus_evt)
{
    ret_code_t err_code;
 
    switch (p_ble_nus_evt->evt_type)
    {
        case BLE_NUS_C_EVT_DISCOVERY_COMPLETE:
 
        err_code = app_button_enable();
            APP_ERROR_CHECK(err_code);
       
            NRF_LOG_INFO("Discovery complete.");
            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);
 
            if(err_code == NRF_ERROR_BUSY)
            {
              retry_operation_tx_notif_enable = true;
            }
            else
            {
              APP_ERROR_CHECK(err_code);
            }
            NRF_LOG_INFO("Connected to device with Nordic UART Service.");
            break;
        case BLE_GATTC_EVT_WRITE_RSP:
        {    
            if(retry_operation_tx_notif_enable == true)
            {
                err_code = ble_nus_c_tx_notif_enable(p_ble_nus_c);
                if(err_code != NRF_ERROR_BUSY)
                {
                    APP_ERROR_CHECK(err_code);
                    retry_operation_tx_notif_enable = false;
                }
            }
         }  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.");
            scan_start();
            break;
        default:
            // No implementation needed.
            break;
    }
}

This should work.

Best regards,

Andreas