This post is older than 2 years and might not be relevant anymore
More Info: Consider searching for newer posts

BLE DEVICE_NAME not showing

Hi,

I am facing problem while developing code for the application.

I am working on the "ble_app_uart" example code to develop my one of the application, But after making some custom changes into the code it stops showing the "DEVICE_NAME" in nRF Connect Nordic application.

I have added some of the code from the "Beacon" project to advertise the company and devices type & all.

Here after adding all these line of code into the "ble_app_uart" from the "Beacon" project it stop showing the DEVICE_NAME in the application. I don't know why is it so.

Can you please guide to resolve this error.

For more I am sharing code which i have used for advertising:

#define DEVICE_NAME                     "SSLBL" 

#define APP_ADV_INTERVAL 64 /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */
#define APP_ADV_TIMEOUT_IN_SECONDS 60 /**< The advertising timeout (in units of seconds). */


#define MIN_CONN_INTERVAL MSEC_TO_UNITS(20, UNIT_1_25_MS) /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(75, UNIT_1_25_MS) /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */
#define SLAVE_LATENCY 0 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */
#define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */

#define UART_TX_BUF_SIZE 256 /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256 /**< UART RX buffer size. */


#define APP_TAG_INFO_LENGTH 0x17 /**< Total length of information advertised by the TAG. */
#define APP_ADV_DATA_LENGTH 0x16 /**< Length of manufacturer specific data in the advertisement. */
#define APP_COMPANY_IDENTIFIER 0x02A1 /**< Company identifier for ASA. as per www.bluetooth.org. */
#define APP_FM_VER 0x02, 0x03 /**< Firmware Version */
#define APP_HW_VER 0x04, 0x05 /**< Hardware Version */

static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t scanrsp;
ble_adv_modes_config_t options;

uint8_t flags = BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED;

ble_advdata_manuf_data_t manuf_specific_data;

manuf_specific_data.company_identifier = APP_COMPANY_IDENTIFIER;


// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;

memset(&scanrsp, 0, sizeof(scanrsp));
scanrsp.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
scanrsp.uuids_complete.p_uuids = m_adv_uuids;

manuf_specific_data.data.p_data = (uint8_t *) m_tag_info;
manuf_specific_data.data.size = APP_TAG_INFO_LENGTH;

// Build and set advertising data.
memset(&advdata, 0, sizeof(advdata));

advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.flags = flags;
advdata.p_manuf_specific_data = &manuf_specific_data;

err_code = ble_advdata_set(&advdata, NULL);
APP_ERROR_CHECK(err_code);

// Initialize advertising parameters (used when starting advertising).
memset(&m_adv_params, 0, sizeof(m_adv_params));

memset(&options, 0, sizeof(options));
options.ble_adv_fast_enabled = true;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;


err_code = ble_advertising_init(&advdata, &scanrsp, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}

And also I am sharing the screenshot of my application more clarification.

