rf_rx_ble.c

/*
 *  rf_rx_ble.c : BLE Support file for RF Receiver 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 "rf_rx_ble.h"

#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 "log.h"
#include "evt_sd_handler.h"
#include "string.h"
#include "hal_nop_delay.h"

#define DEVICE_NAME_CHAR           'B','T'
const uint8_t device_name[] = { DEVICE_NAME_CHAR };


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

#define BTDONGLE_UUID_SERVICE         0xdc70

#define BTDONGLE_UUID_SYSINFO         0xdc71

#define BTDONGLE_UUID_CONFIG          0xdc72

#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)


#define APP_ADV_DATA   {                                        \
                       0x02, BLE_GAP_AD_TYPE_FLAGS, BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE,    \
                       sizeof(device_name) + 1, BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME, DEVICE_NAME_CHAR,   \
                       0x11, BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_COMPLETE, BTDONGLE_UUID_COMPLETE     \
                   }

#define APP_SCAN_RSP_DATA  {                                        \
                           0x02, BLE_GAP_AD_TYPE_TX_POWER_LEVEL, 0   ,     \
                           0x0A, BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME,  \
                           'B', 'T', ' ', 'D', 'o', 'n' , 'g', 'l', 'e',   \
                           0x04, BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA, 0 ,  0 , 0 \
                           }


uint8_t adv_data[] =  APP_ADV_DATA ;
uint8_t h_adv;

uint16_t h_conn;

uint16_t h_rf_rx_service;

ble_gatts_char_handles_t h_status_byte;

//ble_gatts_char_handles_t h_config_char;


volatile bool bluetooth_status = false;
void SWI1_IRQHandler(void)
{
//    log_printf("radio going down\n");
}

void (* connected_callback) (void);

static void ble_evt_handler(ble_evt_t * evt)
{
    uint32_t err_code;
    log_printf("BLE Event : %d\n", evt->header.evt_id);
    switch(evt->header.evt_id)
    {
    case BLE_GAP_EVT_ADV_SET_TERMINATED:
        break;
    case BLE_GAP_EVT_CONN_PARAM_UPDATE:
        break;
        
    case BLE_GAP_EVT_CONNECTED:
        h_conn = evt->evt.gap_evt.conn_handle;
        connected_callback ();
        break;
    case BLE_GAP_EVT_DISCONNECTED:
        h_conn = BLE_CONN_HANDLE_INVALID;
        bluetooth_status = false;
        rf_rx_ble_adv_start(connected_callback);

//        sd_softdevice_disable ();
        break;
    case BLE_GATTS_EVT_WRITE:
        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;
    }
    }

}

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

void rf_rx_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 rf_rx_ble_stack_init()
{
    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 rf_rx_ble_service_init(void)
{
    uint32_t   err_code;
    ble_uuid_t ble_uuid;
    uint8_t uuid_type;

    /**** Create the BT Dongle service *****/
    ble_uuid128_t base_uuid = {{BTDONGLE_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 = BTDONGLE_UUID_SERVICE;

    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
            &ble_uuid, &h_rf_rx_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;
//    ble_gatts_attr_md_t cccd_md;

    memset(&char_md, 0, sizeof(char_md));
//    memset(&cccd_md, 0, sizeof(cccd_md));

//    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
//    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);    
//    cccd_md.vloc = BLE_GATTS_VLOC_STACK;

    char_md.char_props.read = 1;
    char_md.char_props.write = 0;
//    char_md.char_props.notify = 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 = &cccd_md;
    char_md.p_cccd_md = NULL;
    char_md.p_sccd_md = NULL;

    ble_uuid.type = uuid_type;
    ble_uuid.uuid = (BTDONGLE_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(mod_ble_data_t);
    attr_char_value.init_offs = 0;
    attr_char_value.max_len = sizeof(mod_ble_data_t);
    attr_char_value.p_value = NULL;

    err_code = sd_ble_gatts_characteristic_add(
        h_rf_rx_service, &char_md, &attr_char_value, &h_status_byte);
    APP_ERROR_CHECK(err_code);

}

void rf_rx_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 rf_rx_ble_adv_init()
{
    h_adv = BLE_GAP_ADV_SET_HANDLE_NOT_SET;
    uint8_t scn_rsp_data[] = APP_SCAN_RSP_DATA;
    uint32_t err_code;
    ble_gap_adv_data_t adv_payload;
    

    adv_payload.adv_data.p_data = adv_data;
    adv_payload.adv_data.len = sizeof(adv_data);

    adv_payload.scan_rsp_data.p_data = scn_rsp_data;
    adv_payload.scan_rsp_data.len = sizeof(scn_rsp_data);
    
    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_GENERAL_UNLIMITED;

    //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 rf_rx_ble_adv_start(void (*conn_func) (void))
{
    connected_callback = conn_func;
    bluetooth_status = true;
    uint32_t err_code;
    err_code = sd_ble_gap_adv_start(h_adv, BLE_CONN_CFG_TAG_DEFAULT);
    APP_ERROR_CHECK(err_code);
}

bool rf_rx_is_bt_on ()
{
    return bluetooth_status;
}

void rf_rx_ble_update_status_byte (mod_ble_data_t * status_byte)
{
    uint32_t err_code;
//    uint16_t len = sizeof(mod_ble_data_t);
    ble_gatts_value_t val =
    {
        .len = sizeof(mod_ble_data_t),
        .offset = 0,
        .p_value =(uint8_t *) status_byte
    };
    err_code = sd_ble_gatts_value_set(h_conn,
            h_status_byte.value_handle, &val);
    APP_ERROR_CHECK(err_code);
    
//    ble_gatts_hvx_params_t params = 
//    {
//        .p_len = &len,
//        .p_data = (uint8_t *) status_byte,
//        .type = BLE_GATT_HVX_NOTIFICATION,
//        .handle = h_status_byte.value_handle,
//    };
//    
//    err_code = sd_ble_gatts_hvx (h_conn, &params);
//    APP_ERROR_CHECK(err_code);
}