Battery Service reading adc value from other GPIO

[Zachary16]

Hi everyone,

I have connected a potentiometer to a GPIO pin (AIN2) and would like to show the varying values in the battery service.

I was wondering if there's any way for me to amend the battery service so that the service can read other ADC/voltage value from other GPIO pins.

Tools:

• nRF52832
• nRF52DK
• nRF5_SDK_17.1.0
• 132 softdevice

Thanks,

Zachary

[Jared]

Hi,

A good start would be to merge the SAADC example into the battery service example. You should also take a look at our ble_app_uart__saadc_timer_driven__scan_mode example on GitHub which shows how you can use the SAADC with the Softdevice,

regards

Jared 

[Zachary16]

Hi Jared,

thanks for the reply. I have actually tried to merge the saadc and battery service together. 

What I’ve encountered during connection, was that the battery level from the battery service will always be 100%. I’ve also tried powering up the DK with the USB or external power supply (2.6V), but it also still 100%. 

I have also seen some old post regarding this however, the author did not further explain his solution.( https://devzone.nordicsemi.com/f/nordic-q-a/2377/battery-level-service-on-custom-profile)

My concerns are:

1. Why the battery level is always at 100%

2. Is there a way for me to input the adc reading from a GPIO pins into the battery service. 

Regards,

Zachary

[Jared]

Zachary16 said:

thanks for the reply. I have actually tried to merge the saadc and battery service together. 

What I’ve encountered during connection, was that the battery level from the battery service will always be 100%. I’ve also tried powering up the DK with the USB or external power supply (2.6V), but it also still 100%. 

Can you post your code? That would clarify a lot!

[Zachary16]

#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"              //header for advertising
#include "ble_advertising.h"          
#include "ble_conn_params.h"          //header for connection parameters
#include "nrf_sdh.h"                  //header for softdevice
#include "nrf_sdh_soc.h"                      
#include "nrf_sdh_ble.h"       
#include "app_timer.h"                //header for RTC
#include "fds.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"              //header for buttons & led
#include "sensorsim.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"             //header for GATT
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"             //header for sleep mode (may not need it)
#include "nrf.h"
#include "nrf_drv_saadc.h"            //header for saadc
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "boards.h"
#include "nrf_delay.h"
#include "app_util_platform.h"
#include "nrf_log.h"                  //header for log
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "ble_bas.h"                  //header for battery service




#define DEVICE_NAME                     "BLE Tracetogether Token"                       /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME               "NordicSemiconductor"                   /**< Manufacturer. Will be passed to Device Information Service. */

#define APP_ADV_INTERVAL                300                                     /**< The advertising interval (in units of 0.625 ms. This value corresponds to 187.5 ms). */
#define APP_ADV_DURATION                18000                                   /**< The advertising duration (180 seconds) in units of 10 milliseconds. */

#define APP_BLE_OBSERVER_PRIO           3                                       /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_BLE_CONN_CFG_TAG            1                                       /**< A tag identifying the SoftDevice BLE configuration. */

#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(100, UNIT_1_25_MS)        /**< Minimum acceptable connection interval (0.1 seconds). */
#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(200, UNIT_1_25_MS)        /**< Maximum acceptable connection interval (0.2 second). */
#define SLAVE_LATENCY                   0                                       /**< Slave latency. */
#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)         /**< Connection supervisory timeout (4 seconds). */

#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000)                   /**< 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)                  /**< 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 SEC_PARAM_BOND                  1                                       /**< Perform bonding. */
#define SEC_PARAM_MITM                  0                                       /**< Man In The Middle protection not required. */
#define SEC_PARAM_LESC                  0                                       /**< LE Secure Connections not enabled. */
#define SEC_PARAM_KEYPRESS              0                                       /**< Keypress notifications not enabled. */
#define SEC_PARAM_IO_CAPABILITIES       BLE_GAP_IO_CAPS_NONE                    /**< No I/O capabilities. */
#define SEC_PARAM_OOB                   0                                       /**< Out Of Band data not available. */
#define SEC_PARAM_MIN_KEY_SIZE          7                                       /**< Minimum encryption key size. */
#define SEC_PARAM_MAX_KEY_SIZE          16                                      /**< Maximum encryption key size. */

#define DEAD_BEEF                       0xDEADBEEF                              /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */


#define POT_ANALOG_PIN                  NRF_SAADC_INPUT_AIN2
#define SAMPLE_BUFFER_LEN               5
#define ADC_RESULTS_IN_MILLI_VOLTS(ADC_RESULT) (ADC_RESULT * 0.87890625)       //converting adc value into voltage value
#define BATTERY_TIMER_INTERVAL          APP_TIMER_TICKS(2000)                  //battery timer interval (60 secs)
#define SAADC_TIMER_INTERVAL            APP_TIMER_TICKS(200)                    //saadc sampling timer interval (0.2 secs)

NRF_BLE_GATT_DEF(m_gatt);                                                       /**< GATT module instance. */
NRF_BLE_QWR_DEF(m_qwr);                                                         /**< Context for the Queued Write module.*/
BLE_ADVERTISING_DEF(m_advertising);                                             /**< Advertising module instance. */
BLE_BAS_DEF(m_bas);                                                             //battery module

APP_TIMER_DEF(m_saadc_timer_id);                                                //pot timer
APP_TIMER_DEF(m_battery_timer_id);                                              //battery timer

static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;                        /**< Handle of the current connection. */
static void on_bas_evt(ble_bas_t * p_bas, ble_bas_evt_t * p_evt);

static volatile uint8_t battery_level = 0;
static volatile uint8_t pot_level = 0;


//saving sample in buffer
static nrf_saadc_value_t m_buffer_pool[2][SAMPLE_BUFFER_LEN];
//using counter to count the number of events
static uint32_t          m_adc_evt_counter;

//event handler for SAADC
void saadc_callback_handler(nrf_drv_saadc_evt_t const* p_event)
{
  ret_code_t err_code;

  if (p_event-> type == NRF_DRV_SAADC_EVT_DONE)
  {
    uint16_t saadc_voltage[2] = {0};
   
    err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLE_BUFFER_LEN);
    APP_ERROR_CHECK(err_code);

    for (uint8_t i = 0; i < SAMPLE_BUFFER_LEN; i++)
    {
      saadc_voltage[i] = ADC_RESULTS_IN_MILLI_VOLTS(p_event->data.done.p_buffer[i]);
    }

      battery_level = battery_level_in_percent(saadc_voltage[0]);
      //pot_level = (saadc_voltage[1]*100)/saadc_voltage[0];


    }

}


