Changing APP_ADV_INTERVAL when scan request detected

[Jason]

Hi,

I'm making a peripheral device that needs to minimise battery usage.  

My device is essentially a beacon but it allows temporary connections to send a stream of data before closing the connection. I do not think I have enough battery to allow permanent connections that follow the apple design guidelines (220 mAh coin cell and >1 year longevity)

I was surprised to discover that android phones won't reliably connect if APP_ADV_INTERVAL is 10 seconds. With my old samsung S5 I need to reduce the interval to around 2 seconds. 

I have an accelerometer so I was planning to rapidly advertise when the user shakes the device. But maybe it would be better to change the advertising interval when a scan request is detected. Is this possible? Can I detect when my device transmits a scan response? Or is there another mechanism to support this?

Thanks in advance for your help.

-JasonR

[Jason]

I added this to my ble_evt_handler

        case BLE_GAP_EVT_SCAN_REQ_REPORT:
            printf("BLE_GAP_EVT_SCAN_REQ_REPORT rssi =  %d \n", p_ble_evt->evt.gap_evt.params.scan_req_report.rssi);
            break;

but it doesn't get hit when I scan for the peripheral with my android phone. 

Do I need to enable the event "BLE_GAP_EVT_SCAN_REQ_REPORT"? I cannot find mention of it in the s140 softdevice docs

[Karl Ylvisaker]

Hello JasonR, 

I have not heard about the behavior where older android phones require such long advertising intervals, but if you have determined this to be the case then I guess it is probably a power saving measure on the Android's part.

Could you share your advertising configuration?
You will indeed need to enable the scan request notification.
It might be helpful to see this ticket even though it is old and may not apply directly to your case.

Please let me know if this was not what you were looking for.

Best regards,
Karl

[Mishka]

Hi,

I develop a similar app and if you don't mind would like to share some thoughts.

The time to discovery depends not only on how often the beacon advertises (the advertisement interval), but also on the scan window and the scan interval. These two options are intended to save power of the scanner, and it may happen that the advertiser sends its packet just at the moment when scanner doesn't listen. For example, if scan window is 1024 ms and scan interval is 4096 ms as defined by the Android Scan Manager, and the beacon sends a packet every 10 seconds, there's P=0.25 probability to catch the packet from the first attempt. In turn, with the broadcast interval decreased down to 2 seconds, there will be P=0.75 chances to see the packet during the first scan interval. Please note, with these settings it's possible to trap into "blind" zone when advertisements are perfectly aligned with radio off intervals.

