Lese og skrive data til ekstern EEPROM ved hjelp av Arduino: 5 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:22

EEPROM står for Electrically Erasable Programmable Read-Only Memory.

EEPROM er veldig viktig og nyttig fordi det er en ikke-flyktig form for minne. Dette betyr at selv når kortet er slått av, beholder EEPROM -brikken fortsatt programmet som ble skrevet til det. Så når du slår av brettet og deretter slår det på igjen, kan programmet som ble skrevet til EEPROM kjøres. Så i utgangspunktet lagrer og kjører EEPROM et program uansett. Dette betyr at du kan slå av en enhet, holde den av i 3 dager, og komme tilbake og slå den på, og den kan fortsatt kjøre programmet som var programmert i den. Slik fungerer de fleste forbrukerelektroniske enheter.

Dette prosjektet er sponset av LCSC. Jeg har brukt elektroniske komponenter fra LCSC.com. LCSC har et sterkt engasjement for å tilby et bredt utvalg av ekte elektroniske komponenter av høy kvalitet til den beste prisen med et globalt fraktnettverk til over 200 land. Registrer deg i dag og få $ 8 rabatt på din første bestilling.

EEPROM er også veldig effektivt ved at individuelle byte i en tradisjonell EEPROM kan leses, slettes og skrives uavhengig av hverandre. I de fleste andre typer ikke-flyktig minne kan dette ikke gjøres. Serielle EEPROM-enheter som Microchip 24-serien EEPROM lar deg legge til mer minne til alle enheter som kan snakke I²C.

Rekvisita

1. EEPROM - 24LC512
2. ATmega328P-PU
3. 16 MHz krystall
4. Brødbrett
5. Motstand 4,7k Ohm x 2
6. Kondensator 22 pF x 2

Trinn 1: Grunnleggende om EEPROM

Microchip 24LC2512 -brikken kan kjøpes i en 8 -pins DIP -pakke. Pinnene på 24LC512 er ganske rett frem og består av strøm (8), GND (4), skrivebeskyttelse (7), SCL/SDA (6, 5) og tre adressestifter (1, 2, 3).

En kort historie om ROM

Tidlige datamaskiner av typen "lagret program" - for eksempel bordkalkulatorer og tastaturfortolkere - begynte å bruke ROM i form av Diode Matrix ROM. Dette var et minne som består av diskrete halvlederdioder plassert på en spesielt organisert kretskort. Dette ga plass for Mask ROM med ankomsten av integrerte kretser. Mask ROM var mye som Diode Matrix ROM, bare den ble implementert i en mye mindre skala. Dette betydde imidlertid at du ikke bare kunne flytte et par dioder rundt med et loddejern og omprogrammere det. Maske -ROM måtte programmeres av produsenten og kunne deretter ikke endres.

Dessverre var Mask ROM dyrt og tok lang tid å produsere fordi hvert nytt program krevde en helt ny enhet for å bli produsert av et støperi. I 1956 ble dette problemet imidlertid løst med oppfinnelsen av PROM (Programmable ROM) som tillot utviklere å programmere sjetongene selv. Det betydde at produsenter kunne produsere millioner av den samme uprogrammerte enheten, noe som gjorde den billigere og mer praktisk. PROM kunne imidlertid bare skrives til én gang ved bruk av en høyspennings programmeringsenhet. Etter at en PROM -enhet var programmert, var det ingen måte å sette enheten tilbake til sin uprogrammerte tilstand.

Dette endret seg i 1971 med oppfinnelsen av EPROM (Erasable Programmable ROM) som - i tillegg til å legge til en annen bokstav i akronymet - førte til muligheten til å slette enheten og returnere den til en "blank" tilstand ved hjelp av en sterk UV -lyskilde. Det var riktig, du måtte skinne et sterkt lys på IC for å omprogrammere den, hvor kult er det? Vel, det viser seg at det er ganske kult med mindre du er en utvikler som jobber med fastvare, og i så fall vil du virkelig kunne omprogrammere enheten ved hjelp av elektriske signaler. Dette ble endelig en realitet i 1983 med utviklingen av EEPROM (Electrically Erasable Programmable ROM), og med det kommer vi frem til dagens vanskelige akronym.

Trinn 2: Egenskaper ved EEPROM

Det er to store ulemper ved EEPROM som en metode for datalagring. I de fleste applikasjoner oppveier fordelene ulempene, men du bør være oppmerksom på dem før du integrerer EEPROM i ditt neste design.

Først av alt, teknologien som får EEPROM til å fungere, begrenser også antall ganger den kan skrives om. Dette har å gjøre med at elektroner blir fanget i transistorene som utgjør ROM -en og bygger opp til ladningsforskjellen mellom en "1" og en "0" er ugjenkjennelig. Men ikke bekymre deg, de fleste EEPROM-er har et maksimal omskrivningstall på 1 million eller mer. Så lenge du ikke kontinuerlig skriver til EEPROM, er det lite sannsynlig at du når dette maksimumet. For det andre vil ikke EEPROM bli slettet hvis du fjerner strømmen fra den, men den vil ikke holde på dataene dine på ubestemt tid. Elektroner kan drive ut av transistorene og gjennom isolatoren, og effektivt slette EEPROM over tid. Når det er sagt, skjer dette vanligvis i løpet av årene (selv om det kan akselereres av varme). De fleste produsenter sier at dataene dine er trygge på EEPROM i 10 år eller mer ved romtemperatur. Og det er en ting du bør huske på når du velger en EEPROM -enhet for prosjektet ditt. EEPROM -kapasitet måles i biter og ikke byte. En 512K EEPROM vil inneholde 512Kbit data, med andre ord bare 64KB.

