#include <string.h>
#include "ble_srv_common.h"
#include "nrf_gpio.h"
#include "boards.h"
#include "nrf_log.h"
#include "sdk_common.h"
#include "ble_aph_service.h"
/**@brief Function for handling the Connect event.
*
* @param[in] p_cus Custom Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void
on_connect (ble_cus_t * p_cus, ble_evt_t const *p_ble_evt)
{
p_cus->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
ble_cus_evt_t evt;
evt.evt_type = BLE_CUS_EVT_CONNECTED;
p_cus->evt_handler (p_cus, &evt);
}
/**@brief Function for handling the Disconnect event.
*
* @param[in] p_cus Custom Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void
on_disconnect (ble_cus_t * p_cus, ble_evt_t const *p_ble_evt)
{
UNUSED_PARAMETER (p_ble_evt);
p_cus->conn_handle = BLE_CONN_HANDLE_INVALID;
ble_cus_evt_t evt;
evt.evt_type = BLE_CUS_EVT_DISCONNECTED;
p_cus->evt_handler (p_cus, &evt);
}
/**@brief Function for handling the Write event.
*
* @param[in] p_cus Custom Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void
on_write (ble_cus_t * p_cus, ble_evt_t const *p_ble_evt)
{
ble_gatts_evt_write_t const *p_evt_write =
&p_ble_evt->evt.gatts_evt.params.write;
// Custom Value Characteristic Written to.
if (p_evt_write->handle == p_cus->rx_handles.value_handle) {
// nrf_gpio_pin_toggle(LED_4);
/*
if(*p_evt_write->data == 0x01)
{
// nrf_gpio_pin_clear(20);
}
else if(*p_evt_write->data == 0x02)
{
// nrf_gpio_pin_set(20);
}
else
{
//Do nothing
}
*/
}
// Check if the Custom value CCCD is written to and that the value is the appropriate length, i.e 5 bytes.
if ((p_evt_write->handle ==
p_cus->tx_handles.cccd_handle)
&&(p_evt_write->
len == 5)
) {
// CCCD written, call application event handler
if (p_cus->evt_handler != NULL) {
ble_cus_evt_t evt;
if (ble_srv_is_notification_enabled
(p_evt_write->data)) {
evt.evt_type = BLE_CUS_EVT_NOTIFICATION_ENABLED;
} else {
evt.evt_type =
BLE_CUS_EVT_NOTIFICATION_DISABLED;
}
// Call the application event handler.
p_cus->evt_handler (p_cus, &evt);
}
}
}
void
ble_cus_on_ble_evt (ble_evt_t const *p_ble_evt, void *p_context)
{
ble_cus_t * p_cus = (ble_cus_t *) p_context;
NRF_LOG_INFO ("BLE event received. Event type = %d\r\n",
p_ble_evt->header.evt_id);
if (p_cus == NULL || p_ble_evt == NULL) {
return;
}
switch (p_ble_evt->header.evt_id) {
case BLE_GAP_EVT_CONNECTED:
on_connect (p_cus, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect (p_cus, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write (p_cus, p_ble_evt);
break;
/* Handling this event is not necessary
case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST:
NRF_LOG_INFO("EXCHANGE_MTU_REQUEST event received.\r\n");
break;
*/
default:
// No implementation needed.
break;
}
}
/**@brief Function for adding the TX characteristic.
*
* @param[in] p_cus custom Service structure.
* @param[in] p_cus_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static ret_code_t addTXChar (ble_cus_t * p_cus,
const ble_cus_init_t * p_cus_init)
{
ret_code_t err_code;
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
memset (&char_md, 0, sizeof (char_md));
char_md.char_props.read = 0;
char_md.char_props.write = 1;
char_md.char_props.notify = 0;
char_md.char_props.write_wo_resp = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
memset (&attr_md, 0, sizeof (attr_md));
attr_md.read_perm = p_cus_init->custom_value_char_attr_md.read_perm;
attr_md.write_perm = p_cus_init->custom_value_char_attr_md.write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 1;
attr_md.wr_auth = 1;
attr_md.vlen = 0;
ble_uuid.type = p_cus->uuid_type;
ble_uuid.uuid = APH_TX_UUID; //will add the 16-bit UUID
memset (&attr_char_value, 0, sizeof (attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = (sizeof (uint8_t)*5);
attr_char_value.init_offs = 0;
attr_char_value.max_len = (sizeof (uint8_t)*5);
uint8_t v1[5] = {0x1B,0x01,0x00,0x00,0x00};
attr_char_value.p_value = v1;
err_code =
sd_ble_gatts_characteristic_add (p_cus->service_handle, &char_md,
&attr_char_value,
&p_cus->tx_handles);
if (err_code != NRF_SUCCESS) {
return err_code;
}
return NRF_SUCCESS;
}
/**@brief Function for adding the RX Characteristic.
*
* @param[in] p_cus custom Service structure.
* @param[in] p_cus_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static ret_code_t addRXChar (ble_cus_t * p_cus,
const ble_cus_init_t * p_cus_init)
{
ret_code_t err_code;
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
memset (&char_md, 0, sizeof (char_md));
char_md.char_props.read = 1;
char_md.char_props.write = 0;
char_md.char_props.notify = 1;
char_md.char_props.write_wo_resp = 0;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
memset (&attr_md, 0, sizeof (attr_md));
attr_md.read_perm = p_cus_init->custom_value_char_attr_md.read_perm;
attr_md.write_perm = p_cus_init->custom_value_char_attr_md.write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 1;
attr_md.wr_auth = 1;
attr_md.vlen = 0;
ble_uuid.type = p_cus->uuid_type;
ble_uuid.uuid = APH_RX_UUID; //will add the 16-bit UUID
memset (&attr_char_value, 0, sizeof (attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = (sizeof (uint8_t)*5);
attr_char_value.init_offs = 0;
attr_char_value.max_len = (sizeof (uint8_t)*5);
uint8_t v2[5] = {0x00,0x00,0x00,0x00,0x00};
attr_char_value.p_value = v2;
err_code =
sd_ble_gatts_characteristic_add (p_cus->service_handle, &char_md,
&attr_char_value,
&p_cus->tx_handles);
if (err_code != NRF_SUCCESS) {
return err_code;
}
return NRF_SUCCESS;
}
//ble_cus_init
ret_code_t ble_cus_init (ble_cus_t * p_cus,
const ble_cus_init_t * p_cus_init)
{
if (p_cus == NULL || p_cus_init == NULL) {
return NRF_ERROR_NULL;
}
ret_code_t err_code;
ble_uuid_t ble_uuid;
// Initialize service structure
p_cus->evt_handler = p_cus_init->evt_handler;
p_cus->conn_handle = BLE_CONN_HANDLE_INVALID;
// Add Custom Service UUID
ble_uuid128_t base_uuid = {APH_SERVICE_BASE_REV};
err_code = sd_ble_uuid_vs_add (&base_uuid, &p_cus->uuid_type);
APP_ERROR_CHECK (err_code);
ble_uuid.type = p_cus->uuid_type;
ble_uuid.uuid = APH_SERVICE_UUID;
err_code =
sd_ble_gatts_service_add (BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid,
&p_cus->service_handle);
APP_ERROR_CHECK (err_code);
if (err_code != NRF_SUCCESS) {
return err_code;
}
// Add Custom Value characteristic tx
// ble_uuid128_t base_tx ={APH_TX_BASE};
ble_uuid128_t base_tx = {APH_SERVICE_BASE_REV};
err_code = sd_ble_uuid_vs_add (&base_tx, &p_cus->uuid_type); //changing the base for the first characteristic
if (err_code != NRF_SUCCESS) {
return err_code;
}
err_code = addTXChar(p_cus, p_cus_init);
if (err_code != NRF_SUCCESS) {
return err_code;
}
// Add Custom Value characteristic rx
// ble_uuid128_t base_rx = {APH_RX_BASE};
ble_uuid128_t base_rx = {APH_SERVICE_BASE_REV};
err_code = sd_ble_uuid_vs_add (&base_rx, &p_cus->uuid_type); //changing the base for the first characteristic
if (err_code != NRF_SUCCESS) {
return err_code;
}
err_code = addRXChar(p_cus, p_cus_init);
return err_code;
}
//update values to application on device
ret_code_t updateTX (ble_cus_t * p_cus, uint8_t custom_value[5])
{
NRF_LOG_INFO ("In ble_cus_custom_value_update. \r\n");
if (p_cus == NULL) {
return NRF_ERROR_NULL;
}
ret_code_t err_code = NRF_SUCCESS;
ble_gatts_value_t gatts_value;
// Initialize value struct.
memset (&gatts_value, 0, sizeof (gatts_value));
gatts_value.len = (sizeof(uint8_t)*5);
gatts_value.offset = 0;
gatts_value.p_value = custom_value;
// Update database.
err_code = sd_ble_gatts_value_set (p_cus->conn_handle,
p_cus->tx_handles.value_handle,
&gatts_value);
if (err_code != NRF_SUCCESS) {
return err_code;
}
// Send value if connected and notifying.
NRF_LOG_INFO("h2 %d h3 %d\n",custom_value[2],custom_value[3]);
if ((p_cus->conn_handle != BLE_CONN_HANDLE_INVALID)) {
NRF_LOG_INFO("t1");
ble_gatts_hvx_params_t hvx_params;
memset (&hvx_params, 0, sizeof (hvx_params));
hvx_params.handle =
p_cus->tx_handles.value_handle;
hvx_params.type = BLE_GATT_HVX_NOTIFICATION;
hvx_params.offset = gatts_value.offset;
hvx_params.p_len = &gatts_value.len;
hvx_params.p_data = gatts_value.p_value;
err_code =
sd_ble_gatts_hvx (p_cus->conn_handle, &hvx_params);
NRF_LOG_INFO ("sd_ble_gatts_hvx result: %x. \r\n", err_code);
} else {
NRF_LOG_INFO("t2");
err_code = NRF_ERROR_INVALID_STATE;
}
return err_code;
}
/*
*The start of the SALSProbe in NRF style
*/
#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_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 "ble_lbs.h"
#include "nrf_ble_gatt.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "ble_aph_service.h"
/*message*/
#define PACKET_START 0X1B
#define PACKET_END 0X00
#define MSG_TYPE_VALUE 0X01
#define PACKET_LENGTH 5
/*
* packet to send.
* first bit is to start \B1
*second bit is what is in the packet
* 3rd and 4th bit is the payload
*fifth bit is the end to say we got the whole thing.
*/
#define TEST_SIGNAL
#ifdef TEST_SIGNAL
uint16_t value = 0;
bool up = true;
uint16_t testValue (uint16_t v)
{
NRF_LOG_INFO ("test value %d", v);
if (up == true) {
if (v > 1022)
up = false;
return (++v);
} else {
if (v < 2)
up = true;
return (--v);
}
}
#endif
#define DEVICE_NAME "SALS P1"
#define MANUFACTURER_NAME "APH"
#define SENSOR_INTERVAL APP_TIMER_TICKS(50) //1000ms
#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 32 /**< The advertising interval (in units of 0.625 ms; this value corresponds to 40 ms). */
#define APP_ADV_DURATION 0
//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(400, UNIT_1_25_MS) /**< Minimum acceptable connection interval (0.4 seconds). */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(650, UNIT_1_25_MS) /**< Maximum acceptable connection interval (0.65 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(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 DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
BLE_CUS_DEF (m_cus);
NRF_BLE_GATT_DEF (m_gatt); /**< GATT module instance. */
APP_TIMER_DEF (m_sensor_timer_id); /**< Sensor timer. */
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. */
/**@brief Struct that contains pointers to the encoded advertising data. */
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
}
};
/**@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 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;
static ble_uuid_t adv_uuids[] = {
{APH_SERVICE_UUID, BLE_UUID_TYPE_VENDOR_BEGIN}
};
// 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_FLAG_BR_EDR_NOT_SUPPORTED ;
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);
}
static uint8_t msg_packet[PACKET_LENGTH] = { 0, 0, 0, 0, 0 };
//send code
void
sendMsgBlue (uint16_t value)
{
NRF_LOG_INFO ("value %d ", value);
ret_code_t err_code;
msg_packet[0] = PACKET_START;
msg_packet[1] = MSG_TYPE_VALUE;
msg_packet[2] = value & 0xff; //LOW BIT
msg_packet[3] = (value >> 8); //HIGH BIT
msg_packet[4] = PACKET_END;
err_code = updateTX (&m_cus, msg_packet);
APP_ERROR_CHECK (err_code);
}
//sensor timout handler
static void
sensor_timeout_handler (void *p_context)
{
NRF_LOG_INFO ("sensor timout handler");
static bool sensor = false;
UNUSED_PARAMETER (p_context);
sensor = !sensor;
value = testValue (value);
sendMsgBlue (value);
}
/**@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);
//sensor check timer
err_code =
app_timer_create (&m_sensor_timer_id,
APP_TIMER_MODE_REPEATED,
sensor_timeout_handler);
APP_ERROR_CHECK (err_code);
}
/**@brief Function for handling the Custom Service Service events.
* @details This function will be called for all Custom Service events which are passed to
* the application.
* @param[in] p_cus_service Custom Service structure.
* @param[in] p_evt Event received from the Custom Service.
*/
static void
on_cus_evt (ble_cus_t * p_cus_service,
ble_cus_evt_t * p_evt)
{
NRF_LOG_INFO("in on_cus_evt %d",p_evt->evt_type);
ret_code_t err_code;
switch (p_evt->evt_type) {
case BLE_CUS_EVT_NOTIFICATION_ENABLED:
err_code =
app_timer_start (m_sensor_timer_id, SENSOR_INTERVAL, NULL);
APP_ERROR_CHECK (err_code);
break;
case BLE_CUS_EVT_NOTIFICATION_DISABLED:
err_code = app_timer_stop (m_sensor_timer_id);
APP_ERROR_CHECK (err_code);
break;
case BLE_CUS_EVT_CONNECTED:
err_code = app_timer_start (m_sensor_timer_id, SENSOR_INTERVAL, NULL);
APP_ERROR_CHECK (err_code);
break;
case BLE_CUS_EVT_DISCONNECTED:
err_code = app_timer_stop (m_sensor_timer_id);
APP_ERROR_CHECK (err_code);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for initializing services that will be used by the application.
*/
static void
services_init (void)
{
ret_code_t err_code;
NRF_LOG_INFO ("SErvices init");
//create cus structure
ble_cus_init_t cus_init;
// Initialize CUS Service init structure to zero.
memset (&cus_init, 0, sizeof (cus_init));
BLE_GAP_CONN_SEC_MODE_SET_OPEN (&cus_init.
custom_value_char_attr_md.
cccd_write_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN (&cus_init.
custom_value_char_attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN (&cus_init.
custom_value_char_attr_md.write_perm);
err_code = ble_cus_init (&m_cus, &cus_init);
APP_ERROR_CHECK (err_code);
cus_init.evt_handler = on_cus_evt;
}
/**@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);
}
/**@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)
{
NRF_LOG_INFO("ble_event\n");
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 =
app_timer_start (m_sensor_timer_id, SENSOR_INTERVAL, NULL);
APP_ERROR_CHECK (err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO ("Disconnected");
err_code = app_timer_stop (m_sensor_timer_id);
APP_ERROR_CHECK (err_code);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
advertising_start ();
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;
}
}
/**@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);
}
// initialize the 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 application main entry.
*/
int
main (void)
{
// Initialize.
log_init ();
NRF_LOG_INFO ("log init init");
timers_init ();
power_management_init ();
ble_stack_init ();
gap_params_init ();
gatt_init ();
services_init ();
advertising_init ();
conn_params_init ();
// Start execution.
NRF_LOG_INFO ("SALSProbe started");
advertising_start ();
// Enter main loop.
for (;;) {
idle_state_handle ();
}
}
I thought I had everything right. I do not have the code to do the Saadc because I didn't want the extra problems while testing the connection. I have wrote a test function to imulate the type of data being sent in a 5 byte packet. The function in main.c testValue creates the value that would normally come from an SAADC value. it should go up and down between 0 and 1024. It is just there to test sending values to the IOS device. I have watched it work without ble so I know that part is working.
I am using a RayTac mdbt42q nrf 52832 board. which works a lot like all the nordic test boards.
I wrote an earlier message before I learned as much as I have so I am starting over. Everything seems to be working except when I do updateTX which is the code to write from the Ble to the IOS device it errors saying I don't have a valid connection.
The device shows up in the list of devices on my app. When I press to connect it acts like it is connecting then it fails and I think it is timing out because the board does not seem to be getting a connect message. I have watched with logs and see nothing.
I have tried this starting with the template code and with the blinky code. This started as the blinky code because it was more simplified at the start. It has two characteristics with 5 bytes each.
When I start with the blinky code the connection seems to work until I take out the queue code and the button code. I don't need either of those. It actually works until I switch to my service so the problem may be in my service but everything seems to init right. The values look right, and there are no memory errors.
Again I am fully willing to send a fully compilable version if someone has time to take a look at it with nrf connect. I will mention that I am blind and while the new release of nrf connect works better for me I am not able to get any information out of it that helps. It also errors in connecting but it shows my service and characteristics I think.
I am hoping someone can just look at my service initalization and just see the problem. Of course that is wishful thinking. Any help is greatlly appriciated. I am also willing to connect by skype and work that way if needed.
