File content as of revision 10:ee3a359f7d3f:

//=========Header (PR)
// blePRv04, Initial: 20141210 Paul Russell (mbed user: prussell = PR)
// This sample includes code from several projects found on http://developer.mbed.org, including but not limited to:
//    - http://developer.mbed.org/users/jksoft/code/BLE_RCBController/   (Setting up a custom Service/Characteristic)
//    - http://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_HeartRate/
//    - https://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_LoopbackUART/
//    - https://developer.mbed.org/users/takafuminaka/code/BLE_HTM_by_InTempSensr/
//    - https://developer.mbed.org/users/garimagupta002/notebook/ble-uart-lcd-demo/  (Advertise UUID16+UUID128)
//    - http://developer.mbed.org/teams/UCL-IoT/code/BLE_LED_Controller/             (With matching Android App, uses BLE-UART)
//    - https://developer.mbed.org/users/todotani/code/BLE_Health_Thermometer2-010/wiki/BLE_Health_Thermometer2-010 //Temperature handles
//    - 
//    - miscellaneous adopted from more samples...
// Reference:
//    - http://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_API/
//    - Reference: http://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_API/docs/tip/
//    - Reference: http://developer.mbed.org/teams/Bluetooth-Low-Energy/
// Warnings:
//    - As of 20141210 it is necessary to use Android App [nRF-Master Control Panel] to ensure any previous connected 
//      code on mkit is properly Disconnected before trying to connect other Android nRF Apps (nRFToolbox, nRF UART 2.0, etc.).
//      As UART device doesn't offer disconnect you may need to load a 3rf sample, then connect, then discoonect, to clear the link.
// Notes: 
//    - onDataSent() maybe only occuring when confirmed receive by phone, as onDataSent() didn't happen when phone moved out of range, and no onDataSent() with App nRF-MCP.
//    - onDisconnect(Reason:8) occured after ~20Tx with no onDataSent() after phone moved out of range, OnTimeout didn't occur at all.
// ToDo: and ToCheck:
//    - Handle All return codes for all functions not void, including BLE not BLE_ERROR_NONE, as a minimum output some debug and log event in non-volatile memory for diagnostics.
//    - Re-check where voltatile needed
//    - Evaluate setting: IS_SRVC_CHANGED_CHARACT_PRESENT, see: https://devzone.nordicsemi.com/question/22751/nrftoobox-on-android-not-recognizing-changes-in-application-type-running-on-nordic-pcb/?answer=23097#post-id-23097
//    - delete all code with "//x " prefix as that was just for notes and doesn't actually work
//    - change all valid code temporarily commended to "//a " prefix to indicate alternnative is valid code
//==========End of PR's Header

//==========Historic Licencing from original imported sample from mbed website [BLE_HeartRate] ==========
//From: http://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_HeartRate/
/* mbed Microcontroller Library
 * Copyright (c) 2006-2013 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. */
//==========end of Historic Licencing ==========


//==========Compile Options==========
#define ENABLE_SerialUSB_DEBUG_CONSOLE                  1  //PR: Enable Debug on mbed's USB Serial Debug, Setup: Serial 9600,8,N,1,NoFlowControl (TeraTerm: http://en.sourceforge.jp/projects/ttssh2/releases/)
#define UPDATE_PARAMS_FOR_LONGER_CONNECTION_INTERVAL    0  //PR: Option to slow the connection intervsal possibly saving power (After Connected)

//==========Includes==========
#include "mbed.h"                       // mbed
#include "BLEDevice.h"                  // BLE
#include "nrf_soc.h"                    // nRF Internal Temperature Sensor

//Services
#include "BatteryService.h"
#include "DeviceInformationService.h"
#include "HealthThermometerService.h"   
#include "HeartRateService.h"
#include "LinkLossService.h"            //TODO: How support this?
//#include "DFUService"                 //TODO: DFU and FOTA Support
//#include "UARTService.h"              //TODO: Add a UART Channel for streaming data like logs?

//==========Debug Console==========
#if ENABLE_SerialUSB_DEBUG_CONSOLE
    //Restart TeraTerm just before Pressing Reset on mbed, Default:9600-8N1(No Flow Control)
    //Using default baud rate to avoid issues with DEBUG in a constructor being at default baud rate before main()
    Serial  debug_serial(USBTX, USBRX); //PR: DebugSerialOverMbedUSB
    #define DEBUG(...) { debug_serial.printf(__VA_ARGS__); }
#else
    #define DEBUG(...) //Do Nothing, DEBUG() lines are ignored
#endif 

//========== This Section is to Create Debug output showing variable prep before main() ==========
bool u8_prep_dummy(void) {
    DEBUG("\n\nBLE: ____Prep Memory____\n"); //May comment this out if none of the following Objects/Classes call initiator functions with debug
    return true;
}
const bool bPrep = u8_prep_dummy();

//==========LEDs==========
//DigitalOut  out_led1(LED1);             //PR: Firmware heartbeat
//DigitalOut  out_led2(LED2);             //PR: Firmware heartbeat
PwmOut      pwm_led1(LED1);             //PR: Firmware Life Indicator 
PwmOut      pwm_led2(LED2);             //TODO: Controlled by App 
float       f_led1level = 0.1;          //Initial Brightness (Typically 0.0~0.5)
float       f_led2level = 0.1;          //Initial Brightness (Typically 0.0~0.5)

