Eric Tsai
BLE ADV sensor for 2-pin interrupt (i.e. window/door sensor w/ reed switch)
Dependencies: BLE_API mbed nRF51822
Embed:
(wiki syntax)
Show/hide line numbers
main.cpp
00001 /* 00002 * Copyright (c) Eric Tsai 2017 00003 * 00004 * 00005 * Licensed under the Apache License, Version 2.0 (the "License"); 00006 * you may not use this file except in compliance with the License. 00007 * You may obtain a copy of the License at 00008 * 00009 * http://www.apache.org/licenses/LICENSE-2.0 00010 * 00011 * Unless required by applicable law or agreed to in writing, software 00012 * distributed under the License is distributed on an "AS IS" BASIS, 00013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00014 * See the License for the specific language governing permissions and 00015 * limitations under the License. 00016 * 00017 * 00018 * Credit: started with the basic BLE Temperature Beacon code from mbed Bluetooth Low Energy team 00019 * https://developer.mbed.org/teams/Bluetooth-Low-Energy/code/BLE_TemperatureBeacon/file/0a8bbb6dea16/main.cpp 00020 * 00021 * BLE sensor as Beacon advertisements. Intended to function with specific BLE observer. 00022 * Tested on nRF51822 targets on mbed. 00023 * keywords: todo, tochange 00024 */ 00025 00026 00027 extern "C" 00028 { 00029 #include "nrf_ecb.h" //required to call the ecb functions for encryption 00030 } 00031 00032 #include "mbed.h" 00033 #include "toolchain.h" 00034 #include "ble/BLE.h" 00035 #include "TMP_nrf51/TMP_nrf51.h" 00036 00037 00038 /******************************************************************************************* 00039 * START tochange: items that may need customization depending on sensors, hardware, and desired behavior 00040 *******************************************************************************************/ 00041 const uint16_t Periodic_Update_Seconds = 20; //number of seconds between periodic I/O status re-transmits 900s =15 min. 00042 #define MyDebugEnb 0 //enables serial output for debug, consumes ~1mA when idle 00043 uint8_t magnet_near=0; //this I/O, specifically for reed switch sensor 00044 00045 00046 /* hardware interrupt pins, selected based on hardware 00047 *Syntax: Pin "P0.4" on nRF51822 documentation is mbed "p4". 00048 * InterruptIn is pulled-up. GND the pin to activate. 00049 */ 00050 InterruptIn button1(p0); //nRF51822 P0.0 00051 InterruptIn button2(p1); //nRF51822 P0.1 00052 /****************************************************************************************** 00053 * END tochange 00054 *******************************************************************************************/ 00055 00056 00057 #if MyDebugEnb 00058 // if you see ~1mA consumption during sleep, that's because MyDebugEnb==1, it's enabled. 00059 Serial device(p9, p11); //nRF51822 uart : TX=p9. RX=p11 00060 #endif 00061 00062 static Ticker Tic_Stop_Adv; //used to stop advertising after X seconds 00063 static Ticker Tic_Debounce; //debounce I/O 00064 static Ticker Tic_Periodic; //transmit sensor data on a periodic basis outside I/O events 00065 00066 const uint16_t Periodicity = 1800; //birthday periodicity used for spoof checking, must match gateway. Should be 1800 seconds for 30minutes 00067 static Timer Tmr_From_Birthday; //holds number of seconds since birthday, for spoof detection 00068 static Ticker Tic_Birthday; //resets Tmr_From_Birthday every Periodicity seconds, for spoof detection 00069 00070 00071 static bool Flag_Update_IO = false; //flag to indicate event is hardware interrupt 00072 static bool Flag_Periodic_Call = false; //flag to indicate event is periodic callback 00073 static bool Flag_Detach_Adv_Tic = false; //flag to stop advertising 00074 00075 /* Optional: Device Name, add for human read-ability */ 00076 const static char DEVICE_NAME[] = "LOL"; 00077 00078 00079 //Advertisement Data 00080 //note: AdvData[] holds bytes [5] to byte [30] of entire advertising data. The user content part after ADV flag and header 00081 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}; //26 Bytes manufacturer specific data 00082 char buffer[10]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //hold I/O reading json 00083 char bat_volt_char[6] = {0, 0, 0, 0, 0, 0}; //hold json for battery reading 00084 uint8_t Adv_First_Section[10]; //holds the first several bytes with a pattern indicating this sensor is "one of ours" 00085 uint8_t mac_reverse[6] = {0x0,0x0,0x0,0x0,0x0,0x0}; //mac address for this module 00086 00087 /***** Advertisement structure is 31 Bytes **************** 00088 00089 https://docs.mbed.com/docs/ble-intros/en/latest/Advanced/CustomGAP/ 00090 00091 Full Advertisement: 00092 First 5 bytes are set by stack according to flag and header parameters. 00093 Last 26 bytes are user data 00094 -- tabbed -- 00095 Byte 0 | AD1 Length | 0x02 | AD1 is 2 bytes long 00096 Byte 1 | AD1 Type | 0x01 | AD1 Data interpreted as flag 00097 Byte 2 | AD1 Data 0 | 0x06 | AD1 Data flag mean "00000110" 00098 Byte 3 | AD2 Length | 0x1B | AD2 is 27 bytes (0x1B) long (rest of this data) 00099 Byte 4 | AD2 Type | 0xFF | 0xFF mean Manufacturer Specific Data 00100 Byte 5 | AD2 Data 0 | ADV_Data[0] | "our device" flag, MAC[3] 00101 Byte 6 | AD2 Data 1 | ADV_Data[1] | "out device" flag, MAC[2] 00102 Byte 7 | AD2 Data 2 | ADV_Data[2] | "out device" flag, MAC[1] 00103 Byte 8 | AD2 Data 3 | ADV_Data[3] | "out device" flag, MAC[0] 00104 Byte 9 | AD2 Data 4 | ADV_Data[4] | battery voltage json MSB, ie 3 in 3.14 00105 Byte 10 | AD2 Data 5 | ADV_Data[5] | battery voltage json 00106 Byte 11 | AD2 Data 6 | ADV_Data[6] | battery voltage json 00107 Byte 12 | AD2 Data 7 | ADV_Data[7] | battery voltage json LSB, ie 4 in 3.14 00108 Byte 13 | AD2 Data 8 | ADV_Data[8] | reserved 00109 Byte 14 | AD2 Data 9 | ADV_Data[9] | reserved 00110 Byte 15 | AD2 Data 10 | ADV_Data[10] Encrypted | spoof - clock high byte, range 0 to 1800 seconds 00111 Byte 16 | AD2 Data 11 | ADV_Data[11] Encrypted | spoof - clock low byte 00112 Byte 17 | AD2 Data 12 | ADV_Data[12] Encrypted | Xmit_Cnt - increments per transmit event, 0-255 00113 Byte 18 | AD2 Data 13 | ADV_Data[13] Encrypted | JSON[0] 00114 Byte 19 | AD2 Data 14 | ADV_Data[14] Encrypted | JSON[1] 00115 Byte 20 | AD2 Data 15 | ADV_Data[15] Encrypted | JSON[2] 00116 Byte 21 | AD2 Data 16 | ADV_Data[16] Encrypted | JSON[3] 00117 Byte 22 | AD2 Data 17 | ADV_Data[17] Encrypted | JSON[4] 00118 Byte 23 | AD2 Data 18 | ADV_Data[18] Encrypted | JSON[5] 00119 Byte 24 | AD2 Data 19 | ADV_Data[19] Encrypted | JSON[6] 00120 Byte 25 | AD2 Data 20 | ADV_Data[20] Encrypted | JSON[7] 00121 Byte 26 | AD2 Data 21 | ADV_Data[21] Encrypted | JSON[8] 00122 Byte 27 | AD2 Data 22 | ADV_Data[22] Encrypted | JSON[9] 00123 Byte 28 | AD2 Data 23 | ADV_Data[23] Encrypted | JSON[10] 00124 Byte 29 | AD2 Data 24 | ADV_Data[24] Encrypted | JSON[11] 00125 Byte 30 | AD2 Data 25 | ADV_Data[25] Encrypted | JSON[12] 00126 00127 ***************************************************/ 00128 00129 00130 static uint8_t key[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4}; 00131 //26 bytes adv data 00132 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 */ 00133 //static uint8_t key_buf[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4}; 00134 static uint8_t key_buf[16] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x1, 0x2}; 00135 static uint8_t src_buf[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4}; 00136 static uint8_t des_buf[16] = {0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4,0x1,0x2,0x3,0x4}; 00137 00138 uint8_t Xmit_Cnt = 1; 00139 00140 00141 00142 /* **** NOT USED **** */ 00143 //16byte UUID loading happens here 00144 //Look at <GapAdvertisingData.h> for rest of definition 00145 struct ApplicationData_t { 00146 //Byte 0: AppID High Byte 00147 //Byte 1: AppID Low Byte 00148 //Byte 2: sensor High Word 00149 //Byte 3: 00150 //Byte 4: 00151 //Byte 5: sensor Low Byte 00152 00153 00154 //app ID is 16 bit, (0xFEFE) 00155 uint16_t applicationSpecificId; /* An ID used to identify temperature value in the manufacture specific AD data field */ 00156 00157 TMP_nrf51::TempSensorValue_t tmpSensorValue; /* this is a float (32-bit), user data */ 00158 } PACKED; 00159 00160 00161 00162 void debounce_Callback(void) 00163 { 00164 Tic_Debounce.detach(); 00165 Flag_Update_IO = true; //start advertising 00166 /* Note that the buttonPressedCallback() executes in interrupt context, so it is safer to access 00167 * BLE device API from the main thread. */ 00168 00169 } 00170 00171 //ISR for I/O interrupt 00172 void buttonPressedCallback(void) 00173 { 00174 Tic_Debounce.attach(debounce_Callback, 1); //ok to attach multiple times, recent one wins 00175 } 00176 00177 //ISR for I/O interrupt 00178 void buttonReleasedCallback(void) 00179 { 00180 00181 Tic_Debounce.attach(debounce_Callback, 1); 00182 } 00183 00184 00185 void stop_adv_Callback(void) 00186 { 00187 //stops advertising after X seconds 00188 /* Note that the Callback() executes in interrupt context, so it is safer to do 00189 * heavy-weight sensor polling from the main thread (where we should be able to block safely, if needed). */ 00190 Flag_Detach_Adv_Tic = true; 00191 00192 } 00193 00194 /* **************************************** 00195 * Decides what actions need to be performed on periodic basis 00196 *******************************************/ 00197 void periodic_Callback(void) 00198 { 00199 Flag_Update_IO = true; 00200 Flag_Periodic_Call = true; 00201 } 00202 00203 00204 /* **************************************** 00205 * No RTC available, tickers only have a 35 minute range. 00206 * So periodicity for spoof avoidance is set to 30 minutes 00207 *******************************************/ 00208 void clock_reset_Callback(void) 00209 { 00210 #if MyDebugEnb 00211 device.printf("===== reset timer ====="); 00212 device.printf("\r\n"); 00213 #endif 00214 Tmr_From_Birthday.reset(); 00215 }; 00216 00217 00218 void setupApplicationData(ApplicationData_t &appData) 00219 { 00220 // two byte ID: 0xFEFE 00221 static const uint16_t APP_SPECIFIC_ID_TEST = 0xFEFE; //2 byte application ID 00222 00223 appData.applicationSpecificId = APP_SPECIFIC_ID_TEST; 00224 } 00225 00226 00227 00228 /** 00229 * This function is called when the ble initialization process has failled 00230 */ 00231 void onBleInitError(BLE &ble, ble_error_t error) 00232 { 00233 /* Initialization error handling should go here */ 00234 } 00235 00236 00237 00238 /** 00239 * Callback triggered when the ble initialization process has finished 00240 */ 00241 void bleInitComplete(BLE::InitializationCompleteCallbackContext *params) 00242 { 00243 BLE& ble = params->ble; 00244 ble_error_t error = params->error; 00245 00246 if (error != BLE_ERROR_NONE) { 00247 /* In case of error, forward the error handling to onBleInitError */ 00248 onBleInitError(ble, error); 00249 return; 00250 } 00251 00252 /* Ensure that it is the default instance of BLE */ 00253 if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) { 00254 return; 00255 } 00256 00257 /* Set device name characteristic data */ 00258 ble.gap().setDeviceName((const uint8_t *) DEVICE_NAME); 00259 00260 /* Setup advertising payload */ 00261 //set modes "no EDR", "discoverable" for beacon type advertisements 00262 ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE); 00263 00264 00265 //from GAP example 00266 /* Sacrifice 2B of 31B to AdvType overhead, rest goes to AdvData array you define */ 00267 ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, AdvData, sizeof(AdvData)); 00268 00269 /* Setup advertising parameters: not connectable */ 00270 ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_NON_CONNECTABLE_UNDIRECTED); 00271 ble.gap().setAdvertisingInterval(900); //one advertisment every 300ms. Self tickers, so you don't have to worry. 00272 00273 } 00274 00275 00276 //not needed anymore 00277 void my_analogin_init(void) 00278 { 00279 00280 NRF_ADC->CONFIG = (ADC_CONFIG_RES_10bit << ADC_CONFIG_RES_Pos) | 00281 (ADC_CONFIG_INPSEL_SupplyOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | 00282 //(ADC_CONFIG_INPSEL_AnalogInputOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | 00283 (ADC_CONFIG_REFSEL_VBG << ADC_CONFIG_REFSEL_Pos) | 00284 (ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos) | 00285 //(ADC_CONFIG_PSEL_AnalogInput4 << ADC_CONFIG_PSEL_Pos) | 00286 (ADC_CONFIG_EXTREFSEL_None << ADC_CONFIG_EXTREFSEL_Pos); 00287 NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled; 00288 } 00289 00290 00291 /* **************************************** 00292 * Read battery voltage using bandgap reference 00293 * shunt Vdd to ADC, thanks to Marcelo Salazar's notes here: 00294 * https://developer.mbed.org/users/MarceloSalazar/notebook/measuring-battery-voltage-with-nordic-nrf51x/ 00295 *******************************************/ 00296 uint16_t read_bat_volt(void) 00297 { 00298 //10 bit resolution, route Vdd as analog input, set ADC ref to VBG band gap 00299 //disable analog pin select "PSEL" because we're using Vdd as analog input 00300 //no external voltage reference 00301 NRF_ADC->CONFIG = (ADC_CONFIG_RES_10bit << ADC_CONFIG_RES_Pos) | 00302 (ADC_CONFIG_INPSEL_SupplyOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | 00303 //(ADC_CONFIG_INPSEL_AnalogInputOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | 00304 (ADC_CONFIG_REFSEL_VBG << ADC_CONFIG_REFSEL_Pos) | 00305 (ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos) | 00306 //(ADC_CONFIG_PSEL_AnalogInput4 << ADC_CONFIG_PSEL_Pos) | 00307 (ADC_CONFIG_EXTREFSEL_None << ADC_CONFIG_EXTREFSEL_Pos); 00308 00309 //NRF_ADC->CONFIG &= ~ADC_CONFIG_PSEL_Msk; 00310 //NRF_ADC->CONFIG |= ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos; 00311 NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled; 00312 NRF_ADC->TASKS_START = 1; 00313 00314 00315 //while loop doesn't actually loop until reading comlete, use a wait. 00316 while (((NRF_ADC->BUSY & ADC_BUSY_BUSY_Msk) >> ADC_BUSY_BUSY_Pos) == ADC_BUSY_BUSY_Busy) {}; 00317 wait_ms(1); 00318 00319 //save off RESULT before disabling. 00320 //uint16_t myresult = (uint16_t)NRF_ADC->RESULT; 00321 00322 //disable ADC to lower bat consumption 00323 NRF_ADC->TASKS_STOP = 1; 00324 //NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Disabled; //disable to shutdown ADC & lower bat consumption 00325 00326 return (uint16_t)NRF_ADC->RESULT; // 10 bit 00327 //return myresult; 00328 } //end read_bat_volt 00329 00330 00331 00332 /* **************************************** 00333 * Read battery voltage using bandgap reference 00334 * shunt analog pin to ADC, from API here 00335 * https://developer.mbed.org/users/mbed_official/code/mbed-src/file/cb4253f91ada/targets/hal/TARGET_NORDIC/TARGET_NRF51822/analogin_api.c 00336 *******************************************/ 00337 uint16_t read_ADC_pin(void) 00338 { 00339 00340 //10 bit resolution, route PSEL pin as 1/3 input sel, 00341 //set ADC ref to VBG band gap 00342 //set AnalogInput4 as input pin (this is P0.03) 00343 //no external voltage reference 00344 NRF_ADC->CONFIG = (ADC_CONFIG_RES_10bit << ADC_CONFIG_RES_Pos) | 00345 //(ADC_CONFIG_INPSEL_SupplyOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | 00346 (ADC_CONFIG_INPSEL_AnalogInputOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | 00347 (ADC_CONFIG_REFSEL_VBG << ADC_CONFIG_REFSEL_Pos) | 00348 //ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos) | 00349 (ADC_CONFIG_PSEL_AnalogInput4 << ADC_CONFIG_PSEL_Pos) | 00350 (ADC_CONFIG_EXTREFSEL_None << ADC_CONFIG_EXTREFSEL_Pos); 00351 //set pin select to AnalogInput4 = pin 7 = p0.03 = AIN4 00352 //NRF_ADC->CONFIG &= ~ADC_CONFIG_PSEL_Msk; 00353 //NRF_ADC->CONFIG |= ADC_CONFIG_PSEL_AnalogInput4 << ADC_CONFIG_PSEL_Pos; 00354 NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled; 00355 NRF_ADC->TASKS_START = 1; 00356 00357 00358 //while loop doesn't actually loop until reading comlete, use a wait. 00359 while (((NRF_ADC->BUSY & ADC_BUSY_BUSY_Msk) >> ADC_BUSY_BUSY_Pos) == ADC_BUSY_BUSY_Busy) {}; 00360 wait_ms(1); //needed because busy while loop doesn't run. 00361 00362 //save off RESULT before disabling. 00363 //uint16_t myresult = (uint16_t)NRF_ADC->RESULT; 00364 00365 //disable ADC to lower bat consumption 00366 //NRF_ADC->TASKS_STOP = 1; 00367 //NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Disabled; //disable to shutdown ADC & lower bat consumption 00368 00369 return (uint16_t)NRF_ADC->RESULT; // 10 bit 00370 //return myresult; 00371 } //end read_ADC_pin 00372 00373 00374 /* **************************************** 00375 * Pattern scheme indicating "one of ours" 00376 * generate first part of ADV data so that observer can recognize it as "one of ours". 00377 * use specific schema to decide how we're recognizing our sensor ADV 00378 *******************************************/ 00379 void hash_first_section(uint8_t * dest, const uint8_t * mac_addr, const char * bat_volt_str) 00380 { 00381 dest[0] = mac_addr[3]; 00382 dest[1] = mac_addr[2]; 00383 dest[2] = mac_addr[1]; 00384 dest[3] = mac_addr[0]; 00385 dest[4] = bat_volt_str[0]; 00386 dest[5] = bat_volt_str[1]; 00387 dest[6] = bat_volt_str[2]; 00388 dest[7] = bat_volt_str[3]; 00389 dest[8] = 0x10; 00390 dest[9] = 0x11; 00391 #if MyDebugEnb 00392 00393 device.printf("hash array: "); 00394 for (int i=0; i<10; i++) 00395 { 00396 device.printf("%x ", dest[i]); 00397 } 00398 device.printf("\r\n"); 00399 #endif 00400 } 00401 00402 00403 /* **************************************** 00404 * 00405 * Main Loop 00406 * 00407 *******************************************/ 00408 int main(void) 00409 { 00410 00411 #if MyDebugEnb 00412 device.baud(9600); 00413 device.printf("started sensor node 36 "); 00414 device.printf("\r\n"); 00415 #endif 00416 00417 00418 Tmr_From_Birthday.start(); //tracks # sec since birthday 00419 00420 00421 BLE &ble = BLE::Instance(); 00422 ble.init(bleInitComplete); 00423 00424 float bat_reading; //hold battery voltage reading (Vbg/Vcc) 00425 00426 my_analogin_init();//routes band-gap to analog input 00427 00428 /* SpinWait for initialization to complete. This is necessary because the 00429 * BLE object is used in the main loop below. */ 00430 while (ble.hasInitialized() == false) { /* spin loop */ } 00431 00432 //every X seconds, sends period update, up to 1800 (30 minutes) 00433 Tic_Periodic.attach(periodic_Callback, Periodic_Update_Seconds); //send updated I/O every x seconds 00434 Tic_Birthday.attach(clock_reset_Callback, Periodicity); //clock algorithm periodicity 00435 00436 00437 ble.getAddress(0,mac_reverse); //last byte of MAC (as shown on phone app) is at mac[0], not mac[6]; 00438 #if MyDebugEnb 00439 device.printf("mac = "); 00440 for (int i=0; i<6; i++) //prints out MAC address in reverse order; opps. 00441 { 00442 device.printf("%x:", mac_reverse[i]); 00443 } 00444 device.printf("\r\n"); 00445 #endif 00446 while (true) 00447 { //Main Loop 00448 00449 uint16_t seconds_Old =(uint16_t)(Tmr_From_Birthday.read_ms()/1000); // 0-1800 seconds (30 minutes) 00450 00451 #if MyDebugEnb 00452 device.printf("current time in seconds: %d \r\n", seconds_Old); 00453 #endif 00454 00455 //set both pins to pull-up, so they're not floating when we read state 00456 button1.mode(PullUp); 00457 button2.mode(PullUp); 00458 00459 //expect either button1 or button2 is grounded, b/c using SPDT reed switch 00460 //the "common" pin on the reed switch should be on GND 00461 uint8_t button1_state = button1.read(); 00462 uint8_t button2_state = button2.read(); 00463 00464 00465 //let's just update the pins on every wake. Insurance against const drain. 00466 //if state == 0, pin is grounded. Unset interrupt and float pin, set the other pin for ISR 00467 if ( (button1_state == 0) && (button2_state == 1) ) 00468 { 00469 magnet_near = 1; 00470 //button1.disable_irq() //don't know if disables IRQ on port or pin 00471 button1.fall(NULL); //disable interrupt 00472 button1.rise(NULL); //disable interrupt 00473 button1.mode(PullNone); //float pin to save battery 00474 00475 //button2.disable_irq() //don't know if disables IRQ on port or pin 00476 button2.fall(buttonReleasedCallback); //enable interrupt 00477 button2.rise(buttonReleasedCallback); //enable interrupt 00478 button2.mode(PullUp); //pull up on pin to get interrupt 00479 #if MyDebugEnb 00480 device.printf("=== button 1! %d seconds=== \r\n", seconds_Old); 00481 #endif 00482 } //end if button2 00483 else if ( (button1_state == 1) && (button2_state == 0) ) //assume other pin is open circuit 00484 { 00485 magnet_near = 0; 00486 //button1.disable_irq() //don't know if disables IRQ on port or pin 00487 button1.fall(buttonReleasedCallback); //enable interrupt 00488 button1.rise(buttonReleasedCallback); //enable interrupt 00489 button1.mode(PullUp); //pull up on pin to get interrupt 00490 00491 //button2.disable_irq() //don't know if disables IRQ on port or pin 00492 button2.fall(NULL); //disable interrupt 00493 button2.rise(NULL); //disable interrupt 00494 button2.mode(PullNone); //float pin to save battery 00495 #if MyDebugEnb 00496 device.printf("=== button 2! === %d seconds\r\n", seconds_Old); 00497 #endif 00498 } //end if button1 00499 else //odd state, shouldn't happen, suck battery and pullup both pins 00500 { 00501 magnet_near = 2; 00502 //AdvData[4] = 0x33; 00503 //button1.disable_irq() //don't know if disables IRQ on port or pin 00504 button1.fall(buttonReleasedCallback); //disable interrupt 00505 button1.rise(buttonReleasedCallback); //disable interrupt 00506 button1.mode(PullUp); //float pin to save battery 00507 00508 //button2.disable_irq() //don't know if disables IRQ on port or pin 00509 button2.fall(buttonReleasedCallback); //disable interrupt 00510 button2.rise(buttonReleasedCallback); //disable interrupt 00511 button2.mode(PullUp); //float pin to save battery 00512 #if MyDebugEnb 00513 device.printf("no buttons!! %d seconds\r\n", seconds_Old); 00514 #endif 00515 } //end odd state 00516 00517 00518 if (Flag_Update_IO) { 00519 /* Do blocking calls or whatever hardware-specific action is 00520 * necessary to poll the sensor. */ 00521 00522 //call attach again on periodic update to reset ticker 00523 //next periodic updates happens Perioidc_Update_Seconds after I/O events 00524 Tic_Periodic.attach(periodic_Callback, Periodic_Update_Seconds); 00525 Xmit_Cnt++; //increment transmit counter when updating I/O 00526 00527 00528 //read and convert battery voltage 00529 bat_reading = (float)read_bat_volt(); 00530 bat_reading = (bat_reading * 3.6) / 1024.0; 00531 #if MyDebugEnb 00532 device.printf("bat reading: %f \r\n", bat_reading); 00533 #endif 00534 //write battery voltage 00535 uint8_t total_chars; 00536 memset(&bat_volt_char[0], 0, sizeof(bat_volt_char)); //clear out buffer 00537 //convert battery voltage float value to string reprsentation to 2 decimal places, and save the size of string. 00538 total_chars = sprintf (bat_volt_char, "%.2f", bat_reading); 00539 00540 00541 //read and convert analog voltage. Comment out this section if note needed, saves some battery 00542 NRF_ADC->TASKS_STOP = 1; 00543 float analogreading; 00544 analogreading = (float)read_ADC_pin(); 00545 analogreading = (analogreading * 3.6) / 1024.0; 00546 #if MyDebugEnb 00547 device.printf("separate analog reading: %.02f \r\n", analogreading); 00548 #endif 00549 00550 //disable ADC to save power 00551 NRF_ADC->TASKS_STOP = 1; 00552 NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Disabled; //disable to shutdown ADC & lower bat consumption 00553 00554 00555 #if MyDebugEnb 00556 device.printf("char buff: %c%c%c%c \r\n", bat_volt_char[0], bat_volt_char[1], bat_volt_char[2], bat_volt_char[3]); 00557 device.printf("num chars: %d \r\n", total_chars); 00558 #endif 00559 00560 00561 //Generate "First Section" for ADV_Data so gateway will recognize our advertisement pattern 00562 hash_first_section(Adv_First_Section, mac_reverse, bat_volt_char); 00563 00564 00565 /* **************************************** 00566 * start writing out ADVData array 00567 * todo: this is easy to write but hard to read. Maybe make it easy to read and hard to write? 00568 ******************************************/ 00569 memset(&AdvData[0], 0, sizeof(AdvData)); 00570 uint8_t JSON_loc=0; //AdvData[0] 00571 00572 AdvData[0] = Adv_First_Section[0]; //"our device" flag, MAC[3] 00573 JSON_loc++; //JSON_loc == 1 00574 AdvData[1] = Adv_First_Section[1]; //"out device" flag, MAC[2]... 00575 JSON_loc++; //JSON_loc == 2 00576 AdvData[2] = Adv_First_Section[2]; 00577 JSON_loc++; //JSON_loc == 3 00578 AdvData[3] = Adv_First_Section[3]; 00579 JSON_loc++; //JSON_loc == 4 00580 AdvData[4] = Adv_First_Section[4]; 00581 JSON_loc++; //JSON_loc == 5 00582 AdvData[5] = Adv_First_Section[5]; 00583 JSON_loc++; //JSON_loc == 6 00584 AdvData[6] = Adv_First_Section[6]; 00585 JSON_loc++; 00586 AdvData[7] = Adv_First_Section[7]; 00587 JSON_loc++; 00588 AdvData[8] = Adv_First_Section[8]; 00589 JSON_loc++; 00590 AdvData[9] = Adv_First_Section[9]; 00591 JSON_loc++; 00592 00593 #if MyDebugEnb 00594 device.printf("ADV first 10 array: "); 00595 for (int i=0; i<10; i++) 00596 { 00597 device.printf("%x ", AdvData[i]); 00598 } 00599 device.printf("\r\n"); 00600 #endif 00601 00602 00603 JSON_loc = 10; 00604 //Start of encrypted user data 00605 00606 //[10] and [11] hold 2 bytes for how many seconds since birthday, little endian 00607 AdvData[10] = seconds_Old & 0xFF; 00608 JSON_loc++; 00609 AdvData[11] = (seconds_Old >> 8) & 0xFF; 00610 JSON_loc++; 00611 00612 AdvData[12] = Xmit_Cnt; 00613 JSON_loc++; 00614 00615 //start of jason data 00616 //"mag": 00617 JSON_loc = 13; 00618 AdvData[JSON_loc] = 0x22; //ADV_Data[13] = " 00619 JSON_loc++; //14 00620 00621 AdvData[JSON_loc] = 0x6d; //ADV_Data[14] = m 00622 JSON_loc++; //15 00623 00624 AdvData[JSON_loc] = 0x61; //ADV_Data[15] = a 00625 JSON_loc++; //16 00626 00627 AdvData[JSON_loc] = 0x67; //ADV_Data[16] = g 00628 JSON_loc++; //17 00629 00630 //for periodic calls, we want to add an extra mqtt level "p", using "/p" 00631 //to delineate between MQTT publishes from real world I/O interrupts vs timer interrupts 00632 if (Flag_Periodic_Call) 00633 { 00634 AdvData[JSON_loc] = 0x2f; // ADV_Data[17] = / 00635 JSON_loc++; //18 00636 AdvData[JSON_loc] = 0x70; // ADV_Data[18] =p 00637 JSON_loc++; //19 00638 } 00639 00640 AdvData[JSON_loc] = 0x22; //ADV_Data[17 or 19] = " 00641 JSON_loc++; //20 00642 00643 AdvData[JSON_loc] = 0x3a; //ADV_Data[18 or 20] = : 00644 JSON_loc++; //21 00645 00646 //convert magnet variable to string, for magnet sensor, this is easy 00647 //since we only have 1 or 0, but this also works for analog values 00648 memset(&buffer[0], 0, sizeof(buffer)); //clear out buffer 00649 total_chars = sprintf (buffer, "%d", magnet_near); //returns total number of characters, which is 1 character. 00650 for (int i=0; i < total_chars; i++) 00651 { 00652 AdvData[JSON_loc] = buffer[i]; 00653 JSON_loc++; //23 00654 } //JSON_loc left at location of next character 00655 00656 00657 //AdvData[JSON_loc] = 0x0; //since AdvData was cleared to start with, we don't need to null term 00658 00659 ApplicationData_t appData; 00660 setupApplicationData(appData); 00661 00662 /********************* 00663 * start encrypting last 16 bytes of ADV_Data 00664 *********************/ 00665 for (int i=0; i<16; i++) 00666 { 00667 src_buf[i] = AdvData[i+10]; //start of encrypted section is at AdvData[10] 00668 } 00669 nrf_ecb_init(); 00670 nrf_ecb_set_key(key_buf); 00671 bool successful_ecb = nrf_ecb_crypt(des_buf, src_buf); 00672 #if MyDebugEnb 00673 device.printf("success ecb = %d \r\n", successful_ecb); 00674 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]); 00675 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]); 00676 #endif 00677 for (int i=0; i<16; i++) //replace last 16 bytes with encrypted 16 bytes 00678 { 00679 AdvData[i+10] = des_buf[i]; 00680 } 00681 00682 //set payload for advertisement to our custom manufactured data. First 5 bytes is BLE standard, last 26 bytes is our array 00683 //ble.gap().updateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, (uint8_t *) &appData, sizeof(ApplicationData_t)); 00684 ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::MANUFACTURER_SPECIFIC_DATA, AdvData, sizeof(AdvData)); 00685 00686 Flag_Update_IO = false; 00687 Flag_Periodic_Call = false; 00688 00689 ble.gap().startAdvertising(); 00690 Tic_Stop_Adv.attach(stop_adv_Callback, 3); /* trigger turn off advertisement after X seconds */ 00691 00692 }//end Flag_Update_IO 00693 00694 00695 if (Flag_Detach_Adv_Tic == true) //ticker callback flag to stop advertising 00696 { 00697 ble.gap().stopAdvertising(); //may be safer to execute BLE operations in main 00698 Tic_Stop_Adv.detach(); 00699 Flag_Detach_Adv_Tic = false; 00700 } 00701 00702 00703 ble.waitForEvent(); //sleeps until interrupt form ticker or I/O 00704 }//end forever while 00705 }//end main
Generated on Thu Jul 14 2022 14:14:43 by
1.7.2