Die ingeboude EEPROM van u Arduino: 6 stappe

2025 Outeur: John Day | [email protected]. Laas verander: 2025-01-23 12:53

In hierdie artikel gaan ons die interne EEPROM in ons Arduino -borde ondersoek. Wat is 'n EEPROM wat sommige van u sê? 'N EEPROM is 'n programmeerbare leesalleengeheue wat elektries uitvee kan word.

Dit is 'n vorm van nie-vlugtige geheue wat dinge kan onthou terwyl die krag afgeskakel is, of nadat die Arduino herstel is. Die mooi van hierdie soort geheue is dat ons data wat op 'n skets gegenereer word, op 'n meer permanente basis kan stoor.

Waarom sou u die interne EEPROM gebruik? Vir situasies waar data wat uniek is vir 'n situasie 'n meer permanente tuiste benodig. Byvoorbeeld, die berging van die unieke reeksnommer en vervaardigingsdatum van 'n kommersiële Arduino-gebaseerde projek-'n funksie van die skets kan die reeksnommer op 'n LCD vertoon, of die data kan gelees word deur 'n 'diensskets' op te laai. Of u moet sekere gebeurtenisse tel en nie toelaat dat die gebruiker dit herstel nie-soos 'n kilometerteller of 'n siklus-teller.

Stap 1: Watter soort data kan gestoor word?

Enigiets wat as grepe data voorgestel kan word. Een greep data bestaan uit agt stukkies data. 'N Bietjie kan óf aan (waarde 1) óf af (waarde 0) wees, en is perfek om getalle in binêre vorm voor te stel. Met ander woorde, 'n binêre getal kan slegs nulle en ene gebruik om 'n waarde voor te stel. Binêr staan dus ook bekend as base-2 ″, aangesien dit slegs twee syfers kan gebruik.

Hoe kan 'n binêre getal met slegs die gebruik van twee syfers 'n groter getal voorstel? Dit gebruik baie ene en nulle. Kom ons ondersoek 'n binêre getal, sê 10101010. Aangesien dit 'n basis-2 getal is, verteenwoordig elke syfer 2 tot die krag van x, van x = 0 af.

Stap 2:

Kyk hoe elke syfer van die binêre getal 'n basis-10 getal kan verteenwoordig. Die binêre getal hierbo verteenwoordig 85 in basis-10-die waarde 85 is die som van die basis-10 waardes. 'N Ander voorbeeld - 11111111 in binêre is gelyk aan 255 in basis 10.

Stap 3:

Nou gebruik elke syfer in die binêre getal een 'bietjie' geheue, en agt bisse maak 'n greep. As gevolg van interne beperkings van die mikrobeheerders in ons Arduino-borde, kan ons slegs 8-bis-nommers (een byte) in die EEPROM stoor.

Dit beperk die desimale waarde van die getal tussen nul en 255. Dit is dan aan u om te besluit hoe u data met die getalreeks voorgestel kan word. Moenie toelaat dat dit u afskrik nie - getalle wat op die regte manier gerangskik is, kan byna enigiets verteenwoordig! Daar is een beperking om op te let - die aantal kere wat ons aan die EEPROM kan lees of skryf. Volgens die vervaardiger Atmel is die EEPROM goed vir 100 000 lees/skryf siklusse (sien die gegewensblad).

Stap 4:

Nou weet ons ons stukkies en grepe, hoeveel grepe kan in ons Arduino se mikrobeheerder gestoor word? Die antwoord wissel na gelang van die model van die mikrobeheerder. Byvoorbeeld:

• Bord met 'n Atmel ATmega328, soos Arduino Uno, Uno SMD, Nano, Lilypad, ens. - 1024 grepe (1 kilobyte)
• Bord met 'n Atmel ATmega1280 of 2560, soos die Arduino Mega -reeks - 4096 grepe (4 kilobytes)
• Bord met 'n Atmel ATmega168, soos die oorspronklike Arduino Lilypad, ou Nano, Diecimila ens - 512 grepe.

As u nie seker is nie, kyk na die Arduino -hardeware -indeks of vra u bordverskaffer. As u meer EEPROM -berging benodig as wat by u mikrobeheerder beskikbaar is, oorweeg dit om 'n eksterne I2C EEPROM te gebruik.

Op hierdie punt verstaan ons nou watter soort data en hoeveel daar in ons Arduino se EEPROM gestoor kan word. Dit is nou tyd om dit in werking te stel. Soos vroeër bespreek, is daar 'n beperkte hoeveelheid ruimte vir ons data. In die volgende voorbeelde gebruik ons 'n tipiese Arduino -bord met die ATmega328 met 1024 grepe EEPROM -berging.

Stap 5:

'N Biblioteek is nodig om die EEPROM te gebruik, dus gebruik die volgende biblioteek in u sketse:

#sluit "EEPROM.h" in

Die res is baie eenvoudig. Om 'n stukkie data te stoor, gebruik ons die volgende funksie:

EEPROM.skryf (a, b);

Die parameter a is die posisie in die EEPROM om die heelgetal (0 ~ 255) data te stoor b. In hierdie voorbeeld het ons 1024 grepe geheue berging, dus is die waarde van a tussen 0 en 1023. Om 'n stuk data op te haal is net so eenvoudig, gebruik:

z = EEPROM.read (a);

Waar z 'n heelgetal is om die data vanaf die EEPROM -posisie te stoor a. Nou om 'n voorbeeld te sien.

Stap 6:

Hierdie skets skep ewekansige getalle tussen 0 en 255, stoor dit in die EEPROM, haal dit dan op die seriële monitor op en vertoon dit. Die veranderlike EEsize is die boonste limiet van u EEPROM -grootte, dus (byvoorbeeld) sou dit 1024 wees vir 'n Arduino Uno, of 4096 vir 'n Mega.

// Arduino interne EEPROM -demonstrasie

#insluit

int zz; int EEsize = 1024; // grootte in grepe van jou bord se EEPROM

leemte opstelling ()

{Serial.begin (9600); randomSeed (analogRead (0)); } leemte -lus () {Serial.println ("Willekeurige getalle skryf …"); vir (int i = 0; i <EEsize; i ++) {zz = random (255); EEPROM.write (i, zz); } Serial.println (); vir (int a = 0; a <EEsize; a ++) {zz = EEPROM.read (a); Serial.print ("EEPROM -posisie:"); Reeks.afdruk (a); Serial.print ("bevat"); Serial.println (zz); vertraging (25); }}

Die uitset van die seriële monitor sal verskyn, soos in die prentjie gewys word.

So, dit is nog 'n nuttige manier om data met ons Arduino -stelsels te stoor. Alhoewel dit nie die opwindendste tutoriaal is nie, is dit beslis nuttig.

Hierdie pos word deur pmdway.com aan u gebring - alles vir vervaardigers en elektronika -entoesiaste, met gratis aflewering wêreldwyd.