hello everyone,
I am designing a device which is operated with coin cell battery, I want to turn on & turn off a device using single button. when device in on mode it should read the sensor data and send to mobile over BLE. if I turn off device I don't want to perform any task and it should be completely in off mode and power consumption should be in few nano amps.
Please help me to perform this task.
thank you
Hello,
Which SDK you are using? nRF Connect SDK or nRF5 SDK?
Thanks.
Best Regards,
Kazi Afroza Sutana
thanks for your replay,
I am using nRF5 SDK 17.1.0
Hello,
You can look at this https://infocenter.nordicsemi.com/topic/sdk_nrf5_v17.1.0/pin_change_int_example.html?cp=8_1_4_6_20 pin change example as a starting point. In addition to this, you may also look at pwr_mgmt example, that shows how to go to System OFF mode using the nrf_pwr_mgmt library https://infocenter.nordicsemi.com/topic/sdk_nrf5_v17.1.0/pwr_mgmt_example.html
Hi,
if i use pin change interrupt gpiote, power consumption is high that is 1mA.
''if use pin change interrupt gpiote'' - can you please say details about it or showing some part of the codes?
Hi,
thanks for your response, and sorry for late reply.
actually in my case a button is used to control system off and system on. in system on case, power consumption is taking 1mA after using gpiote pin interrupt, but my requirement is power consumption should less then 100uA.
could you please suggest me
Hello,
''in system on case, power consumption is taking 1mA after using gpiote pin interrupt, but my requirement is power consumption should less than 100uA. '' - If the nRF52 is drawing 1mA current then it is not in System OFF mode. It should be closer to 1uA.
Do you have infinite loop after entering system off mode in the code? that could trigger to make system on again. You can look from this point of view, and also if you want can post your code here. I can make the case private.
Thanks.
BR
Kazi
Hello,
''in system on case, power consumption is taking 1mA after using gpiote pin interrupt, but my requirement is power consumption should less than 100uA. '' - If the nRF52 is drawing 1mA current then it is not in System OFF mode. It should be closer to 1uA.
Do you have infinite loop after entering system off mode in the code? that could trigger to make system on again. You can look from this point of view, and also if you want can post your code here. I can make the case private.
Thanks.
BR
Kazi
Hi,
in my project i used saadc, light sensor, temperature sensor, inbult temperature sensor and BLE .
for every 30 sec i need to push sensor data to mobile app over ble, here button is used to turn on and turn off the device. for button interface i used gpiote is used. after using gpiote, power consumption is 1mA. if i remove gpiote it consume below 500ua. i enable all the sensors at that interval and update and disable.
i have attached the code below
#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"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "fds.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "sensorsim.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_temp.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "nrf_drv_clock.h"
#include "nrf_drv_twi.h"
#include "boards.h"
#include "nrf_drv_gpiote.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include <stdio.h>
#include "ds18b20.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#define SAMPLES_IN_BUFFER 2
volatile uint8_t state = 1;
static float temp = 0;
int32_t volatile temp1;
static const nrf_drv_timer_t m_timer = NRF_DRV_TIMER_INSTANCE(1);
static nrf_saadc_value_t m_buffer_pool[2][SAMPLES_IN_BUFFER];
static nrf_ppi_channel_t m_ppi_channel;
static uint32_t m_adc_evt_counter;
#define TWI_INSTANCE_ID 0
//#define LM75B_ADDR (0x46U >> 1)
#define LM75B_ADDR 0x23
static const nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);
/* Buffer for samples read from temperature sensor. */
#define DEVICE_NAME "Nordic_Template" /**< 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 0 /**< 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. */
float B_Y;
float soil_moi;
float soil_tem;
uint8_t soil_moi2;
bool flag=false;
#define BTN 14
#define BTN1 14
#define RED_LED 15
#define GREEN_LED 16
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. */
APP_TIMER_DEF(m_adv_data_update_timer); /**< Advertising module instance. */
APP_TIMER_DEF(m_adv_data_update_timer1); /**< Advertising module instance. */
#define ADV_DATA_UPDATE_INTERVAL APP_TIMER_TICKS(30000)
//#define ADV_DATA_UPDATE_INTERVAL1 APP_TIMER_TICKS(10000)
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
static uint8_t m_adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET;
static uint8_t m_enc_advdata[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< Buffer for storing an encoded advertising set. */
static uint8_t m_enc_scan_response_data[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< Handle of the current connection. */
/* 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}
};
static void advertising_start(bool erase_bonds);
int weather_temperature(void);
int read_data(void);
void saadc_sampling_event_disable(void);
void saadc_sampling_event_enable(void);
static void idle_state_handle(void);
void saadc_sampling_event_init(void);
void saadc_callback(nrf_drv_saadc_evt_t const * p_event);
static void adv_data_update_timer_handler(void * p_context)
{
bool erase_bonds;
ret_code_t err_code;
ble_advdata_manuf_data_t manuf_data;
static ble_advdata_t new_advdata;
saadc_sampling_event_enable();
nrf_drv_twi_enable(&m_twi);
err_code = nrf_drv_saadc_init(NULL, saadc_callback);
if(soil_moi<=0.5) soil_moi2=100;
if((0.5<soil_moi)&&(soil_moi<=1)) soil_moi2=75;
if((1<soil_moi)&&(soil_moi<1.5)) soil_moi2=40;
if((1.5<=soil_moi)&&(soil_moi<1.7)) soil_moi2=25;
if((1.7<=soil_moi)) soil_moi2=0;
temp = ds18b20_get_temp_method_2();
temp1=weather_temperature();
uint8_t s_T = temp;
uint8_t S_M = soil_moi2;
int A_T = temp1-2;
int A_L =50;
uint8_t B_V = B_Y;
uint8_t data_ad[11] = {1,0,0,0,0,1,S_M,s_T,A_T,A_L,B_V};
advertising_start(erase_bonds);
nrf_delay_ms(100);
new_advdata.p_manuf_specific_data = &manuf_data;
static uint8_t payload_index = 0;
manuf_data.company_identifier = 0x0059;
manuf_data.data.p_data =data_ad ;
manuf_data.data.size = sizeof(data_ad);
new_advdata.p_manuf_specific_data = &manuf_data;
err_code = ble_advertising_advdata_update(&m_advertising, &new_advdata, NULL);
APP_ERROR_CHECK(err_code);
nrf_delay_ms(2000);
saadc_sampling_event_disable();
nrf_drv_twi_disable(&m_twi);
err_code= sd_ble_gap_adv_stop(m_advertising.adv_handle);
err_code= sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_clear(4);
idle_state_handle();
}
//static void adv_data_update_timer1_handler(void * p_context)
//{
// UNUSED_PARAMETER(p_context);
// flag=true;
// //nrf_gpio_pin_toggle(RED_LED);
//}
/**@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;
}
}
/**@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.
// lfclk_config();
ret_code_t err_code = app_timer_init();
APP_ERROR_CHECK(err_code);
err_code = app_timer_create(&m_adv_data_update_timer,
APP_TIMER_MODE_REPEATED,
adv_data_update_timer_handler);
APP_ERROR_CHECK(err_code);
// err_code = app_timer_create(&m_adv_data_update_timer1,
// APP_TIMER_MODE_REPEATED,
// adv_data_update_timer1_handler);
//APP_ERROR_CHECK(err_code);
// Create timers.
/* YOUR_JOB: Create any timers to be used by the application.
Below is an example of how to create a timer.
For every new timer needed, increase the value of the macro APP_TIMER_MAX_TIMERS by
one.
ret_code_t err_code;
err_code = app_timer_create(&m_app_timer_id, APP_TIMER_MODE_REPEATED, timer_timeout_handler);
APP_ERROR_CHECK(err_code); */
}
/**@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);
/* YOUR_JOB: Use an appearance value matching the application's use case.
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_);
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 nrf_qwr_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
static void services_init(void)
{
ret_code_t err_code;
nrf_ble_qwr_init_t qwr_init = {0};
// Initialize Queued Write Module.
qwr_init.error_handler = nrf_qwr_error_handler;
err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init);
APP_ERROR_CHECK(err_code);
/* YOUR_JOB: Add code to initialize the services used by the application.
ble_xxs_init_t xxs_init;
ble_yys_init_t yys_init;
// Initialize XXX Service.
memset(&xxs_init, 0, sizeof(xxs_init));
xxs_init.evt_handler = NULL;
xxs_init.is_xxx_notify_supported = true;
xxs_init.ble_xx_initial_value.level = 100;
err_code = ble_bas_init(&m_xxs, &xxs_init);
APP_ERROR_CHECK(err_code);
// Initialize YYY Service.
memset(&yys_init, 0, sizeof(yys_init));
yys_init.evt_handler = on_yys_evt;
yys_init.ble_yy_initial_value.counter = 0;
err_code = ble_yy_service_init(&yys_init, &yy_init);
APP_ERROR_CHECK(err_code);
*/
}
/**@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)
{
/* YOUR_JOB: Start your timers. below is an example of how to start a timer.
ret_code_t err_code;
err_code = app_timer_start(m_app_timer_id, TIMER_INTERVAL, NULL);
APP_ERROR_CHECK(err_code); */
ret_code_t err_code;
err_code = app_timer_start(m_adv_data_update_timer,
ADV_DATA_UPDATE_INTERVAL,
NULL);
APP_ERROR_CHECK(err_code);
// err_code = app_timer_start(m_adv_data_update_timer1,
// ADV_DATA_UPDATE_INTERVAL1,
// NULL);
//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)
{
ret_code_t err_code;
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)
{
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:
sleep_mode_enter();
break;
default:
break;
}
}
/**@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 = NRF_SUCCESS;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected.");
// LED indication will be changed when advertising starts.
break;
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("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;
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 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 initializing the Advertising functionality.
*/
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);
}
/**@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)
//{
// ret_code_t err_code;
// bsp_event_t startup_event;
// err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, 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 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 initializing power management.
*/
static void power_management_init(void)
{
ret_code_t err_code;
err_code = nrf_pwr_mgmt_init();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the idle state (main loop).
*
* @details If there is no pending log operation, then sleep until next the next event occurs.
*/
static void idle_state_handle(void)
{
if (NRF_LOG_PROCESS() == false)
{
nrf_pwr_mgmt_run();
}
}
/**@brief Function for starting advertising.
*/
static void advertising_start(bool erase_bonds)
{
if (erase_bonds == true)
{
delete_bonds();
// Advertising is started by PM_EVT_PEERS_DELETED_SUCEEDED event
}
else
{
ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
}
}
//static void lfclk_config(void)
//{
// ret_code_t err_code = nrf_drv_clock_init(); //Initialize the clock source specified in the nrf_drv_config.h file, i.e. the CLOCK_CONFIG_LF_SRC constant
// APP_ERROR_CHECK(err_code);
// nrf_drv_clock_lfclk_request(NULL);
//}
void timer_handler(nrf_timer_event_t event_type, void * p_context)
{
}
void saadc_sampling_event_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;
err_code = nrf_drv_timer_init(&m_timer, &timer_cfg, timer_handler);
APP_ERROR_CHECK(err_code);
/* setup m_timer for compare event every 400ms */
uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, 400);
nrf_drv_timer_extended_compare(&m_timer,
NRF_TIMER_CC_CHANNEL0,
ticks,
NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
false);
nrf_drv_timer_enable(&m_timer);
uint32_t timer_compare_event_addr = nrf_drv_timer_compare_event_address_get(&m_timer,
NRF_TIMER_CC_CHANNEL0);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
timer_compare_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void saadc_sampling_event_enable(void)
{
nrf_gpio_pin_set(4);
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void saadc_sampling_event_disable(void)
{ nrf_gpio_pin_clear(4);
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
ret_code_t err_code;
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
//int i;
//NRF_LOG_INFO("ADC event number: %d", (int)m_adc_evt_counter);
//for (int i = 0; i < SAMPLES_IN_BUFFER; i++)
// {
//soil_moi = (p_event->data.done.p_buffer[0]*3.6)/1024;
// soil_tem = (p_event->data.done.p_buffer[1]*3.6)/1024;
soil_moi =p_event->data.done.p_buffer[0]*3.6/1024;
B_Y = p_event->data.done.p_buffer[1]/8.8f;
//printf("soil_moi1=",soil_moi1);
//printf(" B_Y=", B_Y);
//soil_moi=soil_moi1*3.6/1024;
//if(soil_moi1<1) soil_moi=100;
//if(1<soil_moi1<1.5) soil_moi=75;
//if(1.5<soil_moi1<2) soil_moi=45;
//if(2<soil_moi1) soil_moi=20;
//soil_tem=(soil_tem1-0.5f)*100;
NRF_LOG_INFO("VOLTAGE1 :%d\n",soil_moi);
//NRF_LOG_INFO("VOLTAGE2 :%f\n",soil_tem1);
NRF_LOG_INFO("Battery percentage:%d\n", B_Y);
//NRF_LOG_INFO("soil_percentage :%d\n",soil_moi);
//}
//m_adc_evt_counter++;
}
}
void saadc_init(void)
{
ret_code_t err_code;
nrf_saadc_channel_config_t channel_0_config =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN3);
nrf_saadc_channel_config_t channel_1_config =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_VDD);
err_code = nrf_drv_saadc_init(NULL, saadc_callback);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &channel_0_config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(1, &channel_1_config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
}
int weather_temperature(void)
{
//while(1)
//{
NRF_TEMP->TASKS_START = 1; /** Start the temperature measurement. */
/* Busy wait while temperature measurement is not finished, you can skip waiting if you enable interrupt for DATARDY event and read the result in the interrupt. */
/*lint -e{845} // A zero has been given as right argument to operator '|'" */
while (NRF_TEMP->EVENTS_DATARDY == 0)
{
// Do nothing.
}
NRF_TEMP->EVENTS_DATARDY = 0;
/**@note Workaround for PAN_028 rev2.0A anomaly 29 - TEMP: Stop task clears the TEMP register. */
temp1 = (nrf_temp_read() / 4);
/**@note Workaround for PAN_028 rev2.0A anomaly 30 - TEMP: Temp module analog front end does not power down when DATARDY event occurs. */
NRF_TEMP->TASKS_STOP = 1; /** Stop the temperature measurement. */
NRF_LOG_INFO("Actual temperature: %d", (int)temp1);
//nrf_delay_ms(500);
return temp1;
NRF_LOG_FLUSH();
//}
}
void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{ //int counter=0;
_Bool repeat=0;
ret_code_t err_code;
//nrf_drv_gpiote_out_toggle(PIN_OUT);
if((nrf_gpio_pin_read(BTN)==0)&&(flag==false))
{
flag=true;
//Turn off LED to indicate the nRF5x is in System-off mode
nrf_drv_gpiote_out_set(RED_LED);
nrf_delay_ms(500);
//NRF_POWER->SYSTEMOFF = 1;
//Disable power-down button to prevent System-off wakeup
nrf_drv_gpiote_in_uninit(BTN);
nrf_drv_gpiote_in_event_disable(BTN);
//Configure wake-up button
nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(false); //Configure to generate interrupt and wakeup on pin signal low. "false" means that gpiote will use the PORT event, which is low power, i.e. does not add any noticable current consumption (<<1uA). Setting this to "true" will make the gpiote module use GPIOTE->IN events which add ~8uA for nRF52 and ~1mA for nRF51.
in_config.pull = NRF_GPIO_PIN_PULLUP; //Configure pullup for input pin to prevent it from floting. Pin is pulled down when button is pressed on nRF5x-DK boards, see figure two in http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.nrf52/dita/nrf52/development/dev_kit_v1.1.0/hw_btns_leds.html?cp=2_0_0_1_4
err_code = nrf_drv_gpiote_in_init(BTN1, &in_config, NULL); //Initialize the wake-up pin
APP_ERROR_CHECK(err_code); //Check error code returned
nrf_drv_gpiote_in_event_enable(BTN1, true); //Enable event and interrupt for the wakeup pin
nrf_drv_gpiote_out_clear(RED_LED);
//Enter System-off
NRF_POWER->SYSTEMOFF = 1;
}
}
static void gpio_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
nrf_gpio_cfg_output(RED_LED);
nrf_gpio_cfg_output(GREEN_LED);
nrf_gpio_cfg_output(4);
nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(false);
err_code = nrf_drv_gpiote_out_init(RED_LED, &out_config);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(true);
in_config.pull = NRF_GPIO_PIN_PULLUP;
err_code = nrf_drv_gpiote_in_init(BTN, &in_config, in_pin_handler);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_in_event_enable(BTN, true);
}
void twi_handler(nrf_drv_twi_evt_t const * p_event, void * p_context)
{
switch (p_event->type)
{
case NRF_DRV_TWI_EVT_DONE:
if (p_event->xfer_desc.type == NRF_DRV_TWI_XFER_RX)
{
NRF_LOG_INFO("SAMPLE RECEIVED: %d.",als_data);
// NRF_LOG_FLUSH();
}
if (p_event->xfer_desc.type == NRF_DRV_TWI_XFER_TX)
{
printf("TRANSFERED\r\n");
}
break;
default:
break;
}
}
void twi_init (void)
{
ret_code_t err_code;
const nrf_drv_twi_config_t twi_als_config = {
.scl = 20,
.sda = 18,
.frequency = NRF_DRV_TWI_FREQ_100K,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
.clear_bus_init = false
};
err_code = nrf_drv_twi_init(&m_twi, &twi_als_config, twi_handler, NULL);
APP_ERROR_CHECK(err_code);
nrf_drv_twi_enable(&m_twi);
}
/**@brief Function for application main entry.
*/
int main(void)
{
//NRF_POWER->SYSRESET =1;
nrf_gpio_pin_set(GREEN_LED);
nrf_delay_ms(500);
nrf_gpio_pin_clear(GREEN_LED);
bool erase_bonds;
ret_code_t err_code;
// Initialize.
nrf_gpio_cfg_output(4);
log_init();
gpio_init();
timers_init();
power_management_init();
ble_stack_init();
gap_params_init();
gatt_init();
advertising_init();
services_init();
conn_params_init();
peer_manager_init();
saadc_init();
saadc_sampling_event_init();
saadc_sampling_event_enable();
twi_init ();
nrf_temp_init();
ds18b20_setResolution(12);
err_code = sd_power_dcdc_mode_set(NRF_POWER_DCDC_ENABLE);
APP_ERROR_CHECK(err_code);
err_code = sd_power_mode_set(NRF_POWER_MODE_LOWPWR);
APP_ERROR_CHECK(err_code);
application_timers_start();
// Enter main loop.
while (true)
{
sd_app_evt_wait();
idle_state_handle();
//Enter System-on idle mode
//__WFE();
//__SEV();
//__WFE();
}
}
/**
* @}
*/
Hello,
Sorry for the late reply.
You got 500uA without the GPIOTE and 1 mA with GPIOTE. That is very high. The GPIOTE will draw approximately 20 uA when IN events are enabled and if port event is used it is nothing.
Can you please measure the current after commenting out the code related to ADC?
Hi, I achieved the low power expected at 15uA.
thank you