To improve catch ratio, it's possible to either decrease the advertisement interval on the beacon, or make the scan window wider and the scan interval shorter on the Android smartphone. Of course, it's also possible to set T_adv < T_scanwindow in order to guarantee the result (there's a small probability of RF congestion though).

Regarding the scan response, as far as I know it is sent in reply to a scan request, which in order is sent in reply to a caught advertisement packet. I.e. the smartphone will be required to catch at least one advertisement before the beacon may respond with a scan response. This, perhaps, reduces significance of the scan response for this particular app.

IMHO to save the beacon battery there are basically two options:

• As you have suggested, on interrupt from the IMU do broadcast more often, probably with T_adv < T_scanwindow so the smartphone may catch it earlier and do it's job quickly.
• Alternativaly, connect the beacon as peripheral with the Slave Latency connection parameter set fairly high so the beacon can have long enough idle times between packets. The slave latency will allow the beacon to respond to the IMU interrupts quickly, but as a drawback the smartphone will have to wait for the Supervision Timeout before it can reach the beacon. Of course, if the beacon will get to the smartphone earlier, the smartphone will be able to respond immediately, and (if needed) adjust the slave response.

Kind regards,
Mishka

[Jason]

Thank you, the scan request notifications work. 

I'm testing using nrfconnect android app. When I press connect it will only connect if the advertising interval is small, 2 seconds sometimes, 1 second is better and 100ms is very reliable.  10 seconds never connects. even if I press connect repeatedly.

I've been looking for a broken setting in my code but I cant find anything. I've been comparing my settings with other examples and not found anything obvious. I'm not sure which settings you want to see so I've attached my sdk_config.h and main,c if you could have a look. 

Fullscreen 8816.main.c Download

#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "ble.h"
#include "ble_err.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_conn_params.h"
#include "ble_conn_state.h"
#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "ble_nus.h"
#include "app_uart.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#include "nrf_delay.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_twi.h"

#include "main.h"


//TODO
// follow apple design guidelines https://developer.apple.com/accessories/Accessory-Design-Guidelines.pdf
// ADV_IND, ADV_SCAN_IND or ADV_NONCONN_IND
// advertising data must contain Flags, TX power level, Local Name and Services.
// Name and TX power can go in SCAN_RSP PDU 

bool test;

#define DEVICE_NAME                     "Vigg10"                         /**< Name of device. Will be included in the advertising data. */

#define APP_BLE_CONN_CFG_TAG            1                                       /**< A tag identifying the SoftDevice BLE configuration. */
#define LINK_TOTAL                      NRF_SDH_BLE_PERIPHERAL_LINK_COUNT + \
                                        NRF_SDH_BLE_CENTRAL_LINK_COUNT

//#define LIGHTS_OFF

#define ADVERTISING_LED1_G              BSP_BOARD_LED_0      //LED1_G           /**< Is on when device is advertising. */
#define CONNECTED_LED2_R                BSP_BOARD_LED_1      //LED2_R           /**< Is on when device has connected. */
#define LEDBUTTON_LED2_G                BSP_BOARD_LED_2      //LED2_G           /**< LED to be toggled with the help of the LED Button Service. */
#define SAADC_LED2_B                    BSP_BOARD_LED_3      //LED2_B           /**< LED to be toggled during SAADC sampling */

#define LEDBUTTON_BUTTON                BSP_BUTTON_0                            /**< Button that will trigger the notification event with the LED Button Service */

#define APP_ADV_INTERVAL                MSEC_TO_UNITS(100, UNIT_0_625_MS)     //connects if this is 1 second
#define APP_ADV_DURATION                BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED   // in units of 10 milliseconds. 
//#define APP_MAX_ADV_EVTS                0


#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(15, UNIT_1_25_MS)   //The central decides anyway
#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(30, UNIT_1_25_MS)   // These comply with apple guidelines  
#define SLAVE_LATENCY                   30                                //       
#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)

//NRF_SDH_BLE_PERIPHERAL_LINK_COUNT = 1 & NRF_SDH_BLE_TOTAL_LINK_COUNT = 1 in sdk_config.h

#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000)                  // I wil disconnect as soon as the data is received from the peripheral, or X seconds after last data received
#define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(30000)                 // So these settings might not do anything 
#define MAX_CONN_PARAMS_UPDATE_COUNT    3                                      

#define MAIN_TIMER_INTERVAL             APP_TIMER_TICKS(20000)                   /**< Was Heart rate measurement interval (ticks). */
#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). */

#define LED_WHILE_ADVERTISING          

//pin 1 of LED SFH4656 is the anode   (positive), this is the large circle on the LED, this is MY_IR_LED_POWER_PIN             
//pin 2 of LED SFH4656 is the cathode (negative), this is the small circle on the LED, this goes to ground with a 100ohm (600 ohm is fine at 3.3v)
//pin 1 of the SFH3015 is the emitter,   this is MY_PHOTOTRANSISTOR_ADC_PIN, this has the green square on the back
//pin 2 of the SFH3015 is the collector, this is MY_PHOTOTRANSISTOR_POWER_PIN - A 500 ohm resistor is fine at 3.3v

#ifdef BOARD_PCA10059     //DONGLE
#define MY_IR_LED_POWER_PIN             NRF_GPIO_PIN_MAP(1,13)        
#define MY_PHOTOTRANSISTOR_POWER_PIN    NRF_GPIO_PIN_MAP(1,15)   //SFH3015 pin 2 (Collector)
#define MY_PHOTOTRANSISTOR_ADC_PIN      NRF_GPIO_PIN_MAP(0,2)    //SFH3015 pin 1, (Emitter), green square
#else
#define MY_IR_LED_POWER_PIN             ARDUINO_0_PIN
#define MY_PHOTOTRANSISTOR_POWER_PIN    ARDUINO_1_PIN
#define MY_PHOTOTRANSISTOR_ADC_PIN    ARDUINO_A0_PIN  //ARDUINO_2_PIN
#endif

#define NUM_BRIGHTNESS_STEPS            4
#define PHOTORESISTOR_WARMING_TIME      160
#define SAADC_SAMPLES_IN_BUFFER         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 DEAD_BEEF                           0xDEADBEEF                              /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */

static uint16_t                         brightness_values[NUM_BRIGHTNESS_STEPS + 1];
static int                              step_num = 0;
static nrf_saadc_value_t                m_saadc_samples[SAADC_SAMPLES_IN_BUFFER];
//static int32_t                          temperature;



#define APP_BLE_OBSERVER_PRIO    3                                              // Priority of the application BLE event handler. You shouldn't need to modify this value.

static uint8_t m_adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET;                   // Advertising handle used to identify an advertising set. 
static uint8_t m_enc_advdata[BLE_GAP_ADV_SET_DATA_SIZE_MAX];                    // Buffer that gets filled with encoded advertising 
static uint8_t m_enc_scan_response_data[BLE_GAP_ADV_SET_DATA_SIZE_MAX];         // Buffer that gets filled with encoded scan data. 

// Struct that gets filled by ble_advdata_encode 
static ble_gap_adv_data_t   m_adv_data =
{
    .adv_data =
    {
        .p_data = m_enc_advdata,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX
    },
    .scan_rsp_data =
    {
        .p_data = m_enc_scan_response_data,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX

    }
};

bool use_advertisement_data_B = false;
static uint8_t m_enc_advdata_B[BLE_GAP_ADV_SET_DATA_SIZE_MAX];                    // Buffer that gets filled with encoded advertising 
static uint8_t m_enc_scan_response_data_B[BLE_GAP_ADV_SET_DATA_SIZE_MAX];         // Buffer that gets filled with encoded scan data. 

// Struct that gets filled by ble_advdata_encode 
static ble_gap_adv_data_t   m_adv_data_B =
{
    .adv_data =
    {
        .p_data = m_enc_advdata_B,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX
    },
    .scan_rsp_data =
    {
        .p_data = m_enc_scan_response_data_B,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX

    }
};

//Data that gets inlcuded in the advertisement
static uint8_t                    m_advertiser_data[4];
static ble_advdata_manuf_data_t   m_ble_advdata_manufacturer_specific_data = 
{
  .company_identifier = 0xFFFF, 
  .data = 
  {
    .size = 4,
    .p_data = m_advertiser_data 
  }
};

//BLE_LBS_DEF(m_lbs);                                         /**< LED Button Service instance. */
BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT);             /**< BLE NUS service instance. */
NRF_BLE_GATT_DEF(m_gatt);                                     /**< GATT module instance. */
NRF_BLE_QWRS_DEF(m_qwr, NRF_SDH_BLE_TOTAL_LINK_COUNT);        /**< Context for the Queued Write module.*/
APP_TIMER_DEF(m_main_timer_id);                               

