11 |
12 |
13 | ### Only use this app if you are familiar with electronics and can fix issues yourself
14 |
15 | ## Hardware
16 |
17 | A custom RFID circuit can be used, but RDM6300 125kHz EM4100 RFID readers can be bought very cheaply and converted for 134.2kHz.
18 |
19 | With reference to the picture below:
20 | - the top image shows the decoding circuitry consisting of:
21 | - a microcontroller that both generates the antenna clock signal and decodes the EM4100 protocol
22 | - an LM358 dual op amp that both amplifies the received signal and cleans it up (configured as a Schmitt trigger)
23 | - the bottom image is the underside which shows the antenna circuit.
24 |
25 | To convert it for 134.2kHz pet microchips:
26 | - the microcontroller and the voltage regulator marked with red crosses can be removed or disabled.
27 | - increase the antenna resonant frequency to 134.2kHz, either:
28 | - reduce the value of the capacitor ringed in cyan.
29 | - remove some turns from the antenna supplied with the RDM6300 to reduce its inductance.
30 | - to assist with selecting values use the `antennaFreq.xlsx` spreadsheet in the `extras` folder.
31 | - the ESP32 supplies the input clock signal and decodes the raw data.
32 | - the end of the resistor pointed to by the green arrow is the raw signal output to be sent to the ESP32.
33 | - the end of the resistor pointed to by the pink arrow is for the input clock signal from the ESP32.
34 | - the above connection points can be wired to repurposed header pins circled in orange.
35 | - both of the connections to the ESP32 should be via 5V/3V3 level shifters.
36 |
37 | 
38 |
39 |
40 | ## Installation
41 |
42 | Download GitHub files into the Arduino IDE sketch folder, removing `-master` from the application folder name.
43 | Compile using arduino core v2.x or V3.x (min v3.0.3) with Partition Scheme: `Minimal SPIFFS (...)`.
44 |
45 | On first installation, the application will start in wifi AP mode - connect to SSID: **ESP32_RFID_...**, to allow router and password details to be entered via the web page on 192.168.4.1. The configuration data file (except passwords) is automatically created, and the application web pages automatically downloaded from GitHub to the SD card **/data** folder when an internet connection is available.
46 |
47 | Subsequent updates to the application, or to the **/data** folder contents, can be made using the **OTA Upload** tab. The **/data** folder can also be reloaded from GitHub using the **Reload /data** button on the **Edit Config** tab, or by using a WebDAV client on `ip_address/webdav`.
48 |
49 |
50 | ## Configuration
51 |
52 | The IO Extender web page has the following tabs:
53 |
54 | * **RFID**: Shows selected encoding type, Tag ID if read, encoding type selection, plus button to clear tag display.
55 |
56 | * **Show Log**: Opens web socket to view log messages dynamically.
57 |
58 | * **Edit Config**:
59 |
60 | * **Reboot ESP**: Restart the ESP to apply some configuration changes.
61 |
62 | * **Reload /data**: Reload data files from github.
63 |
64 | * **Clear NVS**: Clear current passwords.
65 |
66 | * **Wifi**: WiFi and webserver settings.
67 |
68 | * **Peripherals**: Enter pins for connection to RDM6300 and optional LCD1602, and optional pin for physical button to clear display.
69 |
70 | * **Save**: Make configuration changes persist over ESP reboots.
71 |
72 | * **OTA Update**: Use OTA to update application firmware using bin file or files in **/data** folder.
73 |
74 |
--------------------------------------------------------------------------------
/RFID.cpp:
--------------------------------------------------------------------------------
1 | /*
2 | * Decode EM4100 or FDX-B tags
3 | * The following library https://github.com/Sthing/AccessThing/tree/master/Arduino/libraries/EM4100
4 | * was used as a starting point to derive this library
5 | * together with info for decoding FDX-B from http://www.gizmolab.co.za/fdx-b-protocol/
6 | *
7 | * s60sc 2018, 2024
8 | */
9 |
10 | #include "appGlobals.h"
11 | #include "driver/ledc.h"
12 |
13 | int rfidDemod; // input - demod pin from RDM6300, pullup high
14 | int rfidClock; // output - clock pin to RDM6300
15 | int clearPin; // input - clear tag display
16 | float rfidFreq; // RDM6300 antenna frequency
17 | bool encodeFDX = false; // false for EM4100, true for FXD-B
18 | uint64_t currentTag; // read tag value
19 | char encodingStr[17]; // encoding type string
20 | char currentTagStr[17]; // holds string representation of tag
21 | static bool buttonPressed = false; // to clear tag display
22 |
23 | // Buffer sizing
24 | static const uint16_t bitBufferSize = 256; // Room for 2 x FDX-B codeLength bits, EM4100 is smaller
25 | static uint16_t slBoundary, minPulse, maxPulse; // boundary between long and short pulses
26 | static int codeLength, captureSize;
27 | static const int minLength = 64; // min length for complete tag, for FDX-B, only first 64 bits are relevant
28 | static int captureIndex = 0;
29 |
30 | // Variables used during decoding
31 | static uint8_t columnSums[4]; // Used for EM4100 parity calculation of the four columns
32 | static uint8_t bitBuffer[bitBufferSize]; // Each byte contains data for 4 full bit periods. LSB is first bit.
33 | static const char* codeStr[2] = {"EM4100", "FDX-B"};
34 | static volatile bool captured = false; // whether sufficient pulses have been captured for processing
35 | static int headerPos = 0;
36 |
37 | // simulation and debugging
38 | #define simulation false
39 | static uint16_t pulses[bitBufferSize * 2]; // save pulse lengths, 1 bit can be represented by 2 pulses
40 | static int pulseIndex = 0;
41 | static uint32_t simPulse;
42 |
43 | // forward refs
44 | static bool parseNibble(word offset, uint8_t *nibble);
45 | static bool parseBitBufferEM(uint8_t currIndex);
46 | static bool parseBitBufferFDX(uint8_t currIndex);
47 |
48 | static void runClock() {
49 | // output PWM clock to RDM6300 at required frequency
50 | int dutyBits = 1; // 50% duty
51 | #if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
52 | ledcAttach(rfidClock, (int)(rfidFreq * 1000), dutyBits);
53 | ledcWrite(rfidClock, 1);
54 | #else
55 | int rfidChannel = 4;
56 | ledcSetup(rfidChannel, (int)(rfidFreq * 1000), dutyBits);
57 | ledcAttachPin(rfidClock, rfidChannel);
58 | ledcWrite(rfidChannel, 1);
59 | #endif
60 | }
61 | void IRAM_ATTR buttonISR() {
62 | buttonPressed = true;
63 | }
64 |
65 | static void IRAM_ATTR demodISR() {
66 | // obtain the encoded bit stream from the reader demodulated output
67 | // consists of short and long pulses, short pulses must occur in pairs (for one bit)
68 | // FDX-B demodulation: One long pulse = logic 1, two short pulses = logic 0
69 | // EM4100 demodulation: One long pulse = change logic level, two short pulses = same as previous logic level
70 | // - but dont know logic polarity
71 |
72 | bool invalidPulse = false;
73 | static uint8_t level = 1;
74 | static bool gotFirstShort = false;
75 | static uint32_t lastMicros = 0;
76 | uint32_t elapsedMicros;
77 |
78 | if (!captured) {
79 | elapsedMicros = simulation ? simPulse : micros() - lastMicros;
80 | lastMicros = micros(); // elapsed uS between interrupts
81 | if (captureIndex >= captureSize) captured = true;
82 | else {
83 | if (elapsedMicros > minPulse && elapsedMicros < maxPulse) {
84 | // potentially valid pulse
85 | if (elapsedMicros > slBoundary) {
86 | // long pulse
87 | if (gotFirstShort) invalidPulse = true; // as only have single short pulse
88 | else {
89 | if (encodeFDX) bitBuffer[captureIndex++] = 1; // FDX-B long pulse = logic 1
90 | else {
91 | // EM4100 long pulse changes logic level
92 | level ^= 1;
93 | bitBuffer[captureIndex++] = level;
94 | }
95 | }
96 | } else {
97 | // short pulse, FDX-B = logic 0, EM4100 same as previous level
98 | if (gotFirstShort) {
99 | // second of two short pulses
100 | bitBuffer[captureIndex++] = encodeFDX ? 0 : level;
101 | gotFirstShort = false;
102 | } else gotFirstShort = true;
103 | }
104 | pulses[pulseIndex++] = elapsedMicros; // debugging
105 | } else invalidPulse = true;
106 | // restart capture on outliers unless min length achieved
107 | if (invalidPulse) {
108 | gotFirstShort = false;
109 | if (captureIndex < minLength) captureIndex = pulseIndex = 0; // restart capture
110 | else captured = true; // try current capture if minumum capture length achieved
111 | }
112 | }
113 | }
114 | }
115 |
116 | static bool findHeader() {
117 | // Search for the start of the relevant protocol header
118 | // Determine if EM4100 tag or FDX-B tag depending on which header expected
119 | // Header is either:
120 | // - 10 0-bits in a row for FDX-B (eg 100000000001)
121 | // - 9 1-bits in a row for em4100 (eg 01111111110)
122 | // There is no point looking for a header after codelength
123 |
124 | uint8_t theBit;
125 | uint8_t countBit = 0;
126 | uint8_t countEnd = (encodeFDX) ? 10 : 9;
127 |
128 | for (uint16_t i = 0; i <= codeLength; i++) {
129 | theBit = bitBuffer[i];
130 | // (re)start count on an opposite bit
131 | countBit = theBit ? (encodeFDX ? 0 : countBit + 1) : (encodeFDX ? countBit + 1 : 0);
132 | // if appropriate header found, parse data
133 | if (countBit == countEnd) {
134 | if (encodeFDX) return parseBitBufferFDX(i);
135 | else return parseBitBufferEM(i);
136 | }
137 | }
138 | LOG_VRB("No %s header found", codeStr[encodeFDX]);
139 | return false;
140 | }
141 |
142 | static bool parseBitBufferEM(uint8_t currIndex) {
143 | // match data to EM4100 encoding
144 | uint8_t theBit;
145 | // Clear buffers
146 | for (uint8_t i = 0; i < 4; i++) columnSums[i] = 0;
147 | uint16_t countryId = 0;
148 | uint64_t cardTag = 0;
149 |
150 | // Bit currIndex in bitBuffer is the 9th and final header bit (index 8).
151 | // Verify that bit 64 is 0 (stop bit, index 63))
152 | uint32_t offset = currIndex - 8; // How many bits were skipped before the header started (ie index of first header bit)
153 | LOG_VRB("%s header start at: %d", codeStr[encodeFDX], offset);
154 | headerPos = offset;
155 |
156 | uint32_t index = offset + 63;
157 | theBit = bitBuffer[index];
158 | if (theBit) {
159 | LOG_VRB("EM stopbit not 0");
160 | return false;
161 | }
162 |
163 | // Next: 2+8 rows of 4 bits and an even parity bit. MSB first.
164 | // The first 2 rows are the customer id (or version number/manufacturer code), the last 8 rows the data.
165 | // Collect the data in 8 bit facility (countryId) and 32 bit cardUID [cardTag]
166 | uint8_t nibble;
167 | for (uint8_t count = 0; count < 2; count ++) {
168 | if ( !parseNibble(offset + 9 + 5 * count, &nibble)) {
169 | LOG_VRB(" - Wrong parity for card facility, nibble %d", count);
170 | return false;
171 | }
172 | countryId |= nibble << (4 * (1 - count)); // Most significant nibble first
173 | }
174 |
175 | for (uint8_t count = 0; count < 8; count ++) {
176 | if ( ! parseNibble(offset + 19 + 5 * count, &nibble)) {
177 | LOG_VRB(" EM Wrong parity for card UID, nibble %d", count);
178 | return false;
179 | }
180 | cardTag |= ((long)nibble) << (4 * (7 - count)); // Most significant nibble fir
181 | }
182 | // Finally: 4 column parity bits, even
183 | index = offset + 9 + 10 * 5;
184 | for (uint8_t i = 0; i < 4; i++) {
185 | theBit = bitBuffer[index];
186 | if ((columnSums[i] & 1) != theBit) {
187 | LOG_VRB(" - Wrong parity for column %d", i);
188 | return false;
189 | }
190 | index++;
191 | }
192 |
193 | // valid tag found
194 | currentTag = countryId;
195 | currentTag = (currentTag<<32) + cardTag;
196 | return true;
197 | } // End parseBitBufferEM()
198 |
199 | static bool parseNibble(word offset, uint8_t *nibble) {
200 | // Extracts a nibble from the given offset in bitBuffer and checks for even parity in the 5th bit.
201 | // returns true if the parity bit matches the data bits.
202 | uint8_t theBit;
203 | uint8_t bitSum = 0;
204 |
205 | *nibble = 0;
206 | for (uint8_t i = 0; i < 4; i++) {
207 | theBit = bitBuffer[offset];
208 | columnSums[i] += theBit; // Used later for column parity check
209 | bitSum += theBit;
210 | *nibble |= (theBit << (3 - i)); // First bit is MSB
211 | offset++;
212 | }
213 |
214 | // Check for even parity
215 | theBit = bitBuffer[offset];
216 | if ((bitSum & 1) != theBit) return false;
217 |
218 | return true;
219 | } // End parseNibble()
220 |
221 | static bool parseBitBufferFDX(uint8_t currIndex) {
222 | // Match data to FDX-B encoding.
223 | // If decoding succeeds the results are stored in cardTag and countryId.
224 | // Once tag data read, rest can be ignored
225 | uint8_t theBit;
226 | uint16_t countryId = 0;
227 | uint64_t cardTag = 0;
228 |
229 | // now check that next bit is a 1
230 | currIndex++;
231 | theBit = bitBuffer[currIndex];
232 | if (!theBit) {
233 | LOG_VRB("FDX-B header not terminated");
234 | return false;
235 | }
236 | headerPos = currIndex - 10;
237 | LOG_VRB("%s header start at: %d", codeStr[encodeFDX], headerPos);
238 |
239 | // next 54 bits (38 bits + 10 bits + control bits) are card id
240 | // ignore final control bit
241 | uint8_t tagId[48];
242 | uint8_t idCntr = 0;
243 | word count = 0;
244 | uint8_t offset = currIndex+1;
245 | for (uint8_t i = offset; i < offset+53; i++) {
246 | theBit = bitBuffer[i];
247 | if (count < 8) {
248 | // save data bit
249 | tagId[idCntr] = theBit;
250 | count++;
251 | idCntr++;
252 | } else {
253 | // check control bit and skip it
254 | if (!theBit) {
255 | LOG_VRB("FDX-B control bit wrong");
256 | return false;
257 | } else count = 0;
258 | }
259 | }
260 | // convert tag id to decimal, reversing bit order
261 | for (uint8_t i = 38; i > 0; i--) {
262 | cardTag = cardTag << 1;
263 | if (tagId[i-1]) cardTag |= 1;
264 | }
265 |
266 | // convert country code to decimal, reversing bit order
267 | for (uint8_t i = 48; i > 38; i--) {
268 | countryId = countryId << 1;
269 | if (tagId[i-1]) countryId |= 1;
270 | }
271 |
272 | // valid tag found
273 | currentTag = countryId;
274 | currentTag = (currentTag<<38) + cardTag;
275 | LOG_VRB("%s", codeStr[encodeFDX]);
276 | return true;
277 | } // End parseBitBufferFDX()
278 |
279 | static void tagStr() {
280 | // format 64 bit tag into decimal string
281 | // 13 digits for EM41000
282 | // 15 digits for FDX-B
283 | uint64_t thisCardTag;
284 | uint16_t thisCountryId;
285 | uint64_t bitmask = 0x00000000FFFFFFFF; // EM4100
286 | int cardTagBits = 32; // EM4100
287 | int cardTagLen = 10; // EM4100
288 | if (encodeFDX) { // FDX-B
289 | cardTagBits = 38;
290 | cardTagLen = 12;
291 | bitmask = 0x0000003FFFFFFFFF;
292 | }
293 | thisCardTag = (currentTag & bitmask);
294 | thisCountryId = (uint16_t)(currentTag >> cardTagBits);
295 | sprintf(currentTagStr, "%03u", thisCountryId);
296 | // card tag is LSB ordered
297 | for (size_t i = cardTagLen; i--; thisCardTag /= 10) currentTagStr[i + 3] = '0' + (thisCardTag % 10);
298 | currentTagStr[cardTagLen + 3] = 0;
299 | }
300 |
301 | static bool getTag() {
302 | // decode RFID tag
303 | if (findHeader()) {
304 | tagStr();
305 | LOG_INF("Read tag - %s", currentTagStr);
306 | return true;
307 | } else {
308 | LOG_VRB("Tag not read");
309 | currentTag = currentTagStr[0] = 0;
310 | }
311 | return false;
312 | }
313 |
314 | static void showRawData(bool haveTag) {
315 | // show captured pulse lengths and decoding for debugging
316 | if (dbgVerbose) {
317 | logPrint("%s", "------------------------------------------\n");
318 | logPrint("pulses: %d\n", pulseIndex);
319 | logPrint("slBoundary: %d\n", slBoundary);
320 | logPrint("%s", "pulselen: ");
321 | for (int i = 0; i < pulseIndex; i++) logPrint("%d/", pulses[i]);
322 | logPrint("\n%s", "decoded: ");
323 | for (int i = 0; i < captureIndex; i++) logPrint("%u", bitBuffer[i]);
324 | if (haveTag) {
325 | logPrint("\n%s", "tag: ");
326 | for (int i = 0; i < minLength; i++) logPrint("%u", bitBuffer[headerPos + i]);
327 | }
328 | logPrint("%s", "\n------------------------------------------\n\n");
329 | }
330 | }
331 |
332 | static void demodSim() {
333 | // simulate pulses from rfid reader using pregenerated pulse sequence
334 | uint16_t pulseCount = 0;
335 |
336 | const char* delimiter = "/";
337 | // EM4100 tag 0290003174496
338 | const char* pulseLensEM = "200/310/457/308/203/306/204/307/204/305/206/302/210/300/210/299/211/300/210/299/211/301/210/301/210/558/208/301/466/300/210/301/210/300/210/306/203/306/205/301/210/556/210/300/210/299/211/299/467/300/210/300/210/299/212/298/212/300/211/554/212/297/468/299/213/297/213/298/213/297/213/299/211/298/213/554/213/297/213/297/469/297/213/553/218/292/213/297/216/289/222/294/216/294/215/295/217/294/215/295/471/295/216/295/216/552/213/297/215/291/219/296/470/551/216/292/474/294/216/295/217/290/220/290/220/291/219/290/220/291/220/290/220/290/220/290/220/290/220/550/216/295/472/289/221/290/220/290/220/290/221/290/219/294/217/546/220/290/220/292/219/290/477/289/221/289/222/288/221/289/221/289/222/546/220/290/476/289/222/289/221/289/222/288/222/289/222/288/222/545/222/288/222/288/479/289/225/542/221/289/221/289/221/289/221/290/220/290/221/290/219/291/220/289/477/289/222/289/222/544/222/288/221/289/222/289/478/544";
339 | // FDX-B tag 945000001554408
340 | const char* pulseLensFDX = "90/115/100/225/110/110/95/115/105/115/100/120/100/110/95/115/105/115/100/120/100/110/105/105/210/130/95/120/95/115/95/225/110/115/205/225/215/230/210/225/215/125/100/220/210/125/100/225/210/225/215/230/110/110/200/130/95/120/100/115/95/220/110/115/100/115/105/110/100/115/100/115/100/120/100/110/100/120/200/130/95/120/95/115/100/110/105/115/100/120/95/225/105/110/210/125/95/120/100/215/220/125/90/225/210/230/215/120/100/110/105/115/100/120/95/115/100/110/105/115/100/120/95/225/110/105/105/115/100/110/105/115/100/110/105/115/100/115/210/225/105/115/105/110/210/225/110/110/105/110/210/225/215/125/95/225/110/105/105/115/100/115/100/115/205/230/210/125/100/115/95/120/100/115/100/115/100/115/105/110/100/115/100/220/115/110/95/120/100/110/105/115/100/115/95/120/100/110/105/115/210/120/95/120/95/115/105/115/100/110/105/115/95/115/105/115/100/220/110/105/105/115/105/115/95/115/105/110/100/120/100/115/95/115/105/110/100/120/205/120/100/120/95/115/100/225/110/105/210/230/215/225/210/230/215/125/95/220/215/125/100/215/215/230/215/225/110/105/210/130/95/120/95/115/95/225/110/115/100/110/105/110/100/115/105/115/100/115/100/110/100/120/205/130/95/115/95/115";
341 |
342 | char pulseLens[2048]; // as strtok is destructive of original string
343 | encodeFDX ? strcpy(pulseLens, pulseLensFDX) : strcpy(pulseLens, pulseLensEM);
344 | // Calculate the number of pulses
345 | for (int i = 0; pulseLens[i] != '\0'; ++i) if (pulseLens[i] == '/') ++pulseCount;
346 |
347 | // get each pulse length and process
348 | char* token = strtok(pulseLens, delimiter);
349 | for (int i = 0; i < pulseCount; i++) {
350 | simPulse = static_cast406 |
407 |
411 |
412 |
408 |
409 |
410 |
413 |
414 |
460 | 461 |
462 |
463 |
464 | 414 |
415 |
434 |
459 |
416 |
425 |
426 |
427 |
428 |
433 |
429 |
430 |
431 |
432 |
435 |
439 |
440 |
441 |
445 |
446 |
447 |
451 |
452 |
453 |
457 |
458 | 460 | 461 |
462 |
465 |
466 |
468 |
517 |
518 | 466 |
Control
467 | 468 |
469 |
513 |
470 |
474 |
475 |
476 |
480 |
481 |
482 |
486 |
487 |
488 |
489 |
493 |
494 | 489 |
Settings
490 | Press a button to view or modify settings (changed values are not validated)
491 | Press Save button to make changes permanent
492 | 493 |
495 |
499 |
500 |
501 |
505 |
506 |
507 |
511 |
512 |
514 |
515 |
516 |
519 |
520 |
521 |
522 |
583 |
584 |
585 |
--------------------------------------------------------------------------------
/extras/RDM6300.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/s60sc/ESP32_RFID_Reader/7ebddf62a8aac14205afa48076a279e4d8b1adb3/extras/RDM6300.png
--------------------------------------------------------------------------------
/extras/antennaFreq.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/s60sc/ESP32_RFID_Reader/7ebddf62a8aac14205afa48076a279e4d8b1adb3/extras/antennaFreq.xlsx
--------------------------------------------------------------------------------
/extras/lcd.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/s60sc/ESP32_RFID_Reader/7ebddf62a8aac14205afa48076a279e4d8b1adb3/extras/lcd.jpg
--------------------------------------------------------------------------------
/globals.h:
--------------------------------------------------------------------------------
1 | // Global generic declarations
2 | //
3 | // s60sc 2021, 2022
4 |
5 | #include "esp_arduino_version.h"
6 | #pragma once
7 | // to compile with -Wall -Werror=all -Wextra
8 | #pragma GCC diagnostic ignored "-Wunused-function"
9 | #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
10 | //#pragma GCC diagnostic ignored "-Wunused-variable"
11 | //#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
12 | //#pragma GCC diagnostic ignored "-Wignored-qualifiers"
13 | //#pragma GCC diagnostic ignored "-Wclass-memaccess"
14 | #if (ESP_ARDUINO_VERSION_MAJOR >= 3)
15 | #pragma GCC diagnostic ignored "-Wvolatile"
16 | #else
17 | #pragma GCC diagnostic ignored "-Wformat"
18 | #endif
19 |
20 | /******************** Libraries *******************/
21 |
22 | #include "Arduino.h"
23 | #include 93 |
| Wifi setup.. | ||
|---|---|---|
| SSID | 99 |100 | | 101 | |
| Password | 104 |105 | | 106 | |
| 109 | 110 | | ||
113 |
134 |
Upload data file or bin file to ESP32
135 |136 | Go Back 137 |
138 | 145 | 146 | 191 | 192 | 193 | )~"; 194 | -------------------------------------------------------------------------------- /utilsFS.cpp: -------------------------------------------------------------------------------- 1 | // General purpose SD card and flash storage utilities 2 | // 3 | // s60sc 2021, 2022 4 | 5 | #include "appGlobals.h" 6 | 7 | // Storage settings 8 | int sdMinCardFreeSpace = 100; // Minimum amount of card free Megabytes before sdFreeSpaceMode action is enabled 9 | int sdFreeSpaceMode = 1; // 0 - No Check, 1 - Delete oldest dir, 2 - Upload oldest dir to FTP/HFS and then delete on SD 10 | bool formatIfMountFailed = true; // Auto format the file system if mount failed. Set to false to not auto format. 11 | static fs::FS fp = STORAGE; 12 | 13 | // hold sorted list of filenames/folders names in order of newest first 14 | static std::vector