sensepi_ble.c

/*
 *  sensepi_ble.c : BLE Support file for SensePi application 
 *  Copyright (C) 2019  Appiko
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "nrf_nvic.h"
#include "ble.h"
#include "nrf_sdm.h"
#include "app_error.h"
#include "boards.h"
#include "stddef.h"
#include "common_util.h"
#include "nrf_util.h"
#include "sensepi_ble.h"
#include "log.h"
#include "evt_sd_handler.h"
#include "string.h"

#define DEVICE_NAME_CHAR           'S','e','n','s','e','P','i'
const uint8_t device_name[] = { DEVICE_NAME_CHAR };


#define SENSEPI_UUID_COMPLETE        0x0a, 0xde, 0xfb, 0x07, 0x74, 0x83, 0x66, 0xb0, 0x0d, 0x48, 0xf5, 0x07, 0x50, 0xdc, 0x73, 0x3c

#define SENSEPI_UUID_SERVICE         0xdc50

#define SENSEPI_UUID_SYSINFO         0xdc51

#define SENSEPI_UUID_CONFIG          0xdc52

#define ADVERTISING_INTERVAL       MSEC_TO_UNITS(500, UNIT_0_625_MS)

#define MIN_CONN_INTERVAL          MSEC_TO_UNITS(200, UNIT_1_25_MS)

#define MAX_CONN_INTERVAL          MSEC_TO_UNITS(500, UNIT_1_25_MS)

#define SLAVE_LATENCY              0

#define CONN_SUP_TIMEOUT           MSEC_TO_UNITS(4000, UNIT_10_MS)




uint8_t h_adv;

uint16_t h_conn;

uint16_t h_sensepi_service;

ble_gatts_char_handles_t h_sysinfo_char;

ble_gatts_char_handles_t h_config_char;

void (* sensepi_ble_sd_evt)(ble_evt_t * evt);
void (* sensepi_config_t_update)(sensepi_config_t * cfg);

sensepi_sysinfo curr_sysinfo;

void SWI1_IRQHandler(void)
{
//    log_printf("radio going down\n");
}

static void ble_evt_handler(ble_evt_t * evt)
{
    uint32_t err_code;
    switch(evt->header.evt_id)
    {
    case BLE_GAP_EVT_CONNECTED:
        h_conn = evt->evt.gap_evt.conn_handle;
        break;
    case BLE_GAP_EVT_DISCONNECTED:
        h_conn = BLE_CONN_HANDLE_INVALID;
        break;
    case BLE_GATTS_EVT_WRITE:
    {
        sensepi_config_t * config =
                (sensepi_config_t *) evt->evt.gatts_evt.params.write.data;
        sensepi_config_t_update(config);
        break;
    }
    case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST:
    {
        uint16_t mtu_val = BLE_GATT_ATT_MTU_DEFAULT;
        err_code = sd_ble_gatts_exchange_mtu_reply(h_conn, mtu_val);
        APP_ERROR_CHECK(err_code);
        break;
    }
    case BLE_GAP_EVT_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(h_conn, &phys);
        APP_ERROR_CHECK(err_code);
        break;
    }
    case BLE_GAP_EVT_PHY_UPDATE:
    {
        log_printf("Tx_get : %x  Rx_get : %x  Status : %x\n",
                   evt->evt.gap_evt.params.phy_update.tx_phy, 
                   evt->evt.gap_evt.params.phy_update.rx_phy,
                   evt->evt.gap_evt.params.phy_update.status);
        break;
    }
    }

    sensepi_ble_sd_evt(evt);
}

static void soc_evt_handler(uint32_t evt_id)
{
    log_printf("soc evt %x\n", evt_id);
}

void sensepi_ble_init(void (*ble_sd_evt)(ble_evt_t * evt),
        void (* config_update)(sensepi_config_t * cfg))
{
    sensepi_ble_sd_evt = ble_sd_evt;
    sensepi_config_t_update = config_update;
}

void sensepi_ble_disconn(void)
{
    if(h_conn != BLE_CONN_HANDLE_INVALID)
    {
        uint32_t err_code;
        err_code = sd_ble_gap_disconnect(h_conn,
                BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
        APP_ERROR_CHECK(err_code);
    }
}

void sensepi_ble_update_sysinfo(sensepi_sysinfo * sysinfo)
{
    uint32_t err_code;
    ble_gatts_value_t val =
    {
        .len = sizeof(sensepi_sysinfo),
        .offset = 0,
        .p_value = (uint8_t *) sysinfo
    };
    err_code = sd_ble_gatts_value_set(h_conn,
            h_sysinfo_char.value_handle, &val);
    APP_ERROR_CHECK(err_code);
}

void sensepi_ble_update_config(sensepi_config_t * config)
{
    uint32_t err_code;
    ble_gatts_value_t val =
    {
        .len = sizeof(sensepi_config_t),
        .offset = 0,
        .p_value = (uint8_t *) config
    };
    err_code = sd_ble_gatts_value_set(h_conn,
            h_config_char.value_handle, &val);
    APP_ERROR_CHECK(err_code);
}


void sensepi_ble_stack_init(void)
{
    uint32_t err_code;
    const nrf_clock_lf_cfg_t cfg = BOARD_LFCLKSRC_STRUCT;

    err_code = sd_softdevice_enable(&cfg, app_error_fault_handler);
    APP_ERROR_CHECK(err_code);

    uint32_t app_ram_start = 0x20001c00;
    log_printf("Init %x", app_ram_start);
    err_code = sd_ble_enable(&app_ram_start);
    log_printf(" RAM needed %x\n", app_ram_start);
    APP_ERROR_CHECK(err_code);

    evt_sd_handler_init(ble_evt_handler, soc_evt_handler);

    //So that the application wakes up after every radio activity
    err_code = sd_radio_notification_cfg_set(
            NRF_RADIO_NOTIFICATION_TYPE_INT_ON_INACTIVE,
            NRF_RADIO_NOTIFICATION_DISTANCE_NONE);
    APP_ERROR_CHECK(err_code);

    // Initialize Radio Notification software interrupt
    err_code = sd_nvic_ClearPendingIRQ(SWI1_IRQn);
    APP_ERROR_CHECK(err_code);

    err_code = sd_nvic_SetPriority(SWI1_IRQn, APP_IRQ_PRIORITY_LOWEST);
    APP_ERROR_CHECK(err_code);

    err_code = sd_nvic_EnableIRQ(SWI1_IRQn);
    APP_ERROR_CHECK(err_code);

    h_conn = BLE_CONN_HANDLE_INVALID;
}

void sensepi_ble_service_init(void)
{
    uint32_t   err_code;
    ble_uuid_t ble_uuid;
    uint8_t uuid_type;

    /**** Create the Sense Pi service *****/
    ble_uuid128_t base_uuid = {{SENSEPI_UUID_COMPLETE}};
    err_code = sd_ble_uuid_vs_add(&base_uuid, &uuid_type);
    APP_ERROR_CHECK(err_code);

    ble_uuid.type = uuid_type;
    ble_uuid.uuid = SENSEPI_UUID_SERVICE;

    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
            &ble_uuid, &h_sensepi_service);
    APP_ERROR_CHECK(err_code);

    /**** Create the read-only characteristic *****/
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_t attr_char_value;
    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.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;

    ble_uuid.type = uuid_type;
    ble_uuid.uuid = (SENSEPI_UUID_SYSINFO);

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

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);
    attr_md.vloc = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth = 0;
    attr_md.wr_auth = 0;
    attr_md.vlen = 0;

    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(sensepi_sysinfo);
    attr_char_value.init_offs = 0;
    attr_char_value.max_len = sizeof(sensepi_sysinfo);
    attr_char_value.p_value = NULL;

    err_code = sd_ble_gatts_characteristic_add(
        h_sensepi_service, &char_md, &attr_char_value, &h_sysinfo_char);
    APP_ERROR_CHECK(err_code);

    /**** Create the read-write characterisitc *****/
    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.read = 1;
    char_md.char_props.write = 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;

    ble_uuid.type = uuid_type;
    ble_uuid.uuid = (SENSEPI_UUID_CONFIG);

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

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm);
    attr_md.vloc = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth = 0;
    attr_md.wr_auth = 0;
    attr_md.vlen = 0;

    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(sensepi_config_t);
    attr_char_value.init_offs = 0;
    attr_char_value.max_len = sizeof(sensepi_config_t);
    attr_char_value.p_value = NULL;

    err_code = sd_ble_gatts_characteristic_add(
        h_sensepi_service, &char_md, &attr_char_value,&h_config_char);
    APP_ERROR_CHECK(err_code);
}