static uint16_t   m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3;            /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
static ble_uuid_t m_adv_uuids[]          =                                          /**< Universally unique service identifier. */
{
    {BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}
};

/* TWI instance ID. */
#if TWI0_ENABLED
#define TWI_INSTANCE_ID     0
#elif TWI1_ENABLED
#define TWI_INSTANCE_ID     1
#endif

/* TWI instance. */
static const nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);


static void flash_led_num(int led_num, int times, int duration)
{
    for (int i = 0; i < times; i++)
    {
      bsp_board_led_on(led_num);     
      nrf_delay_ms(duration);
      bsp_board_led_off(led_num);     
      nrf_delay_ms(duration);
    }
}

void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
    static uint32_t cnt = 0;
    ret_code_t err_code;
    uint16_t        brightness;

    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
        err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAADC_SAMPLES_IN_BUFFER);
        APP_ERROR_CHECK(err_code);

        NRF_LOG_INFO("%d\r\n", p_event->data.done.p_buffer[0]);
        brightness_values[step_num] = p_event->data.done.p_buffer[0];

        if (step_num == 0)
        {
          // First is the ambient check. Now turn on the LED and repeat 
          nrf_gpio_pin_write(MY_IR_LED_POWER_PIN, 1);           // IR_LED on
//          nrf_delay_us((PHOTORESISTOR_WARMING_TIME / NUM_BRIGHTNESS_STEPS)-10);     // Wait for phototransistor to warm up a bit
          step_num += 1;
          nrf_drv_saadc_sample();                               // Do the next step.
        }
        else if (step_num < NUM_BRIGHTNESS_STEPS)
        {
          nrf_delay_us((PHOTORESISTOR_WARMING_TIME / NUM_BRIGHTNESS_STEPS)-10);     // Wait for phototransistor to warm up a bit more
          step_num += 1;
          nrf_drv_saadc_sample();                               // Do the next step.
        }
        else
        {
          nrf_gpio_pin_clear(MY_IR_LED_POWER_PIN);
          nrf_gpio_pin_clear(MY_PHOTOTRANSISTOR_POWER_PIN);

//#ifndef LIGHTS_OFF    //this isnt using much power
          bsp_board_led_off(SAADC_LED2_B);    //bsp_board_led_off(1);   
//#endif

          m_advertiser_data[0] = cnt++;
          m_advertiser_data[1] = brightness_values[0];    //ambient brightness
          m_advertiser_data[2] = brightness_values[1];
          m_advertiser_data[3] = brightness_values[NUM_BRIGHTNESS_STEPS];

          advertising_update();
        }

// Not sure if calibration needed
//        if((m_adc_evt_counter++ % SAADC_CALIBRATION_INTERVAL) == 0)
//        {
//            nrf_drv_saadc_abort();                                      // Abort all ongoing conversions. Calibration cannot be run if SAADC is busy
//            m_saadc_calibrate = true;                                   // Set flag to trigger calibration in main context when SAADC is stopped
//        }

    }