void saadc_init(void)
{

  ret_code_t err_code;

  nrf_saadc_channel_config_t channel0_config = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_VDD);
  //creating a config struct and assign its default value with pin number
  //configuring the input as single ended
  //nrf_saadc_channel_config_t channel1_config = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(POT_ANALOG_PIN);


 //initializing the saadc
  err_code = nrf_drv_saadc_init(NULL, saadc_callback_handler);
  APP_ERROR_CHECK(err_code);

//initializing the channel
  err_code = nrf_drv_saadc_channel_init(0, &channel0_config);
  APP_ERROR_CHECK(err_code);

  /*err_code = nrf_drv_saadc_channel_init(1, &channel1_config);
  APP_ERROR_CHECK(err_code);
*/

  //initializing the sample buffer for 1st dimension
  err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], SAMPLE_BUFFER_LEN);
  APP_ERROR_CHECK(err_code);

  //initializing the sample buffer for 2nd dimension
  err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], SAMPLE_BUFFER_LEN);
  APP_ERROR_CHECK(err_code);

 
 }


/* YOUR_JOB: Declare all services structure your application is using
 *  BLE_XYZ_DEF(m_xyz);
 */

// YOUR_JOB: Use UUIDs for service(s) used in your application.
static ble_uuid_t m_adv_uuids[] =                                               /**< Universally unique service identifiers. */
{
    {BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE},
    {BLE_UUID_BATTERY_SERVICE, BLE_UUID_TYPE_BLE},
};

static void advertising_start(bool erase_bonds);