Parents Reply Children
  • Hi Susheel, 

    I have seen that DEVICE_NAME in my project it shows in the "GAP_INIT()" function.

    I have all set for the device name. As I mentioned that I have used "ble_app_uart" and in which I have added small portion of the "beacon" project only to advertise the manufacture data to it custom for my application.

    But after all in the end I am Not getting device while broadcasting & watching it into the nrf application.

    And I want to display the DEVICE_NAME with Company identifier, Hardware, Firmware version in advertise data packet.

    Here I am sharing my main.c code for your reference.

    Thanks

  • My Code 

    /* Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
     *
     * The information contained herein is property of Nordic Semiconductor ASA.
     * Terms and conditions of usage are described in detail in NORDIC
     * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
     *
     * Licensees are granted free, non-transferable use of the information. NO
     * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
     * the file.
     *
     */
    
    /** @file
     *
     * @defgroup ble_sdk_uart_over_ble_main main.c
     * @{
     * @ingroup  ble_sdk_app_nus_eval
     * @brief    UART over BLE application main file.
     *
     * This file contains the source code for a sample application that uses the Nordic UART service.
     * This application uses the @ref srvlib_conn_params module.
     */
    
    #include <stdint.h>
    #include <string.h>
    #include "nordic_common.h"
    #include "nrf.h"
    #include "ble_hci.h"
    #include "ble_advdata.h"
    #include "ble_advertising.h"
    #include "ble_conn_params.h"
    #include "softdevice_handler.h"
    #include "app_timer.h"
    #include "app_button.h"
    #include "nrf_adc.h"
    #include "ble_tag.h"
    //#include "ble_nus.h"
    #include "ble_bas.h"
    #include "app_uart.h"
    #include "app_util_platform.h"
    #include "bsp.h"
    #include "bsp_btn_ble.h"
    #include "nrf_drv_gpiote.h"
    #include "ble_conn_state.h"
    #include "app_util.h"
    
    #define IS_SRVC_CHANGED_CHARACT_PRESENT 0                                           /**< Include the service_changed characteristic. If not enabled, the server's database cannot be changed for the lifetime of the device. */
    
    //#define WAKEUP_BUTTON_PIN               BUTTON_0                                    /**< Button used to wake up the application. */
    //#define ADVERTISING_LED_PIN_NO          LED_0                                       /**< LED to indicate advertising state. */
    //#define BATTERY_LED_PIN_NO              LED_1                                       /**< LED to indicate connected state. */
    
    
    #define DEVICE_NAME                     "SSLBL"                              /**< Name of device. Will be included in the advertising data. */
    //#define NUS_SERVICE_UUID_TYPE           BLE_UUID_TYPE_VENDOR_BEGIN                  /**< UUID type for the Nordic UART Service (vendor specific). */
    
    #define APP_ADV_INTERVAL                64                                          /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */
    #define APP_ADV_TIMEOUT_IN_SECONDS      60                                         /**< The advertising timeout (in units of seconds). */
    
    #define APP_TIMER_PRESCALER             0                                           /**< Value of the RTC1 PRESCALER register. */
    #define APP_TIMER_OP_QUEUE_SIZE         4                                           /**< Size of timer operation queues. */
    
    #define APP_FEATURE_NOT_SUPPORTED       BLE_GATT_STATUS_ATTERR_APP_BEGIN + 2        /**< Reply when unsupported features are requested. */
    
    // above are previous macro for batt. below is newer:
    
    //#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(20, UNIT_1_25_MS)             /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */
    //#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(75, UNIT_1_25_MS)             /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */
    //#define SLAVE_LATENCY                   0                                           /**< Slave latency. */
    //#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)             /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */
    //#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER)  /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
    //#define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
    //#define MAX_CONN_PARAMS_UPDATE_COUNT    3                                           /**< Number of attempts before giving up the connection parameter negotiation. */
    // above was perivious and below one was newer for development:
    
    #define MIN_CONN_INTERVAL               MSEC_TO_UNITS(20, UNIT_1_25_MS)             /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */
    #define MAX_CONN_INTERVAL               MSEC_TO_UNITS(75, UNIT_1_25_MS)             /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */
    #define SLAVE_LATENCY                   0                                           /**< Slave latency. */
    #define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)             /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */
    #define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER)  /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
    #define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
    #define MAX_CONN_PARAMS_UPDATE_COUNT    3                                           /**< Number of attempts before giving up the connection parameter negotiation. */
    
    
    #define START_STRING                    "Start...\n"                                /**< The string that will be sent over the UART when the application starts. */
    
    #define DEAD_BEEF                       0xDEADBEEF                                  /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
    
    #define UART_TX_BUF_SIZE                256                                         /**< UART TX buffer size. */
    #define UART_RX_BUF_SIZE                256                                         /**< UART RX buffer size. */
    
    
    #define APP_TAG_INFO_LENGTH             0x17                              /**< Total length of information advertised by the TAG. */
    #define APP_ADV_DATA_LENGTH             0x16                              /**< Length of manufacturer specific data in the advertisement. */
    #define APP_COMPANY_IDENTIFIER          0x0059                            /**< Company identifier for ASA. as per www.bluetooth.org. */
    #define APP_FM_VER                      0x02, 0x03                        /**< Firmware Version */ 
    #define APP_HW_VER                      0x04, 0x05                        /**< Hardware Version */ 
    
    volatile int32_t adc_sample = 0;       																	// adc sampling variables
    volatile uint32_t adc2=52;
    
    
    static ble_tag_t                        m_tag;                                      /**< Structure to identify the Nordic UART Service. */
    static uint16_t                         m_conn_handle = BLE_CONN_HANDLE_INVALID;    /**< Handle of the current connection. */
    
    static ble_uuid_t                       m_adv_uuids[] = {{BLE_UUID_TAG_SERVICE, BLE_UUID_TYPE_BLE}};  /**< Universally unique service identifier. */
    
    
    
    // This below function is for the beacon 
    
    // copied from App Beacon below one
    static ble_gap_adv_params_t m_adv_params;                                 										/**< Parameters to be passed to the stack when starting advertising. */
    // copied from App Beacon below one 
    
    static uint8_t m_tag_info[APP_TAG_INFO_LENGTH] =                    /**< Information advertised by the TAG. */
    {
        APP_ADV_DATA_LENGTH, // Manufacturer specific information. Specifies the length of the 
                             // manufacturer specific data in this implementation.
        APP_FM_VER,     // Firmware Version 
        APP_HW_VER,     // Hardware Version 
        
    }; 
    
    /*****************************************************************************************************************************************************************
    *																														B O A R D  T E S T  M O D U L E S                                         Starts                     *
    *****************************************************************************************************************************************************************/
    
    void uart_error_handle(app_uart_evt_t * p_event)
    {
        if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
        {
            APP_ERROR_HANDLER(p_event->data.error_communication);
        }
        else if (p_event->evt_type == APP_UART_FIFO_ERROR)
        {
            APP_ERROR_HANDLER(p_event->data.error_code);
        }
    }
    
    
    /**
     * @brief UART events handler.
     */
    void uart_events_handler(app_uart_evt_t * p_event)
    {
        switch (p_event->evt_type)
        {
            case APP_UART_COMMUNICATION_ERROR: APP_ERROR_HANDLER(p_event->data.error_communication);
                break;
    
            case APP_UART_FIFO_ERROR:          APP_ERROR_HANDLER(p_event->data.error_code);
                break;
    
            case APP_UART_TX_EMPTY:            
                break;
    
            default: break;
        }
    }
    
    /*
     * @brief Function for the UART communication.
     *
     * @details This function will be called for the button 2 and it will serve the UART comm.
     *
    */
    static void uart_test(void)
    {
       /* 		
    	uint32_t                     err_code;
        const app_uart_comm_params_t comm_params =
        {
            RX_PIN_NUMBER,
            TX_PIN_NUMBER,
            RTS_PIN_NUMBER,
            CTS_PIN_NUMBER,
            APP_UART_FLOW_CONTROL_DISABLED,
            false,
            UART_BAUDRATE_BAUDRATE_Baud115200
        };
    
        APP_UART_FIFO_INIT( &comm_params,
                           UART_RX_BUF_SIZE,
                           UART_TX_BUF_SIZE,
                           uart_events_handler ,
                           APP_IRQ_PRIORITY_LOW,
                           err_code);
        APP_ERROR_CHECK(err_code);
    		*/
    printf("\n\rStart: \n\r");
    	
        while (true)
        {
    				printf("\nIn UART While\n");
            uint8_t cr;
            while(app_uart_get(&cr) != NRF_SUCCESS);
            while(app_uart_put(cr) != NRF_SUCCESS);
    					if (cr == '0' || cr == '0')
    							{
    								printf("Clear image data and display \n Getting SPI function \n to clear the image");
    								nrf_delay_ms(1500);
    								printf("\nSuccess 0x40 | Opcode\n");
    							}
    					else if (cr == '1' || cr == '1')		
    									{
    										 printf("Image data download \n Getting UART Ready for IMAGE RX \n ");
    										nrf_delay_ms(1500);
    										printf("\nRX UART Done");
    										printf("\nSuccess 0x40 | Opcode\n");
    									}
    					else if (cr == '2' || cr == '2')		
    									{
    										printf("Commit image data \n Getting SPI & UART ready \n to Commit data \n");
    										nrf_delay_ms(1500);
    										printf("\nRX IMAGE Commited\n");
    										printf("\nSuccess 0x40 | Opcode\n");
    									}
    					 else if (cr == 'q' || cr == 'Q')		
    										{
    											printf(" \n\rExit!\n\r");
    											while (true)
    													{
    														// Do nothing.
    													}
    										}
    						 
    					else
    						{
    							printf("\nNothing try once again\n");
    							printf("\nFailure 0x80 | Opcode\n");
    						}	
    					
                
            }
        }
    		
    /*****************************************************************************************************************************************************************
    *																														B O A R D  T E S T  M O D U L E S                                   ends                             *
    *****************************************************************************************************************************************************************/
    
    
    
    /**@brief Function for assert macro callback.
     *
     * @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 analyse 
     *          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(DEAD_BEEF, line_num, p_file_name);
    }
    
    
    
    /**
     * @brief ADC interrupt handler.
     */
    void ADC_IRQHandler(void)
    {
        nrf_adc_conversion_event_clean();
    
        adc_sample = nrf_adc_result_get();
    }
    
    
    /**
     * @brief ADC initialization.
     */
    void adc_config(void)
    {
        const nrf_adc_config_t nrf_adc_config = NRF_ADC_CONFIG_DEFAULT;
    
        // Initialize and configure ADC
        nrf_adc_configure( (nrf_adc_config_t *)&nrf_adc_config);
        nrf_adc_input_select(NRF_ADC_CONFIG_INPUT_2);
        nrf_adc_int_enable(ADC_INTENSET_END_Enabled << ADC_INTENSET_END_Pos);
        NVIC_SetPriority(ADC_IRQn, NRF_APP_PRIORITY_HIGH);
        NVIC_EnableIRQ(ADC_IRQn);
    }
    
    
    
    /**@brief Function for the GAP initialization.
     *
     * @details This function will set up all the necessary GAP (Generic Access Profile) parameters of 
     *          the device. It also sets the permissions and appearance.
     */
    static void gap_params_init(void)
    {
        uint32_t                err_code;
        ble_gap_conn_params_t   gap_conn_params;
        ble_gap_conn_sec_mode_t sec_mode;
    
        BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
        
        err_code = sd_ble_gap_device_name_set(&sec_mode,
                                              (const uint8_t *) DEVICE_NAME,
                                              strlen(DEVICE_NAME));
        APP_ERROR_CHECK(err_code);
    
        memset(&gap_conn_params, 0, sizeof(gap_conn_params));
    
        gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
        gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
        gap_conn_params.slave_latency     = SLAVE_LATENCY;
        gap_conn_params.conn_sup_timeout  = CONN_SUP_TIMEOUT;
    
        err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for handling the data from the Nordic UART Service.
     *
     * @details This function will process the data received from the Nordic UART BLE Service and send
     *          it to the UART module.
     *
     * @param[in] p_nus    Nordic UART Service structure.
     * @param[in] p_data   Data to be send to UART module.
     * @param[in] length   Length of the data.
     */
    /**@snippet [Handling the data received over BLE] */
    static void tag_data_handler(ble_tag_t * p_tag, uint8_t * p_data, uint16_t length)
    {
        for (uint32_t i = 0; i < length; i++)
        {
            while(app_uart_put(p_data[i]) != NRF_SUCCESS);
        }
        while(app_uart_put('\n') != NRF_SUCCESS);
    }
    /**@snippet [Handling the data received over BLE] */
    
    
    /**@brief Function for initializing services that will be used by the application.
     */
    static void services_init(void)
    {
    		uint32_t       err_code;
        ble_tag_init_t tag_init;
        	
        memset(&tag_init, 0, sizeof(tag_init));
    
        tag_init.data_handler = tag_data_handler;
        
        err_code = ble_tag_init(&m_tag, &tag_init);
        APP_ERROR_CHECK(err_code);
    	
    }
    
    
    /**@brief Function for handling an event from the Connection Parameters Module.
     *
     * @details This function will be called for all events in the Connection Parameters Module
     *          which are passed to the application.
     *
     * @note All this function does is to disconnect. This could have been done by simply setting
     *       the disconnect_on_fail config parameter, but instead we use the event handler
     *       mechanism to demonstrate its use.
     *
     * @param[in] p_evt  Event received from the Connection Parameters Module.
     */
    static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
    {
        uint32_t err_code;
        
        if(p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
        {
            err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
            APP_ERROR_CHECK(err_code);
        }
    }
    
    
    /**@brief Function for handling errors from the Connection Parameters module.
     *
     * @param[in] nrf_error  Error code containing information about what went wrong.
     */
    static void conn_params_error_handler(uint32_t nrf_error)
    {
        APP_ERROR_HANDLER(nrf_error);
    }
    
    
    /**@brief Function for initializing the Connection Parameters module.
     */
    static void conn_params_init(void)
    {
        uint32_t               err_code;
        ble_conn_params_init_t cp_init;
        
        memset(&cp_init, 0, sizeof(cp_init));
    
        cp_init.p_conn_params                  = NULL;
        cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
        cp_init.next_conn_params_update_delay  = NEXT_CONN_PARAMS_UPDATE_DELAY;
        cp_init.max_conn_params_update_count   = MAX_CONN_PARAMS_UPDATE_COUNT;
        cp_init.start_on_notify_cccd_handle    = BLE_GATT_HANDLE_INVALID;
        cp_init.disconnect_on_fail             = false;
        cp_init.evt_handler                    = on_conn_params_evt;
        cp_init.error_handler                  = conn_params_error_handler;
        
        err_code = ble_conn_params_init(&cp_init);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for putting the chip into sleep mode.
     *
     * @note This function will not return.
     */
    static void sleep_mode_enter(void)
    {
        uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
        APP_ERROR_CHECK(err_code);
    
        // Prepare wakeup buttons.
        err_code = bsp_btn_ble_sleep_mode_prepare();
        APP_ERROR_CHECK(err_code);
    
        // Go to system-off mode (this function will not return; wakeup will cause a reset).
        err_code = sd_power_system_off();
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for handling advertising events.
     *
     * @details This function will be called for advertising events which are passed to the application.
     *
     * @param[in] ble_adv_evt  Advertising event.
     */
    static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
    {
        uint32_t err_code;
    
        switch (ble_adv_evt)
        {
            case BLE_ADV_EVT_FAST:
                err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
                APP_ERROR_CHECK(err_code);
                break;
            case BLE_ADV_EVT_IDLE:
                sleep_mode_enter();
                break;
            default:
                break;
        }
    }
    
    
    /**@brief Function for the Application's S110 SoftDevice event handler.
     *
     * @param[in] p_ble_evt S110 SoftDevice event.
     */
    static void on_ble_evt(ble_evt_t * p_ble_evt)
    {
     uint32_t err_code;
    
        switch (p_ble_evt->header.evt_id)
        {
            case BLE_GAP_EVT_CONNECTED:
                err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
                APP_ERROR_CHECK(err_code);
                m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
                break; // BLE_GAP_EVT_CONNECTED
    
            case BLE_GAP_EVT_DISCONNECTED:
                err_code = bsp_indication_set(BSP_INDICATE_IDLE);
                APP_ERROR_CHECK(err_code);
                m_conn_handle = BLE_CONN_HANDLE_INVALID;
                break; // BLE_GAP_EVT_DISCONNECTED
    
            case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
                // Pairing not supported
                err_code = sd_ble_gap_sec_params_reply(m_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_GATTS_EVT_SYS_ATTR_MISSING:
                // No system attributes have been stored.
                err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
                APP_ERROR_CHECK(err_code);
                break; // BLE_GATTS_EVT_SYS_ATTR_MISSING
    
            case BLE_GATTC_EVT_TIMEOUT:
                // Disconnect on GATT Client timeout event.
                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; // BLE_GATTC_EVT_TIMEOUT
    
            case BLE_GATTS_EVT_TIMEOUT:
                // Disconnect on GATT Server timeout event.
                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; // BLE_GATTS_EVT_TIMEOUT
    
            case BLE_EVT_USER_MEM_REQUEST:
                err_code = sd_ble_user_mem_reply(p_ble_evt->evt.gattc_evt.conn_handle, NULL);
                APP_ERROR_CHECK(err_code);
                break; // BLE_EVT_USER_MEM_REQUEST
    
            case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
            {
                ble_gatts_evt_rw_authorize_request_t  req;
                ble_gatts_rw_authorize_reply_params_t auth_reply;
    
                req = p_ble_evt->evt.gatts_evt.params.authorize_request;
    
                if (req.type != BLE_GATTS_AUTHORIZE_TYPE_INVALID)
                {
                    if ((req.request.write.op == BLE_GATTS_OP_PREP_WRITE_REQ)     ||
                        (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) ||
                        (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
                    {
                        if (req.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
                        {
                            auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
                        }
                        else
                        {
                            auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ;
                        }
                        auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED;
                        err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle,
                                                                   &auth_reply);
                        APP_ERROR_CHECK(err_code);
                    }
                }
            } break; // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST
    
    #if (NRF_SD_BLE_API_VERSION == 3)
            case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST:
                err_code = sd_ble_gatts_exchange_mtu_reply(p_ble_evt->evt.gatts_evt.conn_handle,
                                                           NRF_BLE_MAX_MTU_SIZE);
                APP_ERROR_CHECK(err_code);
                break; // BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST
    #endif
    
            default:
                // No implementation needed.
                break;
        }
    }
    
    
    /**@brief Function for dispatching a S110 SoftDevice event to all modules with a S110 SoftDevice 
     *        event handler.
     *
     * @details This function is called from the S110 SoftDevice event interrupt handler after a S110 
     *          SoftDevice event has been received.
     *
     * @param[in] p_ble_evt  S110 SoftDevice event.
     */
    static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
    {
        ble_conn_params_on_ble_evt(p_ble_evt);
        ble_tag_on_ble_evt(&m_tag, p_ble_evt);
    	  on_ble_evt(p_ble_evt);
        ble_advertising_on_ble_evt(p_ble_evt);
        bsp_btn_ble_on_ble_evt(p_ble_evt);
        
    }
    
    
    /**@brief Function for the S110 SoftDevice initialization.
     *
     * @details This function initializes the S110 SoftDevice and the BLE event interrupt.
     */
    static void ble_stack_init(void)
    {
        uint32_t err_code;
        
        // Initialize SoftDevice.
        SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
    
        // Enable BLE stack.
        ble_enable_params_t ble_enable_params;
        memset(&ble_enable_params, 0, sizeof(ble_enable_params));
    #if (defined(S130) || defined(S132))
        ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;
    #endif
        ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
        err_code = sd_ble_enable(&ble_enable_params);
        APP_ERROR_CHECK(err_code);
        
        // Subscribe for BLE events.
        err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for handling events from the BSP module.
     *
     * @param[in]   event   Event generated by button press.
     */
    void bsp_event_handler(bsp_event_t event)
    {
        uint32_t err_code;
        switch (event)
        {
            case BSP_EVENT_SLEEP:
                sleep_mode_enter();
                break;
    
            case BSP_EVENT_DISCONNECT:
                err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
                if (err_code != NRF_ERROR_INVALID_STATE)
                {
                    APP_ERROR_CHECK(err_code);
                }
                break;
    
            case BSP_EVENT_WHITELIST_OFF:
                if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
                {
                    err_code = ble_advertising_restart_without_whitelist();
                    if (err_code != NRF_ERROR_INVALID_STATE)
                    {
                        APP_ERROR_CHECK(err_code);
                    }
                }
                break;
            
            case BSP_EVENT_KEY_3 :
                printf("\r\n    BUTTON 4 is pressed...\r\n");                
    				
    				break;	
    
            default:
                break;
        }
    }
    
    
    /**@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' i.e '\n' (hex 0x0D) or if the string has reached a length of 
     *          @ref NUS_MAX_DATA_LENGTH.
     */
    /**@snippet [Handling the data received over UART] */
    void uart_event_handle(app_uart_evt_t * p_event)
    {
        static uint8_t data_array[BLE_TAG_MAX_DATA_LEN];
        static uint8_t index = 0;
        uint32_t       err_code;
    
        switch (p_event->evt_type)
        {
            case APP_UART_DATA_READY:
                UNUSED_VARIABLE(app_uart_get(&data_array[index]));
                index++;
    
                if ((data_array[index - 1] == '\n') || (index >= (BLE_TAG_MAX_DATA_LEN)))
                {
                    err_code = ble_tag_string_send(&m_tag, data_array, index);
                    if (err_code != NRF_ERROR_INVALID_STATE)
                    {
                        APP_ERROR_CHECK(err_code);
                    }
                    
                    index = 0;
                }
                break;
    
            case APP_UART_COMMUNICATION_ERROR:
                APP_ERROR_HANDLER(p_event->data.error_communication);
                break;
    
            case APP_UART_FIFO_ERROR:
                APP_ERROR_HANDLER(p_event->data.error_code);
                break;
    
            default:
                break;
        }
    }
    /**@snippet [Handling the data received over UART] */
    
    
    /**@brief  Function for initializing the UART module.
     */
    /**@snippet [UART Initialization] */
    static void uart_init(void)
    {
        uint32_t                     err_code;
        const app_uart_comm_params_t comm_params =
        {
            RX_PIN_NUMBER,
            TX_PIN_NUMBER,
            RTS_PIN_NUMBER,
            CTS_PIN_NUMBER,
            APP_UART_FLOW_CONTROL_ENABLED,
            false,
            UART_BAUDRATE_BAUDRATE_Baud38400
        };
    
        APP_UART_FIFO_INIT( &comm_params,
                           UART_RX_BUF_SIZE,
                           UART_TX_BUF_SIZE,
                           uart_event_handle ,
                           APP_IRQ_PRIORITY_LOW,
                           err_code);
        APP_ERROR_CHECK(err_code);
    }
    /**@snippet [UART Initialization] */
    
    
    /**@brief Function for initializing the Advertising functionality.
     */
    static void advertising_init(void)
    {
        uint32_t      err_code;
        ble_advdata_t advdata;
        ble_advdata_t scanrsp;
    	  ble_adv_modes_config_t options;
    
    		uint8_t       flags = BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED;
    
    	  ble_advdata_manuf_data_t manuf_specific_data;
    
    		manuf_specific_data.company_identifier = APP_COMPANY_IDENTIFIER;
    	
    		
    		// Build advertising data struct to pass into @ref ble_advertising_init.
        memset(&advdata, 0, sizeof(advdata));
        advdata.name_type          = BLE_ADVDATA_FULL_NAME;
        advdata.include_appearance = false;
        advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
    
        memset(&scanrsp, 0, sizeof(scanrsp));
        scanrsp.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
        scanrsp.uuids_complete.p_uuids  = m_adv_uuids;
    
    		manuf_specific_data.data.p_data = (uint8_t *) m_tag_info;
        manuf_specific_data.data.size   = APP_TAG_INFO_LENGTH;
    
        // Build and set advertising data.
        memset(&advdata, 0, sizeof(advdata));
    
        advdata.name_type             = BLE_ADVDATA_NO_NAME;
        advdata.flags                 = flags;
        advdata.p_manuf_specific_data = &manuf_specific_data;
    
        err_code = ble_advdata_set(&advdata, NULL);
        APP_ERROR_CHECK(err_code);
    
        // Initialize advertising parameters (used when starting advertising).
        memset(&m_adv_params, 0, sizeof(m_adv_params));
    
        
    
        memset(&options, 0, sizeof(options));
        options.ble_adv_fast_enabled  = true;
        options.ble_adv_fast_interval = APP_ADV_INTERVAL;
        options.ble_adv_fast_timeout  = APP_ADV_TIMEOUT_IN_SECONDS;
    
        	
    		err_code = ble_advertising_init(&advdata, &scanrsp, &options, on_adv_evt, NULL);
        APP_ERROR_CHECK(err_code);
    	
    }
    
    
    /**@brief Function for initializing buttons and leds.
     *
     * @param[out] p_erase_bonds  Will be true if the clear bonding button was pressed to wake the application up.
     */
    static void buttons_leds_init(bool * p_erase_bonds)
    {
        bsp_event_t startup_event;
    
        uint32_t err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS,
                                     APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), 
                                     bsp_event_handler);
        APP_ERROR_CHECK(err_code);
    
        err_code = bsp_btn_ble_init(NULL, &startup_event);
        APP_ERROR_CHECK(err_code);
    
        *p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
    }
    
    
    /**@brief Function for placing the application in low power state while waiting for events.
     */
    static void power_manage(void)
    {
        uint32_t err_code = sd_app_evt_wait();
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Application main function.
     */
    
    // Adding the button init function for the ... Starts
    /**@brief Function for initializing buttons.
     */
    /*
    static void buttons_init(void)
    {
        // Set Wakeup and Bonds Delete buttons as wakeup sources.
        nrf_gpio_cfg_sense_input(WAKEUP_BUTTON_PIN,
                                 BUTTON_PULL, 
                                 NRF_GPIO_PIN_SENSE_LOW);
        
        nrf_gpio_cfg_sense_input(BONDMNGR_DELETE_BUTTON_PIN_NO,
                                 BUTTON_PULL, 
                                 NRF_GPIO_PIN_SENSE_LOW);
    }
    */
    // 
    int main(void)
    {
        uint32_t err_code;
        bool erase_bonds;
    
        // Initialize.
        //APP_SCHED_INIT(APP_SCHED_MAX_EVT_SIZE, APP_SCHED_QUEUE_SIZE);            //Initialize scheduler
        APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, false);
        uart_init();
    
        buttons_leds_init(&erase_bonds);
        ble_stack_init();
        gap_params_init();
        services_init();
        advertising_init();
        conn_params_init();
    		
    		// GPIO Config for button sensing & UART Triggering
    		// Configure BUTTON0 as a regular input
        nrf_gpio_cfg_input(BUTTON_2, NRF_GPIO_PIN_PULLUP);
        
        // Configure BUTTON1 with SENSE enabled 
        nrf_gpio_cfg_sense_input(BUTTON_2, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW);
        
        // Configure LED pin as output
    		//nrf_gpio_cfg_output(LED_1);
        
    		// Turn on LED 1
        //nrf_gpio_pin_clear(LED_1);
        
        // GPIO Close here	
    
        printf("\r\nUART Start!\r\n");
        err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
        APP_ERROR_CHECK(err_code);
        //uart_test();
        adc_config();                //Initialize ADC
    
    		
        // Enter main loop.
        for (;;)
        {
    				if(nrf_gpio_pin_read(BUTTON_2)== 0)
            {
                // Clear LED0
                nrf_gpio_pin_set(LED_1);
    						uart_test();
                // Enter system OFF. After wakeup the chip will be reset, and code execution will run from the top 
                //NRF_POWER->SYSTEMOFF = 1;
            }
            power_manage();          // Enter sleep mode
            //app_sched_execute();     //Let scheduler execute whatever is in the scheduler queue
        }
    }
    
    
    /** 
     * @}
     */
    

  • in advertising_init() function you have explicitly asked not to include the advertising device name.

    comment it out like below

    //    // Build and set advertising data.
    //    memset(&advdata, 0, sizeof(advdata));
    
    //    advdata.name_type             = BLE_ADVDATA_NO_NAME;
    //    advdata.flags                 = flags;
    //    advdata.p_manuf_specific_data = &manuf_specific_data;
    
    //    err_code = ble_advdata_set(&advdata, NULL);
    //    APP_ERROR_CHECK(err_code);

  • Hi Susheel, 

    Thanks for your answer and answer work out for me it starts advertising.

    But in addition of it I want to advertise the manufacturer specific data too. Like company name, Firmware & Hardware version with it.

    So that we can get the Device_Name, Company_Name, Hardware & Firmware version details within the advertising packet.

    Looking forward for your valuable guidelines ....

    Regards

    Sachin 

  • then you add manufacture data in advertising packet and the device name in the scan response or vice versa.

Related