// Not sure if calibration needed
//    else if (p_event->type == NRF_DRV_SAADC_EVT_CALIBRATEDONE)
//    {        
//        err_code = nrf_drv_saadc_buffer_convert(m_saadc_samples, SAADC_SAMPLES_IN_BUFFER);
//        APP_ERROR_CHECK(err_code);
//        
//#ifdef UART_PRINTING_ENABLED
//        NRF_LOG_INFO("SAADC calibration complete ! \r\n");                                              //Print on UART
//#endif //UART_PRINTING_ENABLED	
//        
//    }

}
static void my_init(void)
{
// bsp_board_init sets voltages to 3v IIRC in bsp_board_init if PCA_10059 is defined.
//    if (NRF_UICR->REGOUT0 != UICR_REGOUT0_VOUT_3V3) 
//    {
//        NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Wen << NVMC_CONFIG_WEN_Pos;
//        while (NRF_NVMC->READY == NVMC_READY_READY_Busy){}
//        NRF_UICR->REGOUT0 = UICR_REGOUT0_VOUT_3V3;
//
//        NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Ren << NVMC_CONFIG_WEN_Pos;
//        while (NRF_NVMC->READY == NVMC_READY_READY_Busy){}
//    }

    bsp_board_init(BSP_INIT_LEDS);
    bsp_board_leds_off();

    nrf_gpio_pin_dir_set(MY_IR_LED_POWER_PIN,          NRF_GPIO_PIN_DIR_OUTPUT);
    nrf_gpio_pin_dir_set(MY_PHOTOTRANSISTOR_POWER_PIN, NRF_GPIO_PIN_DIR_OUTPUT);

    nrf_gpio_pin_dir_set(MY_PHOTOTRANSISTOR_ADC_PIN, NRF_GPIO_PIN_DIR_INPUT);
    nrf_gpio_cfg_input(MY_PHOTOTRANSISTOR_ADC_PIN,   NRF_GPIO_PIN_PULLDOWN);

    nrf_gpio_pin_clear(MY_IR_LED_POWER_PIN);
    nrf_gpio_pin_clear(MY_PHOTOTRANSISTOR_POWER_PIN);
}

void saadc_init(void)
{
    ret_code_t err_code;
#ifdef BOARD_PCA10059     //DONGLE
    nrf_saadc_channel_config_t saadc_channel_config = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN0);
#else
    nrf_saadc_channel_config_t saadc_channel_config = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN1);
#endif

    nrf_drv_saadc_config_t nrf_drv_saadc_config = NRF_DRV_SAADC_DEFAULT_CONFIG;    // config comes from sdk_config.h

    err_code = nrf_drv_saadc_init(&nrf_drv_saadc_config, saadc_callback);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(0, &saadc_channel_config);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_buffer_convert(m_saadc_samples, SAADC_SAMPLES_IN_BUFFER);
    APP_ERROR_CHECK(err_code);
}

/**@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 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)
{//TODO
    app_error_handler(DEAD_BEEF, line_num, p_file_name);
}


static void advertising_start(void)
{
    ret_code_t err_code;

    err_code = sd_ble_gap_adv_start(m_adv_handle, APP_BLE_CONN_CFG_TAG);

    APP_ERROR_CHECK(err_code);
#ifndef LIGHTS_OFF
    bsp_board_led_on(ADVERTISING_LED1_G);
#endif
}

//static void advertising_stop(void)
//{   //Stop advertising when accelerometer detects no movement for an hour
//    ret_code_t err_code;
//
//    err_code = sd_ble_gap_adv_stop(m_adv_handle);
//
//    APP_ERROR_CHECK(err_code);
//#ifndef LIGHTS_OFF
//    bsp_board_led_on(ADVERTISING_LED1_G);
//#endif
//}


/**@brief Function for handling the Heart rate measurement timer timeout.
 *
 * @details This function will be called each time the heart rate measurement timer expires.
 *          It will exclude RR Interval data from every third measurement.
 *
 * @param[in] p_context  Pointer used for passing some arbitrary information (context) from the
 *                       app_start_timer() call to the timeout handler.
 */
static void main_timer_handler(void * p_context)
{
    ret_code_t      err_code;
    UNUSED_PARAMETER(p_context);

    NRF_LOG_INFO("JASON main_timer_handler");
    printf("JASON main_timer_handler\n");

//#ifndef LIGHTS_OFF    //this isnt using much power
    bsp_board_led_on(SAADC_LED2_B);
//#endif
    step_num = 0;
    nrf_gpio_pin_write(MY_PHOTOTRANSISTOR_POWER_PIN, 1);    // Phototransistor power on
    nrf_delay_us(160);                                      // Wait for phototransistor to warm up 		 TODO this should be increased to let the sensor settle
    nrf_drv_saadc_sample();                                 // start getting SAADC readings. First is ambient 
}