/**@brief Callback function for 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] 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 Function for handling Peer Manager events.
 *
 * @param[in] p_evt  Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
    pm_handler_on_pm_evt(p_evt);
    pm_handler_disconnect_on_sec_failure(p_evt);
    pm_handler_flash_clean(p_evt);

    switch (p_evt->evt_id)
    {
        case PM_EVT_PEERS_DELETE_SUCCEEDED:
            advertising_start(false);
            break;

        default:
            break;
    }
}

static void saadc_timer_timeout_handler(void * p_context)
{
      UNUSED_PARAMETER(p_context);
      ret_code_t err_code = nrf_drv_saadc_sample();
      APP_ERROR_CHECK(err_code);

}


//function for updating battery level characteristic in battery service
static void battery_level_update(void)
{
    ret_code_t err_code;
    err_code = ble_bas_battery_level_update(&m_bas, battery_level, BLE_CONN_HANDLE_ALL);
    if ((err_code != NRF_SUCCESS) &&
        (err_code != NRF_ERROR_INVALID_STATE)&&
        (err_code != NRF_ERROR_RESOURCES)&&
        (err_code != NRF_ERROR_BUSY)&&
        (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
        )
        {
        APP_ERROR_HANDLER(err_code);
        }
}


static void battery_timer_timeout_handler(void * p_context)
{
      UNUSED_PARAMETER(p_context);
      battery_level_update();

}

/**@brief Function for the Timer initialization.
 *
 * @details Initializes the timer module. This creates and starts application timers.
 */
static void timers_init(void)
{
    ret_code_t err_code;
    // Initialize timer module.
    err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);

    // Create battery timer
    err_code = app_timer_create(&m_battery_timer_id,
                                APP_TIMER_MODE_REPEATED,
                                battery_timer_timeout_handler);
    APP_ERROR_CHECK(err_code);

     // Create potentio timer.
    err_code = app_timer_create(&m_saadc_timer_id,
                                APP_TIMER_MODE_REPEATED,
                                saadc_timer_timeout_handler);
    APP_ERROR_CHECK(err_code); 

}

//@brief Function for the Peer Manager initialization.

static void peer_manager_init(void)
{
    ble_gap_sec_params_t sec_param;
    ret_code_t           err_code;

    err_code = pm_init();
    APP_ERROR_CHECK(err_code);

    memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));

    // Security parameters to be used for all security procedures.
    sec_param.bond           = SEC_PARAM_BOND;
    sec_param.mitm           = SEC_PARAM_MITM;
    sec_param.lesc           = SEC_PARAM_LESC;
    sec_param.keypress       = SEC_PARAM_KEYPRESS;
    sec_param.io_caps        = SEC_PARAM_IO_CAPABILITIES;
    sec_param.oob            = SEC_PARAM_OOB;
    sec_param.min_key_size   = SEC_PARAM_MIN_KEY_SIZE;
    sec_param.max_key_size   = SEC_PARAM_MAX_KEY_SIZE;
    sec_param.kdist_own.enc  = 1;
    sec_param.kdist_own.id   = 1;
    sec_param.kdist_peer.enc = 1;
    sec_param.kdist_peer.id  = 1;

    err_code = pm_sec_params_set(&sec_param);
    APP_ERROR_CHECK(err_code);

    err_code = pm_register(pm_evt_handler);
    APP_ERROR_CHECK(err_code);
}


/**@brief Clear bond information from persistent storage.
*/ 
static void delete_bonds(void)
{
    ret_code_t err_code;

    NRF_LOG_INFO("Erase bonds!");

    err_code = pm_peers_delete();
    APP_ERROR_CHECK(err_code);
}




/**@brief Function for handling events from the BSP module.
 *
 * @param[in]   event   Event generated when button is pressed.
 
static void bsp_event_handler(bsp_event_t event)
{
    ret_code_t err_code;

    switch (event)
    {
        case BSP_EVENT_SLEEP:
            sleep_mode_enter();
            break; // BSP_EVENT_SLEEP

        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; // BSP_EVENT_DISCONNECT

        case BSP_EVENT_WHITELIST_OFF:
            if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
            {
                err_code = ble_advertising_restart_without_whitelist(&m_advertising);
                if (err_code != NRF_ERROR_INVALID_STATE)
                {
                    APP_ERROR_CHECK(err_code);
                }
            }
            break; // BSP_EVENT_KEY_0

        default:
            break;
    }
}


/**@brief Function for the GAP initialization.
 *
 * @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the
 *          device including the device name, appearance, and the preferred connection parameters.
 */
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);
}


