Hello,
I am developing a low power Bluetooth device based on the nrf52810. The firmware is simple, the device powers up and advertises. Once connected, a timer is started which reads from an accelerometer every second using TWI. If this value changes outside of a certain range, a notification is sent to the central device. Once disconnected, the accelerometer is shut down and the device begins advertising again. With my current code, I get around 24uA when advertising, and 50uA when connected. The accelerometer is responsible for around 10uA of current while connected, so the chip is using around 40uA. I am curious if there is a good way to lower both these values further. The device is powered from a 50mah LIR2032 battery, so I get a little over a month of use currently, but I would like this to be longer. I will post my code here as well. Thank you for any assistance you can provide.
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.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 "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#include "boards.h"
#include "app_timer.h"
#include "app_button.h"
#include "ble_lbs.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"
#include "app_util_platform.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "app_util_platform.h"
#include "ble_bas.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "nrf_drv_clock.h"
#define TWI_INSTANCE_ID 0
//---ACC Addresses---
#define KXTJ3_COMM_OK (0)
#define KXTJ3_COMM_ERROR (-1)
#define KXTJ3_WAI_ERROR (-2)
#define KXTJ3_PARAM_ERROR (-3)
#define KXTJ3_DEVICE_ADDRESS (0x0E)
#define KXTJ3_XOUT_L (0x06)
#define KXTJ3_YOUT_L (0x08)
#define KXTJ3_ZOUT_L (0x0A)
#define KXTJ3_XOUT_H (0x07)
#define KXTJ3_YOUT_H (0x09)
#define KXTJ3_ZOUT_H (0x0B)
#define KXTJ3_WHO_AM_I (0x0F)
#define KXTJ3_CNTL1 (0x1B)
#define KXTJ3_DATA_CNTL (0x21)
#define KXTJ3_WAI_VAL (0x35)
#define KXTJ3_CNTL1_WUFE (1 << 1)
#define KXTJ3_CNTL1_TDTE (1 << 2)
#define KXTJ3_CNTL1_EN16GMASK (0x04)
#define KXTJ3_CNTL1_GSEL_16G (0x04)
#define KXTJ3_CNTL1_GSELMASK (0x18)
#define KXTJ3_CNTL1_GSEL_14BIT (0x18)
#define KXTJ3_CNTL1_GSEL_2G (0x00)
#define KXTJ3_CNTL1_GSEL_4G (0x08)
#define KXTJ3_CNTL1_GSEL_8G (0x10)
#define KXTJ3_CNTL1_DRDYE (1 << 5)
#define KXTJ3_CNTL1_RES (1 << 6)
#define KXTJ3_CNTL1_LOWPOWER (0x00)
#define KXTJ3_CNTL1_HIGHRESO (0x40)
#define KXTJ3_CNTL1_PC1 (1 << 7)
#define KXTJ3_DATA_CNTL_OSA_50HZ (2)
#define KXTJ3_CNTL1_VAL (KXTJ3_CNTL1_LOWPOWER | KXTJ3_CNTL1_GSEL_2G)
#define KXTJ3_DATA_CNTL_VAL (KXTJ3_DATA_CNTL_OSA_50HZ)
#define KXTJ3_DRIVER_VERSION ("1.0\n")
#define KXTJ3_GSENS_2G (2)
#define KXTJ3_GSENS_4G (4)
#define KXTJ3_GSENS_8G (8)
#define KXTJ3_GSENS_16G (16)
#define KXTJ3_GSENS_ERROR (0xFF)
#define KXTJ3_READ_DATA_SIZE (6)
#define KXTJ3_AXIS_SIZE (KXTJ3_READ_DATA_SIZE / 2)
#define KXTJ3_DIVIDE_SHIFT (15)
#define LEDS_ACTIVE_STATE 0
#define ACC_CHECK_INTERVAL APP_TIMER_TICKS(1000)
#define BOARD_LED 6 /**< Is on when device is advertising. */
#define CONNECTED_LED 0//BSP_BOARD_LED_1 /**< Is on when device has connected.
#define LEDBUTTON_LED 0//BSP_BOARD_LED_2 /**< LED to be toggled with the help of the LED Button Service.
#define LEDBUTTON_BUTTON 0//BSP_BUTTON_0 /**< Button that will trigger the notification event with the LED Button Service
#define DEVICE_NAME "Autolith" /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER "AutolithInc"
#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 APP_ADV_INTERVAL 1600 /**< The advertising interval (in units of 0.625 ms; this value corresponds to 40 ms). */
#define APP_ADV_DURATION BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED /**< The advertising time-out (in units of seconds). When set to 0, we will never time out. */
#define MIN_CONN_INTERVAL MSEC_TO_UNITS(100, UNIT_1_25_MS) /**< Minimum acceptable connection interval (0.5 seconds). */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(200, UNIT_1_25_MS) /**< Maximum acceptable connection interval (1 second). */
#define SLAVE_LATENCY 0 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory time-out (4 seconds). */
#define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(20000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (15 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (5 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */
//#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 DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
#define PIN_IN NRF_GPIO_PIN_MAP(0,29)
BLE_LBS_DEF(m_lbs); /**< LED Button Service instance. */
NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
NRF_BLE_QWR_DEF(m_qwr);
//BLE_BAS_DEF(m_bas);
//saadc defines
#define SAMPLES_IN_BUFFER 5
volatile uint8_t state = 1;
//static bool low_Battery = false;
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;
//-------------
APP_TIMER_DEF(m_app_timer_id);
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
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 for storing an encoded advertising set. */
static uint8_t m_enc_scan_response_data[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< Buffer for storing an encoded scan data. */
//"BluetoothLE#BluetoothLE78:2b:46:2d:24:35-a4:c1:38:f9:09:41"
//static void on_bas_evt(ble_bas_t * p_bas, ble_bas_evt_t * p_evt);
//BLE_ITS_DEF(m_its, NRF_SDH_BLE_PERIPHERAL_LINK_COUNT);
//BLE_BAS_DEF(m_bas);
static const nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);
/* Indicates if operation on TWI has ended. */
static volatile bool m_xfer_done = false;
//records the previous prosition of the display
uint8_t old_Orientation = 0;
// saadc battery level detection
/**@brief Function for handling events from the button handler module.
*
* @param[in] pin_no The pin that the event applies to.
* @param[in] button_action The button action (press/release).
*/
static void button_event_handler(uint8_t button_action)
{
ret_code_t err_code;
NRF_LOG_INFO("Send button state change.");
err_code = ble_lbs_on_button_change(m_conn_handle, &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);
}
}
static void led_event_handler(uint8_t led_action)
{
ret_code_t err_code;
NRF_LOG_INFO("Send button state change.");
//err_code = ble_lbs_on_led_change(m_conn_handle, &m_lbs, led_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);
}
}
//void saadc_sampling_event_init(void)
//{
// ret_code_t err_code;
// //app_timer_init();
// 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, 500);//28800000);//86400000);
// 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)
//{
// ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
// APP_ERROR_CHECK(err_code);
//}
//void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
//{
// uint8_t low_Battery = 0;
// 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);
// int adc_result = p_event->data.done.p_buffer[0];
// //for (i = 0; i < SAMPLES_IN_BUFFER; i++)
// //{
// // adc_result = p_event->data.done.p_buffer[i];
// // //adc_result = (adc_result * 3600) >> 10;
// // NRF_LOG_INFO("%d", adc_result);
// //}
// //TODO: If under 1023, low battery indication
// NRF_LOG_INFO("%d", p_event->data.done.p_buffer[0]);
// if (adc_result < 1023)
// {
// //set characteristic low battery to true (desktop will send notification)
// if (low_Battery == 0)
// {
// low_Battery = 1;
// led_event_handler(low_Battery);
// }
// }
// else
// {
// //set characteristic low battery to false
// if (low_Battery == 1)
// {
// low_Battery = 0;
// led_event_handler(low_Battery);
// }
// }
// m_adc_evt_counter++;
// }
//}
//void saadc_init(void)
//{
// ret_code_t err_code;
// nrf_saadc_channel_config_t channel_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_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);
//}
//------------------------------------------------
//-----------------TWI--------------------------
uint8_t acc_shutdown(void)
{
ret_code_t err_code;
uint8_t buf[2];
buf[0] = KXTJ3_CNTL1;
buf[1] = 0x00;
nrf_drv_twi_tx(&m_twi, KXTJ3_DEVICE_ADDRESS, &buf, sizeof(buf), false);
}
uint8_t who_am_i(void)
{
ret_code_t err_code;
uint8_t data;
uint8_t buf[2] = {KXTJ3_WHO_AM_I};
err_code = nrf_drv_twi_tx(&m_twi, KXTJ3_DEVICE_ADDRESS, &buf, 1, false);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_twi_rx(&m_twi, KXTJ3_DEVICE_ADDRESS, &data, sizeof(data));
APP_ERROR_CHECK(err_code);
if (err_code == NRF_SUCCESS && data == KXTJ3_WHO_AM_I){
return KXTJ3_COMM_OK;
}
else{
return KXTJ3_COMM_ERROR;
}
}
uint8_t acc_start(void)
{
ret_code_t err_code;
uint8_t data;
uint8_t buf[2];
buf[0] = KXTJ3_CNTL1;
buf[1] = 0x00;
err_code = nrf_drv_twi_tx(&m_twi, KXTJ3_DEVICE_ADDRESS, &buf, sizeof(buf), false);
APP_ERROR_CHECK(err_code);
buf[0] = KXTJ3_CNTL1;
buf[1] = 0x80;
err_code = nrf_drv_twi_tx(&m_twi, KXTJ3_DEVICE_ADDRESS, &buf, 2, false);
APP_ERROR_CHECK(err_code);
uint8_t control_val;
err_code = nrf_drv_twi_rx(&m_twi, KXTJ3_DEVICE_ADDRESS, &control_val, sizeof(buf));
APP_ERROR_CHECK(err_code);
if (err_code == NRF_SUCCESS && control_val == 0x80){
return KXTJ3_COMM_OK;
}
else{
return KXTJ3_COMM_ERROR;
}
}
uint8_t acc_get_xyz(uint8_t *acc_values)
{
ret_code_t err_code;
uint8_t bufX[1];
uint8_t data;
uint8_t reg_values[6] = {KXTJ3_XOUT_L, KXTJ3_XOUT_H, KXTJ3_YOUT_L, KXTJ3_YOUT_H, KXTJ3_ZOUT_L, KXTJ3_ZOUT_H};
uint8_t j = 1;
for (uint8_t i = 0; i < 5; i = i + 2){
bufX[0] = reg_values[i];
err_code = nrf_drv_twi_tx(&m_twi, KXTJ3_DEVICE_ADDRESS, &bufX, sizeof(bufX), true);
APP_ERROR_CHECK(err_code);
bufX[0] = reg_values[j];
err_code = nrf_drv_twi_tx(&m_twi, KXTJ3_DEVICE_ADDRESS, &bufX, sizeof(bufX), true);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_twi_rx(&m_twi, KXTJ3_DEVICE_ADDRESS, &data, sizeof(data));
APP_ERROR_CHECK(err_code);
acc_values[i] = data;
err_code = nrf_drv_twi_rx(&m_twi, KXTJ3_DEVICE_ADDRESS, &data, sizeof(data));
APP_ERROR_CHECK(err_code);
acc_values[j] = data;
j = j + 2;
}
if (err_code == NRF_SUCCESS){
return KXTJ3_COMM_OK;
}
else{
return KXTJ3_COMM_ERROR;
}
}
void acc_translate_values(uint8_t *acc_values, uint16_t *xyz_values)
{
//x
uint8_t x_a[2] = {acc_values[0], acc_values[1]};
int16_t x = (*(int16_t*) x_a) >> 10;
//y
uint8_t y_a[2] = {acc_values[2], acc_values[3]};
int16_t y = (*(int16_t*) y_a) >> 10;
//z
uint8_t z_a[2] = {acc_values[4], acc_values[5]};
int16_t z = (*(int16_t*) z_a) >> 10;
xyz_values[0] = x;
xyz_values[1] = y;
xyz_values[2] = z;
}
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)
{
uint8_t acc_values[6];
acc_get_xyz(&acc_values);
}
m_xfer_done = true;
break;
default:
break;
}
}
void twi_init (void)
{
ret_code_t err_code;
const nrf_drv_twi_config_t twi_vnet_config = {
.scl = NRF_GPIO_PIN_MAP(0,9),
.sda = NRF_GPIO_PIN_MAP(0,10),
.frequency = NRF_DRV_TWI_FREQ_100K,
.interrupt_priority = APP_IRQ_PRIORITY_LOW,
.clear_bus_init = false
};
err_code = nrf_drv_twi_init(&m_twi, &twi_vnet_config, NULL, NULL);
APP_ERROR_CHECK(err_code);
nrf_drv_twi_enable(&m_twi);
err_code = who_am_i();
err_code = acc_start();
}
//---------------------------------------------------
//---------------Board LED------------------------
uint8_t led_blink(uint8_t count)
{
uint32_t LED = NRF_GPIO_PIN_MAP(0, 11);
nrf_gpio_cfg_output(LED);
for (int i = 0; i < count; i++)
{
nrf_gpio_pin_set(LED);
nrf_delay_ms(100);
nrf_gpio_pin_clear(LED);
nrf_delay_ms(100);
}
}
uint8_t led_on(void)
{
uint32_t LED = NRF_GPIO_PIN_MAP(0, 11);
nrf_gpio_cfg_output(LED);
nrf_gpio_pin_set(LED);
}
uint8_t led_off(void)
{
uint32_t LED = NRF_GPIO_PIN_MAP(0, 11);
nrf_gpio_cfg_output(LED);
nrf_gpio_pin_clear(LED);
}
//------------------------------------------------
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
}
};
//static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifiers. */
//{
// {0x2c2bd69f59d6492ab085607672de3947, BLE_UUID_TYPE_BLE}
//};
/**@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)
{
app_error_handler(DEAD_BEEF, line_num, p_file_name);
}
/**@brief Function for the LEDs initialization.
*
* @details Initializes all LEDs used by the application.
*/
static void leds_init(void)
{
bsp_board_init(BSP_INIT_LEDS);
}
/**@brief Function for the Timer initialization.
*
* @details Initializes the timer module.
*/
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);
}
/**@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);
}
/**@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);
}
/**@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_init(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}};
//TODO: ADD service for battery monitoring
// 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;
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);
ble_gap_adv_params_t adv_params;
// Set advertising parameters.
memset(&adv_params, 0, sizeof(adv_params));
adv_params.primary_phy = BLE_GAP_PHY_1MBPS;
adv_params.duration = APP_ADV_DURATION;
adv_params.properties.type = BLE_GAP_ADV_TYPE_CONNECTABLE_SCANNABLE_UNDIRECTED;
adv_params.p_peer_addr = NULL;
adv_params.filter_policy = BLE_GAP_ADV_FP_ANY;
adv_params.interval = APP_ADV_INTERVAL;
err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, &adv_params);
APP_ERROR_CHECK(err_code);
}
/**@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 write events to the LED characteristic.
*
* @param[in] p_lbs Instance of LED Button Service to which the write applies.
* @param[in] led_state Written/desired state of the LED.
*/
static void led_write_handler(uint16_t conn_handle, ble_lbs_t * p_lbs, uint8_t led_state)
{
if (!BLE_GAP_EVT_DISCONNECTED)
{
bsp_board_led_on(BOARD_LED);
NRF_LOG_INFO("LED ON");
}
else
{
bsp_board_led_off(BOARD_LED);
NRF_LOG_INFO("LED OFF");
}
}
/**@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 init = {0};
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);
// Initialize LBS.
init.led_write_handler = led_write_handler;
err_code = ble_lbs_init(&m_lbs, &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 that
* 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 advertising.
*/
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);
//bsp_board_led_on(ADVERTISING_LED);
}
/**@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_CONNECTED:
NRF_LOG_INFO("Connected");
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);
acc_start();
app_timer_start(m_app_timer_id, ACC_CHECK_INTERVAL, NULL);
led_blink(2);
break;
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected");
m_conn_handle = BLE_CONN_HANDLE_INVALID;
acc_shutdown();
app_timer_stop(m_app_timer_id);
advertising_start();
led_blink(2);
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
// Pairing not supported
err_code = sd_ble_gap_sec_params_reply(m_conn_handle,
BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP,
NULL,
NULL);
APP_ERROR_CHECK(err_code);
break;
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_GATTS_EVT_SYS_ATTR_MISSING:
// No system attributes have been stored.
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
//static void battery_level_meas_timeout_handler(void * p_context)
//{
// UNUSED_PARAMETER(p_context);
// adc_configure();
// ret_code_t err_code;
// err_code = nrf_drv_saadc_sample();
// APP_ERROR_CHECK(err_code);
//}
/**@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);
}
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();
}
}
static void app_timer_handler(void * p_context)
{
NRF_LOG_INFO("Timer Firing!");
uint8_t acc_err_code;
uint8_t acc_values[6];
acc_err_code = acc_get_xyz(&acc_values);
uint8_t new_Orientation = 0;
if (acc_err_code != KXTJ3_COMM_OK){
NRF_LOG_INFO("Accelerometer Error (2)");
}
uint8_t x_a[2] = {acc_values[0], acc_values[1]};
int16_t x = (*(int16_t*) x_a) >> 10;
uint8_t y_a[2] = {acc_values[2], acc_values[3]};
int16_t y = (*(int16_t*) y_a) >> 10;
//z
uint8_t z_a[2] = {acc_values[4], acc_values[5]};
int16_t z = (*(int16_t*) z_a) >> 10;
if (x > 0 && y < 10 && y > -10){ //0 degrees
new_Orientation = 2;//0
}
else if (y < 0 && x < 10 && x > -10){ //270 degrees
new_Orientation = 3;//1
}
else if (x < 0 && y > -10 && y < 10){
new_Orientation = 0;//2
}
else if (y > 0 && x < 10 && x > -10){
new_Orientation = 1;//3
}
if (new_Orientation != old_Orientation){
button_event_handler(new_Orientation);
old_Orientation = new_Orientation;
led_blink(1);
}
}
static void acc_timer_init(void)
{
ret_code_t err_code;
err_code = app_timer_create(&m_app_timer_id, APP_TIMER_MODE_REPEATED, app_timer_handler);
}
/**@brief Function for application main entry.
*/
int main(void)
{
ret_code_t err_code;
err_code = sd_power_dcdc_mode_set(NRF_POWER_DCDC_ENABLE);
// Initialize.
//log_init();
leds_init();
timers_init();
power_management_init();
ble_stack_init();
gap_params_init();
gatt_init();
services_init();
advertising_init();
conn_params_init();
advertising_start();
twi_init();
uint8_t acc_err_code;
//saadc_init();
//saadc_sampling_event_init();
//saadc_sampling_event_enable();
led_blink(2);
acc_shutdown();
acc_timer_init();
// Enter main loop.
for (;;)
{
idle_state_handle();
}
}