///**@brief Function for handling the Heart rate measurement timer timeout.
// *
// * @details This function will be called each time the heart rate measurement timer expires.
// *          It will exclude RR Interval data from every third measurement.
// *
// * @param[in] p_context  Pointer used for passing some arbitrary information (context) from the
// *                       app_start_timer() call to the timeout handler.
// */
//static void advertising_timeout_handler(void * p_context)
//{
//    ret_code_t      err_code;
////    uint32_t    periph_link_cnt = ble_conn_state_peripheral_conn_count(); // Number of peripheral links.
//
//    UNUSED_PARAMETER(p_context);
//    NRF_LOG_INFO("JASON advertising_timeout_handler");
//
//  //  if (periph_link_cnt < NRF_SDH_BLE_PERIPHERAL_LINK_COUNT)
//    {
//        advertising_start();
//    }
//}
/**@brief Function for the Timer initialization.
 *
 * @details Initializes the timer module. This creates and starts application timers.
 */
static void timers_init(void)
{
    // Initialize timer module, making it use the scheduler
    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);
    // Create timers.

    err_code = app_timer_create(&m_main_timer_id,
                                APP_TIMER_MODE_REPEATED,
                                main_timer_handler);
    APP_ERROR_CHECK(err_code);

//    err_code = app_timer_create(&m_advertising_timer_id,
//                                APP_TIMER_MODE_REPEATED,
//                                advertising_timeout_handler);
//    APP_ERROR_CHECK(err_code);

}

/**@brief Function for starting application timers.
 */
static void application_timers_start(void)
{
    ret_code_t err_code;

    err_code = app_timer_start(m_main_timer_id, MAIN_TIMER_INTERVAL, NULL);
    APP_ERROR_CHECK(err_code);

//    err_code = app_timer_start(m_advertising_timer_id, ADVERTISING_TIMER_INTERVAL, NULL);
//    APP_ERROR_CHECK(err_code);

}

static void gap_params_init(void)
{
    ret_code_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 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);
}


static void advertising_init(void)
{
    ret_code_t           err_code;
    ble_advdata_t        advdata;
    ble_advdata_t        srdata;
    ble_gap_adv_params_t adv_params;

    memset(&advdata, 0, sizeof(advdata));
    advdata.name_type          = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance = true;
    advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    advdata.p_manuf_specific_data = &m_ble_advdata_manufacturer_specific_data ;


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

    err_code = ble_advdata_encode(&advdata, m_adv_data.adv_data.p_data, &m_adv_data.adv_data.len);
    APP_ERROR_CHECK(err_code);

    err_code = ble_advdata_encode(&srdata, m_adv_data.scan_rsp_data.p_data, &m_adv_data.scan_rsp_data.len);
    APP_ERROR_CHECK(err_code);

    // Start advertising.
    memset(&adv_params, 0, sizeof(adv_params));
    adv_params.p_peer_addr           = NULL;
    adv_params.filter_policy         = BLE_GAP_ADV_FP_ANY;
    adv_params.interval              = APP_ADV_INTERVAL;
    adv_params.properties.type       = BLE_GAP_ADV_TYPE_CONNECTABLE_SCANNABLE_UNDIRECTED;
    adv_params.duration              = APP_ADV_DURATION;
    adv_params.max_adv_evts          = 0;
    adv_params.primary_phy           = BLE_GAP_PHY_1MBPS;
    adv_params.scan_req_notification = 1;

    err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, &adv_params);
    APP_ERROR_CHECK(err_code);
    //alternate between m_adv_data and m_adv_data_B
    use_advertisement_data_B = true;


    err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_ADV, m_adv_handle, 8); //-40, -30, -20, -16, -12, -8, -4, 0, and 4
    APP_ERROR_CHECK(err_code);  
}

/**@brief Function for initializing the Advertising functionality.
 *
 * @details Encodes the required advertising data and passes it to the stack.
 *          Also builds a structure to be passed to the stack when starting advertising.
 */
static void advertising_update(void)
{
    ret_code_t           err_code;
    ble_advdata_t        advdata;
    ble_advdata_t        srdata;

//    ble_uuid_t adv_uuids[] = {{LBS_UUID_SERVICE, m_lbs.uuid_type}};

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

    advdata.name_type          = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance = true;
    advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    advdata.p_manuf_specific_data = &m_ble_advdata_manufacturer_specific_data ;


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

    if (use_advertisement_data_B)
    {
      err_code = ble_advdata_encode(&advdata, m_adv_data_B.adv_data.p_data, &m_adv_data_B.adv_data.len);
      APP_ERROR_CHECK(err_code);

      err_code = ble_advdata_encode(&srdata, m_adv_data_B.scan_rsp_data.p_data, &m_adv_data_B.scan_rsp_data.len);
      APP_ERROR_CHECK(err_code);

      err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data_B, NULL);
      APP_ERROR_CHECK(err_code);
    }
    else
    {
      err_code = ble_advdata_encode(&advdata, m_adv_data.adv_data.p_data, &m_adv_data.adv_data.len);
      APP_ERROR_CHECK(err_code);

      err_code = ble_advdata_encode(&srdata, m_adv_data.scan_rsp_data.p_data, &m_adv_data.scan_rsp_data.len);
      APP_ERROR_CHECK(err_code);

      err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, NULL);
      APP_ERROR_CHECK(err_code);
      
    }
    use_advertisement_data_B = !use_advertisement_data_B;
}


