Lettura e scrittura di dati su EEPROM esterna utilizzando Arduino: 5 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

EEPROM sta per memoria di sola lettura programmabile cancellabile elettricamente.

La EEPROM è molto importante e utile perché è una forma di memoria non volatile. Ciò significa che anche quando la scheda è spenta, il chip EEPROM conserva ancora il programma che è stato scritto su di essa. Quindi, quando si spegne la scheda e poi la si riaccende, è possibile eseguire il programma che è stato scritto nella EEPROM. Quindi, in pratica, la EEPROM memorizza ed esegue un programma, qualunque cosa accada. Ciò significa che puoi spegnere un dispositivo, tenerlo spento per 3 giorni e tornare indietro e accenderlo e può ancora eseguire il programma che è stato programmato in esso. Ecco come funziona la maggior parte dei dispositivi elettronici di consumo.

Questo progetto è sponsorizzato da LCSC. Ho utilizzato componenti elettronici di LCSC.com. LCSC ha un forte impegno nell'offrire un'ampia selezione di componenti elettronici originali e di alta qualità al miglior prezzo con una rete di spedizione globale in oltre 200 paesi. Iscriviti oggi e ricevi $8 di sconto sul tuo primo ordine.

EEPROM è anche molto efficiente in quanto i singoli byte in una EEPROM tradizionale possono essere letti, cancellati e riscritti in modo indipendente. Nella maggior parte degli altri tipi di memoria non volatile, ciò non è possibile. I dispositivi EEPROM seriali come l'EEPROM della serie 24 di Microchip consentono di aggiungere più memoria a qualsiasi dispositivo in grado di parlare I²C.

Forniture

1. EEPROM - 24LC512
2. ATmega328P-PU
3. Cristallo da 16 MHz
4. tagliere
5. Resistenza 4,7k Ohm x 2
6. Condensatore 22 pF x 2

Passaggio 1: Nozioni di base sulla EEPROM

Il chip Microchip 24LC2512 può essere acquistato in un pacchetto DIP a 8 pin. I pin del 24LC512 sono piuttosto semplici e sono costituiti da alimentazione (8), GND (4), protezione da scrittura (7), SCL/SDA (6, 5) e tre pin di indirizzo (1, 2, 3).

Una breve storia di ROM

I primi computer di tipo "Stored-Program" - come calcolatrici da tavolo e interpreti da tastiera - iniziarono a utilizzare la ROM sotto forma di Diode Matrix ROM. Questa era una memoria composta da diodi a semiconduttore discreti posizionati su un PCB appositamente organizzato. Questo ha dato il via a Mask ROM con l'avvento dei circuiti integrati. Mask ROM era molto simile alla Diode Matrix ROM solo che era implementata su una scala molto più piccola. Ciò significava, tuttavia, che non si poteva semplicemente spostare un paio di diodi con un saldatore e riprogrammarlo. La ROM della maschera doveva essere programmata dal produttore e da allora in poi non era modificabile.

Sfortunatamente, Mask ROM era costoso e richiedeva molto tempo per essere prodotto perché ogni nuovo programma richiedeva che un dispositivo nuovo di zecca fosse prodotto da una fonderia. Nel 1956, tuttavia, questo problema fu risolto con l'invenzione della PROM (ROM programmabile) che consentiva agli sviluppatori di programmare i chip da soli. Ciò significava che i produttori potevano produrre milioni dello stesso dispositivo non programmato, il che lo rendeva più economico e pratico. La PROM, tuttavia, poteva essere scritta solo una volta utilizzando un dispositivo di programmazione ad alta tensione. Dopo che un dispositivo PROM è stato programmato, non c'era modo di riportare il dispositivo allo stato non programmato.

La situazione è cambiata nel 1971 con l'invenzione della EPROM (Erasable Programmable ROM) che - oltre ad aggiungere un'altra lettera all'acronimo - ha portato con sé la possibilità di cancellare il dispositivo e riportarlo a uno stato "vuoto" utilizzando una forte sorgente di luce UV. Esatto, hai dovuto puntare una luce brillante sull'IC per riprogrammarlo, quanto è bello? Bene, si scopre che è piuttosto interessante a meno che tu non sia uno sviluppatore che lavora sul firmware, nel qual caso ti piacerebbe davvero essere in grado di riprogrammare il dispositivo usando segnali elettrici. Questo è diventato finalmente una realtà nel 1983 con lo sviluppo di EEPROM (Electrically Erasable Programmable ROM) e con questo, arriviamo all'attuale sigla ingombrante.