//==========BLE==========
const static char     pcDeviceName[]    = "bleIO"; //PR: Why can App nRF-MCP modify this even though flagged as Const, maybe only temporary mod till App restarts?
BLEDevice   ble;
//Pointers to services for accesses outside main()
    HealthThermometerService    *pServiceHTM;       //tempChar.getValueAttribute().getHandle() 
    BatteryService              *pServiceBattery;   //battLevel.getValueAttribute().getHandle()
    HeartRateService            *pServiceHRM;
    DeviceInformationService    *pServiceDeviceInfo;
    LinkLossService             *pServiceLinkLoss;
    //x DFUService                *pServiceDFU;
    //x UARTService               *pServiceUART;      //FromApp: pServiceUART->getTXCharacteristicHandle(); //ToApp: ble.updateCharacteristicValue(pServiceUART->getRXCharacteristicHandle(), pData, uLen);
    //x bleIOService              *pServiceIO;

//==========UUID==========
//UUID Info:
// 20141213 From https://developer.bluetooth.org/community/lists/community%20discussion/flat.aspx?rootfolder=/community/lists/community+discussion/16+bit+uuid+vs.+128+uuid&folderctid=0x01200200e2f0e56e3d53004dba96bdf0c357551f
 /*     All the custom GATT based services and characteristics must use a 128 bit UUID. 
        The Bluetooth_Base_UUID is: 00000000-0000-1000-8000 00805F9B34FB. 
            All the 16-bit Attribute UUIDs defined in the adopted specifications use the above base. 
        Generating a 128 bit UUID for custom profiles: For the 128 bit UUID, please refer to The ITU-T Rec. X.667. 
        You can download a free copy of ITU-T Rec. X.667 from http://www.itu.int/ITU-T/studygroups/com17/oid/X.667-E.pdf. 
        In addition if you go to http://www.itu.int/ITU-T/asn1/uuid.html, you can generate a unique 128-bit UUID. 
        Latency: Refer to Core Spec V4.0, Vol 3, Part F - 3.3.1, which is "Ready by Type Request". 
        If you look at the PDU, you have to send 2 bytes UUID for adopted profiles and 16 bytes UUID for custom profiles. 
        There is additional 14 extra bytes over head for the custom profiles for "Ready By Type Request Method" 
        Note: All attribute types are effectively compared as 128-bit UUIDs, even if a 16-bit UUID is provided in this request or defined for an attribute. (See Section 3.2.1.) 
        A suggestive alternative will be to use a notification method, (see 3.4.7.1), where you don't need the 128 bit UUID or the indication method (see 3.4.7.2)  */
// 16bit UUID uses: 128bit base(32 hex digits): 0000****-0000-1000-8000 00805F9B34FB (Careful to use unsigned to avoid negatives and overflows)
// 32bit UUID uses: 128bit base(32 hex digits): ********-0000-1000-8000 00805F9B34FB (Careful to use unsigned to avoid negatives and overflows)

//UUID128 List(Only a single UUID128 can fit in advertising)  
//a uint8_t puUUID128_Bluetooth_Base_Rev[16] = {0xFB,0x34,0x9B,0x5F,0x80,0, 0,0x80, 0,0x10, 0,0, 0x00,0x00, 0,0};//0000****-0000-1000-8000 00805F9B34FB, where ****==UUID16
//a uint8_t puUUID128_BatteryService[16]     = {0xFB,0x34,0x9B,0x5F,0x80,0, 0,0x80, 0,0x10, 0,0, 0x0F,0x18, 0,0};//0000****-0000-1000-8000 00805F9B34FB, where ****==0x180F

//a //UUID16 List - Advertising these required by App nRF-Toolbox:HRM&HTM // Keep list short so advertizing not too long.
/*static const uint16_t uuid16_list[]     = { //Service List (Pre-defined standard 16bit services)
    // *Order here doesn't affect order in nRF-MCP Discovery of Services
    //BLE_UUID_GAP  UUID_GENERIC_ACCESS                 //0x1800    //Included by Default, DeviceName, Appearance, PreferredConnectionParam
    //BLE_UUID_GATT UUID_GENERIC ATTRIBUTE              //0x1801    //Included by Default, ServiceChanged, 
    GattService::UUID_HEALTH_THERMOMETER_SERVICE,       //0x1809    //HTM (Might need to be first for nRF App)
    GattService::UUID_HEART_RATE_SERVICE,               //0x180D    //HRM, BodyLocation, ControlPoint
    GattService::UUID_DEVICE_INFORMATION_SERVICE,       //0x180A    //sManufacturer, sModelNumber, sSerialNumber, sHWver, sFWver, sSWver
    GattService::UUID_BATTERY_SERVICE,                  //0x180F    //BatteryLevel
    GattService::UUID_LINK_LOSS_SERVICE,                //0x1803    //LinkLoss
    //x GattService::UUID_DFU,                          //0x1530 - See UARTServiceShortUUID in BLE_API:DFUService.cpp  //
    //x GattService::UARTService,                       //0x0001~0x0003 - See DFUServiceShortUUID  in BLE_API:UARTService.cpp //
    //Possibly useful:
    //x GattService::UUID_ALERT_NOTIFICATION_SERVICE,     //0x1811
    //x GattService::UUID_CURRENT_TIME_SERVICE,           //0x1805
    //x GattService::UUID_HUMAN_INTERFACE_DEVICE_SERVICE, //0x1812
    //x GattService::UUID_IMMEDIATE_ALERT_SERVICE,        //0x1802
    //x GattService::UUID_PHONE_ALERT_STATUS_SERVICE,     //0x180E
    //x GattService::UUID_REFERENCE_TIME_UPDATE_SERVICE,  //0x1806
    //x GattService::UUID_SCAN_PARAMETERS_SERVICE,        //0x1813
};*/