//initializing the GATT module. 
static void gatt_init(void)
{
    ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for initializing services that will be used by the application.
 */
static void bas_init()
{
    ret_code_t       err_code;
    ble_bas_init_t    bas_init;

    //initialising the battery service
    memset(&bas_init, 0, sizeof(bas_init));

    bas_init.evt_handler            = on_bas_evt;
    bas_init.support_notification   = true;
    bas_init.p_report_ref           = NULL;
    bas_init.initial_batt_level     = 100;  //setting the initial battery level to 100%

    //setting security level for the battery service
    bas_init.bl_rd_sec        = SEC_OPEN;    //read security to be open
    bas_init.bl_cccd_wr_sec   = SEC_OPEN;    //notification security to be open
    bas_init.bl_report_rd_sec = SEC_OPEN;    //report read security to be open

    err_code = ble_bas_init(&m_bas, &bas_init);
    APP_ERROR_CHECK(err_code);
}

/**@brief Function for handling Queued Write Module errors.
*/
static void nrf_qwr_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}

static void qwr_init(void)
{
    ret_code_t         err_code;
    nrf_ble_qwr_init_t qwr_init_obj = {0};

    // Initialize Queued Write Module.
    qwr_init_obj.error_handler = nrf_qwr_error_handler;

    err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init_obj);
    APP_ERROR_CHECK(err_code);
}

static void services_init(void)
{
    qwr_init();
    bas_init();

}


/**@brief Function for handling 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)
{
    ret_code_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 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)
{
    APP_ERROR_HANDLER(nrf_error);
}


/**@brief Function for initializing the Connection Parameters module.
 */
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 starting timers.
*/
/*static void application_timers_start(void)
{
    ret_code_t  err_code;

    err_code = app_timer_start(m_saadc_timer_id, SAADC_TIMER_INTERVAL, NULL);
    APP_ERROR_CHECK(err_code); 
}
*/ 



//creating advertisement event handler
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
    ret_code_t err_code;

    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_FAST:
            NRF_LOG_INFO("Fast advertising.");
            err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_ADV_EVT_IDLE:
            err_code = bsp_indication_set(BSP_INDICATE_IDLE);
            APP_ERROR_CHECK(err_code);
            break;

        default:
            break;
    }
}


//initialising advertising
static void advertising_init(void)
{
    ret_code_t             err_code;
    ble_advertising_init_t init;

    memset(&init, 0, sizeof(init));

    init.advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    init.advdata.include_appearance      = true;
    init.advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    init.advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
    init.advdata.uuids_complete.p_uuids  = m_adv_uuids;

    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;

    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}


static void on_bas_evt(ble_bas_t * p_bas, ble_bas_evt_t * p_evt)
{
ret_code_t err_code;

    switch (p_evt->evt_type)
    {
        case BLE_BAS_EVT_NOTIFICATION_ENABLED:
            // Start battery timer
            err_code = app_timer_start(m_battery_timer_id, BATTERY_TIMER_INTERVAL, NULL);
            APP_ERROR_CHECK(err_code);
            break; // BLE_BAS_EVT_NOTIFICATION_ENABLED

        case BLE_BAS_EVT_NOTIFICATION_DISABLED:
            err_code = app_timer_stop(m_battery_timer_id);
            APP_ERROR_CHECK(err_code);
            break; // BLE_BAS_EVT_NOTIFICATION_DISABLED

        default:
            // No implementation needed.
            break;
    }
}


//**@brief Function for handling BLE events.

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    ret_code_t err_code = NRF_SUCCESS;

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("Device is disconnected.");
            // LED indication will be changed when advertising starts.
            break;

        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("Device is connected.");
            err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);          //LED indicates when it is connected to another BLE
            APP_ERROR_CHECK(err_code);
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
            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;
    }
}


/**@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.
    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 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 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(void)
{
    ret_code_t err_code;

    err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, NULL);
    APP_ERROR_CHECK(err_code);

}




/**@brief Function for initializing the nrf 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 starting advertising.
 */
static void advertising_start(bool erase_bonds)
{
        if (erase_bonds == true)
        {
            delete_bonds(); 
        }
        else
        {
        ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);

        APP_ERROR_CHECK(err_code);
        }
}



/**@brief Function for application main entry.
 */
int main(void)
{
    bool erase_bonds;

    // Initialize.
    log_init();
    timers_init();
    buttons_leds_init();
    power_management_init();
    ble_stack_init();
    gap_params_init();
    gatt_init();
    advertising_init();
    services_init();
    conn_params_init();
    saadc_init();
   

    // Start execution.
    NRF_LOG_INFO("Started Reading.");
    //application_timers_start();

    advertising_start(erase_bonds);


    // Enter main loop.
    for (;;)
    {

        
    }
}


