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
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?
User | Revision | Line number | New 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 *) ¤tMaxH)); |
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 | } |