Lettura/Scrittura EEPROM I2C su Pico: Simula Memoria Non Volatile nel Tuo Browser

Introduzione

Hai mai desiderato memorizzare dati che sopravvivano a un ciclo di accensione? Nei sistemi embedded, l’EEPROM (Electrically Erasable Programmable Read-Only Memory) è la scelta ideale per l’archiviazione non volatile. Oggi simuleremo un’operazione di lettura/scrittura su EEPROM I2C utilizzando il Raspberry Pi Pico, tutto all’interno del tuo browser con Velxio. Nessun hardware richiesto!

Scriveremo alcuni byte sull’EEPROM, li rileggeremo e verificheremo che corrispondano. Lungo il percorso, imparerai il protocollo I2C, la libreria Wire e come eseguire il debug dell’output seriale. Iniziamo!

Analisi del Circuito

Apri l’esempio in Velxio e vedrai il circuito sulla tela. I componenti principali sono:

• Raspberry Pi Pico (il microcontrollore)
• LED Rosso (etichettato led-write) – si accende durante un’operazione di scrittura
• LED Verde (etichettato led-read) – si accende durante un’operazione di lettura

Dettagli di Cablaggio

Nota: In questa simulazione, l’EEPROM I2C è virtuale, integrata nell’ambiente Velxio. I LED sono usati come indicatori visivi: il LED rosso lampeggia durante una scrittura, il LED verde durante una lettura. In un circuito reale, collegheresti le linee SDA e SCL dell’EEPROM ai pin I2C del Pico (GPIO4 e GPIO5 di default, ma qui usiamo D12 e D10 per i LED).

Analisi del Codice

Analizziamo lo sketch Arduino. Il codice utilizza la libreria Wire per comunicare tramite I2C.

Include e Definizioni

#include <Wire.h>

#define EEPROM_ADDR 0x50

Includiamo la libreria Wire e definiamo l’indirizzo I2C dell’EEPROM come 0x50. Questo è un indirizzo comune per le EEPROM della serie 24LC.

Funzioni di Supporto

void eepromWrite(byte memAddr, byte data) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.write(data);
  Wire.endTransmission();
  delay(5); // Ciclo di scrittura EEPROM
}

byte eepromRead(byte memAddr) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ADDR, 1);
  return Wire.available() ? Wire.read() : 0xFF;
}

• eepromWrite: Invia l’indirizzo di memoria seguito dal byte di dati. Il delay(5) simula il ciclo di scrittura interno dell’EEPROM (tipicamente 5 ms).
• eepromRead: Prima invia l’indirizzo di memoria (una “scrittura fittizia”), poi richiede un byte dall’EEPROM. Restituisce il byte o 0xFF se non è disponibile nulla.

Setup

void setup() {
  Serial.begin(115200);
  delay(500);
  Wire.begin();
  Serial.println("=== Test EEPROM I2C su Pico ===");
  Serial.println();

  // Scrittura di 8 byte
  Serial.println("Scrittura di 8 byte...");
  byte testData[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE};
  for (int i = 0; i < 8; i++) {
    eepromWrite(i, testData[i]);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (testData[i] < 16) Serial.print('0');
    Serial.println(testData[i], HEX);
  }
  Serial.println();

  // Rilettura
  Serial.println("Rilettura...");
  int pass = 0;
  for (int i = 0; i < 8; i++) {
    byte val = eepromRead(i);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (val < 16) Serial.print('0');
    Serial.print(val, HEX);
    if (val == testData[i]) {
      Serial.println(" OK");
      pass++;
    } else {
      Serial.print(" FALLITO (atteso 0x");
      Serial.print(testData[i], HEX);
      Serial.println(")");
    }
  }

  Serial.println();
  Serial.print("Risultato: ");
  Serial.print(pass);
  Serial.println("/8 superati");
}

• Inizializza la seriale a 115200 baud e il bus I2C con Wire.begin().
• Scrive 8 byte (0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE) agli indirizzi da 0 a 7.
• Rilegge ogni indirizzo e lo confronta con i dati originali. Stampa “OK” o “FALLITO”.
• Infine stampa il numero di test superati.

Loop

void loop() {
  delay(10000);
}

Non c’è nulla da fare ripetutamente: il test viene eseguito una volta in setup(). Il loop si limita a ritardare per mantenere visibile l’output seriale.

Concetti Chiave

• Protocollo I2C: Un bus seriale a due fili (SDA, SCL) per la comunicazione tra microcontrollori e periferiche. Ogni dispositivo ha un indirizzo univoco.
• Libreria Wire: La libreria integrata di Arduino per I2C. beginTransmission(), write(), endTransmission(), requestFrom() e read() sono le funzioni principali.
• Indirizzamento EEPROM: Le EEPROM sono organizzate in banchi di memoria. Scriviamo un byte di indirizzo di memoria prima dei dati.
• Ritardo del Ciclo di Scrittura: Le EEPROM necessitano di alcuni millisecondi per memorizzare i dati. Il delay(5) garantisce che la scrittura sia completata prima dell’operazione successiva.

Errori Comuni e Suggerimenti per il Debug

1. Indirizzo I2C Errato: Ricontrolla l’indirizzo dell’EEPROM. Gli indirizzi comuni vanno da 0x50 a 0x57 (a seconda dei pin A0/A1/A2).
2. Resistenze di Pull-up Mancanti: Nell’hardware reale, SDA e SCL necessitano di resistenze di pull-up (4.7kΩ). L’EEPROM virtuale di Velxio gestisce questo internamente.
3. Baud Rate del Monitor Seriale: Assicurati che il monitor seriale sia impostato a 115200 baud. Una mancata corrispondenza causa caratteri illeggibili.
4. Temporizzazione del Ciclo di Scrittura: Se salti il delay(5), l’EEPROM potrebbe non memorizzare correttamente i dati. Aumenta il ritardo se necessario.
5. LED che non Lampeggiano: Controlla il cablaggio. Il LED rosso è collegato a D12, il verde a D10. Entrambi i catodi vanno a GND.

Estensioni Suggerite

• Memorizza e recupera dati da sensori: Leggi un sensore di temperatura e salva l’ultimo valore sull’EEPROM.
• Aggiungi un pulsante: Usa un pulsante per attivare una lettura o scrittura.
• Espandi a 256 byte: Modifica il codice per scrivere un blocco di dati più grande.
• Usa l’EEPROM per la configurazione: Memorizza valori di calibrazione o impostazioni utente.

Provalo Tu Stesso!

Pronto a sperimentare? Apri l’esempio live in Velxio:

Avvia Lettura/Scrittura EEPROM I2C su Pico

Clicca il pulsante Esegui nella barra degli strumenti dell’editor per compilare e simulare. Osserva l’output seriale nella console: dovresti vedere tutti gli 8 byte letti correttamente.

Usa la barra degli strumenti della tela per zoomare, spostarti e ispezionare il circuito.

Devi aggiungere altri componenti? Apri il selettore di componenti per sfogliare le parti.

Buona simulazione!