/**
 * @}
 */

Hi Jared, thank you for taking your time off to help me with this issue. I'm entirely sure if you mean the whole code hence I've have posted my entire code. I'm afraid it could be other parts of the coding that is affecting my results.

Apologies in advance if it seems too much. 

[Jared]

Hi,

Zachary16 said:

Why the battery level is always at 100%

Not sure I understand your question correctly. The pin that is sampled in the code that you shared is VDD, and you're wondering why the supply is at constant 100% while you supply it via USB?

I would expect the sampled value to be constant if you supply the board via the USB, which would result in the return value from battery_level_in_percent() to be constant. For example if you're supplying the board via a computer.  

Maybe I misunderstood you? In that case, please elaborate. 

Can you set a breakpoint in saadc_callback_handler() and see what p_event->data.done.p_buffer[i] is? Is it constant?

regards

Jared 

[Zachary16]

Hi Jared,

thank you so much for your kind reply and patience with me. I apologise for my broken english and I'm rather new to Nordic.

What I meant was when I supplied the board via the external supply or USB (which was powering less than 3V), the battery level should be less than 100% due to the "app_util.h" file, as it states that any voltage level that is less than 3V should not be 100%. (correct me if I'm wrong).

Hence, I was puzzled when I supplied a 2.5V to the board via the external supply, the battery level in the application remains 100% or 0% after a couple of refreshes. Whereas, I've tried the "ble_app_proximity" example, the battery level reading were quite accurate. (E.g. 2.4V = 18%, 2.1V = 1%). The difference between the example and my code was the way we sample our adc reading. Will this affect how the battery service reads the voltage? 

Jared said:

Can you set a breakpoint in saadc_callback_handler() and see what p_event->data.done.p_buffer[i] is? Is it constant?

I've attached a screenshot the debug and breakpoint in saadc_callback_handler and I've realised that in the debugging terminal, no log was activated and there where no actions or errors while debugging. 

I'm not sure if I've done it correctly, please advice me. 

Once again, thank you for your kind reply and patience. I truly appreciate your time and effort. 

Regards,

Zachary

[Jared]

Zachary16 said:

thank you so much for your kind reply and patience with me. I apologise for my broken english and I'm rather new to Nordic.

What I meant was when I supplied the board via the external supply or USB (which was powering less than 3V), the battery level should be less than 100% due to the "app_util.h" file, as it states that any voltage level that is less than 3V should not be 100%. (correct me if I'm wrong).

Hence, I was puzzled when I supplied a 2.5V to the board via the external supply, the battery level in the application remains 100% or 0% after a couple of refreshes. Whereas, I've tried the "ble_app_proximity" example, the battery level reading were quite accurate. (E.g. 2.4V = 18%, 2.1V = 1%). The difference between the example and my code was the way we sample our adc reading. Will this affect how the battery service reads the voltage? 

I understand. When you supply 2V5 to the board externally, is the 5V USB still connected?

Zachary16 said:

I've attached a screenshot the debug and breakpoint in saadc_callback_handler and I've realised that in the debugging terminal, no log was activated and there where no actions or errors while debugging. 

I'm not sure if I've done it correctly, please advice me. 

Could you set the breakpoint at line 120, and check the value of p_event->data.done.p_buffer[i]? You can check it by adding it to watch:

Note, that Softdevice applications requires you to restart the application after it has been paused. It will assert if you try to resume it. See this and this for more.

regards

Jared 

[Zachary16]

Hi Jared,

Thank you for your reply.

Jared said:

I understand. When you supply 2V5 to the board externally, is the 5V USB still connected?

no, the USB was disconnect from the board.

I've realised that the problem in my code was that the SAMPLE_BUFFER_LENS was at 5 hence causing the battery level to display only 0%.

I have used the link that you provided earlier on and change the way I sample the adc. I changed SAMPLE_BUFFER_LENS to 1 and used oversampling and burst to give me a more accurate reading.

Jared said:

Could you set the breakpoint at line 120, and check the value of p_event->data.done.p_buffer[i]? You can check it by adding it to watch:

I have tried to do this however, it seems like the debugger did not stop at the breakpoint and the callback function is still running. I have attached a screenshot for reference.

Could you kindly explain to me how debugging actually work? Does debugging only stops when there is an error in the code? and what information I can get from doing a debugging?

regards,

Zachary