Läsa och skriva data till extern EEPROM med Arduino: 5 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

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

EEPROM är mycket viktigt och användbart eftersom det är en icke-flyktig form av minne. Detta betyder att även när kortet är avstängt behåller EEPROM -chipet fortfarande programmet som skrevs till det. Så när du stänger av kortet och sedan slår på det igen kan programmet som skrevs till EEPROM köras. Så i princip lagrar och kör EEPROM ett program oavsett vad. Det betyder att du kan stänga av en enhet, hålla den avstängd i 3 dagar och komma tillbaka och slå på den och den kan fortfarande köra programmet som var programmerat i den. Så fungerar de flesta konsumentelektroniska enheter.

Detta projekt är sponsrat av LCSC. Jag har använt elektroniska komponenter från LCSC.com. LCSC har ett starkt engagemang för att erbjuda ett brett urval av äkta elektroniska komponenter av hög kvalitet till bästa pris med ett globalt fraktnät till över 200 länder. Registrera dig idag och få $ 8 rabatt på din första beställning.

EEPROM är också mycket effektivt genom att enskilda byte i en traditionell EEPROM kan läsas, raderas och skrivas om självständigt. I de flesta andra typer av icke-flyktigt minne kan detta inte göras. Seriella EEPROM-enheter som Microchip 24-serien EEPROM låter dig lägga till mer minne till alla enheter som kan tala I²C.

Tillbehör

1. EEPROM - 24LC512
2. ATmega328P-PU
3. 16 MHz kristall
4. Bakbord
5. Motstånd 4,7k Ohm x 2
6. Kondensator 22 pF x 2

Steg 1: EEPROM Basics

Microchip 24LC2512 -chipet kan köpas i ett 8 -stifts DIP -paket. Stiften på 24LC512 är ganska raka och består av kraft (8), GND (4), skrivskydd (7), SCL/SDA (6, 5) och tre adressstift (1, 2, 3).

En kort historia av ROM

Tidiga datorer av "lagrad program" - till exempel skrivbordskalkylatorer och tangentbordstolkar - började använda ROM i form av Diode Matrix ROM. Detta var ett minne bestående av diskreta halvledardioder placerade på ett specialorganiserat kretskort. Detta gav plats för Mask ROM med tillkomsten av integrerade kretsar. Mask ROM liknade Diode Matrix ROM bara det implementerades i mycket mindre skala. Detta innebar dock att du inte bara kunde flytta runt ett par dioder med ett lödkolv och programmera om det. Mask -ROM måste programmeras av tillverkaren och kunde därefter inte ändras.

Tyvärr var Mask ROM dyrt och tog lång tid att producera eftersom varje nytt program krävde att en helt ny enhet tillverkades av ett gjuteri. 1956 löstes dock detta problem med uppfinningen av PROM (Programmerbar ROM) som gjorde det möjligt för utvecklare att programmera chipsen själva. Det innebar att tillverkare kunde producera miljoner av samma oprogrammerade enhet vilket gjorde den billigare och mer praktisk. PROM kunde dock bara skrivas till en gång med en högspännings programmeringsenhet. Efter att en PROM -enhet programmerats fanns det inget sätt att återställa enheten till dess oprogrammerade tillstånd.

Detta ändrades 1971 med uppfinningen av EPROM (Erasable Programmable ROM) som - förutom att lägga till ytterligare en bokstav till akronymen - förde med sig möjligheten att radera enheten och återställa den till ett "tomt" tillstånd med hjälp av en stark UV -ljuskälla. Det var rätt, du var tvungen att lysa ett starkt ljus på IC: n för att omprogrammera den, hur coolt är det? Tja, det visar sig att det är ganska coolt om du inte är en utvecklare som arbetar med firmware, i så fall skulle du verkligen vilja kunna programmera om enheten med elektriska signaler. Detta blev till slut verklighet 1983 med utvecklingen av EEPROM (Electrically Erasable Programmable ROM) och med det når vi fram till den nuvarande otympliga akronymen.

Steg 2: Egenskaper hos EEPROM

Det finns två stora nackdelar med EEPROM som en metod för datalagring. I de flesta applikationer uppväger fördelarna nackdelarna, men du bör vara medveten om dem innan du integrerar EEPROM i din nästa design.

Först och främst begränsar tekniken som får EEPROM att fungera också antalet gånger det kan skrivas om. Detta har att göra med att elektroner fastnar i transistorerna som utgör ROM och bygger upp tills laddningsskillnaden mellan ett "1" och ett "0" är oigenkännligt. Men oroa dig inte, de flesta EEPROM har ett maximalt antal omskrivningar på 1 miljon eller mer. Så länge du inte skriver kontinuerligt till EEPROM är det osannolikt att du når detta maximalt. För det andra kommer EEPROM inte att raderas om du tar bort strömmen från det, men det kommer inte att hålla kvar dina data på obestämd tid. Elektroner kan glida ut från transistorerna och genom isolatorn, vilket effektivt raderar EEPROM över tiden. Som sagt, detta sker vanligtvis under årens lopp (även om det kan accelereras av värme). De flesta tillverkare säger att din data är säker på EEPROM i 10 år eller mer vid rumstemperatur. Och det finns ytterligare en sak du bör tänka på när du väljer en EEPROM -enhet för ditt projekt. EEPROM -kapacitet mäts i bitar och inte byte. En 512K EEPROM rymmer 512Kbits data, med andra ord bara 64KB.