//========== bleIO - A Custom Service for Handling IO with an App (GPIO,PWM,etc.)==========
//UUID128 List - Note only the single Service UUID128 can fit in the advertising  

// Custom UUID128 base for this service and its characteristics (from: http://www.itu.int/ITU-T/asn1/uuid.html)
    // **This is a temporary UUID for testing by anyone, should be replaced before proceeding to real product.**
    // Can check that UUID is correctly entered by viewing with Android App: nRF-Master Control panel
    // UUID128 can be generated using: http://www.itu.int/ITU-T/asn1/uuid.html
    // 20141218PR: [4d3281c0-86d1-11e4-b084-0002a5d5c51b] == OID[2.25.102612802202735078710424021169255859483]
    // Base UUID128 (1 digit modified):{0x4d,0x32,0x81,0xc0,0x86,0xd1,0x11,0xe4,0xb0,0x84,0x00,0x02,0xa5,0xd5,0xc5,0x1*};// NormalOrder
    uint8_t puUUID128_IOService[16]  = {0x4d,0x32,0x81,0xc0,0x86,0xd1,0x11,0xe4,0xb0,0x84,0x00,0x02,0xa5,0xd5,0xc5,0x10};// Service UUID
    uint8_t puUUID128_IOAdvertise[16]= {0x10,0xc5,0xd5,0xa5,0x02,0x00,0x84,0xb0,0xe4,0x11,0xd1,0x86,0xc0,0x81,0x32,0x4d};// Advertising Service UUID (=FlippedOrder)
    // Characteristic UUID: Initially using generic blocks of IO data that may be manually dividied up into Buttons, LEDs, PWM, ADC, etc.
    uint8_t puUUID128_IOw8[16]       = {0x4d,0x32,0x81,0xc0,0x86,0xd1,0x11,0xe4,0xb0,0x84,0x00,0x02,0xa5,0xd5,0xc5,0x11};// Write[8byte]  to mbed from phone
    uint8_t puUUID128_IOr4[16]       = {0x4d,0x32,0x81,0xc0,0x86,0xd1,0x11,0xe4,0xb0,0x84,0x00,0x02,0xa5,0xd5,0xc5,0x12};// Read[4byte]   from mbed to phone
    uint8_t puUUID128_IOn4[16]       = {0x4d,0x32,0x81,0xc0,0x86,0xd1,0x11,0xe4,0xb0,0x84,0x00,0x02,0xa5,0xd5,0xc5,0x13};// Notify[4byte] from mbed to phone 
    // Alternately can have a characterostic for each discrete item, such as:
    //a uint8_t puUUID128_bleConfig32[16] = {0x1X,0xc5,0xd5,0xa5,0x02,0x00,0x84,0xb0,0xe4,0x11,0xd1,0x86,0xc0,0x81,0x32,0x4d};// Configuration 32bits
    //a uint8_t puUUID128_bleOut1[16]     = {0x1X,0xc5,0xd5,0xa5,0x02,0x00,0x84,0xb0,0xe4,0x11,0xd1,0x86,0xc0,0x81,0x32,0x4d};// Output 1bit
    //a uint8_t puUUID128_bleOutPWM100[16]= {0x1X,0xc5,0xd5,0xa5,0x02,0x00,0x84,0xb0,0xe4,0x11,0xd1,0x86,0xc0,0x81,0x32,0x4d};// Output PWM (Range 0~100%)
    //a uint8_t puUUID128_bleOutPWM256[16]= {0x1X,0xc5,0xd5,0xa5,0x02,0x00,0x84,0xb0,0xe4,0x11,0xd1,0x86,0xc0,0x81,0x32,0x4d};// Output PWM (256 levels, 0~255)
    //a uint8_t puUUID128_bleIn1[16]      = {0x1X,0xc5,0xd5,0xa5,0x02,0x00,0x84,0xb0,0xe4,0x11,0xd1,0x86,0xc0,0x81,0x32,0x4d};// Input 1bit
    //a uint8_t puUUID128_bleInADC12[16]  = {0x1X,0xc5,0xd5,0xa5,0x02,0x00,0x84,0xb0,0xe4,0x11,0xd1,0x86,0xc0,0x81,0x32,0x4d};// Input ADC 12bit


