Introduzione alla EEPROM in Arduino

In questo post capiremo cos'è la EEPROM, come vengono memorizzati i dati su EEPROM incorporata Schede Arduino Microcontrollore e anche praticamente testare come scrivere e leggere dati su EEPROM con un paio di esempi.

Perché EEPROM?

Prima di chiederci cos'è l'EEPROM? È molto importante sapere perché la EEPROM viene utilizzata per l'archiviazione in primo luogo. In questo modo, abbiamo un'idea chiara delle EEPROM.

Ci sono molti dispositivi di archiviazione disponibili in questi giorni, che vanno da dispositivi di archiviazione magnetici come dischi rigidi di computer, registratori a cassette vecchia scuola, supporti di archiviazione ottici come CD, DVD, dischi Blu-ray e memorie a stato solido come SSD (Solid State Drive) per computer e schede di memoria ecc.

Si tratta di dispositivi di archiviazione di massa in grado di memorizzare dati come musica, video, documenti ecc. Da un minimo di kilobyte a più terabyte. Si tratta di una memoria non volatile, il che significa che i dati possono essere conservati anche dopo l'interruzione dell'alimentazione al supporto di memorizzazione.

Il dispositivo che fornisce musica rilassante per le orecchie o video strabilianti come computer o smartphone memorizza alcuni dati critici come dati di configurazione, dati di avvio, password, dati biometrici, dati di accesso ecc.

Questi dati non possono essere memorizzati in dispositivi di archiviazione di massa per motivi di sicurezza e anche questi dati potrebbero essere modificati dagli utenti involontariamente, il che potrebbe portare a un malfunzionamento del dispositivo.

Questi dati richiedono solo pochi byte a pochi megabyte, il collegamento di un dispositivo di archiviazione convenzionale come un supporto magnetico o ottico ai chip del processore non è economicamente e fisicamente fattibile.

Quindi, questi dati critici vengono memorizzati nei chip di elaborazione stessi.

L'Arduino non è diverso dal computer o dagli smartphone. In diverse circostanze è necessario memorizzare alcuni dati critici che non devono essere cancellati anche dopo l'interruzione dell'alimentazione, ad esempio i dati dei sensori.

A questo punto, avresti un'idea del motivo per cui abbiamo bisogno di EEPROM su microprocessori e chip di microcontrollori.

Cos'è l'EEPROM?

EEPROM sta per memoria di sola lettura programmabile cancellabile elettricamente. È anche una memoria non volatile che può essere letta e scritta byte saggio.

La lettura e la scrittura a livello di byte lo rende diverso dalle altre memorie a semiconduttore. Ad esempio memoria flash: lettura, scrittura e cancellazione di dati in modo blocco.

Un blocco può contenere da poche centinaia a migliaia di bit, il che è fattibile per l'archiviazione di massa, ma non per le operazioni di 'memoria di sola lettura' in microprocessori e microcontrollori, che devono accedere a dati byte per byte.

Sulla scheda Arduino Uno (ATmega328P) ha a bordo 1KB o 1024 byte di EEPROM. Ogni byte è accessibile singolarmente, ogni byte ha un indirizzo compreso tra 0 e 1023 (che è un totale di 1024).

L'indirizzo (0-1023) è una posizione di memoria in cui verranno archiviati i nostri dati.

Su ogni indirizzo è possibile memorizzare dati a 8 bit, cifre numeriche da 0 a 255. I nostri dati sono memorizzati in forma binaria, quindi se scriviamo il numero 255 in EEPROM memorizzerà la cifra come 11111111 in un indirizzo e se memorizziamo zero, memorizzerà come 00000000.

È inoltre possibile memorizzare testo, caratteri speciali, caratteri alfanumerici ecc. Scrivendo il programma appropriato.

I dettagli di costruzione e il funzionamento non sono discussi qui, il che potrebbe rendere questo articolo lungo e potremmo farti venire sonno. Dirigiti verso YouTube o Google, ci sono articoli / video interessanti riguardanti la costruzione e il funzionamento di EEPORM.