Steg 3: Arduino maskinvaruanslutning

Okej, nu när vi vet vad EEPROM är, låt oss ansluta en och se vad den kan göra! För att få vår enhet att prata måste vi ansluta ström såväl som I²C seriella ledningar. Denna enhet körs i synnerhet på 5VDC så vi ansluter den till 5V -utgången från vår Arduino UNO. I²C-linjerna kommer också att behöva uppdragningsmotstånd för att kommunikationen ska kunna ske korrekt. Värdet på dessa motstånd beror på kapacitansen hos linjerna och frekvensen du vill kommunicera det, men en bra tumregel för icke-kritiska applikationer håller den bara inom kΩ-intervallet. I det här exemplet använder vi 4,7kΩ uppdragningsmotstånd.

Det finns tre stift på den här enheten för att välja I²C -adressen. På så sätt kan du ha mer än en EEPROM på bussen och adressera dem olika. Du kan bara jorda dem alla, men vi kopplar dem så att vi kan släppa in en enhet med högre kapacitet senare i handledningen.

Vi använder en brödbräda för att koppla ihop allt. Diagrammet nedan visar rätt anslutning för de flesta I²C EEPROM-enheter, inklusive Microchip 24-serien EEPROM som vi säljer.

Steg 4: Läsa och skriva

För det mesta när du använder en EEPROM tillsammans med en mikrokontroller behöver du faktiskt inte se allt innehåll i minnet samtidigt. Du kommer bara att läsa och skriva byte här och där efter behov. I det här exemplet kommer vi dock att skriva en hel fil till EEPROM och sedan läsa den igen så att vi kan se den på vår dator. Detta borde göra oss bekväma med tanken på att använda EEPROM och också ge oss en känsla för hur mycket data som verkligen kan rymma på en liten enhet.

Skriva något

Vår exempelskiss tar helt enkelt vilken byte som kommer in över serieporten och skriver den till EEPROM och håller koll på hur många byte vi har skrivit till minnet.

Att skriva en byte minne till EEPROM sker vanligtvis i tre steg:

1. Skicka den viktigaste byten för minnesadressen som du vill skriva till.
2. Skicka den minst signifikanta byten för den minnesadress som du vill skriva till.
3. Skicka den databyte som du vill lagra på den här platsen.

Det finns förmodligen några nyckelord där som bara förklarar:

Minnesadresser

Om du föreställer dig alla byte i en 512 Kbit EEPROM som står i en rad från 0 till 64000 - eftersom det finns 8 bitar till en byte och därför kan du passa 64000 byte på en 512 Kbit EEPROM - då är en minnesadress platsen i linje där du skulle hitta en viss byte. Vi måste skicka den adressen till EEPROM så att den vet var den byte som vi skickar ska placeras.

Mest signifikanta och minst signifikanta bytes

Eftersom det finns 32000 möjliga platser i en 256 Kbit EEPROM - och eftersom 255 är det största antalet du kan koda i en byte - måste vi skicka den här adressen i två byte. Först skickar vi den mest signifikanta byten (MSB) - de första 8 bitarna i det här fallet. Sedan skickar vi Least Significant Byte (LSB) - de andra 8 bitarna. Varför? Eftersom det är så här enheten förväntar sig att ta emot dem, det är allt.

Sidskrivning

Att skriva en byte i taget är bra, men de flesta EEPROM -enheter har något som kallas en "sidskrivbuffert" som gör att du kan skriva flera byte åt gången på samma sätt som en enskild byte. Vi kommer att dra nytta av detta i vår exempelskiss. EEPROM använder en intern räknare som automatiskt ökar minnesplatsen för varje följande databyte som den tar emot. När en minnesadress har skickats kan vi följa den med upp till 64 byte data. EEPROM antar (med rätta) att en adress på 312 följt av 10 byte kommer att spela in byte 0 på adressen 312, byte 1 vid adressen 313, byte 2 vid adressen 314, och så vidare.

Läs något

Läsning från EEPROM följer i princip samma trestegsprocess som att skriva till EEPROM:

1. Skicka den viktigaste byten för minnesadressen som du vill skriva till.
2. Skicka den minst signifikanta byten för den minnesadress som du vill skriva till.
3. Be om databyte på den platsen.

Steg 5: Schema och kod

Koda:

#omfatta

#define eeprom 0x50 // definierar basadressen för EEPROM

void setup () {

Wire.begin (); // skapar ett Wire -objekt

Serial.begin (9600);

osignerad int -adress = 0; // EEPROM: s första adress

Serial.println ("Vi skriver postnumret 22222, ett postnummer"); för (adress = 0; adress <5; adress ++) writeEEPROM (eeprom, address, '2'); // Skriver 22222 till EEPROM

för (adress = 0; adress <5; adress ++) {Serial.print (readEEPROM (eeprom, adress), HEX); }}

void loop () {

/*det finns inget i loop () -funktionen eftersom vi inte vill att arduino upprepade gånger ska skriva samma sak till EEPROM om och om igen. Vi vill bara skriva en gång, så slingan () -funktionen undviks med EEPROM.*/}

// definierar writeEEPROM -funktionen

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 (); }

// definierar readEEPROM -funktionen

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 (); returnera rdata; }