Diff: main.cpp

Revision:

8:46c5e0bfab05

Parent:

7:0a8bbb6dea16

Child:

9:b6302fc4e754

--- a/main.cpp	Tue Jan 12 10:12:43 2016 +0000
+++ b/main.cpp	Mon Jul 10 03:57:10 2017 +0000
@@ -1,51 +1,192 @@
-/* mbed Microcontroller Library
- * Copyright (c) 2006-2015 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.
+/*
+
+ Eric Tsai
+ todo:  hash mac to create unqiue identifier for "my" sensors.
+
+
  */
 
+//required to call the ecb functions
+extern "C"
+{
+   #include "nrf_ecb.h"
+}
+ 
 #include "mbed.h"
 #include "toolchain.h"
 #include "ble/BLE.h"
 #include "TMP_nrf51/TMP_nrf51.h"
 
-static Ticker     ticker;
-static TMP_nrf51  tempSensor;
-static bool       triggerTempValueUpdate = false;
-static DigitalOut alivenessLED(LED1, 1);
+//comment out when done with debug uart, else eats batteries
+#define MyDebugEnb 1
+
+//Pin "P0.4" on nRF51822 = mbed "p4".
+//InterruptIn is pulled-up.  GND the pin to activate.
+
+// waveshare board ******
+//InterruptIn button1(p10);
+//InterruptIn button2(p11);
+
+// purple board ******
+InterruptIn button1(p23);
+InterruptIn button2(p24);
+
+
+//Serial device(p9, p11);  // tx, rx, purple board and Rigado
+#if MyDebugEnb
+// if you see ~1mA consumption during sleep, that's because uart is enabled.
+Serial device(p9, p11);  //nRF51822 uart :  TX=p9.  RX=p11
+#endif
+
+//InterruptIn button(p4);     //Pin P0.4 on  = mbed "p3"; 
+
+
+static Ticker tic_adv;   //stop adv
+static Ticker tic_debounce; //debounce I/O
+static Ticker tic_periodic; //regular updates
+//static TMP_nrf51  tempSensor;
+static bool flag_update_io = false;
+static bool flag_periodic_call = false;
+static bool flag_detach_adv_tic = false;
+static bool flag_set_debounce_tic = false;  //not used
+
+//static DigitalOut alivenessLED(LED1, 1);
+float mySensor = 2.0f;
+
+
+/* Optional: Device Name, add for human read-ability */
+const static char     DEVICE_NAME[] = "CUU";
 
+/* You have up to 26 bytes of advertising data to use. */
+/*
+Advertisement
+
+DECvolt:3.11111111,mag:1
+AdvData[0-2] = Look for DEC on observer
+AdvData[3] = beginning of data
+*/
+//full with nullls
+static uint8_t AdvData[] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};   /* Example of hex data */
+char buffer[10]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //battery analog reading
+uint8_t magnet_near=0;
+
+
+
+static uint8_t key[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4};
+//26 bytes adv data
+static uint8_t encrypted[26] = {0x0,0x0,0x0,0x1,0x1,0x1,0x2,0x2,0x2,0x3,0x3,0x3,0x4,0x4,0x4,0x5,0x5,0x5,0x6,0x6,0x6,0x7,0x7,0x7,0x8,0x8};   /* Example of hex data */
+//static uint8_t key_buf[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4};
+static uint8_t key_buf[16] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x1, 0x2};
+static uint8_t src_buf[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4};
+static uint8_t des_buf[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4};
+
+//const static uint8_t AdvData[] = {"ChangeThisData"};         /* Example of character data */
+
+
+
+/* **** NOT USED **** */
+//16byte UUID loading happens here
+//Look at <GapAdvertisingData.h> for rest of definition
 struct ApplicationData_t {
-    uint16_t                     applicationSpecificId; /* An ID used to identify temperature value in the manufacture specific AD data field */
-    TMP_nrf51::TempSensorValue_t tmpSensorValue;        /* User defined application data */
+    //Byte 0:  AppID High Byte
+    //Byte 1:  AppID Low Byte
+    //Byte 2:  sensor High Word
+    //Byte 3:
+    //Byte 4:
+    //Byte 5:  sensor Low Byte
+    
+    
+    //app ID is 16 bit, (0xFEFE)
+    uint16_t    applicationSpecificId; /* An ID used to identify temperature value in the manufacture specific AD data field */
+    
+    //float = 32-bit.  
+    //tsai: change this to uint32_t!!!
+    TMP_nrf51::TempSensorValue_t tmpSensorValue;        /* this is a float (32-bit), user data */
 } PACKED;
 