/**@brief Function for handling Queued Write Module errors.
 *
 * @details A pointer to this function will be passed to each service which may need to inform the
 *          application about an error.
 *
 * @param[in]   nrf_error   Error code containing information about what went wrong.
 */
static void nrf_qwr_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}


/**@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_evt       Nordic UART Service event.
 */
/**@snippet [Handling the data received over BLE] */
static void nus_data_handler(ble_nus_evt_t * p_evt)
{

    if (p_evt->type == BLE_NUS_EVT_RX_DATA)
    {
        uint32_t err_code;

        NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART.");
        NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);

//        for (uint32_t i = 0; i < p_evt->params.rx_data.length; i++)
//        {
//            do
//            {
//                err_code = app_uart_put(p_evt->params.rx_data.p_data[i]);
//                if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY))
//                {
//                    NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. ", err_code);
//                    APP_ERROR_CHECK(err_code);
//                }
//            } while (err_code == NRF_ERROR_BUSY);
//        }
//        if (p_evt->params.rx_data.p_data[p_evt->params.rx_data.length - 1] == '\r')
//        {
//            while (app_uart_put('\n') == NRF_ERROR_BUSY);
//        }
    }

}

/**@brief Function for initializing services that will be used by the application.
 */
static void services_init(void)
{
    ret_code_t         err_code;
//    ble_lbs_init_t     lbs_init;
    ble_nus_init_t     nus_init;
    nrf_ble_qwr_init_t qwr_init = {0};

    // Initialize Queued Write Module instances.
    qwr_init.error_handler = nrf_qwr_error_handler;

    for (uint32_t i = 0; i < LINK_TOTAL; i++)   
    {
        err_code = nrf_ble_qwr_init(&m_qwr[i], &qwr_init);
        APP_ERROR_CHECK(err_code);
    }


    // Initialize NUS.
    memset(&nus_init, 0, sizeof(nus_init));

    nus_init.data_handler = nus_data_handler;

    err_code = ble_nus_init(&m_nus, &nus_init);
    APP_ERROR_CHECK(err_code);

    ble_conn_state_init();
}


/**@brief Function for handling a Connection Parameters error.
 *
 * @param[in] nrf_error  Error code containing information about what went wrong.
 */
static void conn_params_error_handler(uint32_t nrf_error)
{
    NRF_LOG_INFO("In conn_params_error_handler with nrf_error = %d", nrf_error);
    printf("In conn_params_error_handler with nrf_error = %d\n", nrf_error);    //never prints

    APP_ERROR_HANDLER(nrf_error);
}

static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
{
    uint32_t err_code;
    printf("in on_conn_params_evt\n");    //never prints

    if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
    {
        NRF_LOG_INFO("p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED");
        printf("p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED\n");    //never prints

//        err_code = sd_ble_gap_disconnect(p_evt->conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
//        APP_ERROR_CHECK(err_code);
//
//        for (uint32_t i = 0; i < LINK_TOTAL; i++)   
//        {
//            if (p_evt->conn_handle == m_qwr[i].conn_handle)
//            {
//              m_qwr[i].conn_handle = BLE_CONN_HANDLE_INVALID;
//              break;
//            }
//        }
    }
}


static void conn_params_init(void)
{
    ret_code_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 handling the Connected event.
 *
 * @param[in] p_gap_evt GAP event received from the BLE stack.
 */
static void on_connected(const ble_gap_evt_t * const p_gap_evt)
{
    ret_code_t  err_code;
    uint32_t    periph_link_cnt = ble_conn_state_peripheral_conn_count(); // Number of peripheral links.

    NRF_LOG_INFO("Connection with link 0x%x established.", p_gap_evt->conn_handle);

    // Assign connection handle to available instance of QWR module.
    for (uint32_t i = 0; i < NRF_SDH_BLE_PERIPHERAL_LINK_COUNT; i++)
    {
        if (m_qwr[i].conn_handle == BLE_CONN_HANDLE_INVALID)
        {
            err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr[i], p_gap_evt->conn_handle);
            APP_ERROR_CHECK(err_code);
            break;
        }
    }

//    err_code = app_button_enable();
//    APP_ERROR_CHECK(err_code);

    // Update LEDs
#ifndef LIGHTS_OFF
    bsp_board_led_on(CONNECTED_LED2_R);
#endif
	//JPRHERE comment out the if and else to use advertising timer 
    if (periph_link_cnt == NRF_SDH_BLE_PERIPHERAL_LINK_COUNT)
    {
#ifndef LIGHTS_OFF
        bsp_board_led_off(ADVERTISING_LED1_G);
#endif
    }
    else
    {
        // Continue advertising. More connections can be established because the maximum link count has not been reached.
        advertising_start();
    }

    send_data_to_peers();
}


