Arduino Nano – Konfiguration von der SD-Karte auslesen
Diese Anleitung zeigt Ihnen, wie Sie eine Konfigurationsdatei auf einer Micro-SD-Karte verwenden. Genauer gesagt, werden wir uns Folgendes ansehen:
- Wie man eine config.txt-Datei auf einer Micro-SD-Karte erstellt, die Schlüssel-Wert-Paare enthält
- Wie man die Konfiguration von der Micro-SD-Karte liest und in eine int-Variable speichert
- Wie man die Konfiguration von der Micro-SD-Karte liest und in eine float-Variable speichert
- Wie man die Konfiguration von der Micro-SD-Karte liest und in eine String-Variable speichert
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Über Micro-SD-Kartenmodul
Falls Sie mit dem Micro-SD-Kartenmodul nicht vertraut sind, einschließlich seiner Pinbelegung, Funktionsweise und Programmierung, schauen Sie sich das Tutorial Arduino Nano - Micro-SD-Karte an.
Wie es funktioniert
Jedes Schlüssel-Wert-Paar wird auf der Micro-SD-Karte in einer eigenen Zeile gespeichert. Der Schlüssel und der Wert werden durch ein =-Zeichen getrennt. Ein Zeilenumbruch trennt jedes Schlüssel-Wert-Paar von den anderen.
Der Code des Arduino Nano wird nach dem Schlüssel suchen und den zugehörigen Wert finden und ihn in einer Variablen speichern. Die Variable kann vom Typ int, float oder String sein.
Verdrahtungsdiagramm
- Sie können Jumper-Kabel mit männlich-zu-weiblichen Steckern verwenden, um das Micro-SD-Kartenmodul mit dem Arduino Nano zu verbinden.
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
- Oder du kannst das Micro-SD-Kartenmodul auf das Steckbrett stecken und dann die Männchen-zu-Männchen-Jumperkabel verwenden
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Siehe Der beste Weg, den Arduino Nano und andere Komponenten mit Strom zu versorgen.
Wie man Konfigurationsdaten in Variablen liest
- Erstellen Sie eine config.txt-Datei auf Ihrem PC mit Notepad oder Notepad++.
- Kopieren Sie die folgenden Schlüssel-Wert-Paare und fügen Sie sie in die config.txt-Datei ein:
myString_1=Hello
myString_2=ArduinoGetStarted.com
myInt_1=2
myInt_2=-105
myFloat_1=0.74
myFloat_2=-46.08
- Schließen Sie die Micro-SD-Karte mit einem USB 3.0 SD-Kartenleser an den PC an.
- Stellen Sie sicher, dass die Micro-SD-Karte FAT16 oder FAT32 formatiert ist (Anleitungen dazu können Sie online suchen).
- Legen Sie die config.txt im Hauptordner der Micro-SD-Karte ab.
- Trennen Sie die Micro-SD-Karte vom PC.
- Schließen Sie die Micro-SD-Karte unter Verwendung des Micro-SD-Kartenmoduls an den Arduino Nano an, gemäß dem Verdrahtungsdiagramm.
- Kopieren Sie den untenstehenden Code und öffnen Sie ihn in der Arduino-IDE.
/*
* Dieser Arduino Nano Code wurde von newbiely.de entwickelt
* Dieser Arduino Nano Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-nano/arduino-nano-read-config-from-sd-card
*/
#include <SD.h>
#define PIN_SPI_CS 4
#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;
}
- Klicken Sie in der Arduino IDE auf die Hochladen-Schaltfläche, um den Code zu kompilieren und auf den Arduino Nano hochzuladen.
- Überprüfen Sie den seriellen Monitor auf das Ergebnis.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Nano' on 'COM15')
New Line
9600 baud
SD Card initialized.
myInt_1 = 2
myInt_2 = -105
myFloat_1 = 0.74
myFloat_2 = -46.08
myString_1 = Hello
myString_2 = ArduinoGetStarted.com
- Der serielle Monitor zeigt Werte von Variablen an, die mit den auf der Micro-SD-Karte gespeicherten Werten übereinstimmen.
Sie können nun den Code ändern, um zusätzliche Variablen einzubeziehen.
※ Notiz:
Der Code berücksichtigt nicht die Reihenfolge der Schlüssel-Wert-Paare. Er durchsucht die Datei von Anfang bis Ende, bis der Schlüssel gefunden wird.
Video Tutorial
Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.