ESP32 - Leer la configuración desde la tarjeta SD
En este tutorial, profundizaremos en el uso de un archivo de configuración en una tarjeta microSD. El tutorial cubrirá los siguientes aspectos:
Guardar un archivo config.txt en la tarjeta microSD, que contiene pares clave-valor.
Leer la configuración desde la tarjeta microSD y almacenarla en una variable int.
Leer la configuración desde la tarjeta microSD y almacenarla en una variable float.
Leer la configuración desde la tarjeta microSD y almacenarla en una variable String.
Este tutorial le permite gestionar la configuración a través de un archivo almacenado en la tarjeta microSD, ofreciendo flexibilidad para diversos tipos de datos, como enteros, números de punto flotante y cadenas.
Or you can buy the following kits:
Divulgación: Algunos de los enlaces proporcionados en esta sección son enlaces de afiliado de Amazon. Podemos recibir una comisión por las compras realizadas a través de estos enlaces sin costo adicional para usted. Apreciamos su apoyo.
¿No está familiarizado con el módulo de tarjeta microSD, incluyendo sus pines, funcionalidad y programación? Aprenda sobre ellos en el tutorial ESP32 - Tarjeta microSD.
Los pares clave-valor están prealmacenados en la tarjeta microSD según el siguiente formato:
Cada par clave-valor está en una sola línea. En otras palabras, cada par clave-valor está separado de los demás por un carácter de nueva línea
La clave y el valor están separados por un carácter =
El código ESP32 buscará la clave y encontrará el valor correspondiente, y guardará el valor en una variable. El tipo de variable puede ser int, float o String.
This image is created using Fritzing. Click to enlarge image
Si no sabe c\u00f3mo alimentar ESP32 y otros componentes, encuentre instrucciones en el siguiente tutorial: C\u00f3mo alimentar ESP32.
※ Nota:
Si utiliza un escudo Ethernet o cualquier escudo que tenga un portador para tarjetas Micro SD, no es necesario usar el módulo de Micro SD. Solo necesita insertar la tarjeta Micro SD en el portador de tarjetas Micro SD del escudo.
myString_1=Hello
myString_2=newbiely.com
myInt_1=2
myInt_2=-105
myFloat_1=0.74
myFloat_2=-46.08
Conecta la tarjeta microSD al PC mediante un lector de tarjetas SD USB 3.0.
Asegúrate de que la tarjeta microSD esté formateada en FAT16 o FAT32 (búscalo en Google).
Copia el archivo config.txt al directorio raíz de la tarjeta microSD.
Desconecta la tarjeta microSD del PC.
Conecta la tarjeta microSD al ESP32 a través del módulo de tarjeta microSD según el diagrama de cableado anterior.
Copia el código de abajo y ábrelo con Arduino IDE.
#include <SD.h>
#define PIN_SPI_CS 5
#define FILE_NAME "/config.txt"
#define KEY_MAX_LENGTH 30
#define VALUE_MAX_LENGTH 30
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)) {
while (1) {
Serial.println(F("SD CARD FAILED, OR NOT PRESENT!"));
delay(1000);
}
}
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: Issue encountered while attempting to open the file "));
Serial.println(FILE_NAME);
return;
}
char key_string[KEY_MAX_LENGTH];
char SD_buffer[KEY_MAX_LENGTH + VALUE_MAX_LENGTH + 1];
int key_length = 0;
int value_length = 0;
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);
while (configFile.available()) {
int buffer_length = configFile.readBytesUntil('\n', SD_buffer, 100);
if (SD_buffer[buffer_length - 1] == '\r')
buffer_length--;
if (buffer_length > (key_length + 1)) {
if (memcmp(SD_buffer, key_string, key_length) == 0) {
if (SD_buffer[key_length] == '=') {
value_length = buffer_length - key_length - 1;
memcpy(value, SD_buffer + key_length + 1, value_length);
break;
}
}
}
}
configFile.close();
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;
}
SD Card initialized.
myInt_1 = 2
myInt_2 = -105
myFloat_1 = 0.74
myFloat_2 = -46.08
myString_1 = Hello
myString_2 = newbiely.com
Ahora puedes modificar el código para agregar más variables.
※ Nota:
El código anterior no se preocupa por el orden de los pares clave-valor. Buscará la clave desde el principio hasta el final del archivo hasta que la clave coincida.
Estamos considerando crear tutoriales en video. Si considera que los tutoriales en video son importantes, suscríbase a nuestro canal de YouTube para motivarnos a crear los videos.
※ NUESTROS MENSAJES
No dude en compartir el enlace de este tutorial. Sin embargo, por favor no use nuestro contenido en otros sitios web. Hemos invertido mucho esfuerzo y tiempo en crear el contenido, ¡por favor respete nuestro trabajo!