void sensepi_ble_gap_params_init(void)
{
    uint32_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, sizeof(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);
}

void sensepi_ble_adv_init(sensepi_ble_adv_data_t * sensepi_ble_adv_data)
{
    h_adv = BLE_GAP_ADV_SET_HANDLE_NOT_SET;
    uint32_t err_code;
    
    ble_gap_adv_data_t adv_payload;

    adv_payload.adv_data.p_data = sensepi_ble_adv_data->adv_data;
    adv_payload.adv_data.len = sensepi_ble_adv_data->adv_len;

    adv_payload.scan_rsp_data.p_data = sensepi_ble_adv_data->scan_rsp_data;
    adv_payload.scan_rsp_data.len = sensepi_ble_adv_data->scan_rsp_len;

    ble_gap_adv_params_t adv_params;

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

    //Set channel 37, 38 and 39 as advertising channels
    memset(adv_params.channel_mask, 0, 5);

    //Set the advertising to timeout in 180s
    adv_params.duration = BLE_GAP_ADV_TIMEOUT_LIMITED_MAX;

    //Any device can scan request and connect
    adv_params.filter_policy = BLE_GAP_ADV_FP_ANY;

    //Period between sending advertising packets
    adv_params.interval = ADVERTISING_INTERVAL;

    //Use 1Mbps physical layer to be backward compatible
    adv_params.primary_phy = BLE_GAP_PHY_1MBPS;

    //The advertisement would be unidirected connectable and scannable
    adv_params.properties.type =
            BLE_GAP_ADV_TYPE_CONNECTABLE_SCANNABLE_UNDIRECTED;

    adv_params.p_peer_addr = NULL;
    adv_params.scan_req_notification = 0;

    err_code = sd_ble_gap_adv_set_configure(&h_adv,
            (ble_gap_adv_data_t const *)&adv_payload,
            (ble_gap_adv_params_t const *) &adv_params);
    APP_ERROR_CHECK(err_code);
}

void sensepi_ble_adv_start(void)
{
    uint32_t err_code;
    err_code = sd_ble_gap_adv_start(h_adv, BLE_CONN_CFG_TAG_DEFAULT);
    APP_ERROR_CHECK(err_code);
}