Passaggio 2: stranezze della EEPROM

Ci sono due principali svantaggi di EEPROM come metodo di memorizzazione dei dati. Nella maggior parte delle applicazioni, i pro superano i contro, ma dovresti esserne a conoscenza prima di incorporare la EEPROM nel tuo prossimo progetto.

Innanzitutto la tecnologia che fa funzionare la EEPROM limita anche il numero di volte che può essere riscritta. Questo ha a che fare con gli elettroni che rimangono intrappolati nei transistor che compongono la ROM e si accumulano fino a quando la differenza di carica tra "1" e "0" è irriconoscibile. Ma non preoccuparti, la maggior parte delle EEPROM ha un numero massimo di riscritture di 1 milione o più. Finché non scrivi continuamente sulla EEPROM, è improbabile che tu raggiunga questo massimo. In secondo luogo, la EEPROM non verrà cancellata se togli l'alimentazione da essa, ma non manterrà i tuoi dati a tempo indeterminato. Gli elettroni possono uscire dai transistor e attraversare l'isolatore, cancellando efficacemente la EEPROM nel tempo. Detto questo, questo di solito si verifica nel corso degli anni (sebbene possa essere accelerato dal calore). La maggior parte dei produttori afferma che i tuoi dati sono al sicuro su EEPROM per 10 anni o più a temperatura ambiente. E c'è un'altra cosa che dovresti tenere a mente quando selezioni un dispositivo EEPROM per il tuo progetto. La capacità della EEPROM è misurata in bit e non in byte. Una EEPROM da 512K conterrà 512Kbit di dati, in altre parole, solo 64KB.

Passaggio 3: collegamento all'hardware Arduino

Ok, ora che sappiamo cos'è la EEPROM, colleghiamone una e vediamo cosa può fare! Per far parlare il nostro dispositivo, dovremo collegare l'alimentazione e le linee seriali I²C. Questo dispositivo, in particolare, funziona a 5VDC quindi lo collegheremo all'uscita 5V del nostro Arduino UNO. Inoltre, le linee I²C avranno bisogno di resistori di pull-up affinché la comunicazione avvenga correttamente. Il valore di questi resistori dipende dalla capacità delle linee e dalla frequenza con cui si desidera comunicarlo, ma una buona regola empirica per applicazioni non critiche è semplicemente mantenerlo nell'intervallo kΩ. In questo esempio, useremo resistori di pull-up da 4,7 k.

Ci sono tre pin su questo dispositivo per selezionare l'indirizzo I²C, in questo modo puoi avere più di una EEPROM sul bus e indirizzarle ciascuna in modo diverso. Potresti semplicemente metterli a terra tutti, ma li collegheremo in modo da poter inserire un dispositivo di capacità maggiore più avanti nel tutorial.

Useremo una breadboard per collegare tutto insieme. Il diagramma seguente mostra il collegamento corretto per la maggior parte dei dispositivi EEPROM I²C, inclusa la EEPROM Microchip serie 24 che vendiamo.

Passaggio 4: leggere e scrivere

La maggior parte delle volte, quando si utilizza una EEPROM in combinazione con un microcontrollore, non sarà necessario vedere tutto il contenuto della memoria contemporaneamente. Potrai solo leggere e scrivere byte qua e là, se necessario. In questo esempio, tuttavia, scriveremo un intero file su EEPROM e poi lo rileggeremo tutto in modo da poterlo visualizzare sul nostro computer. Questo dovrebbe farci sentire a nostro agio con l'idea di usare la EEPROM e anche darci un'idea di quanti dati possono davvero stare su un piccolo dispositivo.

Scrivi qualcosa

Il nostro schizzo di esempio prenderà semplicemente qualsiasi byte che arriva sulla porta seriale e lo scriverà nella EEPROM, tenendo traccia di quanti byte abbiamo scritto in memoria.

La scrittura di un byte di memoria nella EEPROM avviene generalmente in tre passaggi:

