Arduinos innebygde EEPROM: 6 trinn

2025 Forfatter: John Day | [email protected]. Sist endret: 2025-01-23 15:02

I denne artikkelen skal vi undersøke den interne EEPROM i våre Arduino -kort. Hva er en EEPROM noen av dere sier? En EEPROM er et elektrisk slettbart programmerbart skrivebeskyttet minne.

Det er en form for ikke-flyktig minne som kan huske ting med strømmen slått av, eller etter å ha tilbakestilt Arduino. Det fine med denne typen minne er at vi kan lagre data generert i en skisse på en mer permanent basis.

Hvorfor vil du bruke den interne EEPROM? For situasjoner der data som er unike for en situasjon trenger et mer permanent hjem. For eksempel lagring av det unike serienummeret og produksjonsdatoen for et kommersielt Arduino-basert prosjekt-en funksjon av skissen kan vise serienummeret på en LCD-skjerm, eller dataene kan leses ved å laste opp en "tjenesteskisse". Eller du må kanskje telle visse hendelser og ikke la brukeren tilbakestille dem-for eksempel en kilometerteller eller en syklus-teller.

Trinn 1: Hva slags data kan lagres?

Alt som kan representeres som byte med data. En byte data består av åtte biter data. En bit kan enten være på (verdi 1) eller av (verdi 0), og er perfekt for å representere tall i binær form. Med andre ord kan et binært tall bare bruke nuller og ettall for å representere en verdi. Dermed er binær også kjent som “base-2 ″, ettersom den bare kan bruke to sifre.

Hvordan kan et binært tall med bare to sifre representere et større tall? Den bruker mange ener og nuller. La oss undersøke et binært tall, si 10101010. Siden dette er et base-2-tall, representerer hvert siffer 2 til effekten x, fra x = 0 og fremover.

Steg 2:

Se hvordan hvert siffer i det binære tallet kan representere et base-10-tall. Så det binære tallet ovenfor representerer 85 i base-10-verdien 85 er summen av base-10-verdiene. Et annet eksempel - 11111111 i binær er 255 i base 10.

Trinn 3:

Nå bruker hvert siffer i det binære tallet en "bit" minne, og åtte bits lager en byte. På grunn av interne begrensninger for mikrokontrollerne i våre Arduino-kort, kan vi bare lagre 8-bits tall (en byte) i EEPROM.

Dette begrenser desimalverdien til tallet til å falle mellom null og 255. Det er deretter opp til deg å bestemme hvordan dataene dine kan representeres med det tallområdet. Ikke la det avskrekke deg - tall arrangert på riktig måte kan representere nesten alt! Det er en begrensning å ta hensyn til - antall ganger vi kan lese eller skrive til EEPROM. I følge produsenten Atmel er EEPROM bra for 100 000 lese/skrive sykluser (se databladet).

Trinn 4:

Nå vet vi våre biter og byte, hvor mange byte kan lagres i Arduinos mikrokontroller? Svaret varierer avhengig av modellen til mikrokontrolleren. For eksempel:

• Tavler med Atmel ATmega328, for eksempel Arduino Uno, Uno SMD, Nano, Lilypad, etc. - 1024 byte (1 kilobyte)
• Brett med Atmel ATmega1280 eller 2560, for eksempel Arduino Mega -serien - 4096 byte (4 kilobyte)
• Tavler med Atmel ATmega168, for eksempel den originale Arduino Lilypad, gamle Nano, Diecimila osv. - 512 byte.

Hvis du er usikker, ta en titt på Arduino -maskinvareindeksen eller spør din brettleverandør. Hvis du trenger mer EEPROM -lagring enn det som er tilgjengelig med mikrokontrolleren, kan du vurdere å bruke en ekstern I2C EEPROM.

På dette tidspunktet forstår vi nå hva slags data og hvor mye som kan lagres i Arduinos EEPROM. Nå er det på tide å sette dette i verk. Som diskutert tidligere, er det en begrenset mengde plass til dataene våre. I de følgende eksemplene vil vi bruke et typisk Arduino -kort med ATmega328 med 1024 byte EEPROM -lagring.

Trinn 5:

For å bruke EEPROM kreves et bibliotek, så bruk følgende bibliotek i skissene dine:

#include "EEPROM.h"

Resten er veldig enkel. For å lagre et stykke data bruker vi følgende funksjon:

EEPROM.write (a, b);

Parameteren a er posisjonen i EEPROM for å lagre heltall (0 ~ 255) for data b. I dette eksemplet har vi 1024 byte minne, så verdien av a er mellom 0 og 1023. For å hente et stykke data er like enkelt, bruk:

z = EEPROM.read (a);

Hvor z er et heltall for å lagre dataene fra EEPROM -posisjonen a. Nå for å se et eksempel.

Trinn 6:

Denne skissen vil opprette tilfeldige tall mellom 0 og 255, lagre dem i EEPROM, deretter hente og vise dem på den serielle skjermen. Variabelen EEsize er den øvre grensen for din EEPROM -størrelse, så (for eksempel) vil dette være 1024 for en Arduino Uno, eller 4096 for en Mega.

// Arduino intern EEPROM -demonstrasjon

#inkludere

int zz; int EEsize = 1024; // størrelse i byte av brettets EEPROM

ugyldig oppsett ()

{Serial.begin (9600); randomSeed (analogRead (0)); } void loop () {Serial.println ("Skrive tilfeldige tall …"); for (int i = 0; i <EEsize; i ++) {zz = tilfeldig (255); EEPROM.write (i, zz); } Serial.println (); for (int a = 0; a <EEsize; a ++) {zz = EEPROM.read (a); Serial.print ("EEPROM -posisjon:"); Serial.print (a); Serial.print ("inneholder"); Serial.println (zz); forsinkelse (25); }}

Utgangen fra den serielle skjermen vil vises, som vist på bildet.

Så der har du det, en annen nyttig måte å lagre data med våre Arduino -systemer. Selv om det ikke er den mest spennende opplæringen, er det absolutt nyttig.

Dette innlegget ble brakt til deg av pmdway.com - alt for produsenter og elektronikkentusiaster, med gratis levering over hele verden.