Hello Everyone,
I am using NRF52833 in my project and I have implemented one service named borrower. The code details are in the attached in the files. When I open nrfconnect app and try to connect to my device, I am able to connect to it. The app asks for pairing request as I have added static security key and it gets connected to the app. Now the firmware has 2 services named borrower and lender. Currently I am working on the borrower service. I can see the service details in the NRFCONNECT app but when I try to send or receive data via Nrfconnect app. I get
Error(0x85):GATT ERROR -
GATT Timeout error.
Can anyone help me resolve the issue? I have seen many threads on it but doesnt seem to find the solution.
Thanks & Regards,
Snehal.
/**
*/
#include "sdk_common.h"
#include "ble.h"
#include "ble_borrower.h"
#include "ble_srv_common.h"
#include "peer_manager.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "app_timer.h"
#define NRF_LOG_MODULE_NAME ble_rcbr
#if BLE_RCBR_CONFIG_LOG_ENABLED
#define NRF_LOG_LEVEL BLE_RCBR_CONFIG_LOG_LEVEL
#define NRF_LOG_INFO_COLOR BLE_RCBR_CONFIG_INFO_COLOR
#define NRF_LOG_DEBUG_COLOR BLE_RCBR_CONFIG_DEBUG_COLOR
#else // BLE_RCBR_CONFIG_LOG_ENABLED
#define NRF_LOG_LEVEL 0
#endif // BLE_RCBR_CONFIG_LOG_ENABLED
#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();
static pm_peer_id_t m_peer_to_be_deleted = PM_PEER_ID_INVALID;
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
/**@brief Function for handling the @ref BLE_GAP_EVT_CONNECTED event from the SoftDevice.
*
* @param[in] p_rcbr R3charge Borrower Service structure.
* @param[in] p_ble_evt Pointer to the event received from BLE stack.
*/
static void on_connect(ble_rcbr_t * p_rcbr, ble_evt_t const * p_ble_evt)
{
ret_code_t err_code;
ble_rcbr_evt_t evt;
ble_gatts_value_t gatts_val;
uint8_t cccd_value[2];
ble_rcbr_client_context_t * p_client = NULL;
err_code = blcm_link_ctx_get(p_rcbr->p_link_ctx_storage,
p_ble_evt->evt.gap_evt.conn_handle,
(void *) &p_client);
if (err_code != NRF_SUCCESS) {
NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.",
p_ble_evt->evt.gap_evt.conn_handle);
}
/* Check the hosts CCCD value to inform of readiness to send data using the RX characteristic */
memset(&gatts_val, 0, sizeof(ble_gatts_value_t));
gatts_val.p_value = cccd_value;
gatts_val.len = sizeof(cccd_value);
gatts_val.offset = 0;
err_code = sd_ble_gatts_value_get(p_ble_evt->evt.gap_evt.conn_handle,
p_rcbr->tx_handles.cccd_handle,
&gatts_val);
if ((err_code == NRF_SUCCESS) &&
(p_rcbr->data_handler != NULL) &&
ble_srv_is_notification_enabled(gatts_val.p_value)) {
if (p_client != NULL) {
p_client->is_notification_enabled = true;
}
memset(&evt, 0, sizeof(ble_rcbr_evt_t));
evt.type = BLE_RCBR_EVT_NOTIF_ENABLED;
evt.p_rcbr = p_rcbr;
evt.conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
evt.p_link_ctx = p_client;
p_rcbr->data_handler(&evt);
}
}
/**@brief Function for handling the @ref BLE_GATTS_EVT_WRITE event from the SoftDevice.
*
* @param[in] p_rcbr R3charge Borrower Service structure.
* @param[in] p_ble_evt Pointer to the event received from BLE stack.
*/
static void on_write(ble_rcbr_t * p_rcbr, ble_evt_t const * p_ble_evt)
{
ret_code_t err_code;
ble_rcbr_evt_t evt;
ble_rcbr_client_context_t * p_client;
ble_gatts_evt_write_t const * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
err_code = blcm_link_ctx_get(p_rcbr->p_link_ctx_storage,
p_ble_evt->evt.gatts_evt.conn_handle,
(void *) &p_client);
if (err_code != NRF_SUCCESS) {
NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.",
p_ble_evt->evt.gatts_evt.conn_handle);
}
memset(&evt, 0, sizeof(ble_rcbr_evt_t));
evt.p_rcbr = p_rcbr;
evt.conn_handle = p_ble_evt->evt.gatts_evt.conn_handle;
evt.p_link_ctx = p_client;
if ((p_evt_write->handle == p_rcbr->tx_handles.cccd_handle) &&
(p_evt_write->len == 2)) {
if (p_client != NULL) {
if (ble_srv_is_notification_enabled(p_evt_write->data)) {
p_client->is_notification_enabled = true;
evt.type = BLE_RCBR_EVT_NOTIF_ENABLED;
} else {
p_client->is_notification_enabled = false;
evt.type = BLE_RCBR_EVT_NOTIF_DISABLED;
}
if (p_rcbr->data_handler != NULL) {
p_rcbr->data_handler(&evt);
}
}
} else if ((p_evt_write->handle == p_rcbr->rx_handles.value_handle) &&
(p_rcbr->data_handler != NULL)) {
evt.type = BLE_RCBR_EVT_RX_DATA;
evt.params.rx_data.p_data = p_evt_write->data;
evt.params.rx_data.length = p_evt_write->len;
p_rcbr->data_handler(&evt);
} else {
// Do Nothing. This event is not relevant for this service.
}
}
/**@brief Function for handling the @ref BLE_GATTS_EVT_HVN_TX_COMPLETE event from the SoftDevice.
*
* @param[in] p_rcbr R3charge Borrower Service structure.
* @param[in] p_ble_evt Pointer to the event received from BLE stack.
*/
static void on_hvx_tx_complete(ble_rcbr_t * p_rcbr, ble_evt_t const * p_ble_evt)
{
ret_code_t err_code;
ble_rcbr_evt_t evt;
ble_rcbr_client_context_t * p_client;
err_code = blcm_link_ctx_get(p_rcbr->p_link_ctx_storage,
p_ble_evt->evt.gatts_evt.conn_handle,
(void *) &p_client);
if (err_code != NRF_SUCCESS) {
NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.",
p_ble_evt->evt.gatts_evt.conn_handle);
return;
}
if ((p_client->is_notification_enabled) && (p_rcbr->data_handler != NULL)) {
memset(&evt, 0, sizeof(ble_rcbr_evt_t));
evt.type = BLE_RCBR_EVT_TX_RDY;
evt.p_rcbr = p_rcbr;
evt.conn_handle = p_ble_evt->evt.gatts_evt.conn_handle;
evt.p_link_ctx = p_client;
p_rcbr->data_handler(&evt);
}
}
void ble_rcbr_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
if ((p_context == NULL) || (p_ble_evt == NULL)) {
return;
}
ble_rcbr_t * p_rcbr = (ble_rcbr_t *)p_context;
switch (p_ble_evt->header.evt_id) {
case BLE_GAP_EVT_CONNECTED:
on_connect(p_rcbr, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_rcbr, p_ble_evt);
break;
case BLE_GATTS_EVT_HVN_TX_COMPLETE:
on_hvx_tx_complete(p_rcbr, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
uint32_t ble_rcbr_init(ble_rcbr_t * p_rcbr, ble_rcbr_init_t const * p_rcbr_init)
{
ret_code_t err_code;
ble_uuid_t ble_uuid;
ble_uuid128_t rcbr_base_uuid = RCBR_BASE_UUID;
ble_add_char_params_t add_char_params;
VERIFY_PARAM_NOT_NULL(p_rcbr);
VERIFY_PARAM_NOT_NULL(p_rcbr_init);
// Initialize the service structure.
p_rcbr->data_handler = p_rcbr_init->data_handler;
/**@snippet [Adding proprietary Service to the SoftDevice] */
// Add a custom base UUID.
err_code = sd_ble_uuid_vs_add(&rcbr_base_uuid, &p_rcbr->uuid_type);
VERIFY_SUCCESS(err_code);
ble_uuid.type = p_rcbr->uuid_type;
ble_uuid.uuid = BLE_UUID_RCBR_SERVICE;
// Add the service.
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_uuid,
&p_rcbr->service_handle);
/**@snippet [Adding proprietary Service to the SoftDevice] */
VERIFY_SUCCESS(err_code);
// Add the RX Characteristic.
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_UUID_RCBR_SETTING_CHARACTERISTIC;
add_char_params.uuid_type = p_rcbr->uuid_type;
add_char_params.max_len = BLE_RCBR_MAX_NOTIF_CHAR_LEN;
add_char_params.init_len = sizeof(uint8_t);
add_char_params.is_var_len = true;
add_char_params.char_props.write = 1;
add_char_params.char_props.write_wo_resp = 1;
add_char_params.read_access = SEC_OPEN;
add_char_params.write_access = SEC_OPEN;
err_code = characteristic_add(p_rcbr->service_handle, &add_char_params, &p_rcbr->rx_handles);
if (err_code != NRF_SUCCESS) {
return err_code;
}
// Add the TX Characteristic.
/**@snippet [Adding proprietary characteristic to the SoftDevice] */
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_UUID_RCBR_NOTIF_CHARACTERISTIC;
add_char_params.uuid_type = p_rcbr->uuid_type;
add_char_params.max_len = BLE_RCBR_MAX_SETTING_CHAR_LEN;
add_char_params.init_len = sizeof(uint8_t);
add_char_params.is_var_len = true;
add_char_params.char_props.notify = 1;
add_char_params.read_access = SEC_OPEN;
add_char_params.write_access = SEC_OPEN;
add_char_params.cccd_write_access = SEC_OPEN;
return characteristic_add(p_rcbr->service_handle, &add_char_params, &p_rcbr->tx_handles);
/**@snippet [Adding proprietary characteristic to the SoftDevice] */
}
uint32_t ble_rcbr_data_send(ble_rcbr_t * p_rcbr,
uint8_t * p_data,
uint16_t * p_length,
uint16_t conn_handle)
{
ret_code_t err_code;
ble_gatts_hvx_params_t hvx_params;
ble_rcbr_client_context_t * p_client;
VERIFY_PARAM_NOT_NULL(p_rcbr);
err_code = blcm_link_ctx_get(p_rcbr->p_link_ctx_storage, conn_handle, (void *) &p_client);
VERIFY_SUCCESS(err_code);
if ((conn_handle == BLE_CONN_HANDLE_INVALID) || (p_client == NULL)) {
return NRF_ERROR_NOT_FOUND;
}
if (!p_client->is_notification_enabled) {
return NRF_ERROR_INVALID_STATE;
}
if (*p_length > BLE_RCBR_MAX_DATA_LEN) {
return NRF_ERROR_INVALID_PARAM;
}
memset(&hvx_params, 0, sizeof(hvx_params));
hvx_params.handle = p_rcbr->tx_handles.value_handle;
hvx_params.p_data = p_data;
hvx_params.p_len = p_length;
hvx_params.type = BLE_GATT_HVX_NOTIFICATION;
return sd_ble_gatts_hvx(conn_handle, &hvx_params);
}
/***************************************************************************** * Copyright (c) [2019-2021], Netobjex INC * All rights reserved. * * File: borrower.c * Summary: Borrower * Developer: [email protected] * */ #include <stdint.h> #include <stdio.h> #include <string.h> #include <math.h> #include <stdlib.h> #include "error_defs.h" #include "FreeRTOS.h" #include "task.h" #include "semphr.h" #include "timers.h" #include "borrower.h" #include "tasks.h" #include "task_borrower.h" #include "button_manager.h" #include "nrf_drv_gpiote.h" #include "boards.h" #include "nrf_log.h" #include "nrf_log_ctrl.h" #include "nrf_log_default_backends.h" #include "borrower_protocol.h" #include "device_configuration.h" #include "borrower.h" #include "product_config.h" #include "byte_helper.h" #include "main.h" #include "battery.h" #include "device_storage.h" #include "task_led_button.h" #include "ble_borrower.h" #include "psf_comm.h" #include "psf_i2c.h" #include "max17211_i2c.h" static device_config_t device_setting; //extern char device_id[16]; extern uint8_t device_id[17]; extern int8_t rssi; extern int8_t rssi_val_change; /** * @brief Send data to Central using RCBR service * * @return NRF_SUCCESS if successful, error otherwise */ uint32_t rcbr_service_send_data(uint8_t * data, uint16_t len) { uint32_t rc = NRF_SUCCESS; ble_rcbr_t * rcbr_srv = get_rcbr_service(); uint16_t length_send = len; rc = ble_rcbr_data_send(rcbr_srv, data, &length_send, get_conn_handle()); if(length_send != len) { NRF_LOG_INFO("Attempted to send %d but only sent %d", len, length_send); } return rc; } borrower_t borrower = {0, 0, 0, 0, 0, {02, 10, 40, 1, 00, 02, 75, 07, 100, 06, 07, 01}}; //uint8_t device_id[DEVICE_ID_BYTE_LEN]; uint8_t flag_saveSetting1 = 0; uint32_t borrower_pos = 0; void borrower_load_settings(void) { err_rc_t rc = RESULT_ERROR_FAILURE; NRF_LOG_INFO("Load Device Setting."); while(rc != RESULT_SUCCESS) { rc = device_storage_load(&borrower.setting); // vTaskDelay(100); } NRF_LOG_INFO("Device Id: %s", borrower.setting.device_id); memcpy(device_id, &borrower.setting.device_id, 16); } void borrower_save_settings(void) { device_storage_store(&borrower.setting);//$$ } void borrower_notify_value(uint8_t cmd) { char payload[20];float soc;float current; uint8_t i = 0; memset(payload, 0x00, 20); payload[0] = cmd; switch (cmd) { case BORROWER_OPCODE_SOC: { NRF_LOG_INFO("BORROWER Notify: SOC"); memcpy(&payload[1], &(session_id), 16); //soc = get_soc(); payload[2] = get_soc(); break; } default: break; } rcbr_service_send_data(payload, 20); } char code1; void borrower_process_ble_setting_msg(char *data, uint8_t len) { activate_led_event(LED_EVENT_SETTINGS_DONE); } void borrower_report_current_status() { borrower_notify_value(BORROWER_OPCODE_SOC); borrower_notify_value(BORROWER_OPCODE_CURRENT); borrower_notify_value(BORROWER_OPCODE_BATTERY); } void borrower_readSetting(void) { // eeprom_read(DEVICE_SETTING_ADDR, (char*)&borrower.setting, sizeof(borrower_setting_t)); // nrf_delay_ms(100); mem_read_device_setting(&borrower.setting); // read setting from flash and set device id. NRF_LOG_INFO("Read setting."); NRF_LOG_INFO("Device Id: %s", device_id); }
/**
*
*/
#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_bas.h"
#include "ble_dis.h"
#include "ble_conn_params.h"
#include "sensorsim.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "nrf_sdh_freertos.h"
#include "app_timer.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "semphr.h"
#include "fds.h"
#include "ble_conn_state.h"
#include "nrf_drv_clock.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "product_config.h"
#include "ble_lender.h"
#include "ble_borrower.h"
#include "task_led_button.h"
#include "task_lender.h"
#include "task_borrower.h"
#include "task_system.h"
#include "task_psf_comm.h"
#include "device_storage.h"
#include "nrf_drv_gpiote.h"
#include "battery.h"
#include "version.h"
#include "lender.h"
#include "borrower.h"
#include "psf_comm.h"
#include "nrf_drv_twi.h"
#include "psf_i2c.h"
#include "task_led_button.h"
#include "bq24292i.h"
#include "max17211_i2c.h"
#define DEVICE_NAME LE_DEVICE_NAME /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME "nordic" /**< Manufacturer. Will be passed to Device Information Service. */
#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 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 RTC_INTERVAL 1000 /**< RTC interval (ms). */
#define MIN_BATTERY_LEVEL 81 /**< Minimum simulated battery level. */
#define MAX_BATTERY_LEVEL 100 /**< Maximum simulated battery level. */
#define MIN_CONN_INTERVAL MSEC_TO_UNITS(200, UNIT_1_25_MS) /**< Minimum acceptable connection interval (0.4 seconds). */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(300, UNIT_1_25_MS) /**< Maximum acceptable connection interval (0.65 second). */
#define SLAVE_LATENCY 0 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(5000, UNIT_10_MS) /**< Connection supervisory time-out (4 seconds). */
#define FIRST_CONN_PARAMS_UPDATE_DELAY 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 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 1 /**< 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_DISPLAY_ONLY /**< 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 OSTIMER_WAIT_FOR_QUEUE 2 /**< Number of ticks to wait for the timer queue to be ready */
#define DEVICEID_SIZE 16
uint8_t device_id[DEVICEID_SIZE+1] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
static char app_fw_version[32];
uint8_t rclr_data_buf[256] = {0};
uint8_t rcbr_data_buf[256] = {0};
uint16_t rclr_data_cnt = 0;
uint16_t rcbr_data_cnt = 0;
BLE_RCLR_DEF(m_rclr, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< BLE R3charge lender service instance. */
BLE_RCBR_DEF(m_rcbr, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< BLE R3charge borrower service instance. */
BLE_BAS_DEF(m_bas); /**< Battery service instance. */
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. */
////////////Added for bonding///////////
// Static passkey
#define STATIC_PASSKEY "123456"
static ble_opt_t m_static_pin_option;
uint8_t passkey[] = STATIC_PASSKEY;
////////////Added for bonding///////////
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifiers. */
{
// {BLE_UUID_RCLR_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN},
{BLE_UUID_RCBR_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN}
};
static TimerHandle_t m_rtc_timer; /**< Definition of battery timer. */
#if NRF_LOG_ENABLED
static TaskHandle_t m_logger_thread; /**< Definition of Logger thread. */
#endif
static void advertising_start(void * p_erase_bonds);
static void nrf_nvmc_write_word(uint32_t address, uint32_t value);
ble_rclr_t * get_rclr_service(void)
{
return &m_rclr;
}
ble_rcbr_t * get_rcbr_service(void)
{
return &m_rcbr;
}
uint16_t get_conn_handle(void)
{
return m_conn_handle;
}
uint8_t * get_rclr_rcv_buffer(void)
{
return rclr_data_buf;
}
uint16_t get_rclr_rcv_cnt(void)
{
return rclr_data_cnt;
}
uint8_t * get_rcbr_rcv_buffer(void)
{
return rcbr_data_buf;
}
uint16_t get_rcbr_rcv_cnt(void)
{
return rcbr_data_cnt;
}
/**@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)
{
bool delete_bonds = false;
pm_handler_on_pm_evt(p_evt);
pm_handler_flash_clean(p_evt);
switch (p_evt->evt_id) {
case PM_EVT_PEERS_DELETE_SUCCEEDED:
//..advertising_start(&delete_bonds);
advertising_start(false);
break;
default:
break;
}
}
/**@brief Function for performing battery measurement and updating the Battery Level characteristic
* in Battery Service.
*/
void battery_level_update(void)
{
ret_code_t err_code;
uint8_t battery_level;
battery_level = battery_get_percentage(); /* Update TODO */
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);
}
}
uint32_t rtc_val = 0;
uint32_t get_system_rtc(void)
{
return rtc_val;
}
/**@brief Function for handling the RTC event
*
* @details This function will be called each time the RTC timer expires.
*
* @param[in] xTimer Handler to the timer that called this function.
* You may get identifier given to the function xTimerCreate using pvTimerGetTimerID.
*/
static void rtc_timeout_handler(TimerHandle_t xTimer)
{
UNUSED_PARAMETER(xTimer);
rtc_val++;
}
static StaticTimer_t xRTCTimer;
/**@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.
ret_code_t err_code = app_timer_init();
APP_ERROR_CHECK(err_code);
// Create timers.
m_rtc_timer = xTimerCreateStatic("RTC",
RTC_INTERVAL,
pdTRUE,
NULL,
rtc_timeout_handler,
&xRTCTimer);
/* Error checking */
if (NULL == m_rtc_timer) {
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
}
/**@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);
//commented for adding device id.
//err_code = sd_ble_gap_device_name_set(&sec_mode,
// (const uint8_t *)DEVICE_NAME,
// strlen(DEVICE_NAME));
#ifdef USE_DEVICEID_ON_SRDATA
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)DEVICE_NAME,
strlen(DEVICE_NAME));
#else
uint8_t basename_size = strlen(DEVICE_NAME);
uint8_t devicename[DEVICEID_SIZE+1+basename_size+1];
memcpy(&devicename[0], (const uint8_t *)DEVICE_NAME, basename_size);
devicename[basename_size] = '-';
memcpy(&devicename[basename_size+1], device_id, DEVICEID_SIZE);
memset(&devicename[basename_size+1+DEVICEID_SIZE], 0x00, 1);
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)devicename,
strlen(devicename));
#endif
APP_ERROR_CHECK(err_code);
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_HEART_RATE_SENSOR_HEART_RATE_BELT);
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);
////////Added for bonding ///////////
m_static_pin_option.gap_opt.passkey.p_passkey = &passkey[0];
err_code = sd_ble_opt_set(BLE_GAP_OPT_PASSKEY, &m_static_pin_option);
APP_ERROR_CHECK(err_code);
////////Added for bonding ///////////
}
/**@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);
err_code = nrf_ble_gatt_att_mtu_periph_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE);
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);
}
static void rclr_data_handler(ble_rclr_evt_t * p_evt)
{
if (p_evt->type == BLE_RCLR_EVT_RX_DATA) {
uint32_t err_code;
if(p_evt->params.rx_data.length < sizeof(rclr_data_buf)) {
memset(rclr_data_buf, 0, sizeof(rclr_data_buf));
memcpy(rclr_data_buf, p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
rclr_data_cnt = p_evt->params.rx_data.length;
/* Inform lender Task we have a command */
lender_task_queue_event(LENDER_TASK_EVT_SETTING_CMD);
}
} else if(p_evt->type == BLE_RCLR_EVT_NOTIF_ENABLED) {
/* Inform lender Task notifications have begun */
lender_task_queue_event(LENDER_TASK_EVT_NOTIF_EN);
}
}
static void rcbr_data_handler(ble_rcbr_evt_t * p_evt)
{
if (p_evt->type == BLE_RCBR_EVT_RX_DATA) {
uint32_t err_code;
if(p_evt->params.rx_data.length < sizeof(rcbr_data_buf)) {
memset(rcbr_data_buf, 0, sizeof(rcbr_data_buf));
memcpy(rcbr_data_buf, p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
rcbr_data_cnt = p_evt->params.rx_data.length;
/* Inform borrower Task we have a command */
borrower_task_queue_event(BORROWER_TASK_EVT_SETTING_CMD);
}
} else if(p_evt->type == BLE_RCLR_EVT_NOTIF_ENABLED) {
/* Inform borrower Task notifications have begun */
borrower_task_queue_event(BORROWER_TASK_EVT_NOTIF_EN);
}
}
/**@brief Function for initializing services that will be used by the application.
*
* @details Initialize the Heart Rate, Battery and Device Information services.
*/
static void services_init(void)
{
ret_code_t err_code;
ble_rclr_init_t rclr_init;
ble_rcbr_init_t rcbr_init;
ble_bas_init_t bas_init;
ble_dis_init_t dis_init;
nrf_ble_qwr_init_t qwr_init = {0};
uint8_t body_sensor_location;
// 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 Battery Service.
memset(&bas_init, 0, sizeof(bas_init));
// Here the sec level for the Battery Service can be changed/increased.
bas_init.bl_rd_sec = SEC_OPEN;
bas_init.bl_cccd_wr_sec = SEC_OPEN;
bas_init.bl_report_rd_sec = SEC_OPEN;
bas_init.evt_handler = NULL;
bas_init.support_notification = true;
bas_init.p_report_ref = NULL;
bas_init.initial_batt_level = 100;
err_code = ble_bas_init(&m_bas, &bas_init);
APP_ERROR_CHECK(err_code);
// Initialize Device Information Service.
memset(&dis_init, 0, sizeof(dis_init));
ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, (char *)MANUFACTURER_NAME);
ble_srv_ascii_to_utf8(&dis_init.model_num_str, (char *)DEVICE_MODEL_NUM);
ble_srv_ascii_to_utf8(&dis_init.serial_num_str, (char *)device_id);
ble_srv_ascii_to_utf8(&dis_init.hw_rev_str, (char *)DEVICE_HW_VER);
ble_srv_ascii_to_utf8(&dis_init.fw_rev_str, (char *)app_fw_version);
dis_init.dis_char_rd_sec = SEC_OPEN;
err_code = ble_dis_init(&dis_init);
APP_ERROR_CHECK(err_code);
// Initialize RCLR- LENDER Service
memset(&rclr_init, 0, sizeof(rclr_init));
rclr_init.data_handler = rclr_data_handler;
err_code = ble_rclr_init(&m_rclr, &rclr_init);
APP_ERROR_CHECK(err_code);
// Initialize RCBR - BORROWER Service
memset(&rcbr_init, 0, sizeof(rcbr_init));
rcbr_init.data_handler = rcbr_data_handler;
err_code = ble_rcbr_init(&m_rcbr, &rcbr_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for starting application timers.
* @details Timers are run after the scheduler has started.
*/
static void application_timers_start(void)
{
// Start application timers.
if (pdPASS != xTimerStart(m_rtc_timer, OSTIMER_WAIT_FOR_QUEUE)) {
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
}
/**@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 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)
{
uint32_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)
{
char passkey[BLE_GAP_PASSKEY_LEN + 1];
uint16_t role = ble_conn_state_role(m_conn_handle);
pm_handler_secure_on_connection(p_ble_evt);
uint32_t err_code;
ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt; //$$ new
switch (p_ble_evt->header.evt_id) {
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);
adv_led_button =1;
led_grn_pwr_active = 1;
led_on_duration = get_system_rtc();
let_btn_task_evt_t evt;
evt.id = LED_TASK_EVT_PROCESS_LED_RC1;
led_btn_task_queue_event(evt);
err_code = sd_ble_gap_rssi_start(p_ble_evt->evt.gap_evt.conn_handle,1,2); //$$ new
APP_ERROR_CHECK(err_code); //$$ new
break;
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected");
m_conn_handle = BLE_CONN_HANDLE_INVALID;
break;
#if 1
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
//NRF_LOG_INFO("%s: BLE_GAP_EVT_SEC_PARAMS_REQUEST", nrf_log_push(roles_str[role]));
break;
//case BLE_GAP_EVT_PASSKEY_DISPLAY:
// memcpy(passkey, p_ble_evt->evt.gap_evt.params.passkey_display.passkey, BLE_GAP_PASSKEY_LEN);
// passkey[BLE_GAP_PASSKEY_LEN] = 0x00;
// NRF_LOG_INFO("%s: BLE_GAP_EVT_PASSKEY_DISPLAY: passkey=%s match_req=%d",
// nrf_log_push(roles_str[role]),
// nrf_log_push(passkey),
// p_ble_evt->evt.gap_evt.params.passkey_display.match_request);
// if (p_ble_evt->evt.gap_evt.params.passkey_display.match_request)
// {
// on_match_request(m_conn_handle, role);
// }
// break;
case BLE_GAP_EVT_PASSKEY_DISPLAY:
{
//char passkey[16 + 1];
memcpy(passkey, p_ble_evt->evt.gap_evt.params.passkey_display.passkey, 16);
passkey[16] = 0;
// Don't send delayed Security Request if security procedure is already in progress.
//err_code = app_timer_stop(m_sec_req_timer_id);
//APP_ERROR_CHECK(err_code);
NRF_LOG_INFO("Passkey: %s", nrf_log_push(passkey));
} break;
case BLE_GAP_EVT_AUTH_KEY_REQUEST:
// NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_KEY_REQUEST", nrf_log_push(roles_str[role]));
break;
case BLE_GAP_EVT_LESC_DHKEY_REQUEST:
//NRF_LOG_INFO("%s: BLE_GAP_EVT_LESC_DHKEY_REQUEST", nrf_log_push(roles_str[role]));
break;
case BLE_GAP_EVT_AUTH_STATUS:
//NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_STATUS: status=0x%x bond=0x%x lv4: %d kdist_own:0x%x kdist_peer:0x%x",
// nrf_log_push(roles_str[role]),
//p_ble_evt->evt.gap_evt.params.auth_status.auth_status,
//p_ble_evt->evt.gap_evt.params.auth_status.bonded,
//p_ble_evt->evt.gap_evt.params.auth_status.sm1_levels.lv4,
//*((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_own),
//*((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_peer));
break;
#endif
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;
case BLE_GAP_EVT_RSSI_CHANGED:
rssi = p_ble_evt->evt.gap_evt.params.rssi_changed.rssi;
// NRF_LOG_INFO("RSSI: %d", p_ble_evt->evt.gap_evt.params.rssi_changed.rssi);
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 handling events from the BSP module.
*
* @param[in] event Event generated by button press.
*/
static void bsp_event_handler(bsp_event_t event)
{
ret_code_t err_code;
switch (event) {
case BSP_EVENT_SLEEP:
sleep_mode_enter();
break;
case BSP_EVENT_DISCONNECT:
err_code = sd_ble_gap_disconnect(m_conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
if (err_code != NRF_ERROR_INVALID_STATE) {
APP_ERROR_CHECK(err_code);
}
break;
case BSP_EVENT_WHITELIST_OFF:
if (m_conn_handle == BLE_CONN_HANDLE_INVALID) {
err_code = ble_advertising_restart_without_whitelist(&m_advertising);
if (err_code != NRF_ERROR_INVALID_STATE) {
APP_ERROR_CHECK(err_code);
}
}
break;
default:
break;
}
}
/**@brief Function for handling events from the GATT library. */
//void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt)
//{
// if ((m_conn_handle == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED))
// {
// m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
// NRF_LOG_INFO("Data len is set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len);
// }
// NRF_LOG_DEBUG("ATT MTU exchange completed. central 0x%x peripheral 0x%x",
// p_gatt->att_mtu_desired_central,
// p_gatt->att_mtu_desired_periph);
//}
/**@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);
err_code = pm_register(pm_evt_handler);
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 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 = false;//..
init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
init.advdata.uuids_more_available.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.advdata.uuids_more_available.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.srdata.name_type = BLE_ADVDATA_FULL_NAME;
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 the nrf log module.
*/
static void log_init(void)
{
ret_code_t err_code = NRF_LOG_INIT(NULL);
// ret_code_t err_code = NRF_LOG_INIT(app_timer_cnt_get); //..snehal
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
}
/**@brief Function for starting advertising. */
static void advertising_start(void * p_erase_bonds)
{
bool erase_bonds = *(bool*)p_erase_bonds;
if (erase_bonds) {
delete_bonds();
// Advertising is started by PM_EVT_PEERS_DELETE_SUCCEEDED event.
} else {
ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
}
}
/* configSUPPORT_STATIC_ALLOCATION is set to 1, so the application must provide an
implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
used by the Idle task. */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer,
StackType_t **ppxIdleTaskStackBuffer,
uint32_t *pulIdleTaskStackSize )
{
/* If the buffers to be provided to the Idle task are declared inside this
function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */
static StaticTask_t xIdleTaskTCB;
static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
/* Pass out a pointer to the StaticTask_t structure in which the Idle task's
state will be stored. */
*ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
/* Pass out the array that will be used as the Idle task's stack. */
*ppxIdleTaskStackBuffer = uxIdleTaskStack;
/* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
}
/* configSUPPORT_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
application must provide an implementation of vApplicationGetTimerTaskMemory()
to provide the memory that is used by the Timer service task. */
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer,
StackType_t **ppxTimerTaskStackBuffer,
uint32_t *pulTimerTaskStackSize )
{
/* If the buffers to be provided to the Timer task are declared inside this
function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */
static StaticTask_t xTimerTaskTCB;
static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
/* Pass out a pointer to the StaticTask_t structure in which the Timer
task's state will be stored. */
*ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
/* Pass out the array that will be used as the Timer task's stack. */
*ppxTimerTaskStackBuffer = uxTimerTaskStack;
/* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t,
configTIMER_TASK_STACK_DEPTH is specified in words, not bytes. */
*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
}
void vApplicationMallocFailedHook( void )
{
NRF_LOG_INFO("Malloc Failed");
}
void vApplicationStackOverflowHook(xTaskHandle *pxTask, signed char *pcTaskName )
{
for( ;; );
}
#if NRF_LOG_ENABLED
/**@brief Thread for handling the logger.
*
* @details This thread is responsible for processing log entries if logs are deferred.
* Thread flushes all log entries and suspends. It is resumed by idle task hook.
*
* @param[in] arg Pointer used for passing some arbitrary information (context) from the
* osThreadCreate() call to the thread.
*/
static void logger_thread(void * arg)
{
UNUSED_PARAMETER(arg);
while (1) {
NRF_LOG_FLUSH();
vTaskSuspend(NULL); // Suspend myself
}
}
#endif //NRF_LOG_ENABLED
/**@brief A function which is hooked to idle task.
* @note Idle hook must be enabled in FreeRTOS configuration (configUSE_IDLE_HOOK).
*/
void vApplicationIdleHook( void )
{
#if NRF_LOG_ENABLED
vTaskResume(m_logger_thread);
#endif
}
/**@brief Function for initializing the clock.
*/
static void clock_init(void)
{
ret_code_t err_code = nrf_drv_clock_init();
APP_ERROR_CHECK(err_code);
}
#define LOGGER_TASK_STACK_SIZE 512
#define LOGGER_TASK_PRIORITY 1
/* Structure that will hold the TCB of the task being created. */
StaticTask_t xLoggerTaskBuffer;
/* Buffer that the task being created will use as its stack. Note this is
an array of StackType_t variables. The size of StackType_t is dependent on
the RTOS port. */
StackType_t xLoggerStack[ LOGGER_TASK_STACK_SIZE ];
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 application main entry.
*/
int main(void)
{
bool erase_bonds;
ret_code_t err_code;
uint32_t APPPROTECT_reg;
bool status;
// Initialize modules.
log_init();
clock_init();
// Do not start any interrupt that uses system functions before system initialisation.
// The best solution is to start the OS before any other initalisation.
#if NRF_LOG_ENABLED
// Start execution.
m_logger_thread = xTaskCreateStatic(logger_thread, "LOGGER", sizeof(xLoggerStack) / sizeof(xLoggerStack[0]), NULL, LOGGER_TASK_PRIORITY, xLoggerStack, &xLoggerTaskBuffer);
if (m_logger_thread == NULL) {
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
#endif
NRF_LOG_INFO("TESTING NEW FIRMWARE");
// buttons_leds_init(&erase_bonds);
// Activate deep sleep mode.
// SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
memset(app_fw_version, 0, sizeof(app_fw_version));
app_version_str(app_fw_version, sizeof(app_fw_version));
mem_init();
// Configure and initialize the BLE stack.
ble_stack_init();
device_storage_init();
borrower_load_settings();
// Initialize modules.
timers_init();
gap_params_init();
gatt_init();
services_init();
advertising_init();
conn_params_init();
peer_manager_init();
application_timers_start();
// Create a FreeRTOS task for the BLE stack.
// The task will run advertising_start() before entering its loop.
nrf_sdh_freertos_init(advertising_start, &erase_bonds);
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
init_led_button_task();
init_borrower_task();
init_psf_comm_task();
// Start FreeRTOS scheduler.
vTaskStartScheduler();
for (;;) {
APP_ERROR_HANDLER(NRF_ERROR_FORBIDDEN);
}
}
uint32_t app_timer_cnt_get(void)
{
return xTaskGetTickCount();
}
uint32_t app_timer_cnt_diff_compute(uint32_t ticks_to,
uint32_t ticks_from)
{
return ((ticks_to - ticks_from) & RTC_COUNTER_COUNTER_Msk);
}
/*****************************************************************************
* Copyright (c) [2019-2021], Netobjex INC
* All rights reserved.
*
* File: task_borrower.c
* Summary: borrower Task
*
*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "error_defs.h"
#include "task_borrower.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "timers.h"
#include "tasks.h"
#include "button_manager.h"
#include "boards.h"
#include "nrf_drv_gpiote.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "product_config.h"
#include "borrower.h"
#include "main.h"
#include "borrower_protocol.h"
#include "psf_uart.h"
#include "max17211_i2c.h"
/* Task Configuration */
StaticTask_t task_borrower_tcb;
/* Buffer that the task being created will use as its stack. Note this is
an array of StackType_t variables. The size of StackType_t is dependent on
the RTOS port. */
StackType_t borrower_stack[ BORROWER_TASK_STACK_SIZE ];
static QueueHandle_t borrower_queue_handle = NULL;
static void borrower_task( void *pvParameters );
err_rc_t borrower_task_queue_event(BORROWER_TASK_EVENTS_t evt);
void rssi_change_timer_callback1( TimerHandle_t xTimer );
void max17211_timer_callback( TimerHandle_t xTimer );
static void water_flow_stop(void);
static void water_flow_start(void);
/* LED Stack Queue */
#define QUEUE_LENGTH 10
#define ITEM_SIZE sizeof( BORROWER_TASK_EVENTS_t )
/* The variable used to hold the queue's data structure. */
static StaticQueue_t xStaticQueue;
/* The array to use as the queue's storage area. This must be at least
uxQueueLength * uxItemSize bytes. */
uint8_t borrower_queue_storage_area[ QUEUE_LENGTH * ITEM_SIZE ];
volatile TaskHandle_t borrower_task_handle = NULL;
char session_id1[16];
static uint16_t timeSinceStart = 0; // in seconds
static float lastWaterConsumption = 0;
static uint32_t lasttotalPulseCount = 0;
static uint32_t lastPulseCount = 0;
int8_t rssi_val_change1;
static const nrf_drv_timer_t m_timer1 = NRF_DRV_TIMER_INSTANCE(1);
static const nrf_drv_timer_t m_timer2 = NRF_DRV_TIMER_INSTANCE(2);
static nrf_ppi_channel_t m_ppi_channel1;
static nrf_ppi_channel_t m_ppi_channel2;
static void process_timer_event(void);
static void borrower_init(void);
static TimerHandle_t rssi_change_timer_handle;
static StaticTimer_t rssi_change_timer;
static TimerHandle_t max17211_handle;
static StaticTimer_t max17211_timer;
/**
* @brief Initializes the borrower Task
*
* @return RESULT_SUCCESS if initialization completed, otherwise error
*/
err_rc_t init_borrower_task(void)
{
err_rc_t rc = RESULT_SUCCESS;
do {
/* Start the two tasks as described in the comments at the top of this
file. */
borrower_task_handle = xTaskCreateStatic(
borrower_task, /* Function that implements the task. */
"borrower", /* Text name for the task. */
BORROWER_TASK_STACK_SIZE, /* Number of indexes in the borrower_stack array. */
( void * ) 1, /* Parameter passed into the task. */
BORROWER_TASK_PRIORITY,/* Priority at which the task is created. */
borrower_stack, /* Array to use as the task's stack. */
&task_borrower_tcb ); /* Variable to hold the task's data structure. */
if(borrower_task_handle == NULL) {
rc = RESULT_ERROR_FAILURE;
break;
}
/* Create a queue */
borrower_queue_handle = xQueueCreateStatic( QUEUE_LENGTH,
ITEM_SIZE,
borrower_queue_storage_area,
&xStaticQueue );
if(borrower_queue_handle == NULL) {
rc = RESULT_ERROR_FAILURE;
break;
}
rssi_change_timer_handle = xTimerCreateStatic("RssiTimer",
20000,
pdFALSE,
( void * ) 0,
rssi_change_timer_callback1,
&rssi_change_timer);
if( rssi_change_timer_handle == NULL ) {
/* The timer was not created */
rc = RESULT_ERROR_FAILURE;
break;
}
max17211_handle = xTimerCreateStatic("Max17211Timer",
10000,
pdTRUE,
( void * ) 0,
max17211_timer_callback,
&max17211_timer);
if( max17211_handle == NULL ) {
/* The timer was not created */
rc = RESULT_ERROR_FAILURE;
break;
}
} while(0);
return rc;
}
/**
* @brief Queues an event to be processed by the borrower Task
*
* @param evt is the event to queue
*
* @return RESULT_SUCCESS if initialization completed, otherwise error
*/
err_rc_t borrower_task_queue_event(BORROWER_TASK_EVENTS_t evt)
{
err_rc_t rc = RESULT_SUCCESS;
BORROWER_TASK_EVENTS_t queue_evt = evt;
BaseType_t result = xQueueSendFromISR(borrower_queue_handle,
&queue_evt,
NULL);
if(result != pdTRUE) {
rc = RESULT_ERROR_FAILURE;
}
return rc;
}
/**
* @brief Main borrower Task thread
*
* @param pvParameters unused
*
*
*/
static void borrower_task( void *pvParameters )
{
BORROWER_TASK_EVENTS_t evt;
btnmgr_return_t btrc;
/* Remove compiler warning about unused parameter. */
( void ) pvParameters;
// borrower_init();
if(xTimerStart(max17211_handle, 0 ) != pdPASS ) {
// The timer could not be set into the Active state.
}
while(1)
{
xQueueReceive( borrower_queue_handle, &evt, portMAX_DELAY );
switch(evt)
{
case BORROWER_TASK_EVT_TIMER:
// process_timer_event();
break;
case BORROWER_TASK_EVT_SETTING_CMD:
borrower_process_ble_setting_msg(get_rcbr_rcv_buffer(), get_rcbr_rcv_cnt());
break;
case BORROWER_TASK_EVT_NOTIF_EN:
/* Notification is enabled, so report the current status */
borrower_report_current_status();
}
}
}
/**@brief water flow measurement setup
*
*/
static void borrower_init(void)
{
borrower_load_settings();
}
void rssi_change_timer_callback1( TimerHandle_t xTimer )
{
borrower_task_queue_event(BORROWER_TASK_EVT_NOTIF_EN);
rssi_val_change1 = 1;
}
void max17211_timer_callback( TimerHandle_t xTimer )
{
get_max17201_data();
borrower_task_queue_event(BORROWER_TASK_EVT_NOTIF_EN);
}