/* Android:
        //bleIO Service and Characteristics
        attributes.put("4d3281c0-86d1-11e4-b084-0002a5d5c51b", "bleIO base");
        attributes.put("4d3281c0-86d1-11e4-b084-0002a5d5c510", "bleIO Service");
        attributes.put("4d3281c0-86d1-11e4-b084-0002a5d5c511", "bleIO w8");
        attributes.put("4d3281c0-86d1-11e4-b084-0002a5d5c512", "bleIO r4");
        attributes.put("4d3281c0-86d1-11e4-b084-0002a5d5c513", "bleIO n4");

        attributes.put("1bc5d5a5-0200-84b0-e411-d186c081324d", "bleIO rev base");
        attributes.put("10c5d5a5-0200-84b0-e411-d186c081324d", "bleIO rev Service");
        attributes.put("11c5d5a5-0200-84b0-e411-d186c081324d", "bleIO rev w8");
        attributes.put("12c5d5a5-0200-84b0-e411-d186c081324d", "bleIO rev r4");
        attributes.put("13c5d5a5-0200-84b0-e411-d186c081324d", "bleIO rev n4");
*/

    // Characteristic Value Storage (with Initial values, should match actual data type transferred, doesn't have to be byte array):
    uint8_t pIOw8[8] = {0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17};   //Value Storage for Characteristic Write8 
    uint8_t pIOr4[4] = {0x20,0x21,0x22,0x23};                       //Value Storage for Characteristic Read4 
    uint8_t pIOn4[4] = {0x30,0x31,0x32,0x33};                       //Value Storage for Characteristic Notify4 

    //x GattCharacteristic::GattAttribute *descriptors[]; //How Set Characteristic Descriptors? Maybe in the App is easier?

    //IO Characteristics: //GattCharacteristics xx(*UUID, *Payload=*Value, LenInit, LenMax, Properties)
    //GattCharacteristic  IOw8(puUUID128_IOw8, pIOw8, sizeof(pIOw8), sizeof(pIOw8), GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
    GattCharacteristic  IOw8(puUUID128_IOw8, pIOw8, sizeof(pIOw8), sizeof(pIOw8), GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);// Allow Host to read back last setting
    GattCharacteristic  IOr4(puUUID128_IOr4, pIOr4, sizeof(pIOr4), sizeof(pIOr4), GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ); // Host can manually request
    //GattCharacteristic  IOn4(puUUID128_IOn4, pIOn4, sizeof(pIOn4), sizeof(pIOn4), GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY);
    GattCharacteristic  IOn4(puUUID128_IOn4, pIOn4, sizeof(pIOn4), sizeof(pIOn4), GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY); // Host is notified of changes
    GattCharacteristic *pCustomCharacteristics[] = {&IOw8, &IOr4, &IOn4};//Table of Pointers to Characteristics

    //IO Service: //GattService::GattService(*UUID, *GattCharacteristics, (numCharacteristics) ) :
    GattService ServiceIO(puUUID128_IOService, pCustomCharacteristics, (sizeof(pCustomCharacteristics)/sizeof(pCustomCharacteristics[0])));
    GattService *pServiceIO= &ServiceIO;  // Pointer to Service

//a Option: Allow device to modify its settings and inform host (Typically the device wouldn't change a host only setting)
/*void vUpdate_IOw8(void)  // Handle in device changes to w8 characteristic 
{
    static uint8_t uw8; //Level: 0..2 
    switch(++uw8){
        case 2:         memcpy(pIOw8, "w2w2w2wc", sizeof(pIOw8)); DEBUG(" w8c"); break;
        case 1:         memcpy(pIOw8, "w1w1w1wb", sizeof(pIOw8)); DEBUG(" w8b"); break;
        default: uw8=0; memcpy(pIOw8, "w0w0w0wa", sizeof(pIOw8)); DEBUG(" w8a"); break;
    }
    //ble.updateCharacteristicValue(uint16_t handle, const uint8_t *value, uint16_t size, bool localOnly)
    ble.updateCharacteristicValue(IOw8.getValueHandle(), pIOw8, sizeof(pIOw8));
    //pServiceHRM->updateHeartRate( u8_hrm );// Update Characteristic so sent by BLE
}*/

void vUpdate_IOr4(void) // Handle in device changes to r4 characteristic
{
    static uint8_t ur4; //Level: 0..2 
    switch(++ur4){
        case 2:         memcpy(pIOr4, "r2r2", sizeof(pIOr4)); DEBUG(" r4c"); break;
        case 1:         memcpy(pIOr4, "r1r1", sizeof(pIOr4)); DEBUG(" r4b"); break;
        default: ur4=0; memcpy(pIOr4, "r0r0", sizeof(pIOr4)); DEBUG(" r4a"); break;
    }
    ble.updateCharacteristicValue(IOr4.getValueHandle(), pIOr4, sizeof(pIOr4));
}

void vUpdate_IOn4(void) // Handle in device changes to n4 characteristic
{
    static uint8_t un4; //Level: 0..2 
    switch(++un4){
        case 2:         memcpy(pIOn4, "n2n2", sizeof(pIOr4)); DEBUG(" n4c"); break;
        case 1:         memcpy(pIOn4, "n1n1", sizeof(pIOr4)); DEBUG(" n4b"); break;
        default: un4=0; memcpy(pIOn4, "n0n0", sizeof(pIOr4)); DEBUG(" n4a"); break;
    }
    ble.updateCharacteristicValue(IOn4.getValueHandle(), pIOn4, sizeof(pIOn4));
}

//==========Functions:BLE==========
void Callback_BLE_onTimeout(void)
{   //PR: Haven't seen this, even when phone moved out of range and events occur like OnDisconnect(Reason0x08) or LinkLoss
    DEBUG("\nBLEi: Callback_BLE_onTimeout()\n" ); 
  
    //DEBUG("\nBLE:Callback_BLE_onTimeout(), Restarting Advertising\n" );
    //ble.startAdvertising();
}

void Callback_BLE_onDisconnect(Gap::Handle_t tHandle, Gap::DisconnectionReason_t eReason)
{   //PR: onDisconnect(Reason:8) occured after ~20Tx with no onDataSent() after phone moved out of range

    //   REMOTE_USER_TERMINATED_CONNECTION = 0x13 = 19,
    //   LOCAL_HOST_TERMINATED_CONNECTION  = 0x16 = 22,
    //   CONN_INTERVAL_UNACCEPTABLE        = 0x3B = 59,
    DEBUG("\nBLEi: Callback_BLE_Disconnect(Handle:%d, eReason:0x%02x), Restarting Advertising\n",tHandle,eReason );//PR: Occurs properly when click disconnect in App nRFToolbox:HRM

    //DEBUG("Wait10sec...\n");wait(10.0); //PR: Optional to test effect on advertising
    ble.startAdvertising(); // restart advertising
}

