ESP8266 - Lire la configuration depuis une carte SD
Ce tutoriel vous guide à travers l'utilisation d'un fichier de configuration sur une carte Micro SD avec un ESP8266, couvrant les aspects suivants :
- Placer un fichier config.txt sur la carte Micro SD, comprenant des paires clé-valeur.
- Programmer l'ESP8266 pour lire les données de configuration de la carte Micro SD et les stocker dans une variable int.
- Programmer l'ESP8266 pour lire les données de configuration de la carte Micro SD et les stocker dans une variable float.
- Programmer l'ESP8266 pour lire les données de configuration de la carte Micro SD et les stocker dans une variable String.
Préparation du matériel
Or you can buy the following sensor kits:
| 1 | × | DIYables Sensor Kit (30 sensors/displays) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À propos du module de carte Micro SD
Si vous ne connaissez pas le module de carte Micro SD, y compris son brochage, son fonctionnement et comment le programmer, alors consultez le tutoriel ESP8266 - Carte Micro SD.
Comment ça fonctionne
Chaque paire clé-valeur est située sur une seule ligne de la carte Micro SD, avec la clé et la valeur séparées par un caractère =. De plus, chaque paire est séparée des autres par un caractère de saut de ligne.
Le code ESP8266 recherchera la clé et localisera la valeur associée, qu'il stockera dans une variable. Cette variable peut être un int, un float ou une String.
Diagramme de câblage
This image is created using Fritzing. Click to enlarge image
Voir plus dans l'agencement des broches de l'ESP8266 et comment alimenter l'ESP8266 et d'autres composants.
※ NOTE THAT:
Si vous avez un shield Ethernet ou tout autre shield incluant un support de carte Micro SD, vous n'avez pas besoin d'utiliser le module de carte Micro SD. Insérez simplement la carte Micro SD dans le support sur le shield.
Comment lire la configuration dans des variables
- Générez un fichier config.txt sur votre PC en utilisant Notepad ou Notepad++.
- Copiez et collez les paires clé-valeur suivantes dans le config.txt :
myString_1=Hello
myString_2=newbiely.fr
myInt_1=2
myInt_2=-105
myFloat_1=0.74
myFloat_2=-46.08
- Attachez la carte Micro SD au PC via un lecteur de carte SD USB 3.0.
- Assurez-vous que la carte Micro SD est formatée en FAT16 ou FAT32 (consultez les instructions en ligne).
- Placez le fichier config.txt dans le répertoire principal de la carte Micro SD.
- Une fois terminé, débranchez la carte Micro SD du PC.
- Connectez la carte Micro SD à l'ESP8266 en utilisant le module de carte Micro SD conformément au schéma de câblage.
- Copiez le code ci-dessous et ouvrez-le avec l'IDE Arduino.
/*
* Ce code ESP8266 NodeMCU a été développé par newbiely.fr
* Ce code ESP8266 NodeMCU est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp8266/esp8266-read-config-from-sd-card
*/
#include <SD.h>
#define PIN_SPI_CS D8
#define FILE_NAME "config.txt"
#define KEY_MAX_LENGTH 30 // change it if key is longer
#define VALUE_MAX_LENGTH 30 // change it if value is longer
// variables
int myInt_1;
int myInt_2;
float myFloat_1;
float myFloat_2;
String myString_1;
String myString_2;
void setup() {
Serial.begin(9600);
if (!SD.begin(PIN_SPI_CS)) {
Serial.println(F("SD Card failed, or not present"));
while (1); // don't do anything more:
}
Serial.println(F("SD Card initialized."));
myInt_1 = SD_findInt(F("myInt_1"));
myInt_2 = SD_findInt(F("myInt_2"));
myFloat_1 = SD_findFloat(F("myFloat_1"));
myFloat_2 = SD_findFloat(F("myFloat_2"));
myString_1 = SD_findString(F("myString_1"));
myString_2 = SD_findString(F("myString_2"));
Serial.print(F("myInt_1 = "));
Serial.println(myInt_1);
Serial.print(F("myInt_2 = "));
Serial.println(myInt_2);
Serial.print(F("myFloat_1 = "));
Serial.println(myFloat_1);
Serial.print(F("myFloat_2 = "));
Serial.println(myFloat_2);
Serial.print(F("myString_1 = "));
Serial.println(myString_1);
Serial.print(F("myString_2 = "));
Serial.println(myString_2);
}
void loop() {
}
bool SD_available(const __FlashStringHelper * key) {
char value_string[VALUE_MAX_LENGTH];
int value_length = SD_findKey(key, value_string);
return value_length > 0;
}
int SD_findInt(const __FlashStringHelper * key) {
char value_string[VALUE_MAX_LENGTH];
int value_length = SD_findKey(key, value_string);
return HELPER_ascii2Int(value_string, value_length);
}
float SD_findFloat(const __FlashStringHelper * key) {
char value_string[VALUE_MAX_LENGTH];
int value_length = SD_findKey(key, value_string);
return HELPER_ascii2Float(value_string, value_length);
}
String SD_findString(const __FlashStringHelper * key) {
char value_string[VALUE_MAX_LENGTH];
int value_length = SD_findKey(key, value_string);
return HELPER_ascii2String(value_string, value_length);
}
int SD_findKey(const __FlashStringHelper * key, char * value) {
File configFile = SD.open(FILE_NAME);
if (!configFile) {
Serial.print(F("SD Card: error on opening file "));
Serial.println(FILE_NAME);
return;
}
char key_string[KEY_MAX_LENGTH];
char SD_buffer[KEY_MAX_LENGTH + VALUE_MAX_LENGTH + 1]; // 1 is = character
int key_length = 0;
int value_length = 0;
// Flash string to string
PGM_P keyPoiter;
keyPoiter = reinterpret_cast<PGM_P>(key);
byte ch;
do {
ch = pgm_read_byte(keyPoiter++);
if (ch != 0)
key_string[key_length++] = ch;
} while (ch != 0);
// check line by line
while (configFile.available()) {
int buffer_length = configFile.readBytesUntil('\n', SD_buffer, 100);
if (SD_buffer[buffer_length - 1] == '\r')
buffer_length--; // trim the \r
if (buffer_length > (key_length + 1)) { // 1 is = character
if (memcmp(SD_buffer, key_string, key_length) == 0) { // equal
if (SD_buffer[key_length] == '=') {
value_length = buffer_length - key_length - 1;
memcpy(value, SD_buffer + key_length + 1, value_length);
break;
}
}
}
}
configFile.close(); // close the file
return value_length;
}
int HELPER_ascii2Int(char *ascii, int length) {
int sign = 1;
int number = 0;
for (int i = 0; i < length; i++) {
char c = *(ascii + i);
if (i == 0 && c == '-')
sign = -1;
else {
if (c >= '0' && c <= '9')
number = number * 10 + (c - '0');
}
}
return number * sign;
}
float HELPER_ascii2Float(char *ascii, int length) {
int sign = 1;
int decimalPlace = 0;
float number = 0;
float decimal = 0;
for (int i = 0; i < length; i++) {
char c = *(ascii + i);
if (i == 0 && c == '-')
sign = -1;
else {
if (c == '.')
decimalPlace = 1;
else if (c >= '0' && c <= '9') {
if (!decimalPlace)
number = number * 10 + (c - '0');
else {
decimal += ((float)(c - '0') / pow(10.0, decimalPlace));
decimalPlace++;
}
}
}
}
return (number + decimal) * sign;
}
String HELPER_ascii2String(char *ascii, int length) {
String str;
str.reserve(length);
str = "";
for (int i = 0; i < length; i++) {
char c = *(ascii + i);
str += String(c);
}
return str;
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour envoyer le code à l'ESP8266.
- Vérifiez le moniteur série pour le résultat.
COM6
SD Card initialized.
myInt_1 = 2
myInt_2 = -105
myFloat_1 = 0.74
myFloat_2 = -46.08
myString_1 = Hello
myString_2 = newbiely.fr
Autoscroll
Clear output
9600 baud
Newline
- Le moniteur série affiche les valeurs des variables qui sont identiques à celles enregistrées sur la carte micro SD.
Vous pouvez maintenant modifier le code afin d'inclure des variables supplémentaires.
※ NOTE THAT:
Le code ne prend pas en compte l'agencement des paires clé-valeur. Il effectuera une recherche du début à la fin du fichier jusqu'à ce que la clé soit trouvée.