/**@brief Function for handling the Disconnected event.
 *
 * @param[in] p_gap_evt GAP event received from the BLE stack.
 */
static void on_disconnected(ble_gap_evt_t const * const p_gap_evt)
{
    ret_code_t  err_code;
    uint32_t    periph_link_cnt = ble_conn_state_peripheral_conn_count(); // Number of peripheral links.

    NRF_LOG_INFO("Connection 0x%x has been disconnected. Reason: 0x%X",
                 p_gap_evt->conn_handle,
                 p_gap_evt->params.disconnected.reason);

    for (uint32_t i = 0; i < NRF_SDH_BLE_PERIPHERAL_LINK_COUNT; i++)
    {
        if (m_qwr[i].conn_handle == p_gap_evt->conn_handle)
        {
            m_qwr[i].conn_handle = BLE_CONN_HANDLE_INVALID;
            break;
        }
    }

    if (periph_link_cnt == 0)
    {
#ifndef LIGHTS_OFF
        bsp_board_led_off(CONNECTED_LED2_R);
#endif
//        err_code = app_button_disable();
        APP_ERROR_CHECK(err_code);
    }

//JPRHERE comment out this if to use advertising timer 
    if (periph_link_cnt == (NRF_SDH_BLE_PERIPHERAL_LINK_COUNT - 1))
    {
        // Advertising is not running when all connections are taken, and must therefore be started.
        advertising_start();
    }
}


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

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_SCAN_REQ_REPORT:
            printf("BLE_GAP_EVT_SCAN_REQ_REPORT rssi =  %d \n", p_ble_evt->evt.gap_evt.params.scan_req_report.rssi);
            break;

        case BLE_GAP_EVT_CONNECTED:
            on_connected(&p_ble_evt->evt.gap_evt);
            break;

        case BLE_GAP_EVT_DISCONNECTED:
            on_disconnected(&p_ble_evt->evt.gap_evt);
            break;

        case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
            // Pairing not supported    
            //TODO 
            err_code = sd_ble_gap_sec_params_reply(p_ble_evt->evt.gap_evt.conn_handle,
                                                   BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP,
                                                   NULL,
                                                   NULL);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GAP_EVT_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_GAP_EVT_ADV_SET_TERMINATED:
//JPRHERE TODO advertising completed
//            bsp_board_led_off(ADVERTISING_LED1_G);
//            break;
        

        case BLE_GATTS_EVT_SYS_ATTR_MISSING:
            // No system attributes have been stored.
            err_code = sd_ble_gatts_sys_attr_set(p_ble_evt->evt.gap_evt.conn_handle, NULL, 0, 0);
            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;
    }
}


/**@brief Function for initializing the BLE stack.
 *
 * @details Initializes the SoftDevice and the BLE event interrupt.
 */
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. 
    // TODO set linker RAM start using value returned here
    // soft device uses about 4KB per Peripheral link. 
    // 2 peripherals RAM_START = 0x20003a28  (~14 KB for softdevice)
    // 10 peripherals RAM_START = 0x2000b6c8 (~45 KB for softdevice)

    // So to be conservative I will give the soft_device 64Kb and set app RAM as 192 KB 
    // 0x20010000

    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    printf("RAM start is 0x%08x\n", ram_start);

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

}


///**@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 uint32_t led_status_send_to_all(uint8_t button_action)
//{
//    ret_code_t                        err_code;
//    ble_conn_state_conn_handle_list_t conn_handles = ble_conn_state_periph_handles();
//
//    for (uint8_t i = 0; i < conn_handles.len; i++)
//    {
//        err_code = ble_lbs_on_button_change(conn_handles.conn_handles[i], &m_lbs, button_action);
//
//        if (err_code != NRF_SUCCESS &&
//            err_code != BLE_ERROR_INVALID_CONN_HANDLE &&
//            err_code != NRF_ERROR_INVALID_STATE &&
//            err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
//        {
//            APP_ERROR_CHECK(err_code);
//            NRF_LOG_DEBUG("Sent button change 0x%x on connection handle 0x%x.", button_action, conn_handles.conn_handles[i]);
//        }
//    }
//    return NRF_SUCCESS;
//}



/**@brief Function for initializing the logging 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 power management.
 */
static void power_management_init(void)
{
    ret_code_t err_code;
    err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}




static void send_data_to_peer(uint16_t conn_handle)
{
//    static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
//    static uint8_t index = 0;
////    uint32_t       err_code;
    ret_code_t       err_code;
    static uint32_t counter = 0;
//
    uint16_t length = 10;  // Max BLE_NUS_MAX_DATA_LEN
    static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
    sprintf(data_array, "Hi %d", counter++);

    err_code = ble_nus_data_send(&m_nus, data_array, &length, conn_handle);
}