void Callback_BLE_onConnect(Gap::Handle_t tHandle, Gap::addr_type_t ePeerAddrType, const Gap::address_t c6PeerAddr, const Gap::ConnectionParams_t *params)
{
    DEBUG("\nBLEi: Callback_BLE_Connect(Handle:%d, eType:%d, Add:%u ...)\n", tHandle, ePeerAddrType, c6PeerAddr);

    #if UPDATE_PARAMS_FOR_LONGER_CONNECTION_INTERVAL //PR: Adopted optional code never tested
        /* Updating connection parameters can be attempted only after a connection has been
         * established. Please note that the ble-Central is still the final arbiter for
         * the effective parameters; the peripheral can only hope that the request is
         * honored. Please also be mindful of the constraints that might be enforced by
         * the BLE stack on the underlying controller.*/
        #define MIN_CONN_INTERVAL 250  /**< Minimum connection interval (250 ms) */
        #define MAX_CONN_INTERVAL 350  /**< Maximum connection interval (350 ms). */
        #define CONN_SUP_TIMEOUT  6000 /**< Connection supervisory timeout (6 seconds). */
        #define SLAVE_LATENCY     4

        Gap::ConnectionParams_t tGap_conn_params;
        tGap_conn_params.minConnectionInterval        = Gap::MSEC_TO_GAP_DURATION_UNITS(MIN_CONN_INTERVAL);
        tGap_conn_params.maxConnectionInterval        = Gap::MSEC_TO_GAP_DURATION_UNITS(MAX_CONN_INTERVAL);
        tGap_conn_params.connectionSupervisionTimeout = Gap::MSEC_TO_GAP_DURATION_UNITS(CONN_SUP_TIMEOUT);
        tGap_conn_params.slaveLatency                 = SLAVE_LATENCY;
        ble.updateConnectionParams(tHandle, &tGap_conn_params);
    #endif // #if UPDATE_PARAMS_FOR_LONGER_CONNECTION_INTERVAL
}

static volatile bool bSent = false; //Volatile, don't optimize, changes under interrupt control
static volatile unsigned uSentBLE;
void Callback_BLE_onDataSent(unsigned uSent){
    uSentBLE=uSent;
    DEBUG("BLEi: SentI(%u)", uSentBLE); //TODO: PR: Why uSent always "1", expected it to match sent bytes length
    bSent = true;
    //FYI: App nRF-MCP doesn't cause onDataSent(), while App nRF-ToolBox:HRM does cause onDataSent()
    //TBD: onDataSent() maybe only occuring when confirmed receive by phone, as onDataSent() didn't happen when phone moved out of range.
}

void Callback_BLE_onDataWritten(const GattCharacteristicWriteCBParams *pParams)
{   // This occurs when use nRF-MCP to save a new Characteristic Value (SingleUpASrrowIcon) such as New Heart Rate Control Point (unsent if incorrect length)
    GattAttribute::Handle_t tHandle=pParams->charHandle;

    //Warning: *data may not be NULL terminated
    DEBUG("\nBLEi: Callback_BLE_onDataWritten(Handle:%d, eOp:%d, uOffset:%u uLen:%u Data0[0x%02x]=Data[%*s]\n", tHandle, pParams->op, pParams->offset, pParams->len, (char)(pParams->data[0]), pParams->len, pParams->data);

    /* //TODO: Add check of op type with tHandle check: switch(pParams->op){ case: GATTS_CHAR_OP_WRITE_REQ:}...  
        switch(pParams->op){
        case GATTS_CHAR_OP_INVALID:
        case GATTS_CHAR_OP_WRITE_REQ  
        case GATTS_CHAR_OP_WRITE_CMD
        case GATTS_CHAR_OP_SIGN_WRITE_CMD         //< Signed Write Command
        case GATTS_CHAR_OP_PREP_WRITE_REQ         //< Prepare Write Request
        case GATTS_CHAR_OP_EXEC_WRITE_REQ_CANCEL  //< Execute Write Request: Cancel all prepared writes
        case GATTS_CHAR_OP_EXEC_WRITE_REQ_NOW     //< Execute Write Request: Immediately execute all prepared writes
        default: Error?
    }*/

    //a These are equivalent ways of accessing characteristic handles:
    //a if (pParams->charHandle == IOw8.getValueHandle()) { DEBUG("\n\nOK tHandle %d\n\n", pParams->charHandle); }
    //a if (pParams->charHandle == ServiceIO.getCharacteristic(0)->getValueHandle()) { DEBUG("\n\nOK tHandle %d\n\n", pParams->charHandle); }
    //a if (IOw8.getValueHandle() == ServiceIO.getCharacteristic(0)->getValueHandle()) { DEBUG("\n\nOK tHandle equivalent %d\n\n", pParams->charHandle); }

    //Handle Changes to Service Characteristics:
    if(!ble.getGapState().connected){ //Ensure BLE still connected
        DEBUG("BLEi: Callback_BLE_onDataWritten() while disconnected!!");
    } else {
        uint16_t uLen; 
        if (tHandle == IOw8.getValueHandle()) {     // This occurs from Write by App nRF-MCP since has Write Property set
            ble.readCharacteristicValue(tHandle, pIOw8, &uLen);
            DEBUG("  IOw8[%d]:%02X %02X %02X %02X %02X %02X %02X %02X\n", uLen, pIOw8[0], pIOw8[1], pIOw8[2], pIOw8[3],pIOw8[4], pIOw8[5], pIOw8[6], pIOw8[7]);
            //TODO: Update Outputs
        //} else if (tHandle == IOr4.getValueHandle()) {
        //    ble.readCharacteristicValue(tHandle, pIOr4, &uLen);
        //    DEBUG("  IOr4[%d]:%02X %02X %02X %02X\n", uLen, pIOr4[0], pIOr4[1], pIOr4[2], pIOr4[3]);
        //    //TODO: Update Outputs
        //} else if (tHandle == IOn4.getValueHandle()) {
        //    ble.readCharacteristicValue(tHandle, pIOn4, &uLen);
        //    DEBUG("  IOn4[%d]:%02X %02X %02X %02X\n", uLen, pIOn4[0], pIOn4[1], pIOn4[2], pIOn4[3]);
        //    //TODO: Update Outputs
        } else {
            DEBUG("\n  Unknown onWrite(tHandle:%d)\n\n", tHandle);
        }
    }

    //LinkLoss:
    //x pServiceLinkLoss->setAlertLevel( AlertLevel_t  newLevel )  
    //x Triggered by BluetoothLEGatt sample changing Linkloss setting:
    //x Alert=1:  Debug=BLEi: Callback_BLE_onDataWritten(Handle:12, eOp:1, uOffset:0 uLen:1 Data0[0x01]=Data[])
    //x Alert=2:  Debug=BLEi: Callback_BLE_onDataWritten(Handle:12, eOp:1, uOffset:0 uLen:1 Data0[0x02]=Data[])

    //Characteristic Status:
    DEBUG("  IOw8: Handle:%d Len:%d Initial:[%02X %02X %02X %02X %02X %02X %02X %02X]\n", IOw8.getValueHandle(), sizeof(pIOw8), pIOw8[0], pIOw8[1], pIOw8[2], pIOw8[3],pIOw8[4], pIOw8[5], pIOw8[6], pIOw8[7]);
    DEBUG("  IOr4: Handle:%d Len:%d Initial:[%02X %02X %02X %02X]\n", IOr4.getValueHandle(), sizeof(pIOr4), pIOr4[0], pIOr4[1], pIOr4[2], pIOr4[3]);
    DEBUG("  IOn4: Handle:%d Len:%d Initial:[%02X %02X %02X %02X]\n", IOn4.getValueHandle(), sizeof(pIOn4), pIOn4[0], pIOn4[1], pIOn4[2], pIOn4[3]);
}

