Daniel Yang / Mbed 2 deprecated Song_Control

working version of song control with initialization from sd card

Dependencies:   MFRC522 NRF2401P SDFileSystem SPI_TFT_ILI9341 TFT_fonts mbed

Fork of Song_Control by Malcolm McCulloch

hub.cpp@7:0aee09577ad3, 2016-02-29 (annotated)

Committer:
dxyang
Date:
Mon Feb 29 11:39:29 2016 +0000
Revision:
7:0aee09577ad3
Parent:
6:00a132a076d5
Child:
8:b40c4553f6d4
made the userIndex a parameter for a lot of methods, decoupled dependence on the global variable a bit (still used in the main loop though)

Who changed what in which revision?

UserRevisionLine numberNew contents of line
epgmdm 1:c2232b1eaf31 1 /**
epgmdm 1:c2232b1eaf31 2 * All the code associated to run the mbed as a hub.
epgmdm 1:c2232b1eaf31 3 * Link with locker
epgmdm 1:c2232b1eaf31 4 */
epgmdm 1:c2232b1eaf31 5 #include "mbed.h"
epgmdm 1:c2232b1eaf31 6 #include "utils.h"
epgmdm 2:d1eae91343a9 7 #include "NRF2401P.h"
dxyang 3:86773d65ed58 8
dxyang 3:86773d65ed58 9 #include "MFRC522.h"
dxyang 3:86773d65ed58 10 #include "SPI_TFT_ILI9341.h"
dxyang 3:86773d65ed58 11 #include "Arial24x23.h"
dxyang 3:86773d65ed58 12 #include "SDFileSystem.h"
dxyang 3:86773d65ed58 13
epgmdm 1:c2232b1eaf31 14 #define debug
epgmdm 1:c2232b1eaf31 15
dxyang 3:86773d65ed58 16 /*************************************************************************************************/
dxyang 3:86773d65ed58 17 /* Global variables */
dxyang 3:86773d65ed58 18 /*************************************************************************************************/
epgmdm 1:c2232b1eaf31 19 // tx nRF2401
epgmdm 2:d1eae91343a9 20 extern char txBuff[];
epgmdm 2:d1eae91343a9 21 extern NRF2401P nrf1;
epgmdm 2:d1eae91343a9 22 extern int channel;
epgmdm 1:c2232b1eaf31 23 long long addrLcker=0xBBBBBBBBBB;
dxyang 3:86773d65ed58 24
dxyang 3:86773d65ed58 25 // MFRC522 RfChip (SPI_MOSI, SPI_MISO, SPI_SCLK, SPI_CS, MF_RESET);
dxyang 3:86773d65ed58 26 MFRC522 BatteryRfChipH (PTD2, PTD3, PTD1, PTE25, PTB3);
dxyang 3:86773d65ed58 27 MFRC522 PoshoRfChipH (PTD2, PTD3, PTD1, PTB10, PTB11);
dxyang 3:86773d65ed58 28 MFRC522 IncubatorRfChipH (PTD2, PTD3, PTD1, PTC11, PTC10);
dxyang 3:86773d65ed58 29
dxyang 3:86773d65ed58 30 // tickers and flags for checking rfid statuses
dxyang 3:86773d65ed58 31 Ticker tickBatteryRfidH;
dxyang 3:86773d65ed58 32 Ticker tickPoshoRfidH;
dxyang 3:86773d65ed58 33 Ticker tickIncubatorRfidH;
dxyang 3:86773d65ed58 34 char flagBatteryRfidH = 0;
dxyang 3:86773d65ed58 35 char flagPoshoRfidH = 0;
dxyang 3:86773d65ed58 36 char flagIncubatorRfidH = 0;
dxyang 3:86773d65ed58 37
dxyang 3:86773d65ed58 38 //SPI_TFT_ILI9341(PinName mosi, PinName miso, PinName sclk,
dxyang 3:86773d65ed58 39 // PinName cs, PinName reset, PinName dc, const char* name ="TFT");
dxyang 3:86773d65ed58 40 SPI_TFT_ILI9341 TFT_H(PTD2, PTD3, PTD1, PTB2, PTB20, PTB18,"TFT");
dxyang 3:86773d65ed58 41
dxyang 3:86773d65ed58 42 // button interrupt signals and respective flags
dxyang 3:86773d65ed58 43 InterruptIn buttonOneH(PTC3);
dxyang 3:86773d65ed58 44 InterruptIn buttonTwoH(PTC2);
dxyang 3:86773d65ed58 45 InterruptIn buttonThreeH(PTA2);
dxyang 3:86773d65ed58 46 InterruptIn buttonFourH(PTB23);
dxyang 3:86773d65ed58 47 char flagButtonOneH = 0;
dxyang 3:86773d65ed58 48 char flagButtonTwoH = 0;
dxyang 3:86773d65ed58 49 char flagButtonThreeH = 0;
dxyang 3:86773d65ed58 50 char flagButtonFourH = 0;
dxyang 3:86773d65ed58 51
dxyang 3:86773d65ed58 52 // ticker that causes time to be displayed
dxyang 3:86773d65ed58 53 Ticker tickTimeCheckH;
dxyang 3:86773d65ed58 54 char flagTimeCheckH = 0;
dxyang 3:86773d65ed58 55
dxyang 3:86773d65ed58 56 // ticker that causes an interrupt to update the user table every 1/2 an hour
dxyang 3:86773d65ed58 57 Ticker tickerUpdateUserTableH;
dxyang 3:86773d65ed58 58 char flagUpdateUserTableH = 0;
dxyang 3:86773d65ed58 59
dxyang 3:86773d65ed58 60 // ticker that goes off every second
dxyang 3:86773d65ed58 61 unsigned char flag1sH = 0;
dxyang 3:86773d65ed58 62 Ticker tick1sHub;
dxyang 3:86773d65ed58 63
dxyang 3:86773d65ed58 64 // Maximum current that each cube can consume.
dxyang 3:86773d65ed58 65 float currentMaxH = 1.5;
dxyang 3:86773d65ed58 66
dxyang 3:86773d65ed58 67 // A hubUser can be assigned any of four lockers, each with a unique locker address
dxyang 3:86773d65ed58 68 enum LockerAddressH {
dxyang 3:86773d65ed58 69 lockerUnassigned,
dxyang 3:86773d65ed58 70 lockerOne,
dxyang 3:86773d65ed58 71 lockerTwo,
dxyang 3:86773d65ed58 72 lockerThree,
dxyang 3:86773d65ed58 73 lockerFour
dxyang 3:86773d65ed58 74 };
dxyang 3:86773d65ed58 75
dxyang 3:86773d65ed58 76 // The hub display screen can involve multiple stages
dxyang 3:86773d65ed58 77 enum HubScreenStageH {
dxyang 3:86773d65ed58 78 initialScanRfid,
dxyang 3:86773d65ed58 79 waitForRfid,
dxyang 3:86773d65ed58 80 batterySelectAction,
dxyang 3:86773d65ed58 81 batterySelectNumberForPickup,
dxyang 3:86773d65ed58 82 batterySelectNumberForDropoff
dxyang 3:86773d65ed58 83 };
dxyang 3:86773d65ed58 84 enum HubScreenStageH currentScreenH = initialScanRfid;
dxyang 3:86773d65ed58 85
dxyang 3:86773d65ed58 86 // hubUser struct containing the users uid, rfid, number of batteries, current account credit,
dxyang 3:86773d65ed58 87 // an enum corresponding to a locker channel address, and pod ID within a locker
dxyang 3:86773d65ed58 88 struct hubUserH {
dxyang 3:86773d65ed58 89 uint32_t uid;
dxyang 3:86773d65ed58 90 uint32_t rfid;
dxyang 3:86773d65ed58 91 int32_t accountCredit;
dxyang 3:86773d65ed58 92 enum LockerAddressH lockerID;
dxyang 3:86773d65ed58 93 int32_t podID;
dxyang 3:86773d65ed58 94 int32_t batteriesOut;
dxyang 3:86773d65ed58 95 int32_t batterySubscription;
dxyang 3:86773d65ed58 96 };
dxyang 3:86773d65ed58 97
dxyang 3:86773d65ed58 98 // community ID should be defined somewhere and accessible globally
dxyang 3:86773d65ed58 99 uint32_t communityID_H = 1;
dxyang 3:86773d65ed58 100
dxyang 3:86773d65ed58 101 // array to store all users and index of end of the current list
dxyang 3:86773d65ed58 102 hubUserH allUsersH[256];
dxyang 3:86773d65ed58 103 uint8_t userCountH = 0;
dxyang 3:86773d65ed58 104 uint8_t currentUserH;
dxyang 3:86773d65ed58 105
dxyang 3:86773d65ed58 106 // Data is being logged and collected
dxyang 3:86773d65ed58 107 // these actions depend on a known user using the system
dxyang 3:86773d65ed58 108 enum HubActionForLoggingH {
dxyang 3:86773d65ed58 109 hubAction_RfidScanned,
dxyang 3:86773d65ed58 110 hubAction_Exit,
dxyang 3:86773d65ed58 111 hubAction_OneBatteryDropped,
dxyang 3:86773d65ed58 112 hubAction_TwoBatteryDropped,
dxyang 3:86773d65ed58 113 hubAction_ThreeBatteryDropped,
dxyang 3:86773d65ed58 114 hubAction_OneBatteryPicked,
dxyang 3:86773d65ed58 115 hubAction_TwoBatteryPicked,
dxyang 3:86773d65ed58 116 hubAction_ThreeBatteryPicked
dxyang 3:86773d65ed58 117 };
dxyang 3:86773d65ed58 118
dxyang 3:86773d65ed58 119 /*************************************************************************************************/
dxyang 3:86773d65ed58 120 /* Set a flag when an interrupt is detected */
dxyang 3:86773d65ed58 121 /*************************************************************************************************/
dxyang 3:86773d65ed58 122 /**
dxyang 3:86773d65ed58 123 * Time check interrupt
dxyang 3:86773d65ed58 124 */
dxyang 3:86773d65ed58 125 void interruptTimeCheckH()
dxyang 3:86773d65ed58 126 { flagTimeCheckH = 1; }
dxyang 3:86773d65ed58 127
dxyang 3:86773d65ed58 128 /**
dxyang 3:86773d65ed58 129 * Update user table interrupt
dxyang 3:86773d65ed58 130 */
dxyang 3:86773d65ed58 131 void interruptUpdateUserTableH()
dxyang 3:86773d65ed58 132 { flagUpdateUserTableH = 1; }
dxyang 3:86773d65ed58 133
dxyang 3:86773d65ed58 134 /**
dxyang 3:86773d65ed58 135 * Battery RFID reader interrupt
dxyang 3:86773d65ed58 136 */
dxyang 3:86773d65ed58 137 void interruptBatteryRfidH()
dxyang 3:86773d65ed58 138 { flagBatteryRfidH = 1; }
dxyang 3:86773d65ed58 139
dxyang 3:86773d65ed58 140 /**
dxyang 3:86773d65ed58 141 * Posho RFID reader interrupt
dxyang 3:86773d65ed58 142 */
dxyang 3:86773d65ed58 143 void interruptPoshoRfidH()
dxyang 3:86773d65ed58 144 { flagPoshoRfidH = 1; }
dxyang 3:86773d65ed58 145
dxyang 3:86773d65ed58 146 /**
dxyang 3:86773d65ed58 147 * Incubator RFID reader interrupt
dxyang 3:86773d65ed58 148 */
dxyang 3:86773d65ed58 149 void interruptIncubatorRfidH()
dxyang 3:86773d65ed58 150 { flagIncubatorRfidH = 1; }
dxyang 3:86773d65ed58 151
dxyang 3:86773d65ed58 152 /**
dxyang 3:86773d65ed58 153 * buttone one interrupt
dxyang 3:86773d65ed58 154 */
dxyang 3:86773d65ed58 155 void interruptButtonOneH()
dxyang 3:86773d65ed58 156 { flagButtonOneH = 1; }
dxyang 3:86773d65ed58 157
dxyang 3:86773d65ed58 158 /**
dxyang 3:86773d65ed58 159 * buttone two interrupt
dxyang 3:86773d65ed58 160 */
dxyang 3:86773d65ed58 161 void interruptButtonTwoH()
dxyang 3:86773d65ed58 162 { flagButtonTwoH = 1; }
dxyang 3:86773d65ed58 163
dxyang 3:86773d65ed58 164 /**
dxyang 3:86773d65ed58 165 * buttone three interrupt
dxyang 3:86773d65ed58 166 */
dxyang 3:86773d65ed58 167 void interruptButtonThreeH()
dxyang 3:86773d65ed58 168 { flagButtonThreeH = 1; }
dxyang 3:86773d65ed58 169
dxyang 3:86773d65ed58 170 /**
dxyang 3:86773d65ed58 171 * buttone four interrupt
dxyang 3:86773d65ed58 172 */
dxyang 3:86773d65ed58 173 void interruptButtonFourH()
dxyang 3:86773d65ed58 174 { flagButtonFourH = 1; }
dxyang 3:86773d65ed58 175
epgmdm 2:d1eae91343a9 176 /**
epgmdm 2:d1eae91343a9 177 * Fast interrupt routine for every 1 second
epgmdm 2:d1eae91343a9 178 */
epgmdm 2:d1eae91343a9 179 void int1sH()
dxyang 3:86773d65ed58 180 { flag1sH=1; }
dxyang 3:86773d65ed58 181
dxyang 3:86773d65ed58 182 /*************************************************************************************************/
dxyang 3:86773d65ed58 183 /* Transfer Info */
dxyang 3:86773d65ed58 184 /*************************************************************************************************/
epgmdm 2:d1eae91343a9 185 /**
epgmdm 2:d1eae91343a9 186 * Sends a time stamp
epgmdm 2:d1eae91343a9 187 */
epgmdm 2:d1eae91343a9 188 void txTimeH()
epgmdm 2:d1eae91343a9 189 {
epgmdm 2:d1eae91343a9 190 #ifdef debug
epgmdm 2:d1eae91343a9 191 printf("Send time \n\r");
epgmdm 2:d1eae91343a9 192 #endif
epgmdm 2:d1eae91343a9 193 time_t now= time(NULL);
epgmdm 2:d1eae91343a9 194 sprintf(txBuff,"T %X",now);
epgmdm 2:d1eae91343a9 195 nrf1.transmitData(txBuff,strlen(txBuff));
epgmdm 2:d1eae91343a9 196 #ifdef debug
epgmdm 2:d1eae91343a9 197 printf("Tx %s [nrf:%s] \n\r", txBuff,nrf1.statusString());
epgmdm 2:d1eae91343a9 198 #endif
epgmdm 2:d1eae91343a9 199 }
epgmdm 2:d1eae91343a9 200
epgmdm 2:d1eae91343a9 201 /**
epgmdm 2:d1eae91343a9 202 * Sends max Current
epgmdm 2:d1eae91343a9 203 */
epgmdm 2:d1eae91343a9 204 void txCurrentH()
epgmdm 2:d1eae91343a9 205 {
epgmdm 2:d1eae91343a9 206 #ifdef debug
epgmdm 2:d1eae91343a9 207 printf("Send current \n\r");
epgmdm 2:d1eae91343a9 208 #endif
epgmdm 2:d1eae91343a9 209 sprintf(txBuff,"I %04X", *((int *) &currentMaxH));
epgmdm 2:d1eae91343a9 210 nrf1.transmitData(txBuff,strlen(txBuff));
epgmdm 2:d1eae91343a9 211 #ifdef debug
epgmdm 2:d1eae91343a9 212 printf("Tx %s [nrf:%s] \n\r", txBuff,nrf1.statusString());
epgmdm 2:d1eae91343a9 213 #endif
epgmdm 2:d1eae91343a9 214 }
epgmdm 1:c2232b1eaf31 215
epgmdm 2:d1eae91343a9 216 /**
epgmdm 2:d1eae91343a9 217 * Slow interrupt routine for every 1 second
epgmdm 2:d1eae91343a9 218 */
epgmdm 2:d1eae91343a9 219 void do1sH()
epgmdm 2:d1eae91343a9 220 {
dxyang 3:86773d65ed58 221 flag1sH = 0;
epgmdm 2:d1eae91343a9 222 #ifdef debug
epgmdm 2:d1eae91343a9 223 printf("Hub 1s \n\r");
epgmdm 2:d1eae91343a9 224 #endif
epgmdm 2:d1eae91343a9 225
epgmdm 2:d1eae91343a9 226 time_t now= time(NULL);
epgmdm 2:d1eae91343a9 227 if ((now % 60)==0){
epgmdm 2:d1eae91343a9 228 txTimeH();
epgmdm 2:d1eae91343a9 229 }
epgmdm 2:d1eae91343a9 230 txCurrentH();
epgmdm 2:d1eae91343a9 231 #ifdef debug
epgmdm 2:d1eae91343a9 232 printf("Tx %s [nrf:%s] \n\r", txBuff,nrf1.statusString());
epgmdm 2:d1eae91343a9 233 #endif
epgmdm 2:d1eae91343a9 234 }
dxyang 6:00a132a076d5 235
dxyang 6:00a132a076d5 236 /**
dxyang 6:00a132a076d5 237 * Sends a signal to a locker that the current user is picking up numBatteries batteries
dxyang 6:00a132a076d5 238 */
dxyang 6:00a132a076d5 239 void txBatteryPickUp(int numBatteries) {
dxyang 6:00a132a076d5 240
dxyang 6:00a132a076d5 241 }
dxyang 6:00a132a076d5 242
dxyang 6:00a132a076d5 243 /**
dxyang 6:00a132a076d5 244 * Sends a signal to a locker that the current user is dropping off numBatteries batteries
dxyang 6:00a132a076d5 245 */
dxyang 6:00a132a076d5 246 void txBatteryDropOff(int numBatteries) {
dxyang 6:00a132a076d5 247
dxyang 6:00a132a076d5 248 }
dxyang 6:00a132a076d5 249
dxyang 6:00a132a076d5 250
dxyang 5:88c516cf34e6 251 /*************************************************************************************************/
dxyang 5:88c516cf34e6 252 /* Initialization */
dxyang 5:88c516cf34e6 253 /*************************************************************************************************/
epgmdm 2:d1eae91343a9 254 /**
dxyang 3:86773d65ed58 255 * Initialize system on reset and set the time from the terminal
dxyang 3:86773d65ed58 256 */
dxyang 3:86773d65ed58 257 void initializeTimeH()
dxyang 3:86773d65ed58 258 {
epgmdm 2:d1eae91343a9 259 // get the current time from the terminal
epgmdm 2:d1eae91343a9 260 struct tm t;
epgmdm 2:d1eae91343a9 261 printf("Enter current date :\n\r");
epgmdm 2:d1eae91343a9 262 printf("YYYY MM DD [enter]\n\r");
epgmdm 2:d1eae91343a9 263 scanf("%d %d %d", &t.tm_year, &t.tm_mon, &t.tm_mday);
epgmdm 2:d1eae91343a9 264 printf("Enter current time:\n\r");
epgmdm 2:d1eae91343a9 265 printf("HH MM SS [enter]\n\r");
epgmdm 2:d1eae91343a9 266 scanf("%d %d %d", &t.tm_hour, &t.tm_min, &t.tm_sec);
epgmdm 2:d1eae91343a9 267
epgmdm 2:d1eae91343a9 268 // adjust for tm structure required values
epgmdm 2:d1eae91343a9 269 t.tm_year = t.tm_year - 1900;
epgmdm 2:d1eae91343a9 270 t.tm_mon = t.tm_mon - 1;
epgmdm 2:d1eae91343a9 271
epgmdm 2:d1eae91343a9 272 // set the time
epgmdm 2:d1eae91343a9 273 set_time(mktime(&t));
dxyang 3:86773d65ed58 274 #ifdef debug
dxyang 3:86773d65ed58 275 printf("Time initialized\n\r");
dxyang 3:86773d65ed58 276 #endif
dxyang 3:86773d65ed58 277 }
dxyang 3:86773d65ed58 278
dxyang 3:86773d65ed58 279 /**
dxyang 3:86773d65ed58 280 * Initialize all the interrupts
dxyang 3:86773d65ed58 281 */
dxyang 3:86773d65ed58 282 void initializeInterruptsH()
dxyang 3:86773d65ed58 283 {
dxyang 3:86773d65ed58 284 tickTimeCheckH.attach(&interruptTimeCheckH, 5.0);
dxyang 3:86773d65ed58 285 tickBatteryRfidH.attach(&interruptBatteryRfidH, 1.0);
dxyang 3:86773d65ed58 286 tickPoshoRfidH.attach(&interruptPoshoRfidH, 1.0);
dxyang 3:86773d65ed58 287 tickIncubatorRfidH.attach(&interruptIncubatorRfidH, 1.0);
dxyang 3:86773d65ed58 288 tickerUpdateUserTableH.attach(&interruptUpdateUserTableH, 1800.0);
dxyang 3:86773d65ed58 289 buttonOneH.rise(&interruptButtonOneH);
dxyang 3:86773d65ed58 290 buttonTwoH.rise(&interruptButtonTwoH);
dxyang 3:86773d65ed58 291 buttonThreeH.rise(&interruptButtonThreeH);
dxyang 3:86773d65ed58 292 buttonFourH.rise(&interruptButtonFourH);
dxyang 3:86773d65ed58 293 tick1sHub.attach(&int1sH, 10.0);
dxyang 3:86773d65ed58 294
dxyang 3:86773d65ed58 295 #ifdef debug
dxyang 3:86773d65ed58 296 printf("Interrupts initialized\n\r");
dxyang 3:86773d65ed58 297 #endif
dxyang 3:86773d65ed58 298 }
dxyang 3:86773d65ed58 299
dxyang 3:86773d65ed58 300 /**
dxyang 3:86773d65ed58 301 * Initialize RFID readers
dxyang 3:86773d65ed58 302 */
dxyang 3:86773d65ed58 303 void initializeRfidReadersH()
dxyang 3:86773d65ed58 304 {
dxyang 3:86773d65ed58 305 BatteryRfChipH.PCD_Init();
dxyang 3:86773d65ed58 306 PoshoRfChipH.PCD_Init();
dxyang 3:86773d65ed58 307 IncubatorRfChipH.PCD_Init();
dxyang 3:86773d65ed58 308
dxyang 3:86773d65ed58 309 #ifdef debug
dxyang 3:86773d65ed58 310 uint8_t tempA = BatteryRfChipH.PCD_ReadRegister(MFRC522::VersionReg);
dxyang 3:86773d65ed58 311 printf("Battery MFRC522 version: %d\n\r", tempA & 0x07);
dxyang 3:86773d65ed58 312 printf("\n\r");
dxyang 3:86773d65ed58 313 uint8_t tempB = PoshoRfChipH.PCD_ReadRegister(MFRC522::VersionReg);
dxyang 3:86773d65ed58 314 printf("Posho MFRC522 version: %d\n\r", tempB & 0x07);
dxyang 3:86773d65ed58 315 printf("\n\r");
dxyang 3:86773d65ed58 316 uint8_t tempC = IncubatorRfChipH.PCD_ReadRegister(MFRC522::VersionReg);
dxyang 3:86773d65ed58 317 printf("Incubator MFRC522 version: %d\n\r", tempC & 0x07);
dxyang 3:86773d65ed58 318 printf("\n\r");
dxyang 3:86773d65ed58 319 #endif
dxyang 3:86773d65ed58 320
dxyang 3:86773d65ed58 321 #ifdef debug
dxyang 3:86773d65ed58 322 printf("RFID readers initialized\n\r");
dxyang 3:86773d65ed58 323 #endif
dxyang 3:86773d65ed58 324 }
dxyang 3:86773d65ed58 325
dxyang 3:86773d65ed58 326 /**
dxyang 3:86773d65ed58 327 * Initialize LCD screen
dxyang 3:86773d65ed58 328 */
dxyang 3:86773d65ed58 329 void initializeLCD_H()
dxyang 3:86773d65ed58 330 {
dxyang 3:86773d65ed58 331 TFT_H.background(Black); // set background to black
dxyang 3:86773d65ed58 332 TFT_H.foreground(White); // set chars to white
dxyang 3:86773d65ed58 333 TFT_H.cls(); // clear the screen
dxyang 3:86773d65ed58 334 TFT_H.set_font((unsigned char*) Arial24x23);
dxyang 3:86773d65ed58 335 TFT_H.set_orientation(3); //Portrait, wiring on left
dxyang 3:86773d65ed58 336 #ifdef debug
dxyang 3:86773d65ed58 337 printf("LCD initialized\n\r");
dxyang 3:86773d65ed58 338 #endif
dxyang 3:86773d65ed58 339 }
dxyang 3:86773d65ed58 340
dxyang 3:86773d65ed58 341 /**
dxyang 3:86773d65ed58 342 * Creates a new user by defining user attributes.
dxyang 3:86773d65ed58 343 * @param rfid - uint32_t corresponding to unique id of the RFID tag
dxyang 3:86773d65ed58 344 * @param accountCredit - int32 for user account balance (can be negative)
dxyang 3:86773d65ed58 345 * @param locker - int32_t for which locker (originaly 1-4) user is assigned
dxyang 3:86773d65ed58 346 * @param batterySubscription - max batteries user can get (can be 0)
dxyang 3:86773d65ed58 347 * @param batteriesOut - number of batteries user has out (usually 0 initially)
dxyang 3:86773d65ed58 348 * @param podID - pod associated with the user (originally 0-15) *must be 0 indexed*
dxyang 3:86773d65ed58 349 */
dxyang 3:86773d65ed58 350 void createNewUserH(uint32_t rfid, int32_t accountCredit, int32_t locker,
dxyang 3:86773d65ed58 351 int32_t batterySubscription, int32_t batteriesOut, int32_t podID)
dxyang 3:86773d65ed58 352 {
dxyang 3:86773d65ed58 353 allUsersH[userCountH].rfid = rfid;
dxyang 3:86773d65ed58 354 allUsersH[userCountH].accountCredit = accountCredit;
dxyang 3:86773d65ed58 355 switch(locker) {
dxyang 3:86773d65ed58 356 case 1:
dxyang 3:86773d65ed58 357 allUsersH[userCountH].lockerID = lockerOne;
dxyang 3:86773d65ed58 358 break;
dxyang 3:86773d65ed58 359 case 2:
dxyang 3:86773d65ed58 360 allUsersH[userCountH].lockerID = lockerTwo;
dxyang 3:86773d65ed58 361 break;
dxyang 3:86773d65ed58 362 case 3:
dxyang 3:86773d65ed58 363 allUsersH[userCountH].lockerID = lockerThree;
dxyang 3:86773d65ed58 364 break;
dxyang 3:86773d65ed58 365 case 4:
dxyang 3:86773d65ed58 366 allUsersH[userCountH].lockerID = lockerFour;
dxyang 3:86773d65ed58 367 break;
dxyang 3:86773d65ed58 368 default:
dxyang 3:86773d65ed58 369 allUsersH[userCountH].lockerID = lockerUnassigned;
dxyang 3:86773d65ed58 370 break;
dxyang 3:86773d65ed58 371 }
dxyang 3:86773d65ed58 372 allUsersH[userCountH].batterySubscription = batterySubscription;
dxyang 3:86773d65ed58 373 allUsersH[userCountH].batteriesOut = batteriesOut;
dxyang 3:86773d65ed58 374 allUsersH[userCountH].podID = podID;
dxyang 3:86773d65ed58 375
dxyang 3:86773d65ed58 376 // generate the user id, a 32 byte value
dxyang 3:86773d65ed58 377 // [community byte 1][community byte 2][locker byte 3][podID (1/2 byte) | 0000 (1/2 byte)]
dxyang 3:86773d65ed58 378 uint32_t actualUid = ((((uint32_t)communityID_H << 16) | ((uint32_t)locker << 8)) |
dxyang 3:86773d65ed58 379 ((uint32_t)podID << 4));
dxyang 3:86773d65ed58 380 allUsersH[userCountH].uid = actualUid;
dxyang 3:86773d65ed58 381
dxyang 3:86773d65ed58 382 userCountH++;
dxyang 3:86773d65ed58 383
dxyang 3:86773d65ed58 384 #ifdef debug
dxyang 3:86773d65ed58 385 printf("UserID (decimal):%u\n\r", actualUid);
dxyang 3:86773d65ed58 386 printf("**************************\n\r");
dxyang 3:86773d65ed58 387 #endif
dxyang 3:86773d65ed58 388 }
dxyang 3:86773d65ed58 389
dxyang 3:86773d65ed58 390 /**
dxyang 3:86773d65ed58 391 * Initialize system with users from users.txt on SD card
dxyang 3:86773d65ed58 392 */
dxyang 3:86773d65ed58 393 void initializeUsersFromSD_H()
dxyang 3:86773d65ed58 394 {
dxyang 3:86773d65ed58 395 spiSD();
dxyang 3:86773d65ed58 396 FILE *fp = fopen("/sd/users.txt", "r");
dxyang 3:86773d65ed58 397
dxyang 3:86773d65ed58 398 if (fp == NULL) {
dxyang 3:86773d65ed58 399 #ifdef debug
dxyang 3:86773d65ed58 400 printf("User text file can't be opened");
dxyang 3:86773d65ed58 401 #endif
dxyang 3:86773d65ed58 402 return;
dxyang 3:86773d65ed58 403 }
dxyang 3:86773d65ed58 404
dxyang 3:86773d65ed58 405 // the first line of the user file has the headers for the following roles - get to the next line
dxyang 3:86773d65ed58 406 char line[180];
dxyang 3:86773d65ed58 407 if (fgets(line, 180, fp) != NULL) {
dxyang 3:86773d65ed58 408 #ifdef debug
dxyang 3:86773d65ed58 409 printf("Format of text file:\n\r%s\n\r", line);
dxyang 3:86773d65ed58 410 printf("**************************\n\r");
dxyang 3:86773d65ed58 411 #endif
dxyang 3:86773d65ed58 412 }
dxyang 3:86773d65ed58 413
dxyang 3:86773d65ed58 414 // read a set of six values at a time, corresponding to a line, from the user text file. Generate a user per line.
dxyang 3:86773d65ed58 415 uint32_t rfid;
dxyang 3:86773d65ed58 416 int32_t accountCredit;
dxyang 3:86773d65ed58 417 int32_t locker;
dxyang 3:86773d65ed58 418 int32_t batterySubscription;
dxyang 3:86773d65ed58 419 int32_t batteriesOut;
dxyang 3:86773d65ed58 420 int32_t podID;
dxyang 3:86773d65ed58 421 while (fscanf(fp, "%u %d %d %d %d %d", &rfid, &accountCredit, &locker, &batterySubscription, &batteriesOut, &podID) != EOF) {
dxyang 3:86773d65ed58 422 #ifdef debug
dxyang 3:86773d65ed58 423 printf("rfid: %u\n\r accountCredit: %d\n\r locker: %d\n\r batterySubscription: %d\n\r batteriesOut: %d\n\r podID: %d\n\r",
dxyang 3:86773d65ed58 424 rfid, accountCredit, locker, batterySubscription, batteriesOut, podID);
dxyang 3:86773d65ed58 425 #endif
dxyang 3:86773d65ed58 426 createNewUserH(rfid, accountCredit, locker, batterySubscription, batteriesOut, podID);
dxyang 3:86773d65ed58 427 }
dxyang 3:86773d65ed58 428 #ifdef debug
dxyang 3:86773d65ed58 429 printf("Users created\n\r");
dxyang 3:86773d65ed58 430 #endif
dxyang 3:86773d65ed58 431 }
dxyang 3:86773d65ed58 432
dxyang 3:86773d65ed58 433 /*************************************************************************************************/
dxyang 3:86773d65ed58 434 /* Logging */
dxyang 3:86773d65ed58 435 /*************************************************************************************************/
dxyang 3:86773d65ed58 436 /**
dxyang 3:86773d65ed58 437 * Log an action from a selection of predefined actions done by the current user
dxyang 3:86773d65ed58 438 * Actions used with this method should require a known user to be using system
dxyang 3:86773d65ed58 439 * @param action - enumerated HubActionForLogging that selects from predefined actions
dxyang 7:0aee09577ad3 440 * @param userIndex - int corresponding to the index of the user in the user table
dxyang 3:86773d65ed58 441 */
dxyang 7:0aee09577ad3 442 void logActionWithUserInfoH(enum HubActionForLoggingH action, int userIndex)
dxyang 3:86773d65ed58 443 {
dxyang 3:86773d65ed58 444 // Append to a log text file
dxyang 3:86773d65ed58 445 spiSD();
dxyang 3:86773d65ed58 446 char * name = "/sd/HubLog.txt";
dxyang 3:86773d65ed58 447 FILE *fp;
dxyang 3:86773d65ed58 448 fp = fopen(name, "a");
dxyang 3:86773d65ed58 449
dxyang 3:86773d65ed58 450 // get the time and append it to an output buffer
dxyang 3:86773d65ed58 451 time_t seconds = time(NULL);
dxyang 3:86773d65ed58 452 char logLine[180];
dxyang 3:86773d65ed58 453 sprintf(logLine, "%x", seconds);
dxyang 3:86773d65ed58 454
dxyang 3:86773d65ed58 455 // append relevant information for action
dxyang 3:86773d65ed58 456 switch (action) {
dxyang 3:86773d65ed58 457 case hubAction_RfidScanned:
dxyang 3:86773d65ed58 458 strcat(logLine, " R ");
dxyang 3:86773d65ed58 459 break;
dxyang 3:86773d65ed58 460 case hubAction_Exit:
dxyang 3:86773d65ed58 461 strcat(logLine, " X ");
dxyang 3:86773d65ed58 462 break;
dxyang 3:86773d65ed58 463 case hubAction_OneBatteryDropped:
dxyang 3:86773d65ed58 464 strcat(logLine, " D 1 ");
dxyang 3:86773d65ed58 465 break;
dxyang 3:86773d65ed58 466 case hubAction_TwoBatteryDropped:
dxyang 3:86773d65ed58 467 strcat(logLine, " D 2 ");
dxyang 3:86773d65ed58 468 break;
dxyang 3:86773d65ed58 469 case hubAction_ThreeBatteryDropped:
dxyang 3:86773d65ed58 470 strcat(logLine, " D 3 ");
dxyang 3:86773d65ed58 471 break;
dxyang 3:86773d65ed58 472 case hubAction_OneBatteryPicked:
dxyang 3:86773d65ed58 473 strcat(logLine, " P 1 ");
dxyang 3:86773d65ed58 474 break;
dxyang 3:86773d65ed58 475 case hubAction_TwoBatteryPicked:
dxyang 3:86773d65ed58 476 strcat(logLine, " P 2 ");
dxyang 3:86773d65ed58 477 break;
dxyang 3:86773d65ed58 478 case hubAction_ThreeBatteryPicked:
dxyang 3:86773d65ed58 479 strcat(logLine, " P 3 ");
dxyang 3:86773d65ed58 480 break;
dxyang 3:86773d65ed58 481 }
dxyang 3:86773d65ed58 482
dxyang 3:86773d65ed58 483 // append general user information
dxyang 3:86773d65ed58 484 char rfidBuffer[20];
dxyang 3:86773d65ed58 485 char uidBuffer[20];
dxyang 3:86773d65ed58 486 char acctBalanceBuffer[20];
dxyang 7:0aee09577ad3 487 sprintf(rfidBuffer, "%u ", allUsersH[userIndex].rfid);
dxyang 7:0aee09577ad3 488 sprintf(uidBuffer, "%u ", allUsersH[userIndex].uid);
dxyang 7:0aee09577ad3 489 sprintf(acctBalanceBuffer, "%d\n", allUsersH[userIndex].accountCredit);
dxyang 3:86773d65ed58 490 strcat(logLine, rfidBuffer);
dxyang 3:86773d65ed58 491 strcat(logLine, uidBuffer);
dxyang 3:86773d65ed58 492 strcat(logLine, acctBalanceBuffer);
dxyang 3:86773d65ed58 493
dxyang 3:86773d65ed58 494 // write the line to the log file and close the file
dxyang 3:86773d65ed58 495 fputs(logLine, fp);
dxyang 3:86773d65ed58 496 fclose(fp);
dxyang 3:86773d65ed58 497
dxyang 3:86773d65ed58 498 #ifdef debug
dxyang 3:86773d65ed58 499 printf("%s\n\r", logLine);
dxyang 3:86773d65ed58 500 #endif
dxyang 3:86773d65ed58 501
dxyang 3:86773d65ed58 502 }
dxyang 3:86773d65ed58 503
dxyang 3:86773d65ed58 504 /**
dxyang 3:86773d65ed58 505 * Log an error - RFID not associated with a known user is scanned
dxyang 3:86773d65ed58 506 * @param unknownRfid - uint32 for the unique ID of the unknown rfid tag
dxyang 3:86773d65ed58 507 */
dxyang 3:86773d65ed58 508 void logErrorUnknownRfidScannedH(uint32_t unknownRfid)
dxyang 3:86773d65ed58 509 {
dxyang 3:86773d65ed58 510 // Append to a log text file
dxyang 3:86773d65ed58 511 char * name = "/sd/HubLog.txt";
dxyang 3:86773d65ed58 512 spiSD();
dxyang 3:86773d65ed58 513 FILE *fp;
dxyang 3:86773d65ed58 514 fp = fopen(name, "a");
dxyang 3:86773d65ed58 515
dxyang 3:86773d65ed58 516 // get the time and append it to an output buffer
dxyang 3:86773d65ed58 517 time_t seconds = time(NULL);
dxyang 3:86773d65ed58 518 char logLine[180];
dxyang 3:86773d65ed58 519 sprintf(logLine, "%x", seconds);
dxyang 3:86773d65ed58 520
dxyang 3:86773d65ed58 521 // RFID action
dxyang 3:86773d65ed58 522 strcat(logLine, " R X ");
dxyang 3:86773d65ed58 523
dxyang 3:86773d65ed58 524 // include just the RFID (indicates that no known user was found)
dxyang 3:86773d65ed58 525 char rfidBuffer[20];
dxyang 3:86773d65ed58 526 sprintf(rfidBuffer, "%u ", unknownRfid);
dxyang 3:86773d65ed58 527 strcat(logLine, rfidBuffer);
dxyang 3:86773d65ed58 528 strcat(logLine, "\n");
dxyang 3:86773d65ed58 529
dxyang 3:86773d65ed58 530 // write the line to the log file and close the file
dxyang 3:86773d65ed58 531 fputs(logLine, fp);
dxyang 3:86773d65ed58 532 fclose(fp);
dxyang 3:86773d65ed58 533
dxyang 3:86773d65ed58 534 #ifdef debug
dxyang 3:86773d65ed58 535 printf("%s\n\r", logLine);
dxyang 3:86773d65ed58 536 #endif
epgmdm 2:d1eae91343a9 537
epgmdm 2:d1eae91343a9 538 }
epgmdm 2:d1eae91343a9 539
dxyang 3:86773d65ed58 540 /*************************************************************************************************/
dxyang 5:88c516cf34e6 541 /* Housekeeping - flag clearing, cancelling, check time, update user table */
dxyang 3:86773d65ed58 542 /*************************************************************************************************/
dxyang 3:86773d65ed58 543 /*
dxyang 3:86773d65ed58 544 * Reset all user initiated flags. Useful after sequences of events where flags may have
dxyang 3:86773d65ed58 545 * piled up from misc inputs and you don't want the system to act seemingly sporadically.
dxyang 3:86773d65ed58 546 */
dxyang 3:86773d65ed58 547 void clearAllUserInitiatedFlagsH() {
dxyang 3:86773d65ed58 548 flagButtonOneH = 0;
dxyang 3:86773d65ed58 549 flagButtonTwoH = 0;
dxyang 3:86773d65ed58 550 flagButtonThreeH = 0;
dxyang 3:86773d65ed58 551 flagButtonFourH = 0;
dxyang 3:86773d65ed58 552 flagBatteryRfidH = 0;
dxyang 3:86773d65ed58 553 flagPoshoRfidH = 0;
dxyang 3:86773d65ed58 554 flagIncubatorRfidH = 0;
dxyang 3:86773d65ed58 555 }
epgmdm 2:d1eae91343a9 556
dxyang 3:86773d65ed58 557 /*
dxyang 3:86773d65ed58 558 * User presses the button corresponding to an exit. Returns to home screen
dxyang 3:86773d65ed58 559 * after logging the action.
dxyang 7:0aee09577ad3 560 * @param userIndex - int representing index of user in user table
dxyang 3:86773d65ed58 561 */
dxyang 7:0aee09577ad3 562 void cancelPressedH(int userIndex) {
dxyang 3:86773d65ed58 563 clearAllUserInitiatedFlagsH();
dxyang 3:86773d65ed58 564 currentScreenH = initialScanRfid;
dxyang 7:0aee09577ad3 565 logActionWithUserInfoH(hubAction_Exit, userIndex);
dxyang 3:86773d65ed58 566 }
dxyang 3:86773d65ed58 567
dxyang 3:86773d65ed58 568 /**
dxyang 3:86773d65ed58 569 * Do if time check flag is set
dxyang 3:86773d65ed58 570 * reads the unix time, converts into human readable format, and displays on PC
dxyang 3:86773d65ed58 571 */
dxyang 3:86773d65ed58 572 void doTimeCheckH()
dxyang 3:86773d65ed58 573 {
dxyang 3:86773d65ed58 574 flagTimeCheckH = 0;
dxyang 3:86773d65ed58 575 time_t seconds = time(NULL);
dxyang 3:86773d65ed58 576 printf("%s\n\r", ctime(&seconds));
dxyang 3:86773d65ed58 577 }
dxyang 3:86773d65ed58 578
dxyang 3:86773d65ed58 579 /**
dxyang 3:86773d65ed58 580 * Do if update user table flag is set
dxyang 3:86773d65ed58 581 */
dxyang 3:86773d65ed58 582 void doUpdateUserTableH()
dxyang 3:86773d65ed58 583 {
dxyang 3:86773d65ed58 584 flagUpdateUserTableH = 0;
dxyang 3:86773d65ed58 585 // Write to a users.txt file
dxyang 3:86773d65ed58 586 spiSD();
dxyang 3:86773d65ed58 587 char * name = "/sd/users.txt";
dxyang 3:86773d65ed58 588 FILE *fp;
dxyang 3:86773d65ed58 589 fp = fopen(name, "w");
dxyang 3:86773d65ed58 590
dxyang 3:86773d65ed58 591 // output the header for the users.txt file
dxyang 3:86773d65ed58 592 fputs("rfid accountCredit locker batterySubscription batteriesOut podID\n", fp);
dxyang 3:86773d65ed58 593
dxyang 3:86773d65ed58 594 // output buffer
dxyang 3:86773d65ed58 595 char logLine[180];
dxyang 3:86773d65ed58 596
dxyang 3:86773d65ed58 597 for (int i = 0; i < userCountH; i++) {
dxyang 3:86773d65ed58 598 // get all the needed information in strings
dxyang 3:86773d65ed58 599 sprintf(logLine, "%u ", allUsersH[i].rfid);
dxyang 3:86773d65ed58 600 char accountCreditBuffer[20];
dxyang 3:86773d65ed58 601 char* lockerBuffer;
dxyang 3:86773d65ed58 602 char batterySubscriptionBuffer[20];
dxyang 3:86773d65ed58 603 char batteriesOutBuffer[20];
dxyang 3:86773d65ed58 604 char podIdBuffer[20];
dxyang 3:86773d65ed58 605
dxyang 3:86773d65ed58 606 sprintf(accountCreditBuffer, "%d ", allUsersH[i].accountCredit);
dxyang 3:86773d65ed58 607 switch (allUsersH[i].lockerID) {
dxyang 3:86773d65ed58 608 case lockerOne:
dxyang 3:86773d65ed58 609 lockerBuffer = "1 ";
dxyang 3:86773d65ed58 610 break;
dxyang 3:86773d65ed58 611 case lockerTwo:
dxyang 3:86773d65ed58 612 lockerBuffer = "2 ";
dxyang 3:86773d65ed58 613 break;
dxyang 3:86773d65ed58 614 case lockerThree:
dxyang 3:86773d65ed58 615 lockerBuffer = "3 ";
dxyang 3:86773d65ed58 616 break;
dxyang 3:86773d65ed58 617 case lockerFour:
dxyang 3:86773d65ed58 618 lockerBuffer = "4 ";
dxyang 3:86773d65ed58 619 break;
dxyang 3:86773d65ed58 620 case lockerUnassigned:
dxyang 3:86773d65ed58 621 default:
dxyang 3:86773d65ed58 622 lockerBuffer = "0 ";
dxyang 3:86773d65ed58 623 break;
dxyang 3:86773d65ed58 624 }
dxyang 3:86773d65ed58 625 sprintf(batterySubscriptionBuffer, "%d ", allUsersH[i].batterySubscription);
dxyang 3:86773d65ed58 626 sprintf(batteriesOutBuffer, "%d ", allUsersH[i].batteriesOut);
dxyang 3:86773d65ed58 627 sprintf(podIdBuffer, "%d\n", allUsersH[i].podID);
dxyang 3:86773d65ed58 628
dxyang 3:86773d65ed58 629 // concatenate all the strings
dxyang 3:86773d65ed58 630 strcat(logLine, accountCreditBuffer);
dxyang 3:86773d65ed58 631 strcat(logLine, lockerBuffer);
dxyang 3:86773d65ed58 632 strcat(logLine, batterySubscriptionBuffer);
dxyang 3:86773d65ed58 633 strcat(logLine, batteriesOutBuffer);
dxyang 3:86773d65ed58 634 strcat(logLine, podIdBuffer);
dxyang 3:86773d65ed58 635
dxyang 3:86773d65ed58 636 // write the line to the log file
dxyang 3:86773d65ed58 637 fputs(logLine, fp);
dxyang 3:86773d65ed58 638
dxyang 3:86773d65ed58 639 #ifdef debug
dxyang 3:86773d65ed58 640 printf("%s\n\r", logLine);
dxyang 3:86773d65ed58 641 #endif
dxyang 3:86773d65ed58 642 }
dxyang 3:86773d65ed58 643 fclose(fp);
dxyang 3:86773d65ed58 644 }
epgmdm 2:d1eae91343a9 645
dxyang 5:88c516cf34e6 646 /*************************************************************************************************/
dxyang 5:88c516cf34e6 647 /* Battery Services */
dxyang 5:88c516cf34e6 648 /*************************************************************************************************/
epgmdm 1:c2232b1eaf31 649 /**
dxyang 3:86773d65ed58 650 * Do if Battery RFID flag is set. Read RFID tag and check user status.
dxyang 3:86773d65ed58 651 * If there's a valid battery subscription, display drop off and/or pick up.
dxyang 3:86773d65ed58 652 * Otherwise, returns to initial screen.
dxyang 3:86773d65ed58 653 */
dxyang 3:86773d65ed58 654 void doBatteryRfidH()
dxyang 3:86773d65ed58 655 {
dxyang 3:86773d65ed58 656 flagBatteryRfidH = 0;
dxyang 3:86773d65ed58 657
dxyang 3:86773d65ed58 658 // is there a new readable card?
dxyang 3:86773d65ed58 659 if (!BatteryRfChipH.PICC_IsNewCardPresent()) {
dxyang 3:86773d65ed58 660 return;
dxyang 3:86773d65ed58 661 }
dxyang 3:86773d65ed58 662
dxyang 3:86773d65ed58 663 if (!BatteryRfChipH.PICC_ReadCardSerial()) {
dxyang 3:86773d65ed58 664 #ifdef debug
dxyang 3:86773d65ed58 665 printf("Card not readable\n\r");
dxyang 3:86773d65ed58 666 #endif
dxyang 3:86773d65ed58 667 return;
dxyang 3:86773d65ed58 668 }
dxyang 3:86773d65ed58 669
dxyang 3:86773d65ed58 670 // get the id of the scanned tag
dxyang 3:86773d65ed58 671 uint8_t tempReadingRfid[4];
dxyang 3:86773d65ed58 672 for(uint8_t i = 0; i < BatteryRfChipH.uid.size; i++) {
dxyang 3:86773d65ed58 673 tempReadingRfid[i] = BatteryRfChipH.uid.uidByte[i];
dxyang 3:86773d65ed58 674 }
dxyang 3:86773d65ed58 675
dxyang 3:86773d65ed58 676 // concatenate the 4 bytes into a single integer via bit shifting
dxyang 3:86773d65ed58 677 uint32_t actualRfid = ((((uint32_t)tempReadingRfid[0] << 24) |
dxyang 3:86773d65ed58 678 ((uint32_t)tempReadingRfid[1] << 16)) |
dxyang 3:86773d65ed58 679 (((uint32_t)tempReadingRfid[2] << 8) |
dxyang 3:86773d65ed58 680 ((uint32_t)tempReadingRfid[3] << 0)));
dxyang 3:86773d65ed58 681
dxyang 3:86773d65ed58 682 // find the user info
dxyang 3:86773d65ed58 683 char foundUserFlag = 0;
dxyang 7:0aee09577ad3 684 int foundUserIndex;
dxyang 3:86773d65ed58 685 for (int i = 0; i < userCountH; i++) {
dxyang 3:86773d65ed58 686 if (allUsersH[i].rfid == actualRfid) {
dxyang 3:86773d65ed58 687 currentUserH = i;
dxyang 7:0aee09577ad3 688 foundUserIndex = i;
dxyang 3:86773d65ed58 689 foundUserFlag = 1;
dxyang 3:86773d65ed58 690 break;
dxyang 3:86773d65ed58 691 }
dxyang 3:86773d65ed58 692 }
dxyang 3:86773d65ed58 693
dxyang 3:86773d65ed58 694 // if the user is found, set the global variable for current user interacting with the system
dxyang 3:86773d65ed58 695 // if the user isn't found, log that an rfid without a user was used and display
dxyang 3:86773d65ed58 696 if (!foundUserFlag) {
dxyang 3:86773d65ed58 697 #ifdef debug
dxyang 3:86773d65ed58 698 printf("User not found\n\r");
dxyang 3:86773d65ed58 699 printf("ID:%u\n\r", actualRfid);
dxyang 3:86773d65ed58 700 #endif
dxyang 3:86773d65ed58 701 // log the error interaction
dxyang 3:86773d65ed58 702 logErrorUnknownRfidScannedH(actualRfid);
dxyang 3:86773d65ed58 703
dxyang 3:86773d65ed58 704 // let user know tag wasn't found
dxyang 3:86773d65ed58 705 TFT_H.cls();
dxyang 3:86773d65ed58 706 TFT_H.locate(0,0);
dxyang 3:86773d65ed58 707 TFT_H.printf("User not found\n\r");
dxyang 3:86773d65ed58 708 TFT_H.printf("ID:%u\n\r", actualRfid);
dxyang 3:86773d65ed58 709 wait(1);
dxyang 3:86773d65ed58 710 currentScreenH = initialScanRfid;
dxyang 3:86773d65ed58 711 return;
dxyang 3:86773d65ed58 712 }
dxyang 3:86773d65ed58 713
dxyang 3:86773d65ed58 714 // log user scan
dxyang 7:0aee09577ad3 715 logActionWithUserInfoH(hubAction_RfidScanned, foundUserIndex);
dxyang 3:86773d65ed58 716
dxyang 3:86773d65ed58 717 // Display info about the user
dxyang 3:86773d65ed58 718 char authorizationFlag = 0;
dxyang 3:86773d65ed58 719 TFT_H.cls();
dxyang 3:86773d65ed58 720 TFT_H.locate(0,0);
dxyang 3:86773d65ed58 721 TFT_H.printf("UserID: %u\n\r", actualRfid);
dxyang 7:0aee09577ad3 722 TFT_H.printf("Balance:%d\n\r", allUsersH[foundUserIndex].accountCredit);
dxyang 7:0aee09577ad3 723 if (allUsersH[foundUserIndex].batterySubscription > 0) {
dxyang 3:86773d65ed58 724 authorizationFlag = 1;
dxyang 3:86773d65ed58 725 }
dxyang 3:86773d65ed58 726 TFT_H.printf("Authorization:%s\n\r", (authorizationFlag)? "YES":"NO");
dxyang 3:86773d65ed58 727
dxyang 3:86773d65ed58 728 #ifdef debug
dxyang 3:86773d65ed58 729 printf("User:");
dxyang 3:86773d65ed58 730 for(uint8_t i = 0; i < BatteryRfChipH.uid.size; i++)
dxyang 3:86773d65ed58 731 {
dxyang 3:86773d65ed58 732 uint8_t uidByte = BatteryRfChipH.uid.uidByte[i];
dxyang 3:86773d65ed58 733 printf(" %d", uidByte);
dxyang 3:86773d65ed58 734 }
dxyang 3:86773d65ed58 735 printf("\n\rUserID: %u\n\r", actualRfid);
dxyang 3:86773d65ed58 736 #endif
dxyang 3:86773d65ed58 737
dxyang 3:86773d65ed58 738 // if not authorized for batteries, return to main screen
dxyang 3:86773d65ed58 739 wait(1);
dxyang 3:86773d65ed58 740 if (!authorizationFlag) {
dxyang 3:86773d65ed58 741 currentScreenH = initialScanRfid;
dxyang 3:86773d65ed58 742 return;
dxyang 3:86773d65ed58 743 }
dxyang 3:86773d65ed58 744
dxyang 3:86773d65ed58 745 // otherwise, ask user if the user wants to pick up or drop off batteries?
dxyang 3:86773d65ed58 746 TFT_H.locate(0,160);
dxyang 3:86773d65ed58 747 TFT_H.printf("Battery Action?\n\r");
dxyang 3:86773d65ed58 748 TFT_H.locate(0,200);
dxyang 3:86773d65ed58 749
dxyang 7:0aee09577ad3 750 uint8_t maxBatteries = allUsersH[foundUserIndex].batterySubscription;
dxyang 7:0aee09577ad3 751 uint8_t outBatteries = allUsersH[foundUserIndex].batteriesOut;
dxyang 3:86773d65ed58 752
dxyang 3:86773d65ed58 753 if ((maxBatteries - outBatteries) == 0) { // can only drop off
dxyang 3:86773d65ed58 754 TFT_H.printf(" drop exit");
dxyang 3:86773d65ed58 755 } else if (outBatteries == 0) { // can only pick up
dxyang 3:86773d65ed58 756 TFT_H.printf(" pick exit");
dxyang 3:86773d65ed58 757 } else { // can pickup or dropoff
dxyang 3:86773d65ed58 758 TFT_H.printf(" pick drop exit");
dxyang 3:86773d65ed58 759 }
dxyang 3:86773d65ed58 760
dxyang 3:86773d65ed58 761 // go to action selecting screen and clear buttons beforehand
dxyang 3:86773d65ed58 762 currentScreenH = batterySelectAction;
dxyang 3:86773d65ed58 763 clearAllUserInitiatedFlagsH();
dxyang 3:86773d65ed58 764 return;
dxyang 3:86773d65ed58 765 }
dxyang 3:86773d65ed58 766
dxyang 3:86773d65ed58 767 /**
dxyang 3:86773d65ed58 768 * Do if user selects to pickup a battery. Determines how many batteries
dxyang 3:86773d65ed58 769 * a user can pickup based off user info and displays corresponding text
dxyang 7:0aee09577ad3 770 * @param userIndex - int representing index of user in user table
dxyang 3:86773d65ed58 771 */
dxyang 7:0aee09577ad3 772 void batteryPickUpH(int userIndex) {
dxyang 3:86773d65ed58 773 TFT_H.cls();
dxyang 3:86773d65ed58 774 TFT_H.locate(0,0);
dxyang 7:0aee09577ad3 775 TFT_H.printf("UserID: %u\n\r\n\r", allUsersH[userIndex].rfid);
dxyang 3:86773d65ed58 776
dxyang 3:86773d65ed58 777 TFT_H.printf("Action: PICK UP\n\r");
dxyang 3:86773d65ed58 778 TFT_H.locate(0,160);
dxyang 3:86773d65ed58 779 TFT_H.printf("How many batteries?\n\r");
dxyang 3:86773d65ed58 780 TFT_H.locate(0,200);
dxyang 7:0aee09577ad3 781 switch (allUsersH[userIndex].batterySubscription - allUsersH[userIndex].batteriesOut) {
dxyang 3:86773d65ed58 782 case 1: {
dxyang 3:86773d65ed58 783 TFT_H.printf(" 1 exit");
dxyang 3:86773d65ed58 784 break;
dxyang 3:86773d65ed58 785 }
dxyang 3:86773d65ed58 786 case 2: {
dxyang 3:86773d65ed58 787 TFT_H.printf(" 1 2 exit");
dxyang 3:86773d65ed58 788 break;
dxyang 3:86773d65ed58 789 }
dxyang 3:86773d65ed58 790 case 3: {
dxyang 3:86773d65ed58 791 TFT_H.printf(" 1 2 3 exit");
dxyang 3:86773d65ed58 792 break;
dxyang 3:86773d65ed58 793 }
dxyang 3:86773d65ed58 794 }
dxyang 3:86773d65ed58 795
dxyang 3:86773d65ed58 796 // go to wait for selection input and reset button flags
dxyang 3:86773d65ed58 797 currentScreenH = batterySelectNumberForPickup;
dxyang 3:86773d65ed58 798 clearAllUserInitiatedFlagsH();
dxyang 3:86773d65ed58 799 return;
dxyang 3:86773d65ed58 800 }
dxyang 3:86773d65ed58 801
dxyang 3:86773d65ed58 802 /**
dxyang 3:86773d65ed58 803 * Do if user selects to dropoff a battery. Determines how many batteries
dxyang 3:86773d65ed58 804 * a user can pickup based off user info and displays corresponding text
dxyang 7:0aee09577ad3 805 * @param userIndex - int representing index of user in user table
dxyang 3:86773d65ed58 806 */
dxyang 7:0aee09577ad3 807 void batteryDropOffH(int userIndex) {
dxyang 3:86773d65ed58 808 TFT_H.cls();
dxyang 3:86773d65ed58 809 TFT_H.locate(0,0);
dxyang 7:0aee09577ad3 810 TFT_H.printf("UserID: %u\n\r\n\r", allUsersH[userIndex].rfid);
dxyang 3:86773d65ed58 811
dxyang 3:86773d65ed58 812 TFT_H.printf("Action: DROP OFF\n\r");
dxyang 3:86773d65ed58 813 TFT_H.locate(0,160);
dxyang 3:86773d65ed58 814 TFT_H.printf("How many batteries?\n\r");
dxyang 3:86773d65ed58 815 TFT_H.locate(0,200);
dxyang 7:0aee09577ad3 816 switch (allUsersH[userIndex].batteriesOut) {
dxyang 3:86773d65ed58 817 case 1: {
dxyang 3:86773d65ed58 818 TFT_H.printf(" 1 exit");
dxyang 3:86773d65ed58 819 break;
dxyang 3:86773d65ed58 820 }
dxyang 3:86773d65ed58 821 case 2: {
dxyang 3:86773d65ed58 822 TFT_H.printf(" 1 2 exit");
dxyang 3:86773d65ed58 823 break;
dxyang 3:86773d65ed58 824 }
dxyang 3:86773d65ed58 825 case 3: {
dxyang 3:86773d65ed58 826 TFT_H.printf(" 1 2 3 exit");
dxyang 3:86773d65ed58 827 break;
dxyang 3:86773d65ed58 828 }
dxyang 3:86773d65ed58 829 }
dxyang 3:86773d65ed58 830
dxyang 3:86773d65ed58 831 // go to wait for selection input and reset button flags
dxyang 3:86773d65ed58 832 currentScreenH = batterySelectNumberForDropoff;
dxyang 3:86773d65ed58 833 clearAllUserInitiatedFlagsH();
dxyang 3:86773d65ed58 834 return;
dxyang 3:86773d65ed58 835 }
dxyang 3:86773d65ed58 836
dxyang 3:86773d65ed58 837 /**
dxyang 3:86773d65ed58 838 * Do after use selects number of batteries to drop off.
dxyang 3:86773d65ed58 839 * Logs the action, changes user info, transmits instructions to other systems
dxyang 3:86773d65ed58 840 * @param numBatteries - int for number of batteries selected to drop off
dxyang 7:0aee09577ad3 841 * @param userIndex - int representing index of user in user table
dxyang 3:86773d65ed58 842 */
dxyang 7:0aee09577ad3 843 void batteryDropOffH(int numBatteries, int userIndex) {
dxyang 3:86773d65ed58 844 switch(numBatteries) {
dxyang 3:86773d65ed58 845 case 1:
dxyang 7:0aee09577ad3 846 logActionWithUserInfoH(hubAction_OneBatteryDropped, userIndex);
dxyang 6:00a132a076d5 847 txBatteryDropOff(1);
dxyang 7:0aee09577ad3 848 allUsersH[userIndex].batteriesOut--;
dxyang 3:86773d65ed58 849 break;
dxyang 3:86773d65ed58 850 case 2:
dxyang 7:0aee09577ad3 851 logActionWithUserInfoH(hubAction_TwoBatteryDropped, userIndex);
dxyang 6:00a132a076d5 852 txBatteryDropOff(2);
dxyang 7:0aee09577ad3 853 allUsersH[userIndex].batteriesOut -= 2;
dxyang 3:86773d65ed58 854 break;
dxyang 3:86773d65ed58 855 case 3:
dxyang 7:0aee09577ad3 856 logActionWithUserInfoH(hubAction_ThreeBatteryDropped, userIndex);
dxyang 6:00a132a076d5 857 txBatteryDropOff(3);
dxyang 7:0aee09577ad3 858 allUsersH[userIndex].batteriesOut -= 3;
dxyang 3:86773d65ed58 859 break;
dxyang 3:86773d65ed58 860 }
dxyang 3:86773d65ed58 861
dxyang 3:86773d65ed58 862 currentScreenH = initialScanRfid;
dxyang 3:86773d65ed58 863 return;
dxyang 3:86773d65ed58 864 }
dxyang 3:86773d65ed58 865
dxyang 3:86773d65ed58 866 /**
dxyang 3:86773d65ed58 867 * Do after use selects number of batteries to pick up.
dxyang 3:86773d65ed58 868 * Logs the action, changes user info, transmits instructions to other systems
dxyang 3:86773d65ed58 869 * @param numBatteries - int for number of batteries selected to pick up
dxyang 7:0aee09577ad3 870 * @param userIndex - int representing index of user in user table
dxyang 3:86773d65ed58 871 */
dxyang 7:0aee09577ad3 872 void batteryPickUpH(int numBatteries, int userIndex) {
dxyang 3:86773d65ed58 873 switch(numBatteries) {
dxyang 3:86773d65ed58 874 case 1:
dxyang 7:0aee09577ad3 875 logActionWithUserInfoH(hubAction_OneBatteryPicked, userIndex);
dxyang 6:00a132a076d5 876 txBatteryPickUp(1);
dxyang 7:0aee09577ad3 877 allUsersH[userIndex].batteriesOut++;
dxyang 3:86773d65ed58 878 break;
dxyang 3:86773d65ed58 879 case 2:
dxyang 7:0aee09577ad3 880 logActionWithUserInfoH(hubAction_TwoBatteryPicked, userIndex);
dxyang 6:00a132a076d5 881 txBatteryPickUp(2);
dxyang 7:0aee09577ad3 882 allUsersH[userIndex].batteriesOut += 2;
dxyang 3:86773d65ed58 883 break;
dxyang 3:86773d65ed58 884 case 3:
dxyang 7:0aee09577ad3 885 logActionWithUserInfoH(hubAction_ThreeBatteryPicked, userIndex);
dxyang 6:00a132a076d5 886 txBatteryPickUp(3);
dxyang 7:0aee09577ad3 887 allUsersH[userIndex].batteriesOut += 3;
dxyang 3:86773d65ed58 888 break;
dxyang 3:86773d65ed58 889 }
dxyang 3:86773d65ed58 890
dxyang 3:86773d65ed58 891 currentScreenH = initialScanRfid;
dxyang 3:86773d65ed58 892 return;
dxyang 3:86773d65ed58 893 }
dxyang 3:86773d65ed58 894
dxyang 5:88c516cf34e6 895 /*************************************************************************************************/
dxyang 5:88c516cf34e6 896 /* Misc Services */
dxyang 5:88c516cf34e6 897 /*************************************************************************************************/
dxyang 3:86773d65ed58 898 /**
dxyang 3:86773d65ed58 899 * Do if Posho RFID flag is set. Add posho functionality later.
dxyang 3:86773d65ed58 900 */
dxyang 3:86773d65ed58 901 void doPoshoRfidH()
dxyang 3:86773d65ed58 902 {
dxyang 3:86773d65ed58 903 flagPoshoRfidH = 0;
dxyang 3:86773d65ed58 904 }
dxyang 3:86773d65ed58 905
dxyang 3:86773d65ed58 906 /**
dxyang 3:86773d65ed58 907 * Do if Incubator RFID flag is set. Add incubator functionality later.
dxyang 3:86773d65ed58 908 */
dxyang 3:86773d65ed58 909 void doIncubatorRfidH()
dxyang 3:86773d65ed58 910 {
dxyang 3:86773d65ed58 911 flagIncubatorRfidH = 0;
dxyang 3:86773d65ed58 912 }
dxyang 3:86773d65ed58 913
dxyang 3:86773d65ed58 914 /*************************************************************************************************/
dxyang 3:86773d65ed58 915 /* Public Methods */
dxyang 3:86773d65ed58 916 /*************************************************************************************************/
dxyang 3:86773d65ed58 917 /**
dxyang 3:86773d65ed58 918 * Initialise for a hub
epgmdm 1:c2232b1eaf31 919 * fp is the config file if additonal information is needed.
epgmdm 1:c2232b1eaf31 920 */
epgmdm 1:c2232b1eaf31 921 void initialiseHub(FILE *fp){
epgmdm 1:c2232b1eaf31 922 #ifdef debug
dxyang 3:86773d65ed58 923 printf("Initializing Hub\n\r");
epgmdm 1:c2232b1eaf31 924 #endif
epgmdm 1:c2232b1eaf31 925
epgmdm 1:c2232b1eaf31 926 // Read in hub address and channel
epgmdm 1:c2232b1eaf31 927 if (fscanf (fp,"%x %*c %*s",&channel )!=1) writeError("Hub config: cannot read channel");
epgmdm 1:c2232b1eaf31 928 if (fscanf (fp,"%llx %*c %*s",&addrLcker )!=1) writeError("Hub config: cannot read hub address");
epgmdm 1:c2232b1eaf31 929
epgmdm 1:c2232b1eaf31 930 #ifdef debug
epgmdm 1:c2232b1eaf31 931 printf(" Channel:%x, Hub Address %llx \n\r",channel, addrLcker);
epgmdm 1:c2232b1eaf31 932 #endif
epgmdm 2:d1eae91343a9 933
epgmdm 2:d1eae91343a9 934 // Setup nrf
epgmdm 2:d1eae91343a9 935 #ifdef debug
epgmdm 2:d1eae91343a9 936 printf("Steup doNrf \n\r");
epgmdm 2:d1eae91343a9 937 #endif
epgmdm 2:d1eae91343a9 938 spiNrf();
epgmdm 2:d1eae91343a9 939 nrf1.quickTxSetup(channel, addrLcker);
epgmdm 2:d1eae91343a9 940 #ifdef debug
epgmdm 2:d1eae91343a9 941 nrf1.printDetails();
epgmdm 2:d1eae91343a9 942 nrf1.checkStatus();
epgmdm 2:d1eae91343a9 943 printf("Setup doNrf complete [nrf:%s]\n\r",nrf1.statusString());
epgmdm 2:d1eae91343a9 944 #endif
epgmdm 2:d1eae91343a9 945
dxyang 3:86773d65ed58 946 // Other initialization routines
dxyang 3:86773d65ed58 947 initializeTimeH();
dxyang 3:86773d65ed58 948 initializeInterruptsH();
dxyang 3:86773d65ed58 949 initializeRfidReadersH();
dxyang 3:86773d65ed58 950 initializeLCD_H();
dxyang 3:86773d65ed58 951 initializeUsersFromSD_H();
epgmdm 1:c2232b1eaf31 952 }
epgmdm 2:d1eae91343a9 953
dxyang 3:86773d65ed58 954 void loopHub(){
dxyang 3:86773d65ed58 955 while (true) {
dxyang 3:86773d65ed58 956 // put interrupts here that should supercede anything else
dxyang 3:86773d65ed58 957 if (flag1sH) { do1sH(); }
epgmdm 1:c2232b1eaf31 958
dxyang 3:86773d65ed58 959 // put interrupts here that may be active depending on screen stage
dxyang 3:86773d65ed58 960 switch(currentScreenH) {
dxyang 3:86773d65ed58 961 case initialScanRfid: {
dxyang 3:86773d65ed58 962 TFT_H.cls();
dxyang 3:86773d65ed58 963 TFT_H.locate(0,0);
dxyang 3:86773d65ed58 964 TFT_H.printf("Please scan your ID");
dxyang 3:86773d65ed58 965 currentScreenH = waitForRfid;
dxyang 3:86773d65ed58 966 clearAllUserInitiatedFlagsH();
dxyang 3:86773d65ed58 967 }
dxyang 3:86773d65ed58 968 case waitForRfid: {
dxyang 3:86773d65ed58 969 if (flagTimeCheckH) doTimeCheckH();
dxyang 3:86773d65ed58 970 if (flagBatteryRfidH) doBatteryRfidH();
dxyang 3:86773d65ed58 971 if (flagPoshoRfidH) doPoshoRfidH();
dxyang 3:86773d65ed58 972 if (flagIncubatorRfidH) doIncubatorRfidH();
dxyang 3:86773d65ed58 973 if (flagUpdateUserTableH) doUpdateUserTableH();
dxyang 3:86773d65ed58 974 break;
dxyang 3:86773d65ed58 975 }
dxyang 3:86773d65ed58 976 case batterySelectAction: {
dxyang 3:86773d65ed58 977 uint8_t maxBatteries = allUsersH[currentUserH].batterySubscription;
dxyang 3:86773d65ed58 978 uint8_t outBatteries = allUsersH[currentUserH].batteriesOut;
dxyang 3:86773d65ed58 979
dxyang 3:86773d65ed58 980 if ((maxBatteries - outBatteries) == 0) {
dxyang 7:0aee09577ad3 981 if (flagButtonOneH) batteryDropOffH(currentUserH);
dxyang 7:0aee09577ad3 982 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 983 } else if (outBatteries == 0) {
dxyang 7:0aee09577ad3 984 if (flagButtonOneH) batteryPickUpH(currentUserH);
dxyang 7:0aee09577ad3 985 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 986 } else {
dxyang 7:0aee09577ad3 987 if (flagButtonOneH) batteryPickUpH(currentUserH);
dxyang 7:0aee09577ad3 988 if (flagButtonThreeH) batteryDropOffH(currentUserH);
dxyang 7:0aee09577ad3 989 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 990 }
epgmdm 1:c2232b1eaf31 991
dxyang 3:86773d65ed58 992 break;
dxyang 3:86773d65ed58 993 }
dxyang 3:86773d65ed58 994 case batterySelectNumberForDropoff: {
dxyang 3:86773d65ed58 995 switch (allUsersH[currentUserH].batteriesOut) {
dxyang 3:86773d65ed58 996 case 1: {
dxyang 7:0aee09577ad3 997 if (flagButtonOneH) batteryDropOffH(1, currentUserH);
dxyang 7:0aee09577ad3 998 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 999 break;
dxyang 3:86773d65ed58 1000 }
dxyang 3:86773d65ed58 1001 case 2: {
dxyang 7:0aee09577ad3 1002 if (flagButtonOneH) batteryDropOffH(1, currentUserH);
dxyang 7:0aee09577ad3 1003 if (flagButtonTwoH) batteryDropOffH(2, currentUserH);
dxyang 7:0aee09577ad3 1004 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 1005 break;
dxyang 3:86773d65ed58 1006 }
dxyang 3:86773d65ed58 1007 case 3: {
dxyang 7:0aee09577ad3 1008 if (flagButtonOneH) batteryDropOffH(1, currentUserH);
dxyang 7:0aee09577ad3 1009 if (flagButtonTwoH) batteryDropOffH(2, currentUserH);
dxyang 7:0aee09577ad3 1010 if (flagButtonThreeH) batteryDropOffH(3, currentUserH);
dxyang 7:0aee09577ad3 1011 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 1012 break;
dxyang 3:86773d65ed58 1013 }
dxyang 3:86773d65ed58 1014 }
dxyang 3:86773d65ed58 1015 break;
dxyang 3:86773d65ed58 1016 }
dxyang 3:86773d65ed58 1017 case batterySelectNumberForPickup: {
dxyang 3:86773d65ed58 1018 switch (allUsersH[currentUserH].batterySubscription - allUsersH[currentUserH].batteriesOut) {
dxyang 3:86773d65ed58 1019 case 1: {
dxyang 7:0aee09577ad3 1020 if (flagButtonOneH) batteryPickUpH(1, currentUserH);
dxyang 7:0aee09577ad3 1021 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 1022 break;
dxyang 3:86773d65ed58 1023 }
dxyang 3:86773d65ed58 1024 case 2: {
dxyang 7:0aee09577ad3 1025 if (flagButtonOneH) batteryPickUpH(1, currentUserH);
dxyang 7:0aee09577ad3 1026 if (flagButtonTwoH) batteryPickUpH(2, currentUserH);
dxyang 7:0aee09577ad3 1027 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 1028 break;
dxyang 3:86773d65ed58 1029 }
dxyang 3:86773d65ed58 1030 case 3: {
dxyang 7:0aee09577ad3 1031 if (flagButtonOneH) batteryPickUpH(1, currentUserH);
dxyang 7:0aee09577ad3 1032 if (flagButtonTwoH) batteryPickUpH(2, currentUserH);
dxyang 7:0aee09577ad3 1033 if (flagButtonThreeH) batteryPickUpH(3, currentUserH);
dxyang 7:0aee09577ad3 1034 if (flagButtonFourH) cancelPressedH(currentUserH);
dxyang 3:86773d65ed58 1035 break;
dxyang 3:86773d65ed58 1036 }
dxyang 3:86773d65ed58 1037 }
dxyang 3:86773d65ed58 1038 break;
dxyang 3:86773d65ed58 1039 }
dxyang 3:86773d65ed58 1040 }
epgmdm 2:d1eae91343a9 1041 }
epgmdm 1:c2232b1eaf31 1042 }