Trinn 3: Arduino maskinvaretilkobling

Ok, nå som vi vet hva EEPROM er, la oss koble til en og se hva den kan gjøre! For å få enheten til å snakke, må vi koble til strøm så vel som I²C serielle linjer. Denne enheten kjører spesielt på 5VDC, så vi kobler den til 5V -utgangen på vår Arduino UNO. I²C-linjene trenger også opptrekkmotstander for at kommunikasjonen skal skje korrekt. Verdien av disse motstandene avhenger av kapasitansen til linjene og frekvensen du vil kommunisere den, men en god tommelfingerregel for ikke-kritiske applikasjoner holder den bare i kΩ-området. I dette eksemplet bruker vi 4,7 kΩ opptrekkmotstander.

Det er tre pinner på denne enheten for å velge I²C -adressen. På denne måten kan du ha mer enn én EEPROM på bussen og adressere dem hver for seg. Du kan bare koble dem alle, men vi vil koble dem til slik at vi kan slippe inn en enhet med høyere kapasitet senere i opplæringen.

Vi bruker et brødbrett for å koble alt sammen. Diagrammet nedenfor viser riktig oppkobling for de fleste I²C EEPROM-enheter, inkludert Microchip 24-serien EEPROM som vi selger.

Trinn 4: Lese og skrive

Mesteparten av tiden når du bruker en EEPROM sammen med en mikrokontroller, trenger du faktisk ikke å se alt innholdet i minnet samtidig. Du vil bare lese og skrive byte her og der etter behov. I dette eksemplet skal vi imidlertid skrive en hel fil til EEPROM og deretter lese den av igjen slik at vi kan se den på datamaskinen vår. Dette bør gjøre oss komfortable med ideen om å bruke EEPROM og også gi oss en følelse av hvor mye data som virkelig kan passe på en liten enhet.

Skrive noe

Eksempelskissen vår vil ganske enkelt ta hvilken som helst byte som kommer inn over serieporten og skrive den til EEPROM, og følge med på hvor mange byte vi har skrevet til minnet.

Å skrive en byte minne til EEPROM skjer vanligvis i tre trinn:

1. Send den mest betydningsfulle byten til minneadressen du vil skrive til.
2. Send den minst signifikante byten til minneadressen du vil skrive til.
3. Send databyte du vil lagre på dette stedet.

Det er sannsynligvis noen få stikkord der som bare forklarer:

Minneadresser

Hvis du forestiller deg at alle byte i en 512 Kbit EEPROM står på en linje fra 0 til 64000 - fordi det er 8 bits til en byte og derfor kan du passe 64000 byte på en 512 Kbit EEPROM - så er en minneadresse stedet i linje der du finner en bestemt byte. Vi må sende den adressen til EEPROM, slik at den vet hvor vi skal legge byten vi sender.

Mest signifikante og minst signifikante byte

Fordi det er 32000 mulige steder i en 256 Kbit EEPROM - og fordi 255 er det største antallet du kan kode i en byte - må vi sende denne adressen i to byte. Først sender vi den mest betydningsfulle byten (MSB) - de første 8 bitene i dette tilfellet. Så sender vi Least Significant Byte (LSB) - de andre 8 bitene. Hvorfor? Fordi det er slik enheten forventer å motta dem, det er alt.

Side skriving

Å skrive en byte om gangen er greit, men de fleste EEPROM -enheter har noe som kalles en "side skrivebuffer" som lar deg skrive flere byte om gangen på samme måte som en enkelt byte. Vi drar fordel av dette i vår eksempelskisse. EEPROM bruker en intern teller som automatisk øker minneplasseringen for hver følgende databyte den mottar. Når en minneadresse er sendt, kan vi følge den med opptil 64 byte med data. EEPROM antar (med rette) at en adresse på 312 etterfulgt av 10 byte vil registrere byte 0 på adresse 312, byte 1 på adresse 313, byte 2 på adresse 314, og så videre.

Les noe

Å lese fra EEPROM følger i utgangspunktet den samme tretrinnsprosessen som å skrive til EEPROM:

1. Send den mest betydningsfulle byten til minneadressen du vil skrive til.
2. Send den minst signifikante byten til minneadressen du vil skrive til.
3. Be om databyte på det stedet.

Trinn 5: Skjemaer og kode

Kode:

#inkludere

#define eeprom 0x50 // definerer basisadressen til EEPROM

ugyldig oppsett () {

Wire.begin (); // oppretter et Wire -objekt

Serial.begin (9600);

usignert int -adresse = 0; // første adresse til EEPROM

Serial.println ("Vi skriver postnummeret 22222, et postnummer"); for (adresse = 0; adresse <5; adresse ++) writeEEPROM (eeprom, adresse, '2'); // Skriver 22222 til EEPROM

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

void loop () {

/*det er ingenting i loop () -funksjonen fordi vi ikke vil at arduinoen skal skrive det samme til EEPROM gjentatte ganger. Vi vil bare skrive en gang, så sløyfe () -funksjonen unngås med EEPROM.*/}

// definerer writeEEPROM -funksjonen

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

// definerer readEEPROM -funksjonen

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