void Callback_BLE_onUpdatesEnabled(Gap::Handle_t tHandle)
{   //Triggered when click the UpdateContinuousIcon in nRF-MCP(ThreeDownArrows)
    if        (tHandle == IOn4.getValueHandle())    { DEBUG("  onUpdates(Handle:%d) Enabled - IOn4\n", tHandle); //This Occurs when selected by App nRF-MCP as has Notify property set
  //} else if (tHandle == IOr4.getValueHandle())    { DEBUG("  onUpdates(Handle:%d) Enabled - IOr4\n", tHandle);
  //} else if (tHandle == IOw8.getValueHandle())    { DEBUG("  onUpdates(Handle:%d) Enabled - IOw8\n", tHandle);
    } else                                          { DEBUG("  onUpdates(Handle:%d) Enabled - Characteristic?\n", tHandle);
    }
}

// Adopted 20141213 from http://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_LinkLoss/file/440ee5e8595f/main.cpp
void Callback_BLE_onLinkLoss(LinkLossService::AlertLevel_t level)
{
    printf("\nBLEi: Link Loss Alert, Level:%d\n", level);
    //TODO: Handle Link Loss, maybe lower power mode and/or advertising mode
}
//==========BLE:HRM==========
//Adopted 2014Dec from http://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_HeartRate/
uint8_t update_hrm(void)//(bool bInit)
{
    static uint8_t u8_hrm = 100;
    if (++u8_hrm >= 175) {
        u8_hrm = 100;
        DEBUG(" HRM>100");
    } else {
        DEBUG(" HRM:%d", u8_hrm); 
    }  
    pServiceHRM->updateHeartRate( u8_hrm );// Update Characteristic so sent by BLE
    return(u8_hrm);
}
//==========BLE:HTM(Using nRF Internal Temperature)==========
// *If not using nRF51822 IC then change this to a simple counter like BLE:Battery section
// Adopted 2014Dec from: https://developer.mbed.org/users/takafuminaka/code/BLE_HTM_by_InTempSensr/
// Service:  https://developer.bluetooth.org/gatt/services/Pages/ServiceViewer.aspx?u=org.bluetooth.service.health_thermometer.xml
// HTM Char: https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.temperature_measurement.xml
//****Although nRF-MCP displays float OK, the HTM Apps don't, it is likely IEEE format required like in the original project: BLE_HTM_by_InTempSensr 
float update_htm(void)
{
    //static float fTemperature = 0;//-123.456;
    int32_t i32_temp;
    sd_temp_get(&i32_temp);   //Read the nRF Internal Temperature (Die in 0.25'C steps, Counting From TBD), TODO:Check Scaling
    float fTemperature = (float(i32_temp)/4.0) - 16.0;   // Scale&Shift (0.25'C from -16'C?)

    //{//Force to IEEE format to match needs of Apps like nRF-HTM and nRF-Toolbox:HTM
    // PR: Didn't work 20141213, might need 5byte style from BLE_HTM_by_InTempSensr if this is really necessary. OK in nRF-MCP for now.
    //    uint8_t  exponent = 0xFE; //exponent is -2
    //    uint32_t mantissa = (uint32_t)(fTemperature*100);
    //    uint32_t temp_ieee11073 = ((((uint32_t)exponent) << 24) | (mantissa)); //Note: Assumes Mantissa within 24bits
    //    memcpy(((uint8_t*)&fTemperature)+1, (uint8_t*)&temp_ieee11073, 4); //Overwrite with IEEE format float
    //}

    pServiceHTM->updateTemperature( fTemperature );// Update Characteristic so sent by BLE
    DEBUG(" HTM%03d==%2.2f", i32_temp, fTemperature);
    return(fTemperature);
}
//==========BLE:Battery==========
uint8_t update_batt(void)
{
    static uint8_t u8_BattPercent=33; //Level: 0..100% 
    u8_BattPercent <= 50 ? u8_BattPercent=100 : u8_BattPercent--; // Simulate Battery Decay
    pServiceBattery->updateBatteryLevel( u8_BattPercent ); // Update Characteristic so sent by BLE
    DEBUG(" Batt%03d%%", u8_BattPercent);
    return(u8_BattPercent);
}