1. Invia il Byte più significativo dell'indirizzo di memoria a cui vuoi scrivere.
2. Invia il byte meno significativo dell'indirizzo di memoria su cui vuoi scrivere.
3. Invia il byte di dati che desideri archiviare in questa posizione.

Probabilmente ci sono alcune parole chiave che non spiegano nulla:

Indirizzi di memoria

Se immagini tutti i byte in una EEPROM da 512 Kbit in una linea da 0 a 64000 - perché ci sono 8 bit per byte e quindi puoi adattare 64000 byte su una EEPROM da 512 Kbit - allora un indirizzo di memoria è il posto in riga in cui si trova un particolare byte. Dobbiamo inviare quell'indirizzo alla EEPROM in modo che sappia dove mettere il byte che stiamo inviando.

Byte più significativi e meno significativi

Poiché ci sono 32000 posti possibili in una EEPROM da 256 Kbit - e poiché 255 è il numero più grande che puoi codificare in un byte - dobbiamo inviare questo indirizzo in due byte. Innanzitutto, inviamo il Most Significant Byte (MSB), i primi 8 bit in questo caso. Quindi inviamo il Least Significant Byte (LSB) - i secondi 8 bit. Come mai? Perché è così che il dispositivo si aspetta di riceverli, tutto qui.

Scrittura della pagina

Scrivere un byte alla volta va bene, ma la maggior parte dei dispositivi EEPROM ha qualcosa chiamato "buffer di scrittura della pagina" che ti consente di scrivere più byte alla volta nello stesso modo in cui faresti un singolo byte. Ne approfitteremo nel nostro schizzo di esempio. La EEPROM utilizza un contatore interno che aumenta automaticamente la posizione di memoria con ogni successivo byte di dati che riceve. Una volta inviato un indirizzo di memoria, possiamo seguirlo con un massimo di 64 byte di dati. La EEPROM assume (giustamente) che un indirizzo di 312 seguito da 10 byte registrerà il byte 0 all'indirizzo 312, il byte 1 all'indirizzo 313, il byte 2 all'indirizzo 314 e così via.

Leggi qualcosa

La lettura dalla EEPROM segue fondamentalmente lo stesso processo in tre fasi della scrittura sulla EEPROM:

1. Invia il Byte più significativo dell'indirizzo di memoria a cui vuoi scrivere.
2. Invia il byte meno significativo dell'indirizzo di memoria su cui vuoi scrivere.
3. Richiedi il byte di dati in quella posizione.

Passaggio 5: schemi e codice

Codice:

#includere

#define eeprom 0x50 //definisce l'indirizzo base della EEPROM

void setup() {

Wire.begin(); //crea un oggetto Wire

Serial.begin(9600);

indirizzo int senza segno = 0; //primo indirizzo della EEPROM

Serial.println("Scriviamo il codice postale 22222, un codice postale"); for(indirizzo = 0; indirizzo< 5; indirizzo++) writeEEPROM(eeprom, indirizzo, '2'); // Scrive 22222 nella EEPROM

for(indirizzo = 0; indirizzo< 5; indirizzo++) { Serial.print(readEEPROM(eeprom, indirizzo), HEX); } }

ciclo vuoto() {

/*non c'è nulla nella funzione loop() perché non vogliamo che arduino scriva ripetutamente la stessa cosa nella EEPROM più e più volte. Vogliamo solo una scrittura una tantum, quindi la funzione loop() viene evitata con le EEPROM.*/ }

//definisce la funzione writeEEPROM

void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data) { Wire.beginTransmission(deviceaddress); Wire.write((int)(eeaddress >> 8)); //scrive MSB Wire.write((int)(eeaddress & 0xFF)); //scrive LSB Wire.write(data); Wire.endTransmission(); }

//definisce la funzione readEEPROM

byte readEEPROM(int deviceaddress, unsigned int eeaddress) { byte rdata = 0xFF; Wire.beginTransmission(indirizzodispositivo); Wire.write((int)(eeaddress >> 8)); //scrive MSB Wire.write((int)(eeaddress & 0xFF)); //scrive l'LSB Wire.endTransmission(); Wire.requestFrom(indirizzodispositivo, 1); if (Wire.available()) rdata = Wire.read(); restituire rdata; }