Non confondere EEPROM con EPROM:

In poche parole, l'EPROM è una memoria di sola lettura programmabile elettricamente, il che significa che può essere programmata (memorizzare la memoria) elettricamente, ma non può essere cancellata elettricamente.

Utilizza la brillantezza della luce ultravioletta sopra il chip di archiviazione che cancella i dati memorizzati. EEPROM è venuto in sostituzione di EPROM e ora difficilmente utilizzato in tutti i dispositivi elettronici.

Non confondere la memoria flash per EEPROM:

Una memoria flash è una memoria a semiconduttore e non volatile che è anche cancellabile elettricamente e programmabile elettricamente, infatti la memoria flash è derivata dalla EEPROM. Ma l'accesso alla memoria block-wise o, in altre parole, il modo in cui si accede alla memoria e la sua costruzione lo differenzia dalla EEPROM.

Arduino Uno (microcontrollore ATmega328P) dispone anche di 32 KB di memoria flash per l'archiviazione dei programmi.

Durata della EEPROM:

Come qualsiasi altro supporto di memorizzazione elettronico, EEPROM ha anche cicli di lettura, scrittura e cancellazione finiti. Ma il problema è che ha una durata minima rispetto a qualsiasi altro tipo di memoria a semiconduttore.

Sulla EEPROM di Arduino, Atmel ha affermato circa 100000 (un lakh) cicli di scrittura per cella. Se la temperatura ambiente è inferiore, maggiore è la durata della EEPROM.

Si noti che la lettura dei dati da EEPROM non influisce in modo significativo sulla durata.

Esistono circuiti integrati EEPROM esterni che possono essere interfacciati con Arduino con facilità con capacità di memoria che vanno da 8 KB, 128KB, 256 KB ecc. Con una durata di circa 1 milione di cicli di scrittura per cella.

Questa è la conclusione dell'EEPROM, ora avresti acquisito una conoscenza teorica sufficiente sulle EEPROM.

Nella sezione seguente impareremo come testare praticamente la EEPROM su arduino.

Come testare la EEPROM in Arduino

Per implementarlo, tutto ciò di cui hai bisogno è un cavo USB e una scheda Arduino Uno, sei pronto per partire.

Dalle spiegazioni precedenti abbiamo capito che le EEPROM hanno un indirizzo in cui memorizziamo i nostri dati. Possiamo memorizzare da 0 a 1023 posizioni in Arduino Uno. Ogni posizione può contenere 8 bit o un byte.

In questo esempio memorizzeremo i dati in un indirizzo. Per ridurre la complessità del programma e per mantenerlo il più breve possibile, memorizzeremo un intero a una cifra (da 0 a 9) su un indirizzo da 0 a 9.

Codice programma n. 1

Ora, carica il codice su Arduino:
//------------------Program Developed by R.GIRISH-------------------//
#include
int inputAddress = 0
int inputValue = 0
int ReadData = 0
boolean Readadd = true
boolean Readval = true
void setup()
{
Serial.begin(9600)
Serial.println('Enter the address (0 to 9)')
Serial.println('')
while(Readadd)
{
inputAddress = Serial.read()
if(inputAddress > 0)
{
inputAddress = inputAddress - 48
Readadd = false
}
}
Serial.print('You have selected Address: ')
Serial.println(inputAddress)
Serial.println('')
delay(2000)
Serial.println('Enter the value to be stored (0 to 9)')
Serial.println('')
while(Readval)
{
inputValue = Serial.read()
if(inputValue > 0)
{
inputValue = inputValue - 48
Readval = false
}
}
Serial.print('The value you entered is: ')
Serial.println(inputValue)
Serial.println('')
delay(2000)
Serial.print('It will be stored in Address: ')
Serial.println(inputAddress)
Serial.println('')
delay(2000)
Serial.println('Writing on EEPROM.....')
Serial.println('')
EEPROM.write(inputAddress, inputValue)
delay(2000)
Serial.println('Value stored successfully!!!')
Serial.println('')
delay(2000)
Serial.println('Reading from EEPROM....')
delay(2000)
ReadData = EEPROM.read(inputAddress)
Serial.println('')
Serial.print('The value read from Address ')
Serial.print(inputAddress)
Serial.print(' is: ')
Serial.println(ReadData)
Serial.println('')
delay(1000)
Serial.println('Done!!!')
}
void loop()
{
// DO nothing here.
}
//------------------Program Developed by R.GIRISH-------------------//