//==========Functions:Timer==========
static volatile bool  b_Ticker1 = false;//Volatile, don't optimize, changes under interrupt control
void CallbackTicker1(void)
{
    static uint32_t    u32_Counter; // Counter for Debug Output
    f_led1level+=0.1; if (f_led1level>0.5){f_led1level = 0.1;}; pwm_led1=f_led1level;//PR: Ramp Blink
    DEBUG("\nBLEi: Ticker1(%u) ", ++u32_Counter);
    b_Ticker1 = true;   //PR: Flag to handle Ticker1 Event in Main loop so interupts not blocked.
}
//==========main==========
int main(void)
{
    f_led1level = 1; pwm_led1 = f_led1level;//Start LED1=OnMax
    f_led2level = 1; pwm_led2 = f_led2level;//Start LED2=OnMax

    //Restart TeraTerm just before Pressing Reset on mbed, 9600-8N1(No Flow Control)
    DEBUG("\nBLE: ___%s___\n", pcDeviceName); 
    DEBUG("BLE: Connect App for Data: nRF-MCP, nRF-Toolbox:HRM/HTM, Android Sample BluetoothLeGatt, etc.\n");
    DEBUG("BLE: BluetoothLeGatt: App->mbed: LinkLoss->AlertLevel(UpArrow)\n"); 
    DEBUG("BLE: BluetoothLeGatt: App->mbed: BatteryService->BatteryLevel(DownArrow)\n"); 
    DEBUG("BLE: BluetoothLeGatt: mbed->App: BatteryService->BatteryLevel->EnableNotify(ThreeDownArrows), Also App Acks the send=DEBUG('SentI')\n"); 

    Ticker ticker1;                             //PR: Timer Object(Structure)
    ticker1.attach(CallbackTicker1, 2.0);       //PR: Timer Handler, Float=PeriodSeconds

    //BLE1: Setup BLE Service (and event actions) //TODO: Check for services declared before main() - Is that OK?
    DEBUG("BLE: Setup BLE\n");
    ble.init();
    ble.onDisconnection(Callback_BLE_onDisconnect);
    ble.onConnection(Callback_BLE_onConnect); //PR: Not required if no actions enabled, enabled now just for debug printf()
    ble.onDataSent(Callback_BLE_onDataSent);
    ble.onDataWritten(Callback_BLE_onDataWritten);
    ble.onTimeout(Callback_BLE_onTimeout);
    ble.onUpdatesEnabled(Callback_BLE_onUpdatesEnabled);
    
    //BLE2: Setup Services (with their initial values and options)
    DEBUG("BLE: Setup Services\n");
    // *Order here affects order in nRF-MCP Discovery of Services
    DeviceInformationService    ServiceDeviceInfo(ble, "Maker", pcDeviceName, "sn1234", "hw00", "fw00", "sw00");//(BLEDevice), pcManufacturer, pcModelNumber, pcSerialNumber, pcHWver, pcFWver, pcSWver
        pServiceDeviceInfo      = &ServiceDeviceInfo; //DEBUG("   Handle Service DeviceInfo:%d\n", ServiceDeviceInfo.XXXgetHandle());
    LinkLossService             ServiceLinkLoss(ble, Callback_BLE_onLinkLoss, LinkLossService::HIGH_ALERT); //New20141213, TBD
        pServiceLinkLoss        = &ServiceLinkLoss;
    BatteryService              ServiceBattery(ble, 10);
        pServiceBattery         = &ServiceBattery;
    HeartRateService            ServiceHRM(ble, (uint8_t)111, HeartRateService::LOCATION_FINGER);
        pServiceHRM             = &ServiceHRM;
    HealthThermometerService    ServiceHTM(ble, 33.3, HealthThermometerService::LOCATION_EAR); 
        pServiceHTM             = &ServiceHTM;
    //UARTService               ServiceUART(ble);
    //  pServiceUART            = &ServiceUART;

    //Start CustomIO Service:
    ble.addService(ServiceIO); //Pointer: pServiceIO
        DEBUG("  IOw8: Handle:%d Len:%d Initial:[%02X %02X %02X %02X %02X %02X %02X %02X]\n", IOw8.getValueHandle(), sizeof(pIOw8), pIOw8[0], pIOw8[1], pIOw8[2], pIOw8[3],pIOw8[4], pIOw8[5], pIOw8[6], pIOw8[7]);
        DEBUG("  IOr4: Handle:%d Len:%d Initial:[%02X %02X %02X %02X]\n", IOr4.getValueHandle(), sizeof(pIOr4), pIOr4[0], pIOr4[1], pIOr4[2], pIOr4[3]);
        DEBUG("  IOn4: Handle:%d Len:%d Initial:[%02X %02X %02X %02X]\n", IOn4.getValueHandle(), sizeof(pIOn4), pIOn4[0], pIOn4[1], pIOn4[2], pIOn4[3]);
        //TODO: Ensure outputs in correct Initial state

    //BLE3: Setup advertising
    // Note: the Advertising payload is limited to 31bytes, so careful don't overflow this. Multiple UUID16's or a single UUID128 are possible in advertising.
    // If there isn't enough space, then the accumulate payload won't add that block to the advertising, it won't add a partial block, and if name last then device shows as unnamed in App.
    DEBUG("BLE: Setup Advertising - Apps like HRM/HTM/UART require matching UUID\n");
    ble.clearAdvertisingPayload(); //Prep
    ble.setAdvertisingInterval(Gap::MSEC_TO_ADVERTISEMENT_DURATION_UNITS(1000));    //PR: Advertise 1sec (1Hz)
    ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);       //PR: TODO: To Study
    ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE); //PR: BLE Only (Option:LE_LIMITED_DISCOVERABLE)
    // Does "LE_GENERAL_DISCOVERABLE" affect whether UUID needs to be advertised to discover services?
    //a ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list)); // Multiple UUID16 for Standard Services
    ble.accumulateAdvertisingPayload(GapAdvertisingData::INCOMPLETE_LIST_128BIT_SERVICE_IDS, (const uint8_t *)puUUID128_IOService, sizeof(puUUID128_IOService)); //Single UUID128 for primary Service
    
    //? PR: I'm not sure what these lines do, they were inherited from an example:
    //? ble.accumulateAdvertisingPayload(GapAdvertisingData::GENERIC_HEART_RATE_SENSOR);
    //? ble.accumulateAdvertisingPayload(GapAdvertisingData::GENERIC_THERMOMETER);         
    
    // Add LocalName last so if Advertising too long will easily see as Name won't be available for the device.
    ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)pcDeviceName, sizeof(pcDeviceName)-1);//PR: LocalName (No NULL) 
    ble.startAdvertising();

    //Example Advertising (Max 31 bytes):              0x01020304050607080910111213141516171819202122232425262728293031
    // Example Raw Advertising caught by App nRF-MCP:  0x020106070309180A180D180909626C655052763034
    // = Len02 Type01 Value06                                   (Flags: BREDR_NOT_SUPPORTED, LE_GENERAL_DISCOVERABLE)
    // = Len07 Type03 Values: 0918 0A18 0D18                    (ListUUID16: 1809 180A 180D )
    // = Len09 Type09 Values: 62 6C 65 50 52 76 30 34           (LocalName = "blePRv04")
    // Example Raw Advertising caught by App nRF-MCP:  0x0201061106FB349B5F80000080001000000F180000070209180A180D18
    // = Len02 Type01 Value06                                   (Flags: BREDR_NOT_SUPPORTED, LE_GENERAL_DISCOVERABLE)
    // = Len11 Type06 ValueFB349B5F8000008000100000_0F18_0000   (UUID128: BluetoothBattery=0x180F)
    // = Len07 Type02 Value 0918 0A18 0D18                      (UUID16: 1809 180A 180D )
    // = LocalName field wasn't appended as insufficient space, so Device won't be named when scanning.

    DEBUG("BLE: Main Loop\n");
    uint32_t u32_wakeevents=0, u32_wakelast=0; // Counter&Register for tracking Wake Events (to see monitor their Frequency)
    while (true) {
        if (b_Ticker1 && ble.getGapState().connected) { //If Ticker1 and Connected Update Data
            b_Ticker1 = false; // Clear flag for next Ticker1, see CallbackTicker1()
  
            // Read Sensors, and update matching Service Characteristics (only if connected)
            // *Order here doesn't affect order in nRF-MCP Discovery of Services
            //TBD: Maybe save power by not Tx unless enabled by App?
            // The Services are discovered if they were setup/started (They don't need update to be discovered)        
            update_htm();
            update_hrm();
            update_batt();

            //a vUpdate_IOw8();
            vUpdate_IOr4();
            vUpdate_IOn4();

            DEBUG("  BLE:Wakes:%u,Delta:%u ", u32_wakeevents, u32_wakeevents-u32_wakelast); //For Evaluating Timing
            u32_wakelast = u32_wakeevents;           
        } else if (b_Ticker1) {
            b_Ticker1 = false; // Clear flag for next Ticker1, see CallbackTicker1()
            DEBUG("BLE: Tick while unconnected ");
        } else if (bSent){
            bSent=false; //clear flag
            //DEBUG("BLE: Sent %ubytes ", uSentBLE);
        } else {
            //DEBUG("BLE: Wait for Event\n\r"); //x Debug output here causes unnecessary wakes resulting in endless awakes.    
            ble.waitForEvent(); //PR: Wait for event - Yield control to BLE Stack and other events (Process ALL pending events before waiting again)
            f_led2level+=0.25; if (f_led2level>0.5){f_led2level = 0.0;}; pwm_led2=f_led2level;//PR: Ramp Blink
            u32_wakeevents++;   //PR: Count events for frequency monitoring (20141207PR: nRF51822 mbed HRM = 50Hz)
        }
    }
}
//========== end of main.cpp ==========