Merck / Mbed OS SmartCap_OS5

Dependencies:   nRF51822

Source/main.cpp@25:42163d650266, 2019-03-25 (annotated)

Committer:
sgetz7908
Date:
Mon Mar 25 15:24:15 2019 +0000
Revision:
25:42163d650266
Parent:
24:761c30334cf4
Child:
26:a577c4b69fe0
Everything here except EOL mode.; Some Flashing led stuff is in here for debugging.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
sgetz7908 23:7ca590427f0e 1 //**********************************************************************
sgetz7908 23:7ca590427f0e 2 //
sgetz7908 23:7ca590427f0e 3 // SmartCap2 Main
sgetz7908 23:7ca590427f0e 4 //
sgetz7908 23:7ca590427f0e 5 // SPG 2/22/2019
sgetz7908 23:7ca590427f0e 6 //
sgetz7908 23:7ca590427f0e 7 // Copyright (c) 2019 Polygenesis
sgetz7908 23:7ca590427f0e 8 //
sgetz7908 23:7ca590427f0e 9 //**********************************************************************
sgetz7908 23:7ca590427f0e 10 /// @file main.cpp
sgetz7908 23:7ca590427f0e 11
sgetz7908 23:7ca590427f0e 12 #include <events/mbed_events.h>
sgetz7908 23:7ca590427f0e 13 #include <mbed.h>
sgetz7908 24:761c30334cf4 14 #include <ctype.h>
sgetz7908 23:7ca590427f0e 15 #include "main.h"
sgetz7908 23:7ca590427f0e 16 #include "hw.h"
sgetz7908 23:7ca590427f0e 17 #include "ble/BLE.h"
sgetz7908 23:7ca590427f0e 18 #include "ble/Gap.h"
sgetz7908 23:7ca590427f0e 19 #include "BLE_Stuff.h"
sgetz7908 23:7ca590427f0e 20 #include "ble/services/UARTService.h"
sgetz7908 23:7ca590427f0e 21 #include "infoService.h"
sgetz7908 23:7ca590427f0e 22 #include "log.h"
sgetz7908 23:7ca590427f0e 23 #include "nrf_soc.h"
sgetz7908 23:7ca590427f0e 24 #include "mem.h"
sgetz7908 23:7ca590427f0e 25
sgetz7908 23:7ca590427f0e 26 void process_state(void);
sgetz7908 24:761c30334cf4 27 void start_periodic_tick(uint32_t sec);
sgetz7908 23:7ca590427f0e 28
sgetz7908 23:7ca590427f0e 29 EventQueue eventQueue(/* event count */ 16 * EVENTS_EVENT_SIZE);
sgetz7908 23:7ca590427f0e 30
sgetz7908 23:7ca590427f0e 31 #if TEST_ON_NRF51_DK==0
sgetz7908 23:7ca590427f0e 32 // real board
sgetz7908 23:7ca590427f0e 33 //int reg_mode = 1;
sgetz7908 23:7ca590427f0e 34 InterruptIn is_package_open(LIGHT_SENSE, PullNone); // will be pulled hi when package_is_open (only if package_open_sense_enable = 1)
sgetz7908 23:7ca590427f0e 35 DigitalOut package_open_sense_enable(LIGHT_SENSE_ENABLE, 0);
sgetz7908 23:7ca590427f0e 36
sgetz7908 23:7ca590427f0e 37 DigitalOut cap_sense_led(CAP_SENSE_LED, 0);
sgetz7908 23:7ca590427f0e 38 DigitalOut vdd_enable(VDD_ENABLE, 0);
sgetz7908 23:7ca590427f0e 39
sgetz7908 23:7ca590427f0e 40 DigitalOut led(LED, 0); // LED for debugging purposes
sgetz7908 24:761c30334cf4 41
sgetz7908 24:761c30334cf4 42 #if UART_DEBUGGING
sgetz7908 24:761c30334cf4 43 #define debug(STR) BLE_UART_xmit(STR); BLE_UART_xmit("\n");
sgetz7908 24:761c30334cf4 44 #else
sgetz7908 24:761c30334cf4 45 #define debug(...)
sgetz7908 24:761c30334cf4 46 #endif
sgetz7908 23:7ca590427f0e 47 #else
sgetz7908 23:7ca590427f0e 48 // simulate on nRF51-DK
sgetz7908 23:7ca590427f0e 49 DigitalIn capon(BUTTON1, PullUp);
sgetz7908 23:7ca590427f0e 50 //DigitalIn reg_mode(BUTTON3, PullUp);
sgetz7908 24:761c30334cf4 51 InterruptIn is_package_open(BUTTON2, PullUp); // will be pulled hi when package_is_open
sgetz7908 23:7ca590427f0e 52 DigitalOut package_open_sense_enable(LED3, 0);
sgetz7908 23:7ca590427f0e 53
sgetz7908 23:7ca590427f0e 54 DigitalOut cap_sense_led(LED2, 0);
sgetz7908 23:7ca590427f0e 55 DigitalOut vdd_enable(LED4, 0);
sgetz7908 23:7ca590427f0e 56
sgetz7908 23:7ca590427f0e 57 DigitalOut led(LED1, 0); // LED for debugging purposes
sgetz7908 24:761c30334cf4 58 #if UART_DEBUGGING
sgetz7908 24:761c30334cf4 59 Serial pc(USBTX, USBRX); // tx, rx
sgetz7908 24:761c30334cf4 60 #define debug(STR) pc.printf(STR)
sgetz7908 24:761c30334cf4 61 #else
sgetz7908 24:761c30334cf4 62 #define debug(...)
sgetz7908 24:761c30334cf4 63 #endif
sgetz7908 23:7ca590427f0e 64 #endif
sgetz7908 23:7ca590427f0e 65
sgetz7908 23:7ca590427f0e 66 LowPowerTicker periodic_ticker; // this handle the RTC
sgetz7908 23:7ca590427f0e 67
sgetz7908 24:761c30334cf4 68 float tick_rate = FAST_TICK_SEC;
sgetz7908 23:7ca590427f0e 69
sgetz7908 24:761c30334cf4 70 bool package_open_detected = false;
sgetz7908 23:7ca590427f0e 71 bool is_cap_off = false; // 0=cap on, 1=cap off
sgetz7908 23:7ca590427f0e 72 uint32_t cap_off_time;
sgetz7908 23:7ca590427f0e 73
sgetz7908 24:761c30334cf4 74 uint16_t off_reading;
sgetz7908 24:761c30334cf4 75 uint16_t on_reading;
sgetz7908 24:761c30334cf4 76
sgetz7908 23:7ca590427f0e 77 typedef enum {
sgetz7908 23:7ca590427f0e 78 INIT,
sgetz7908 23:7ca590427f0e 79 POST,
sgetz7908 23:7ca590427f0e 80 TEST_MODE,
sgetz7908 23:7ca590427f0e 81 SHIP_MODE_WAIT_DARK,
sgetz7908 23:7ca590427f0e 82 SHIP_MODE_WAIT_LIGHT,
sgetz7908 24:761c30334cf4 83 SHIP_MODE_CHECK_CAP,
sgetz7908 23:7ca590427f0e 84 SHIP_MODE_WAIT_CAP_OFF,
sgetz7908 23:7ca590427f0e 85 IN_USE_SETUP,
sgetz7908 23:7ca590427f0e 86 WAIT_CAP_OFF,
sgetz7908 23:7ca590427f0e 87 WAIT_CAP_ON,
sgetz7908 23:7ca590427f0e 88 OTHER
sgetz7908 23:7ca590427f0e 89 } state_t;
sgetz7908 23:7ca590427f0e 90
sgetz7908 23:7ca590427f0e 91 state_t state = INIT;
sgetz7908 23:7ca590427f0e 92
sgetz7908 23:7ca590427f0e 93 /// Light detected interrupt
sgetz7908 23:7ca590427f0e 94 void light_interrupt(void)
sgetz7908 24:761c30334cf4 95 { // dark to light transition
sgetz7908 24:761c30334cf4 96 package_open_detected = true;
sgetz7908 25:42163d650266 97 start_periodic_tick(FAST_TICK_SEC);
sgetz7908 23:7ca590427f0e 98 }
sgetz7908 23:7ca590427f0e 99
sgetz7908 23:7ca590427f0e 100 /// Test to see if Cap is off or on
sgetz7908 23:7ca590427f0e 101 void test_cap(void)
sgetz7908 23:7ca590427f0e 102 {
sgetz7908 24:761c30334cf4 103 #if TEST_ON_NRF51_DK == 0
sgetz7908 23:7ca590427f0e 104 vdd_enable = 1; // enable analog power
sgetz7908 23:7ca590427f0e 105 wait(0.00075);
sgetz7908 23:7ca590427f0e 106 off_reading = adc_read(ADC_CHAN_CAP_SENSE,2);
sgetz7908 23:7ca590427f0e 107 cap_sense_led = 1; // enable led
sgetz7908 23:7ca590427f0e 108 wait(0.00075);
sgetz7908 23:7ca590427f0e 109 on_reading = adc_read(ADC_CHAN_CAP_SENSE,2);
sgetz7908 23:7ca590427f0e 110 // turn everything off
sgetz7908 23:7ca590427f0e 111 cap_sense_led = 0;
sgetz7908 23:7ca590427f0e 112 vdd_enable = 0;
sgetz7908 23:7ca590427f0e 113
sgetz7908 23:7ca590427f0e 114 if(on_reading > off_reading+CAP_THRESHOLD)
sgetz7908 23:7ca590427f0e 115 #else
sgetz7908 23:7ca590427f0e 116 if(capon)
sgetz7908 23:7ca590427f0e 117 #endif
sgetz7908 23:7ca590427f0e 118 {
sgetz7908 23:7ca590427f0e 119 is_cap_off = 0;
sgetz7908 24:761c30334cf4 120 #if ENABLE_LED
sgetz7908 24:761c30334cf4 121 led = 0;
sgetz7908 24:761c30334cf4 122 #endif
sgetz7908 23:7ca590427f0e 123 }
sgetz7908 23:7ca590427f0e 124 else
sgetz7908 23:7ca590427f0e 125 {
sgetz7908 23:7ca590427f0e 126 is_cap_off = 1;
sgetz7908 24:761c30334cf4 127 #if ENABLE_LED
sgetz7908 24:761c30334cf4 128 led = 1;
sgetz7908 24:761c30334cf4 129 #endif
sgetz7908 23:7ca590427f0e 130 }
sgetz7908 24:761c30334cf4 131 }
sgetz7908 24:761c30334cf4 132
sgetz7908 24:761c30334cf4 133 void periodic_tick_task(void)
sgetz7908 24:761c30334cf4 134 {
sgetz7908 24:761c30334cf4 135 test_cap();
sgetz7908 24:761c30334cf4 136 process_state();
sgetz7908 23:7ca590427f0e 137 }
sgetz7908 23:7ca590427f0e 138
sgetz7908 23:7ca590427f0e 139 /// this interrupt is run every PERIODIC_TICK_SEC seconds
sgetz7908 23:7ca590427f0e 140 void periodic_tick()
sgetz7908 23:7ca590427f0e 141 {
sgetz7908 24:761c30334cf4 142 update_rtc(tick_rate); // keep rtc updated
sgetz7908 24:761c30334cf4 143 eventQueue.call(periodic_tick_task); // starts as non-interrupt task so we can use wait();
sgetz7908 24:761c30334cf4 144 }
sgetz7908 24:761c30334cf4 145
sgetz7908 24:761c30334cf4 146 void start_periodic_tick(uint32_t sec)
sgetz7908 24:761c30334cf4 147 {
sgetz7908 24:761c30334cf4 148 tick_rate = sec;
sgetz7908 24:761c30334cf4 149 periodic_ticker.detach();
sgetz7908 24:761c30334cf4 150 periodic_ticker.attach(&periodic_tick ,sec);
sgetz7908 24:761c30334cf4 151 }
sgetz7908 24:761c30334cf4 152
sgetz7908 24:761c30334cf4 153 void stop_periodic_tick(void)
sgetz7908 24:761c30334cf4 154 {
sgetz7908 24:761c30334cf4 155 periodic_ticker.detach();
sgetz7908 23:7ca590427f0e 156 }
sgetz7908 23:7ca590427f0e 157
sgetz7908 23:7ca590427f0e 158 /// call here to flash the LED n times.
sgetz7908 23:7ca590427f0e 159 // n=0 to flash forever
sgetz7908 23:7ca590427f0e 160 void flash_led(int n, float sec)
sgetz7908 23:7ca590427f0e 161 {
sgetz7908 23:7ca590427f0e 162 if(n==0)
sgetz7908 23:7ca590427f0e 163 { // flash forever
sgetz7908 23:7ca590427f0e 164 while(1)
sgetz7908 23:7ca590427f0e 165 {
sgetz7908 23:7ca590427f0e 166 led = 1;
sgetz7908 23:7ca590427f0e 167 wait(sec);
sgetz7908 23:7ca590427f0e 168 led = 0;
sgetz7908 23:7ca590427f0e 169 wait(sec);
sgetz7908 23:7ca590427f0e 170 }
sgetz7908 23:7ca590427f0e 171 }
sgetz7908 23:7ca590427f0e 172 else
sgetz7908 23:7ca590427f0e 173 { // flash n times
sgetz7908 23:7ca590427f0e 174 while(n--)
sgetz7908 23:7ca590427f0e 175 {
sgetz7908 23:7ca590427f0e 176 led = 1;
sgetz7908 23:7ca590427f0e 177 wait(sec);
sgetz7908 23:7ca590427f0e 178 led = 0;
sgetz7908 23:7ca590427f0e 179 wait(sec);
sgetz7908 23:7ca590427f0e 180 }
sgetz7908 23:7ca590427f0e 181 }
sgetz7908 23:7ca590427f0e 182 }
sgetz7908 23:7ca590427f0e 183
sgetz7908 23:7ca590427f0e 184
sgetz7908 23:7ca590427f0e 185 state_t last_state = OTHER;
sgetz7908 23:7ca590427f0e 186
sgetz7908 23:7ca590427f0e 187 /// Main state machine
sgetz7908 23:7ca590427f0e 188 /// Called whenever a sensor changes
sgetz7908 23:7ca590427f0e 189 void process_state(void)
sgetz7908 23:7ca590427f0e 190 {
sgetz7908 24:761c30334cf4 191 do
sgetz7908 23:7ca590427f0e 192 {
sgetz7908 24:761c30334cf4 193 #if UART_DEBUGGING==1
sgetz7908 24:761c30334cf4 194 if(last_state != state)
sgetz7908 24:761c30334cf4 195 {
sgetz7908 24:761c30334cf4 196 debug(uli2a(state));
sgetz7908 24:761c30334cf4 197 debug("\n");
sgetz7908 24:761c30334cf4 198 }
sgetz7908 24:761c30334cf4 199 #endif
sgetz7908 23:7ca590427f0e 200 last_state = state;
sgetz7908 23:7ca590427f0e 201
sgetz7908 24:761c30334cf4 202 switch(state)
sgetz7908 24:761c30334cf4 203 {
sgetz7908 24:761c30334cf4 204 case INIT:
sgetz7908 24:761c30334cf4 205 log_add(EVENT_POWER, 0, 0, 0); // log event
sgetz7908 24:761c30334cf4 206 set_radio(true);
sgetz7908 25:42163d650266 207 start_periodic_tick(FAST_TICK_SEC);
sgetz7908 24:761c30334cf4 208 #if SKIP_SHIP_MODE
sgetz7908 24:761c30334cf4 209 state = IN_USE_SETUP;
sgetz7908 24:761c30334cf4 210 #else
sgetz7908 24:761c30334cf4 211 state = POST;
sgetz7908 24:761c30334cf4 212 #endif
sgetz7908 24:761c30334cf4 213 break;
sgetz7908 24:761c30334cf4 214
sgetz7908 24:761c30334cf4 215 case POST:
sgetz7908 24:761c30334cf4 216 // check CRC ?
sgetz7908 24:761c30334cf4 217
sgetz7908 24:761c30334cf4 218 // Check Misc.
sgetz7908 24:761c30334cf4 219
sgetz7908 24:761c30334cf4 220 //if(error) flash_led(0,0.1); // flash forever to indicate error
sgetz7908 25:42163d650266 221
sgetz7908 24:761c30334cf4 222 if(NV_TESTING_REQUIRED)
sgetz7908 24:761c30334cf4 223 {
sgetz7908 24:761c30334cf4 224 flash_led(1, 1.0);
sgetz7908 24:761c30334cf4 225 package_open_sense_enable = 1;
sgetz7908 25:42163d650266 226 start_periodic_tick(FAST_TICK_SEC);
sgetz7908 24:761c30334cf4 227 state = TEST_MODE;
sgetz7908 24:761c30334cf4 228 }
sgetz7908 24:761c30334cf4 229 else
sgetz7908 24:761c30334cf4 230 {
sgetz7908 24:761c30334cf4 231 state = IN_USE_SETUP;
sgetz7908 24:761c30334cf4 232 }
sgetz7908 25:42163d650266 233
sgetz7908 24:761c30334cf4 234 break;
sgetz7908 24:761c30334cf4 235
sgetz7908 25:42163d650266 236 case TEST_MODE:
sgetz7908 24:761c30334cf4 237 test_cap();
sgetz7908 24:761c30334cf4 238 led = is_cap_off;
sgetz7908 25:42163d650266 239 if(!NV_TESTING_REQUIRED && is_package_open)
sgetz7908 24:761c30334cf4 240 { // testing passed
sgetz7908 24:761c30334cf4 241 set_radio(false); // already done when NV_TESTING_REQUIRED was cleared.
sgetz7908 24:761c30334cf4 242 led = 0;
sgetz7908 24:761c30334cf4 243 state = SHIP_MODE_WAIT_DARK;
sgetz7908 24:761c30334cf4 244 }
sgetz7908 24:761c30334cf4 245 break;
sgetz7908 24:761c30334cf4 246
sgetz7908 24:761c30334cf4 247 case SHIP_MODE_WAIT_DARK: // Wait for light sensor to see darkness
sgetz7908 25:42163d650266 248 flash_led(1,0.1);
sgetz7908 25:42163d650266 249 if(!is_package_open)
sgetz7908 24:761c30334cf4 250 { // its dark
sgetz7908 24:761c30334cf4 251 state = SHIP_MODE_WAIT_LIGHT;
sgetz7908 24:761c30334cf4 252 }
sgetz7908 24:761c30334cf4 253 break;
sgetz7908 24:761c30334cf4 254
sgetz7908 24:761c30334cf4 255 case SHIP_MODE_WAIT_LIGHT:
sgetz7908 24:761c30334cf4 256 // set up and enable the Light Sense Interrupt
sgetz7908 24:761c30334cf4 257 // go to lowest power state
sgetz7908 25:42163d650266 258
sgetz7908 24:761c30334cf4 259 debug("Going SHIP MODE\n");
sgetz7908 24:761c30334cf4 260 is_package_open.disable_irq();
sgetz7908 24:761c30334cf4 261 stop_periodic_tick();
sgetz7908 24:761c30334cf4 262 led = 0;
sgetz7908 24:761c30334cf4 263 package_open_detected = false;
sgetz7908 25:42163d650266 264 is_package_open.mode(PullNone);
sgetz7908 24:761c30334cf4 265 is_package_open.rise(&light_interrupt);
sgetz7908 24:761c30334cf4 266 is_package_open.enable_irq();
sgetz7908 24:761c30334cf4 267 state = SHIP_MODE_CHECK_CAP;
sgetz7908 24:761c30334cf4 268
sgetz7908 23:7ca590427f0e 269 break;
sgetz7908 23:7ca590427f0e 270
sgetz7908 24:761c30334cf4 271 case SHIP_MODE_CHECK_CAP:
sgetz7908 25:42163d650266 272
sgetz7908 24:761c30334cf4 273 if(package_open_detected)
sgetz7908 24:761c30334cf4 274 {
sgetz7908 24:761c30334cf4 275 debug("Awake\n");
sgetz7908 25:42163d650266 276 flash_led(10,0.25);
sgetz7908 24:761c30334cf4 277 test_cap();
sgetz7908 24:761c30334cf4 278 if(is_cap_off)
sgetz7908 24:761c30334cf4 279 {
sgetz7908 24:761c30334cf4 280 state = SHIP_MODE_WAIT_DARK;
sgetz7908 24:761c30334cf4 281 }
sgetz7908 24:761c30334cf4 282 else
sgetz7908 24:761c30334cf4 283 {
sgetz7908 24:761c30334cf4 284 state = SHIP_MODE_WAIT_CAP_OFF;
sgetz7908 24:761c30334cf4 285 }
sgetz7908 24:761c30334cf4 286 }
sgetz7908 24:761c30334cf4 287 break;
sgetz7908 24:761c30334cf4 288
sgetz7908 24:761c30334cf4 289 case SHIP_MODE_WAIT_CAP_OFF:
sgetz7908 25:42163d650266 290 if(!is_package_open)
sgetz7908 24:761c30334cf4 291 {
sgetz7908 24:761c30334cf4 292 state = SHIP_MODE_WAIT_LIGHT;
sgetz7908 24:761c30334cf4 293 }
sgetz7908 24:761c30334cf4 294 else
sgetz7908 24:761c30334cf4 295 {
sgetz7908 24:761c30334cf4 296 test_cap();
sgetz7908 24:761c30334cf4 297 if(is_cap_off)
sgetz7908 24:761c30334cf4 298 {
sgetz7908 24:761c30334cf4 299 package_open_sense_enable = 0;
sgetz7908 24:761c30334cf4 300 log_add(EVENT_WAKE_FROM_SHIP, 0, 0, 0);
sgetz7908 24:761c30334cf4 301 state = IN_USE_SETUP;
sgetz7908 24:761c30334cf4 302 }
sgetz7908 24:761c30334cf4 303 }
sgetz7908 24:761c30334cf4 304 break;
sgetz7908 24:761c30334cf4 305
sgetz7908 24:761c30334cf4 306 case IN_USE_SETUP:
sgetz7908 25:42163d650266 307 flash_led(3, .25);
sgetz7908 24:761c30334cf4 308 start_periodic_tick(PERIODIC_TICK_SEC);
sgetz7908 24:761c30334cf4 309 debug("In Use\n");
sgetz7908 24:761c30334cf4 310 state = WAIT_CAP_OFF;
sgetz7908 24:761c30334cf4 311 break;
sgetz7908 23:7ca590427f0e 312
sgetz7908 24:761c30334cf4 313 case WAIT_CAP_OFF: // cap is on, waiting for cap to be removed
sgetz7908 24:761c30334cf4 314 if(is_cap_off)
sgetz7908 24:761c30334cf4 315 { // cap just taken off
sgetz7908 24:761c30334cf4 316 // save cap off time
sgetz7908 24:761c30334cf4 317 cap_off_time = read_clock();
sgetz7908 24:761c30334cf4 318 debug("Cap Off \n");
sgetz7908 24:761c30334cf4 319 state = WAIT_CAP_ON;
sgetz7908 23:7ca590427f0e 320 }
sgetz7908 24:761c30334cf4 321
sgetz7908 24:761c30334cf4 322 break;
sgetz7908 24:761c30334cf4 323
sgetz7908 24:761c30334cf4 324 case WAIT_CAP_ON: // cap currently off, waiting for cap to be put on
sgetz7908 24:761c30334cf4 325
sgetz7908 24:761c30334cf4 326 if(!is_cap_off)
sgetz7908 24:761c30334cf4 327 { // cap just put on
sgetz7908 24:761c30334cf4 328 // log time cap was off
sgetz7908 24:761c30334cf4 329 uint32_t cap_off_dur = read_clock()-cap_off_time;
sgetz7908 24:761c30334cf4 330 if(cap_off_dur>65535) cap_off_dur = 65535;
sgetz7908 24:761c30334cf4 331 log_add(EVENT_CAP_ON, cap_off_dur & 0xff, (cap_off_dur >> 8)&0xff, 0); // log event
sgetz7908 24:761c30334cf4 332 set_radio(true);
sgetz7908 24:761c30334cf4 333 state = WAIT_CAP_OFF;
sgetz7908 23:7ca590427f0e 334 }
sgetz7908 23:7ca590427f0e 335 break;
sgetz7908 23:7ca590427f0e 336
sgetz7908 24:761c30334cf4 337 default: // illegal state
sgetz7908 24:761c30334cf4 338 state = INIT;
sgetz7908 23:7ca590427f0e 339 break;
sgetz7908 23:7ca590427f0e 340 }
sgetz7908 24:761c30334cf4 341 } while(state != last_state);
sgetz7908 23:7ca590427f0e 342 }
sgetz7908 23:7ca590427f0e 343
sgetz7908 24:761c30334cf4 344 /// process commands sent to the SmartCap over Bluetooth UART
sgetz7908 23:7ca590427f0e 345 void process_cmd(char * cmd)
sgetz7908 23:7ca590427f0e 346 {
sgetz7908 23:7ca590427f0e 347 switch(tolower(cmd[0])) {
sgetz7908 23:7ca590427f0e 348 case 'r': // Get records
sgetz7908 23:7ca590427f0e 349 log_show();
sgetz7908 23:7ca590427f0e 350 //batt_voltage = read_battery_voltage();
sgetz7908 23:7ca590427f0e 351 //updateBattValue(batt_voltage);
sgetz7908 23:7ca590427f0e 352 break;
sgetz7908 23:7ca590427f0e 353
sgetz7908 23:7ca590427f0e 354 case 's': // status
sgetz7908 23:7ca590427f0e 355 switch(tolower(cmd[1])) {
sgetz7908 23:7ca590427f0e 356 case 0: // old, check battery voltage
sgetz7908 23:7ca590427f0e 357 batt_voltage = read_battery_voltage();
sgetz7908 23:7ca590427f0e 358 BLE_UART_xmit("Bat=");
sgetz7908 23:7ca590427f0e 359 BLE_UART_xmit(batt_voltage);
sgetz7908 23:7ca590427f0e 360 BLE_UART_xmit("\n");
sgetz7908 23:7ca590427f0e 361 break;
sgetz7908 23:7ca590427f0e 362
sgetz7908 24:761c30334cf4 363 case 'x': // checksum
sgetz7908 24:761c30334cf4 364 BLE_UART_xmit("sx=");
sgetz7908 23:7ca590427f0e 365 BLE_UART_xmit(0);
sgetz7908 23:7ca590427f0e 366 BLE_UART_xmit("\n");
sgetz7908 23:7ca590427f0e 367 break;
sgetz7908 25:42163d650266 368
sgetz7908 24:761c30334cf4 369 case 'c': // cap sensor analog readings
sgetz7908 24:761c30334cf4 370 BLE_UART_xmit("sc=");
sgetz7908 24:761c30334cf4 371 test_cap();
sgetz7908 24:761c30334cf4 372 BLE_UART_xmit(on_reading);
sgetz7908 24:761c30334cf4 373 BLE_UART_xmit(",");
sgetz7908 24:761c30334cf4 374 BLE_UART_xmit(off_reading);
sgetz7908 24:761c30334cf4 375 BLE_UART_xmit("\n");
sgetz7908 24:761c30334cf4 376 break;
sgetz7908 23:7ca590427f0e 377
sgetz7908 25:42163d650266 378 case 's': // sensors as binary, with bits '00000tcp', t=(1=TESTING REQUIRED), c=(1 is cap off), p=(1 is light sensed)
sgetz7908 25:42163d650266 379 //int val = 0;
sgetz7908 25:42163d650266 380 BLE_UART_xmit("ss=00000");
sgetz7908 25:42163d650266 381 if(NV_TESTING_REQUIRED) BLE_UART_xmit("1"); else BLE_UART_xmit("0");
sgetz7908 25:42163d650266 382 int save = package_open_sense_enable;
sgetz7908 24:761c30334cf4 383 package_open_sense_enable = 1;
sgetz7908 24:761c30334cf4 384 test_cap();
sgetz7908 25:42163d650266 385 if(is_cap_off) BLE_UART_xmit("1"); else BLE_UART_xmit("0");
sgetz7908 25:42163d650266 386 if(is_package_open) BLE_UART_xmit("1"); else BLE_UART_xmit("0");
sgetz7908 25:42163d650266 387 package_open_sense_enable = save;
sgetz7908 23:7ca590427f0e 388 BLE_UART_xmit("\n");
sgetz7908 23:7ca590427f0e 389 break;
sgetz7908 23:7ca590427f0e 390 }
sgetz7908 23:7ca590427f0e 391 break;
sgetz7908 24:761c30334cf4 392 case 'p': // test passed
sgetz7908 24:761c30334cf4 393 if(tolower(cmd[1])=='z')
sgetz7908 24:761c30334cf4 394 {
sgetz7908 24:761c30334cf4 395 log_add(EVENT_TEST_PASS, 0, 0, 0);
sgetz7908 24:761c30334cf4 396 nv_clear(NV_TESTING_REQUIRED_ADDR);
sgetz7908 24:761c30334cf4 397 }
sgetz7908 25:42163d650266 398 #if 0
sgetz7908 25:42163d650266 399 else if(tolower(cmd[1])=='e')
sgetz7908 25:42163d650266 400 {
sgetz7908 25:42163d650266 401 set_radio(false);
sgetz7908 25:42163d650266 402 wait(1.0);
sgetz7908 25:42163d650266 403 log_erase();
sgetz7908 25:42163d650266 404 }
sgetz7908 25:42163d650266 405 #endif
sgetz7908 24:761c30334cf4 406 break;
sgetz7908 24:761c30334cf4 407
sgetz7908 23:7ca590427f0e 408 case 't': // get time
sgetz7908 23:7ca590427f0e 409 BLE_UART_xmit(read_clock());
sgetz7908 23:7ca590427f0e 410 BLE_UART_xmit("\n");
sgetz7908 23:7ca590427f0e 411 break;
sgetz7908 23:7ca590427f0e 412
sgetz7908 23:7ca590427f0e 413 case 'c': // set time
sgetz7908 23:7ca590427f0e 414 {
sgetz7908 23:7ca590427f0e 415 int i = 1;
sgetz7908 23:7ca590427f0e 416 uint32_t num = 0;
sgetz7908 23:7ca590427f0e 417
sgetz7908 23:7ca590427f0e 418 while(cmd[i]>='0' && cmd[i]<='9') {
sgetz7908 23:7ca590427f0e 419 num = num*10 + cmd[i++]-'0';
sgetz7908 23:7ca590427f0e 420 }
sgetz7908 23:7ca590427f0e 421
sgetz7908 23:7ca590427f0e 422 if(i>1) {
sgetz7908 23:7ca590427f0e 423 set_time_offset(num);
sgetz7908 23:7ca590427f0e 424 BLE_UART_xmit("*Time Set\n");
sgetz7908 23:7ca590427f0e 425 }
sgetz7908 23:7ca590427f0e 426 }
sgetz7908 23:7ca590427f0e 427 break;
sgetz7908 23:7ca590427f0e 428
sgetz7908 23:7ca590427f0e 429 case 'v': // version
sgetz7908 24:761c30334cf4 430 BLE_UART_xmit("v=");
sgetz7908 23:7ca590427f0e 431 BLE_UART_xmit(FW_VERSION);
sgetz7908 23:7ca590427f0e 432 BLE_UART_xmit("\n");
sgetz7908 23:7ca590427f0e 433 break;
sgetz7908 23:7ca590427f0e 434
sgetz7908 23:7ca590427f0e 435 default:
sgetz7908 23:7ca590427f0e 436 BLE_UART_xmit("S=Status\n");
sgetz7908 23:7ca590427f0e 437 break;
sgetz7908 23:7ca590427f0e 438 }
sgetz7908 23:7ca590427f0e 439 cmd[0] = 0;
sgetz7908 23:7ca590427f0e 440 }
sgetz7908 25:42163d650266 441
sgetz7908 25:42163d650266 442 //*****************************************************************************
sgetz7908 25:42163d650266 443
sgetz7908 25:42163d650266 444 int main(void)
sgetz7908 25:42163d650266 445 {
sgetz7908 25:42163d650266 446 // blink LED to indicate power applied
sgetz7908 25:42163d650266 447 //flash_led(1,1.0);
sgetz7908 25:42163d650266 448
sgetz7908 25:42163d650266 449 if(Init_BLE_Stuff()) // init and start advertising
sgetz7908 25:42163d650266 450 {
sgetz7908 25:42163d650266 451 flash_led(0, 0.05); // indicate a ble init error
sgetz7908 25:42163d650266 452 }
sgetz7908 25:42163d650266 453
sgetz7908 25:42163d650266 454 eventQueue.call(process_state);
sgetz7908 25:42163d650266 455
sgetz7908 25:42163d650266 456 eventQueue.dispatch_forever(); // run all tasks in the event queue (non-interrupt routines)
sgetz7908 25:42163d650266 457 return 0;
sgetz7908 25:42163d650266 458 }
sgetz7908 25:42163d650266 459
sgetz7908 25:42163d650266 460