PRODUZIONE:

Una volta caricato il codice, apri il monitor seriale.

Ti chiederà di inserire un indirizzo compreso tra 0 e 9. Dall'output sopra, ho inserito l'indirizzo 3. Quindi, memorizzerò un valore intero nella posizione (indirizzo) 3.

Ora, ti chiederà di inserire un valore intero a una cifra compreso tra 0 e 9. Dall'output sopra, ho inserito il valore 5.

Quindi, ora il valore 5 verrà memorizzato nella posizione dell'indirizzo 3.

Una volta inserito il valore, scriverà il valore su EEPROM.

Mostrerà un messaggio di successo, il che significa che il valore è stato memorizzato.

Dopo un paio di secondi leggerà il valore memorizzato sull'indirizzo commentato e visualizzerà il valore sul monitor seriale.

In conclusione, abbiamo scritto e letto i valori dalla EEPROM del microcontrollore di Arduino.

Ora useremo la EEPROM per memorizzare la password.

Inseriremo un numero di 6 cifre (né meno né più) password, verrà memorizzato in 6 indirizzi diversi (ogni indirizzo per ogni cifra) e un indirizzo aggiuntivo per memorizzare '1' o '0'.

Una volta inserita la password, l'indirizzo aggiuntivo memorizzerà il valore “1” indicante che la password è impostata e il programma chiederà di inserire la password per accendere il LED.

Se il valore memorizzato dell'indirizzo aggiuntivo è '0' o è presente un altro valore, verrà chiesto di creare una nuova password a 6 cifre.

Con il metodo sopra, il programma può identificare se hai già impostato una password o se devi creare una nuova password.

Se la password inserita è corretta, il LED integrato al pin # 13 si accende, se la password inserita non è corretta, il LED non si accende e il monitor seriale chiederà che la password è sbagliata.

Codice programma n. 2

