Lettura/Scrittura EEPROM I2C con Arduino: Guida Completa

Introduzione

Hai mai avuto bisogno di memorizzare dati di configurazione o piccole quantità di informazioni non volatili nei tuoi progetti Arduino? Le EEPROM I2C sono una soluzione perfetta: sono economiche, facili da usare e richiedono solo due fili per la comunicazione. In questo tutorial, utilizzeremo il simulatore in-browser Velxio per costruire un test completo di lettura/scrittura EEPROM I2C. Imparerai come scrivere dati su una EEPROM virtuale all’indirizzo 0x50 e leggerli indietro, verificando che tutto funzioni.

Velxio fornisce un ambiente di simulazione analogica accurato a livello SPICE, così puoi testare il tuo codice senza alcun hardware fisico. Iniziamo!

Panoramica del Circuito

Il circuito è notevolmente semplice perché la EEPROM I2C è integrata nell’ambiente virtuale. L’unico componente di cui abbiamo bisogno è un Arduino Uno. La EEPROM è simulata internamente e collegata ai pin I2C di Arduino (A4 per SDA e A5 per SCL). Non è richiesto alcun cablaggio esterno: il simulatore gestisce automaticamente il bus I2C.

Per impostare il circuito:

1. Apri l’editor Velxio e aggiungi un Arduino Uno dal selettore di componenti.
2. La EEPROM I2C è già parte della simulazione; non devi aggiungerla manualmente.
3. Il codice comunicherà con la EEPROM all’indirizzo 0x50.

Puoi trovare Arduino Uno nella categoria “Microcontrollori” nel selettore di componenti. Una volta posizionato, la tela mostrerà la scheda pronta per la programmazione.

Panoramica del Codice

Esaminiamo lo sketch Arduino che esegue le operazioni di lettura/scrittura. Il codice è scritto in C++ utilizzando la libreria standard Wire per la comunicazione I2C.

// I2C EEPROM Read/Write Test
// Virtual EEPROM at address 0x50
// Writes values to registers, then reads them back.

#include <Wire.h>

#define EEPROM_ADDR 0x50

void writeEEPROM(byte reg, byte value) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);    // register address
  Wire.write(value);  // data
  Wire.endTransmission();
  delay(5); // EEPROM write cycle time
}

byte readEEPROM(byte reg) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);
  Wire.endTransmission();

  Wire.requestFrom(EEPROM_ADDR, 1);
  if (Wire.available()) {
    return Wire.read();
  }
  return 0xFF;
}

void setup() {
  Wire.begin();
  Serial.begin(9600);

  Serial.println("============================");
  Serial.println(" I2C EEPROM R/W Test (0x50)");
  Serial.println("============================");
  Serial.println();

  // Write test pattern
  Serial.println("Writing test data...");
  for (byte i = 0; i < 8; i++) {
    byte value = (i + 1) * 10;  // 10, 20, 30, ...
    writeEEPROM(i, value);
    Serial.print("  Write reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.println(value);
  }

  Serial.println();
  Serial.println("Reading back...");

  // Read back and verify
  byte errors = 0;
  for (byte i = 0; i < 8; i++) {
    byte expected = (i + 1) * 10;
    byte actual = readEEPROM(i);
    Serial.print("  Read  reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.print(actual);

    if (actual == expected) {
      Serial.println("  [OK]");
    } else {
      Serial.print("  [FAIL] expected ");
      Serial.println(expected);
      errors++;
    }
  }

  Serial.println();
  if (errors == 0) {
    Serial.println("All tests PASSED!");
  } else {
    Serial.print(errors);
    Serial.println(" test(s) FAILED.");
  }
}

void loop() {
  // Nothing to do
  delay(1000);
}

Come Funziona il Codice

• writeEEPROM(reg, value): Questa funzione invia l’indirizzo del registro e il byte di dati alla EEPROM. Utilizza Wire.beginTransmission(), Wire.write() e Wire.endTransmission(). Un ritardo di 5 ms simula il tempo del ciclo di scrittura della EEPROM.
• readEEPROM(reg): Prima invia l’indirizzo del registro alla EEPROM (una “scrittura fittizia”), poi richiede un byte usando Wire.requestFrom(). Se i dati sono disponibili, li legge e li restituisce; altrimenti, restituisce 0xFF.
• setup(): Inizializza la libreria Wire e la comunicazione seriale. Scrive un pattern di test (10, 20, 30, …) nei registri da 0 a 7, poi li legge indietro e li confronta con i valori attesi. Qualsiasi discrepanza incrementa un contatore di errori.
• loop(): Vuoto, con un piccolo ritardo per mantenere la scheda attiva.

Concetti Chiave per Studenti

1. Protocollo I2C: I2C utilizza due fili (SDA e SCL) e un indirizzo a 7 bit per comunicare con più dispositivi. L’indirizzo EEPROM 0x50 è comune per molti chip della serie AT24C.
2. Ciclo di Scrittura EEPROM: Le EEPROM richiedono alcuni millisecondi per scrivere i dati internamente. Il delay(5) in writeEEPROM() assicura che la scrittura sia completata prima dell’operazione successiva.
3. Scrittura Fittizia per Lettura: Per leggere da un registro specifico, prima invii l’indirizzo del registro (un’operazione di scrittura), poi emetti un riavvio o un arresto/avvio per leggere i dati. Il codice utilizza un approccio di arresto/avvio.
4. Controllo degli Errori: Lo sketch verifica ogni lettura rispetto al valore atteso, che è una buona pratica per testare la comunicazione.

Insidie Comuni e Suggerimenti per il Debug

• Indirizzo Sbagliato: Assicurati che l’indirizzo della EEPROM corrisponda al tuo dispositivo. La EEPROM virtuale utilizza 0x50. Se ricevi 0xFF, l’indirizzo potrebbe essere sbagliato.
• Resistenze di Pull-up Mancanti: Nell’hardware reale, le linee I2C necessitano di resistenze di pull-up. In Velxio, sono simulate internamente, quindi non devi aggiungerle.
• Monitor Seriale: Usa il Monitor Seriale in Velxio per vedere l’output. Clicca l’icona del Monitor Seriale nella barra degli strumenti.
• Temporizzazione: Se le letture falliscono in modo intermittente, aumenta il ritardo dopo le scritture. La EEPROM virtuale è veloce, ma i dispositivi reali potrebbero aver bisogno di più tempo.

Usa la barra degli strumenti per compilare ed eseguire il tuo codice. Il Monitor Seriale mostrerà i risultati del test.

Estensioni Suggerite

1. Scrivere Dati Più Grandi: Modifica il codice per scrivere e leggere una stringa o un array di byte.
2. Scrittura a Pagina: Molte EEPROM supportano scritture a pagina (scrivere più byte in una singola transazione). Prova a implementarlo.
3. EEPROM Esterna: Aggiungi un componente EEPROM fisico (se disponibile in Velxio) e collegalo ad Arduino.
4. Registrazione Dati: Usa la EEPROM per memorizzare letture di sensori e recuperarle in seguito.

Conclusione

Hai costruito con successo un test di lettura/scrittura EEPROM I2C in Velxio! Questo progetto dimostra i fondamenti della comunicazione I2C e della memoria non volatile. L’ambiente virtuale rende facile sperimentare senza hardware. Ora, prova a estendere il codice o integrarlo in un progetto più grande.

Pronto per costruire il tuo? Apri l’esempio live in Velxio e inizia a programmare: Esempio di Lettura/Scrittura EEPROM I2C. Buona simulazione!