///**@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.
// */
///**@snippet [Handling the data received over UART] */
static void send_data_to_peers()
{

    ble_conn_state_conn_handle_list_t conn_handles = ble_conn_state_periph_handles();

    for (uint8_t i = 0; i < conn_handles.len; i++)
    {
      send_data_to_peer(conn_handles.conn_handles[i]);
    }
}

//    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') ||
//                (data_array[index - 1] == '\r') ||
//                (index >= m_ble_nus_max_data_len))
//            {
//                if (index > 1)
//                {
//                    NRF_LOG_DEBUG("Ready to send data over BLE NUS");
//                    NRF_LOG_HEXDUMP_DEBUG(data_array, index);
//
//                    do
//                    {
//                        uint16_t length = (uint16_t)index;
//                        err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
//                        if ((err_code != NRF_ERROR_INVALID_STATE) &&
//                            (err_code != NRF_ERROR_RESOURCES) &&
//                            (err_code != NRF_ERROR_NOT_FOUND))
//                        {
//                            APP_ERROR_CHECK(err_code);
//                        }
//                    } while (err_code == NRF_ERROR_RESOURCES);
//                }
//
//                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;
//    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,
//#if defined (UART_PRESENT)
//        .baud_rate    = NRF_UART_BAUDRATE_115200
//#else
//        .baud_rate    = NRF_UARTE_BAUDRATE_115200
//#endif
//    };
//
//    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);
//}
///**@snippet [UART Initialization] */


/**@brief Function for handling the idle state (main loop).
 *
 * @details If there is no pending log operation, then sleep until next the next event occurs.
 */
static void idle_state_handle(void)
{   //TODO why is this commented out????
//    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}



void twi_init (void)
{
    ret_code_t err_code;

    const nrf_drv_twi_config_t twi_config = {
       .scl                = NRF_GPIO_PIN_MAP(0, 22),
       .sda                = NRF_GPIO_PIN_MAP(0, 20), 
       .frequency          = NRF_DRV_TWI_FREQ_400K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = true
    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);
}


static void scan_twi()
{
  uint8_t address;
  uint32_t  err_code;
     uint8_t sample_data;
    bool detected_device = false;
 
    while (true)
    {
      for (address = 0x1; address <= 127; address++)
      {

          err_code = nrf_drv_twi_rx(&m_twi, address, &sample_data, sizeof(sample_data));
          if (err_code == NRF_SUCCESS)
          {
              detected_device = true;
              NRF_LOG_INFO("TWI device detected at address 0x%x.", address);
              printf("TWI device detected at address 0x%x.\n", address);
          }
          NRF_LOG_FLUSH();
        nrf_delay_ms(10);
      }

      if (!detected_device)
      {
          NRF_LOG_INFO("No device was found.");
          printf("No device was found.\n");
          NRF_LOG_FLUSH();
      }

//      nrf_delay_ms(1000);
    }

}


/**@brief Function for application main entry.
 */
int main(void)
{
    // Initialize.
//    uart_init();
    log_init();
    twi_init();
    timers_init();
    my_init();

flash_led_num(ADVERTISING_LED1_G, 5, 50);   // So I know if it's crashing, resetting
//flash_led_num(CONNECTED_LED2_R, 5, 50);
//flash_led_num(LEDBUTTON_LED2_G, 5, 50);
//flash_led_num(SAADC_LED2_B, 10, 50);

    power_management_init();
    ble_stack_init();
    saadc_init();
    gap_params_init();
    gatt_init();
    services_init();
    advertising_init();
    conn_params_init();

//flash_led_num(ADVERTISING_LED1_G, 1, 1000);

    advertising_start();
//flash_led_num(CONNECTED_LED2_R, 1, 1000);

    application_timers_start();

    // Start execution.
    NRF_LOG_INFO("Multiperipheral example started.");

//flash_led_num(ADVERTISING_LED1_G, 5, 50);
//flash_led_num(CONNECTED_LED2_R, 5, 50);  
//flash_led_num(LEDBUTTON_LED2_G, 5, 50);
//flash_led_num(SAADC_LED2_B, 15, 50);

//    scan_twi();

    // Enter main loop.
    for (;;)
    {
        send_data_to_peers();
        idle_state_handle();
    }
}


/**
 * @}
 */

84827.sdk_config.h

[Karl Ylvisaker]

Hello Mishka,

Mishka said:

I develop a similar app and if you don't mind would like to share some thoughts.

Absolutely, we're happy to hear your thoughts on the matter!

You are absolutely correct about the impact different scanning and advertising intervals will have on performance, and how they affect power consumption. This is also the reason, as far as I know, that you cant choose scanning intervals freely on Android / iOS.

I am not sure I have understood you correctly about your explanation on slave latency.
Slave latency controls the peripherals ability to skip a number of connection intervals, in the case that it has nothing to transfer.
So for example, a peripheral sensor might skip a couple of intervals if there is no update to the measurements.
This might greatly reduce the amount of empty packets being transmitted to maintain the connection, which in turn will save a lot of power.

Best regards,
Karl