-void periodicCallback(void)
+
+
+void debounce_Callback(void)
+{
+    tic_debounce.detach();
+    flag_set_debounce_tic = false;      //not used
+    flag_update_io = true;  //start advertising
+    /* Note that the buttonPressedCallback() executes in interrupt context, so it is safer to access
+     * BLE device API from the main thread. */
+    //buttonState = PRESSED;
+}
+
+//----- button rising ---
+void buttonPressedCallback(void)
 {
-    alivenessLED = !alivenessLED;  /* Do blinky on LED1 while we're waiting for BLE events. */
+
+
+    //flag_update_io = true;
+    
+    tic_debounce.attach(debounce_Callback, 1); //ok to attach multiple times, first one wins
+    
+
+    //buttonState = PRESSED;
+    
+    /*
+    if (flag_set_debounce_tic == false)
+    {
+        flag_set_debounce_tic = true;
+        
+    }
+    */
+}
 
-    /* Note that the periodicCallback() executes in interrupt context, so it is safer to do
+//----- button falling ---
+void buttonReleasedCallback(void)
+{
+    
+
+    //flag_update_io = true;
+    
+    tic_debounce.attach(debounce_Callback, 1);
+    
+    
+  
+}
+
+
+void stop_adv_Callback(void)
+{
+    //stops advertising after X seconds
+    /* Note that the Callback() executes in interrupt context, so it is safer to do
      * heavy-weight sensor polling from the main thread (where we should be able to block safely, if needed). */
-    triggerTempValueUpdate = true;
+    
+    //tic_adv.detach();
+    
+    flag_detach_adv_tic = true;
+    //ble.gap().stopAdvertising();
+    
+
+}
+
+
+
+
+
+void periodic_Callback(void)
+{
+    flag_update_io = true;
+    flag_periodic_call = true;
 }
 
 void setupApplicationData(ApplicationData_t &appData)
 {
-    static const uint16_t APP_SPECIFIC_ID_TEST = 0xFEFE;
+    // two byte ID:  0xFEFE
+    static const uint16_t APP_SPECIFIC_ID_TEST = 0xFEFE;        //2 byte application ID
 
     appData.applicationSpecificId = APP_SPECIFIC_ID_TEST;
-    appData.tmpSensorValue        = tempSensor.get();
+    //appData.tmpSensorValue        = tempSensor.get();
+    appData.tmpSensorValue        = mySensor;
 }
 
+
+
 /**
  * This function is called when the ble initialization process has failled
  */
@@ -72,43 +213,416 @@
     if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
         return;
     }
+    
+    /* Set device name characteristic data */
+    ble.gap().setDeviceName((const uint8_t *) DEVICE_NAME);
 
     /* Setup advertising payload */
+    //set modes "no EDR", "discoverable" for beacon type advertisements
     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
-    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::GENERIC_THERMOMETER);
-    ApplicationData_t appData;
-    setupApplicationData(appData);
-    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, (uint8_t *)&appData, sizeof(ApplicationData_t));
+    
+    //set device profile in ADV/GATT
+    //ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::GENERIC_THERMOMETER);
+    
+    //set advertising data (ADV data)
+    //ApplicationData_t appData;
+    //setupApplicationData(appData);
+    //in /BLE_API/ble/GapAdvertisingData.h:  sets payload (uuid)
+    //ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, (uint8_t *)&appData, sizeof(ApplicationData_t));
+
+    //from GAP example
+    /* Sacrifice 2B of 31B to AdvType overhead, rest goes to AdvData array you define */
+    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, AdvData, sizeof(AdvData));
+
+    /* Setup advertising parameters:  not connectable */
+    ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_NON_CONNECTABLE_UNDIRECTED);
+    ble.gap().setAdvertisingInterval(300);  //one advertisment every 300ms.  Self tickers, so you don't have to worry.
+
+
+
+    //don't start advertising on init.  Only advertise on pin interrupt.
+    //ble.gap().startAdvertising();
+}
+
 
