ESP32 und SD-Karte, SPI-Protokoll.

Die SPI-Kommunikation (Serial Peripheral Interface) ist ein synchrones Kommunikationsprotokoll, das die Datenübertragung zwischen elektronischen Geräten ermöglicht. Es wurde von Motorola entwickelt und wird aufgrund seiner Einfachheit, Geschwindigkeit und Effizienz in eingebetteten Systemen und Mikrocontrollern weit verbreitet eingesetzt.

Das SPI-Protokoll arbeitet mit einer Master-Slave-Architektur. Ein Gerät fungiert als Master, während ein oder mehrere Geräte als Slaves agieren. Die Kommunikation erfolgt über vier Signalleitungen:

1. SCLK (Serial Clock): ist ein von dem Master generiertes Takt-Signal, um die Datenübertragung zwischen den Geräten zu synchronisieren.
2. MOSI (Master Out Slave In): ist die Datenleitung vom Master-Ausgang und zum Slave-Eingang. Der Master sendet Daten über diese Leitung an die Slave-Geräte.
3. MISO (Master In Slave Out): ist die Datenleitung vom Slave-Ausgang und zum Master-Eingang. Die Slave-Geräte senden Daten über diese Leitung an den Master.
4. SS (Slave Select) oder CS (Chip Select): ist eine Slave-Auswahlleitung, die vom Master verwendet wird, um ein bestimmtes Slave-Gerät auszuwählen, mit dem er kommunizieren möchte. Jeder Slave verfügt über seine eigene SS/CS-Leitung.

Die grundlegende Funktionsweise der SPI-Kommunikation ist wie folgt:

1. Der Master setzt die SS/CS-Leitung auf einen niedrigen Zustand, um einen bestimmten Slave auszuwählen.
2. Der Master erzeugt ein Taktsignal auf der SCLK-Leitung.
3. Während jedes Taktzyklus sendet der Master ein Datenbit über die MOSI-Leitung und liest ein Datenbit von der MISO-Leitung. Die Daten werden seriell, Bit für Bit, übertragen.
4. Nach Abschluss der Übertragung setzt der Master die SS/CS-Leitung auf einen hohen Zustand, um die Kommunikation mit dem Slave zu deaktivieren.

Die SPI-Kommunikation ist Vollduplex, das bedeutet, dass Daten gleichzeitig gesendet und empfangen werden können. Darüber hinaus ist es möglich, die Polarität und Phase der Uhr (SPI-Modus) anzupassen, um sich an verschiedene Geräte und Anwendungen anzupassen.

Zusammenfassend ist die SPI-Kommunikation ein synchrones, einfaches und effizientes Kommunikationsprotokoll, das die Datenübertragung zwischen elektronischen Geräten über ein Master-Slave-System und vier Signalleitungen ermöglicht: SCLK, MOSI, MISO und SS/CS.

// Incluir las bibliotecas necesarias

#include <SPI.h> // Librería para la comunicación SPI (Serial Peripheral Interface)
#include <SD.h>  // Librería para manejar la tarjeta SD
#include <FS.h>  // Librería para manejar el sistema de archivos

#define SD_CS_PIN 5 // Definir el pin CS (Chip Select) de la tarjeta SD

// La función setup() se ejecuta una vez al inicio del programa

void setup() {

  // Inicializar la comunicación serie a una velocidad de 115200 baudios

  Serial.begin(115200);

  // Inicializar la tarjeta SD utilizando el pin CS definido anteriormente

  if (!SD.begin(SD_CS_PIN)) {

    // Si la inicialización falla, mostrar un mensaje de error y terminar

    Serial.println("Error al inicializar la tarjeta SD");
    return;
  }

  // Si la inicialización tiene éxito, mostrar un mensaje de confirmación

  Serial.println("Tarjeta SD inicializada correctamente");

  // Crear o abrir un archivo en la tarjeta SD con el nombre "test.txt" y modo de escritura
  
  File myFile = SD.open("/test.txt", FILE_WRITE);
  if (!myFile) {

    // Si no se puede abrir el archivo, mostrar un mensaje de error y terminar

    Serial.println("Error al abrir el archivo");
    return;
  }

  // Escribir datos en el archivo (en este caso, una cadena de texto)

  myFile.println("Hola, tarjeta SD!");

  // Cerrar el archivo para asegurar que los datos se guarden correctamente

  myFile.close();

  // Mostrar un mensaje indicando que los datos se han escrito en el archivo

  Serial.println("Datos escritos en el archivo");

  // Abrir el archivo "test.txt" en modo de lectura

  myFile = SD.open("/test.txt", FILE_READ);
  if (!myFile) {

    // Si no se puede abrir el archivo, mostrar un mensaje de error y terminar

    Serial.println("Error al abrir el archivo");
    return;
  }

  // Leer los datos del archivo y enviarlos a través de la comunicación serie

  while (myFile.available()) {

    // Leer un byte del archivo y enviarlo a través de la comunicación serie

    Serial.write(myFile.read());
  }

  // Cerrar el archivo después de leer todos los datos

  myFile.close();
}