Ora carica il codice:
//------------------Program Developed by R.GIRISH---------------//
#include
int passExistAdd = 200
const int LED = 13
int inputAddress = 0
int word1 = 0
int word2 = 0
int word3 = 0
int word4 = 0
int word5 = 0
int word6 = 0
int wordAddress1 = 0
int wordAddress2 = 1
int wordAddress3 = 2
int wordAddress4 = 3
int wordAddress5 = 4
int wordAddress6 = 5
int passwordExist = 0
boolean ReadVal1 = true
boolean ReadVal2 = true
boolean ReadVal3 = true
boolean ReadVal4 = true
boolean ReadVal5 = true
boolean ReadVal6 = true
int checkWord1 = 0
int checkWord2 = 0
int checkWord3 = 0
int checkWord4 = 0
int checkWord5 = 0
int checkWord6 = 0
void setup()
{
Serial.begin(9600)
pinMode(LED, OUTPUT)
digitalWrite(LED, LOW)
passwordExist = EEPROM.read(passExistAdd)
if(passwordExist != 1)
{
Serial.println('Enter a new 6 number password:')
while(ReadVal1)
{
word1 = Serial.read()
if(word1 > 0)
{
word1 = word1 - 48
ReadVal1 = false
}
}
while(ReadVal2)
{
word2 = Serial.read()
if(word2 > 0)
{
word2 = word2 - 48
ReadVal2 = false
}
}
while(ReadVal3)
{
word3 = Serial.read()
if(word3 > 0)
{
word3 = word3 - 48
ReadVal3 = false
}
}
while(ReadVal4)
{
word4 = Serial.read()
if(word4 > 0)
{
word4 = word4 - 48
ReadVal4 = false
}
}
while(ReadVal5)
{
word5 = Serial.read()
if(word5 > 0)
{
word5 = word5 - 48
ReadVal5 = false
}
}
while(ReadVal6)
{
word6 = Serial.read()
if(word6 > 0)
{
word6 = word6 - 48
ReadVal6 = false
}
}
Serial.println('')
Serial.print(word1)
Serial.print(word2)
Serial.print(word3)
Serial.print(word4)
Serial.print(word5)
Serial.print(word6)
EEPROM.write(wordAddress1, word1)
EEPROM.write(wordAddress2, word2)
EEPROM.write(wordAddress3, word3)
EEPROM.write(wordAddress4, word4)
EEPROM.write(wordAddress5, word5)
EEPROM.write(wordAddress6, word6)
EEPROM.write(passExistAdd,1)
Serial.println(' Password saved Sucessfully!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
if(passwordExist == 1)
{
Serial.println('')
Serial.println('Please enter the 6 digit number password:')
while(ReadVal1)
{
word1 = Serial.read()
if(word1 > 0)
{
word1 = word1 - 48
ReadVal1 = false
}
}
while(ReadVal2)
{
word2 = Serial.read()
if(word2 > 0)
{
word2 = word2 - 48
ReadVal2 = false
}
}
while(ReadVal3)
{
word3 = Serial.read()
if(word3 > 0)
{
word3 = word3 - 48
ReadVal3 = false
}
}
while(ReadVal4)
{
word4 = Serial.read()
if(word4 > 0)
{
word4 = word4 - 48
ReadVal4 = false
}
}
while(ReadVal5)
{
word5 = Serial.read()
if(word5 > 0)
{
word5 = word5 - 48
ReadVal5 = false
}
}
while(ReadVal6)
{
word6 = Serial.read()
if(word6 > 0)
{
word6 = word6 - 48
ReadVal6 = false
}
}
checkWord1 = EEPROM.read(wordAddress1)
if(checkWord1 != word1)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord2 = EEPROM.read(wordAddress2)
if(checkWord2 != word2)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord3 = EEPROM.read(wordAddress3)
if(checkWord3 != word3)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord4 = EEPROM.read(wordAddress4)
if(checkWord4 != word4)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord5 = EEPROM.read(wordAddress5)
if(checkWord5 != word5)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord6 = EEPROM.read(wordAddress6)
if(checkWord6 != word6)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
digitalWrite(LED, HIGH)
Serial.println('')
Serial.println('LED is ON')
Serial.println('')
Serial.println('Press Reset Button.')
}
}
void loop()
{
}
//------------------Program Developed by R.GIRISH---------------//

PRODUZIONE:

Aprire il monitor seriale ti chiederà di creare una password con numero di 6 cifre.

Immettere una password di 6 cifre qualsiasi, annotarla e premere Invio. Ora la password è stata memorizzata.

È possibile premere il pulsante di ripristino o scollegare il cavo USB dal PC, interrompendo l'alimentazione alla scheda Arduino.

Ora, ricollega il cavo USB, apri il monitor seriale, che ti chiederà di inserire la password di 6 cifre salvata.

Immettere la password corretta, il LED si accenderà.

Se vuoi cambiare la password cambia la cifra del codice:

int passExistAdd = 200

La riga sopra è l'indirizzo aggiuntivo di cui abbiamo discusso prima. Modificare ovunque da 6 a 1023. Da 0 a 5 indirizzi è riservato per la memorizzazione della password a 6 cifre.

La modifica di questo indirizzo aggiuntivo ingannerà il programma sul fatto che la password non è ancora stata creata e ti chiederà di creare una nuova password di 6 cifre.

Se hai domande su questa EEPROM nel tutorial di Arduino, esprimi nei commenti, potresti ricevere una rapida risposta.