-    /* Setup advertising parameters */
-    ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_NON_CONNECTABLE_UNDIRECTED);
-    ble.gap().setAdvertisingInterval(500);
+//https://developer.mbed.org/users/MarceloSalazar/notebook/measuring-battery-voltage-with-nordic-nrf51x/
+void my_analogin_init(void)
+{
+    NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled;
+    NRF_ADC->CONFIG = (ADC_CONFIG_RES_10bit << ADC_CONFIG_RES_Pos) |
+                      (ADC_CONFIG_INPSEL_SupplyOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) |
+                      (ADC_CONFIG_REFSEL_VBG << ADC_CONFIG_REFSEL_Pos) |
+                      (ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos) |
+                      (ADC_CONFIG_EXTREFSEL_None << ADC_CONFIG_EXTREFSEL_Pos);
+}
 
-    ble.gap().startAdvertising();
+uint16_t my_analogin_read_u16(void)
+{
+    NRF_ADC->CONFIG     &= ~ADC_CONFIG_PSEL_Msk;
+    NRF_ADC->CONFIG     |= ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos;
+    NRF_ADC->TASKS_START = 1;
+    
+    
+    //while loop doesn't actually loop until reading comlete, use a wait.
+    while (((NRF_ADC->BUSY & ADC_BUSY_BUSY_Msk) >> ADC_BUSY_BUSY_Pos) == ADC_BUSY_BUSY_Busy) {};
+    wait_ms(2);
+
+    //save off RESULT before disabling.
+    //uint16_t myresult = (uint16_t)NRF_ADC->RESULT;
+    
+    //disable ADC to lower bat consumption
+    //NRF_ADC->TASKS_STOP = 1;
+    //NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Disabled;    //disable to shutdown ADC & lower bat consumption
+    
+    return (uint16_t)NRF_ADC->RESULT; // 10 bit
+    //return myresult;
 }
 
 int main(void)
 {
-    ticker.attach(periodicCallback, 2); /* trigger sensor polling every 2 seconds */
+
+#if MyDebugEnb
+    device.baud(9600);
+    device.printf("started sensor node 36 ");
+    device.printf("\r\n");
+#endif
+
+    
+    
+    Timer myTimer;  //timed advertising
+    myTimer.start();
+
+
+    AdvData[0] = 0x44;          //D
+    AdvData[1] = 0x45;          //E
+    AdvData[2] = 0x43;          //C
+    AdvData[3] = 0x22;          //"
+    AdvData[4] = 0x76;          //V volt
+    AdvData[5] = 0x6f;          //o
+    AdvData[6] = 0x22;          //"
+    AdvData[7] = 0x3a;          //:
+    AdvData[8] = 0x24;          //3     #
+    AdvData[9] = 0x24;          //.     #
+    AdvData[10] = 0x24;         //1     #
+    AdvData[11] = 0x24;         //1     #
+    AdvData[12] = 0x2c;         //,     
+    AdvData[13] = 0x22;         //" mag
+    AdvData[14] = 0x6d;         //a
+    AdvData[15] = 0x22;         //"
+    AdvData[16] = 0x3a;         //:
+    AdvData[17] = 0x24;         //0 or 1, 30 or 31
+
+    button1.fall(buttonPressedCallback);
+    button1.rise(buttonReleasedCallback);
+    button1.mode(PullNone);
+    button1.fall(NULL);
+    button1.rise(NULL); 
 
     BLE &ble = BLE::Instance();
     ble.init(bleInitComplete);
+    
+    //debug uart
+    //device.baud(115200);
+    float bat_reading;  //hold battery voltage reading (Vbg/Vcc)
+    
+    my_analogin_init();//routes band-gap to analog input
 
     /* SpinWait for initialization to complete. This is necessary because the
      * BLE object is used in the main loop below. */
-    while (ble.hasInitialized()  == false) { /* spin loop */ }
+    while (ble.hasInitialized() == false) { /* spin loop */ }
+    
+    //every X seconds, sends period update, up to 1800 (30 minutes)
+    tic_periodic.attach(periodic_Callback, 10);
 
     while (true) {
-        if (triggerTempValueUpdate) {
+        
+        uint16_t mySeconds =(uint16_t)(myTimer.read_ms()/1000); //problem:  mySeconds is only 2 byte
+        //reading the ADV value, only goes up to 0-255;
+        //reading the uart:  current time in seconds: -1782, goes negative.
+        //need to be able to count 1800 seconds since that's the length of timer.
+        
+#if MyDebugEnb
+        device.printf("current time in seconds: %d \r\n", mySeconds);
+#endif
+        //**** set which pin should be interrupt, set pullups ***
+        
+        //set both pins to pull-up, so they're not floating when we read state
+        button1.mode(PullUp);
+        button2.mode(PullUp);
+        
+        //wait_ms(300);   //contact settle
+        
+
+        //AdvData[12] is automatically CR?  why?
+        
+        //0x33 0x2E 0x33 0x32 0x13
+        //   3    .    3    2   CR
+        
+        //expect either button1 or button2 is grounded, b/c using SPDT reed switch
+        //the "common" pin on the reed switch should be on GND
+        uint8_t button1_state = button1.read();
+        uint8_t button2_state = button2.read();
+        
+        
+        //let's just update the pins on every wake.  Insurance against const drain.
+        //if state == 0, pin is grounded.  Unset interrupt and float pin
+        //set the other input
+        if ( (button1_state == 0) && (button2_state == 1) )
+        {
+            magnet_near = 1;
+            //AdvData[4] = 0x11;  //dont' set ADV data directly.  Using json now, need spacing
+            //button1.disable_irq() //don't know if disables IRQ on port or pin
+            button1.fall(NULL);     //disable interrupt
+            button1.rise(NULL);     //disable interrupt
+            button1.mode(PullNone); //float pin to save battery
+            
+            //button2.disable_irq() //don't know if disables IRQ on port or pin
+            button2.fall(buttonReleasedCallback);     //disable interrupt
+            button2.rise(buttonReleasedCallback);     //disable interrupt
+            button2.mode(PullUp); //float pin to save battery
+        }
+        else if ( (button1_state == 1) && (button2_state == 0) )       //assume other pin is open circuit
+        {
+            magnet_near = 0;
+            //AdvData[4] = 0x22;    //dont' set ADV data directly.  Using json now, need spacing
+            //button1.disable_irq() //don't know if disables IRQ on port or pin
+            button1.fall(buttonReleasedCallback);     //disable interrupt
+            button1.rise(buttonReleasedCallback);     //disable interrupt
+            button1.mode(PullUp); //float pin to save battery
+            
+            //button2.disable_irq() //don't know if disables IRQ on port or pin
+            button2.fall(NULL);     //disable interrupt
+            button2.rise(NULL);     //disable interrupt
+            button2.mode(PullNone); //float pin to save battery
+        }    
+        else    //odd state, shouldn't happen, suck battery and pullup both pins
+        {
+            magnet_near = 2;
+            //AdvData[4] = 0x33;
+            //button1.disable_irq() //don't know if disables IRQ on port or pin
+            button1.fall(buttonReleasedCallback);     //disable interrupt
+            button1.rise(buttonReleasedCallback);     //disable interrupt
+            button1.mode(PullUp); //float pin to save battery
+            
+            //button2.disable_irq() //don't know if disables IRQ on port or pin
+            button2.fall(buttonReleasedCallback);     //disable interrupt
+            button2.rise(buttonReleasedCallback);     //disable interrupt
+            button2.mode(PullUp); //float pin to save battery
+        }         
+        
+        
+        if (flag_update_io) {
             /* Do blocking calls or whatever hardware-specific action is
              * necessary to poll the sensor. */
+
+            //analog reading consumes 940uA if not disabled
+            bat_reading = (float)my_analogin_read_u16();    
+            bat_reading = (bat_reading * 3.6) / 1024.0;
+#if MyDebugEnb
+            device.printf("bat reading: %f \r\n", bat_reading);
+#endif
+
+            //memset(&buffer[0], 0, sizeof(buffer));      //clear out buffer
+            //sprintf (buffer, "%f.2", bat_reading);    //don't know what i'm doing
+            //sprintf (buffer, "%.2f", bat_reading);
+            //AdvData[8] = buffer[0]; //"3"=0x33
+            //AdvData[9] = buffer[1]; //"."=0x2E
+            //AdvData[10] = buffer[2];//"3"=0x33
+            //AdvData[11] = buffer[3];//"2"=0x32
+            
+            //disable ADC
+            NRF_ADC->TASKS_STOP = 1;
+            NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Disabled;    //disable to shutdown ADC & lower bat consumption
+
+            //***********************************
+            //form JSON string in ADV_DATA
+            //1)  volts starts at AdvData[8]
+            
+
+            memset(&AdvData[0], 0, sizeof(AdvData));
+            uint8_t JSON_loc=0; //DEC"vo": <---
+
+            AdvData[JSON_loc] = 0x44;          //D
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x45;          //E
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x43;          //C
+            JSON_loc++;
+            AdvData[JSON_loc] = mySeconds & 0xFF;           //reserved for timer
+            JSON_loc++;
+            AdvData[JSON_loc] = (mySeconds >> 8) & 0xFF;;           //reserved for timer
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x22;          //"
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x76;          //V volt
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x6f;          //o
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x6C;          //l
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x74;          //t
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x22;          //"
+            JSON_loc++;
+            AdvData[JSON_loc] = 0x3a;          //:
+            JSON_loc++;
+    
+    
+            
+            //write battery voltage
+            uint8_t total_chars;
+            memset(&buffer[0], 0, sizeof(buffer));      //clear out buffer
+            total_chars = sprintf (buffer, "%.2f", bat_reading);    //returns total number of characters
+
+#if MyDebugEnb
+            device.printf("char buff: %c%c%c%c \r\n", buffer[0], buffer[1], buffer[2], buffer[3]);
+            device.printf("num chars: %d \r\n", total_chars);
+#endif
+
+            for (int i=0; i < total_chars; i++)
+            {
+                AdvData[JSON_loc] = buffer[i];
+                JSON_loc++;
+#if MyDebugEnb
+                device.printf("JSON_loc: %d     buf[]:%c \r\n", JSON_loc, buffer[i]);
+#endif
+            } //JSON_loc left at location of next character
+            
+            //DEC"vo":3.11,"
+            AdvData[JSON_loc] = 0x2c;       //,
+            JSON_loc++;
+            
+            AdvData[JSON_loc] = 0x22;       //" start mag
+            JSON_loc++;
+            
+            AdvData[JSON_loc] = 0x6d;       //m
+            JSON_loc++;
+            
+            AdvData[JSON_loc] = 0x61;       //a
+            JSON_loc++;
+            
+            AdvData[JSON_loc] = 0x67;       //g
+            JSON_loc++;
+            
+            if (flag_periodic_call)
+            {
+                //AdvData[JSON_loc] = 0x2f;       // "/"
+                //JSON_loc++;
+                AdvData[JSON_loc] = 0x2f;       // "/"
+                JSON_loc++;
+                AdvData[JSON_loc] = 0x70;       // "p"
+                JSON_loc++;
+            }//end if period call
+            
+            AdvData[JSON_loc] = 0x22;       //"
+            JSON_loc++;
+
+            AdvData[JSON_loc] = 0x3a;       //:
+            JSON_loc++;
+            
+            //prep magnet location (1 or 0) for char[]
+            memset(&buffer[0], 0, sizeof(buffer));      //clear out buffer
+            //magnet_near is an integer
+            total_chars = sprintf (buffer, "%d", magnet_near);    //returns total number of characters
+            for (int i=0; i < total_chars; i++)
+            {
+                AdvData[JSON_loc] = buffer[i];
+                JSON_loc++;
+            } //JSON_loc left at location of next character
+            
+            //MUST null terminate for JSON to read correctly, else get intermittent JSON parse errors at gateway
+            //happens when string is shorter than last string, get trash left overs
+            //not really needed after clearning AdvData at start.
+            
+            
+            //AdvData[JSON_loc] = 0x0;    //null terminate here
+
             ApplicationData_t appData;
             setupApplicationData(appData);
-            ble.gap().updateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, (uint8_t *) &appData, sizeof(ApplicationData_t));
+            
+
+            for (int i=0; i<16; i++)
+            {
+                src_buf[i] = AdvData[i+3];
+            }
 
-            triggerTempValueUpdate = false;
+            //nrf_ecb_set_key(key_buf);
+            nrf_ecb_init();
+            nrf_ecb_set_key(key_buf);
+            bool successful_ecb = nrf_ecb_crypt(des_buf, src_buf);
+#if MyDebugEnb
+            device.printf("success ecb = %d \r\n", successful_ecb);
+            device.printf("src_buf: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x \r\n", src_buf[0], src_buf[1], src_buf[2], src_buf[3], src_buf[4], src_buf[5], src_buf[6], src_buf[7], src_buf[8], src_buf[9], src_buf[10], src_buf[11], src_buf[12], src_buf[13], src_buf[14], src_buf[15]);
+            device.printf("des_buf: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x \r\n", des_buf[0], des_buf[1], des_buf[2], des_buf[3], des_buf[4], des_buf[5], des_buf[6], des_buf[7], des_buf[8], des_buf[9], des_buf[10], des_buf[11], des_buf[12], des_buf[13], des_buf[14], des_buf[15]);
+#endif
+            for (int i=0; i<16; i++)
+            {
+                AdvData[i+3] = des_buf[i];
+            }
+            
+            //ble.gap().updateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, (uint8_t *) &appData, sizeof(ApplicationData_t));
+            ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, AdvData, sizeof(AdvData));
+            
+            flag_update_io = false;
+            flag_periodic_call = false;
+            
+            //GAP::AddressType_t *myType;
+            //GAP::Address_t myAddress
+            //ble_error_t getAddress(Gap::AddressType_t *typeP, Gap::Address_t address)
+            //ble.gap().getAddress(myType, myAddress);
+            //ble.gap().getAddress(Gap::AddressType_t *typeP, Gap::Address_t address);
+            uint8_t mac[6] = {0x0,0x0,0x0,0x0,0x0,0x0};
+            ble.getAddress(0,mac);  //NOTE:  last byte of MAC (as shown on phone app) is at mac[0], not mac[6];
+#if MyDebugEnb
+            device.printf("mac = ");
+            for (int i=0; i<6; i++)
+            {
+                device.printf("%x:", mac[i]);
+            }
+            device.printf("\r\n");
+#endif
+            ble.gap().startAdvertising();
+            tic_adv.attach(stop_adv_Callback, 2); /* trigger turn off advertisement after X seconds */
+
+            /*
+            Timer myTimer;  //timed advertising
+            myTimer.start();
+            uint32_t duration = myTimer.read_ms();
+            
+            //do this as a ticker instead of keeping processor on
+            while (duration < 15000)            //advertise for 1000 ms
+            {
+                duration = myTimer.read_ms();   //read miliseconds
+            }
+            myTimer.stop();
+            ble.gap().stopAdvertising();
+            */
+        
+        }//end flag_update_io
+        
+        
+        /*
+        if (flag_set_debounce_tic == true)
+        {
+            tic_debounce.attach();
+            //flag_set_debounce_tic = false;
+            
         }
+        */
+        
+        //if (trigger_Detach_ADV_Tick == false)
+        //{  
+        //}
+        if (flag_detach_adv_tic == true)    //Stop Advertising
+        {
+            ble.gap().stopAdvertising();    //may be safer to execute BLE operations in main
+            tic_adv.detach();
+            flag_detach_adv_tic = false;
+        }
+        //device.printf("Input Voltage: %f\n\r",bat_reading);
+        
+        ble.waitForEvent(); //sleeps until interrupt
+        
 
-        ble.waitForEvent();
-    }
-}
+    }//end forever while
+}//end main