// La función loop() se ejecuta repetidamente en un bucle infinito

void loop() {

  // No es necesario hacer nada en el loop en este ejemplo
}

Code in MicroPython, um ihn auf einem ESP32 mit dem MicroPython-Interpreter auszuführen.

import machine
import os
import sdcard
from machine import Pin, SPI

# Configurar pines para SPI y CS
SCK_PIN = 18
MOSI_PIN = 23
MISO_PIN = 19
CS_PIN = 5

# Inicializar SPI
spi = SPI(2, sck=Pin(SCK_PIN), mosi=Pin(MOSI_PIN), miso=Pin(MISO_PIN))

# Inicializar tarjeta SD
sd = sdcard.SDCard(spi, Pin(CS_PIN))

# Montar la tarjeta SD como un sistema de archivos
vfs = os.VfsFat(sd)
os.mount(vfs, '/sd')

# Crear o abrir un archivo
with open('/sd/test.txt', 'w') as f:
    # Escribir datos en el archivo
    f.write('Hola, tarjeta SD!')

# Leer datos del archivo
with open('/sd/test.txt', 'r') as f:
    # Mostrar datos del archivo
    print(f.read())

# Desmontar la tarjeta SD
os.umount('/sd')

Dieser Code erstellt ein Programm, das Daten in einer Datei auf einer SD-Karte schreibt und anschließend diese Daten liest und über die serielle Kommunikation anzeigt. Das Programm beginnt mit dem Import der erforderlichen Bibliotheken (SPI, SD und FS) und der Definition des CS-Pins für die SD-Karte.

In der Funktion setup() wird die serielle Kommunikation mit 115200 Baud initialisiert und versucht, die SD-Karte zu initialisieren. Wenn die Initialisierung erfolgreich ist, erstellt das Programm eine Datei namens „test.txt“ im Schreibmodus oder öffnet sie und schreibt eine Textzeichenkette hinein. Anschließend wird die Datei geschlossen, um sicherzustellen, dass die Daten korrekt gespeichert werden.

Anschließend öffnet das Programm die Datei „test.txt“ im Lese-Modus und liest deren Daten. Die Daten werden über die serielle Kommunikation gesendet, sodass Sie den Inhalt der Datei im seriellen Monitor der Arduino-Entwicklungsumgebung sehen können.

Nachdem alle Daten gelesen wurden, schließt das Programm die Datei und beendet die Funktion setup(). In der Funktion loop() gibt es keine Aktion, da dieses Beispiel sich ausschließlich auf das Lesen und Schreiben einer Datei auf einer SD-Karte konzentriert.

Zusammenfassend zeigt dieser Code, wie man eine SD-Karte mit einem ESP32 und der Arduino-SD-Bibliothek verwendet, um eine Datei zu erstellen, Daten hineinzuschreiben, die Daten zu lesen und sie über die serielle Kommunikation anzuzeigen.

Das Verbindungsschema ist wie folgt:

1. Verbinde den VCC-Pin des SD-Kartenmoduls mit dem 3,3-V-Pin des ESP32.
2. Verbinde den GND-Pin des SD-Kartenmoduls mit dem GND-Pin des ESP32.
3. Verbinde den MISO-Pin des SD-Kartenmoduls mit dem Pin 19 (MISO) des ESP32.
4. Verbinde den MOSI-Pin des SD-Kartenmoduls mit dem Pin 23 (MOSI) des ESP32.
5. Verbinde den SCK-Pin des SD-Kartenmoduls mit dem Pin 18 (SCK) des ESP32.
6. Verbinde den CS-Pin des SD-Kartenmoduls mit dem Pin, den du als SD_CS_PIN in deinem Code definiert hast (im Beispiel wurde Pin 5 verwendet).

Ein Video, in dem du ein Beispiel sehen kannst: