Gegevens lezen en schrijven naar externe EEPROM met Arduino - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

EEPROM staat voor Electrically Erasable Programmable Read-Only Memory.

EEPROM is erg belangrijk en nuttig omdat het een niet-vluchtige vorm van geheugen is. Dit betekent dat zelfs wanneer het bord is uitgeschakeld, de EEPROM-chip nog steeds het programma behoudt dat erop is geschreven. Dus wanneer u het bord uitschakelt en vervolgens weer inschakelt, kan het programma dat naar de EEPROM is geschreven, worden uitgevoerd. Dus eigenlijk slaat de EEPROM een programma op en voert het uit, wat er ook gebeurt. Dit betekent dat je een apparaat kunt uitschakelen, het 3 dagen uit kunt laten staan, en dan terug kunt komen en het weer aan kunt zetten en het programma kan nog steeds draaien dat erin is geprogrammeerd. Dit is hoe de meeste elektronische apparaten voor consumenten werken.

Dit project wordt gesponsord door LCSC. Ik gebruik elektronische componenten van LCSC.com. LCSC zet zich sterk in om een brede selectie van echte, hoogwaardige elektronische componenten tegen de beste prijs aan te bieden met een wereldwijd verzendnetwerk naar meer dan 200 landen. Meld u vandaag nog aan en ontvang $ 8 korting op uw eerste bestelling.

EEPROM is ook zeer efficiënt omdat individuele bytes in een traditionele EEPROM onafhankelijk kunnen worden gelezen, gewist en herschreven. In de meeste andere soorten niet-vluchtig geheugen is dit niet mogelijk. Met seriële EEPROM-apparaten zoals de Microchip 24-serie EEPROM kunt u meer geheugen toevoegen aan elk apparaat dat I²C kan spreken.

Benodigdheden

1. EEPROM - 24LC512
2. ATMega328P-PU
3. 16 MHz kristal
4. Breadboard
5. Weerstand 4,7k Ohm x 2
6. Condensator 22 pF x 2

Stap 1: Basisprincipes van EEPROM

De Microchip 24LC2512-chip kan worden gekocht in een 8-pins DIP-pakket. De pinnen op de 24LC512 zijn vrij eenvoudig en bestaan uit voeding (8), GND (4), schrijfbeveiliging (7), SCL/SDA (6, 5) en drie adrespinnen (1, 2, 3).

Een korte geschiedenis van ROM

Vroege computers van het type "Stored-Program" - zoals bureaucalculators en toetsenbordtolken - begonnen ROM te gebruiken in de vorm van Diode Matrix ROM. Dit was een geheugen dat bestond uit discrete halfgeleiderdiodes die op een speciaal georganiseerde PCB waren geplaatst. Dit maakte plaats voor Mask ROM met de komst van geïntegreerde schakelingen. Mask ROM leek veel op Diode Matrix ROM, alleen werd het op veel kleinere schaal geïmplementeerd. Dit betekende echter dat je niet zomaar een paar diodes kon verplaatsen met een soldeerbout en deze opnieuw kon programmeren. Mask ROM moest door de fabrikant worden geprogrammeerd en was daarna niet meer te wijzigen.

Helaas was Mask ROM duur en kostte het veel tijd om te produceren, omdat voor elk nieuw programma een gloednieuw apparaat door een gieterij moest worden vervaardigd. In 1956 werd dit probleem echter opgelost met de uitvinding van PROM (Programmable ROM), waarmee ontwikkelaars de chips zelf konden programmeren. Dat betekende dat fabrikanten miljoenen van hetzelfde ongeprogrammeerde apparaat konden produceren, wat het goedkoper en praktischer maakte. PROM kon echter maar één keer worden beschreven met behulp van een hoogspanningsprogrammeerapparaat. Nadat een PROM-apparaat was geprogrammeerd, was er geen manier om het apparaat terug te brengen naar de ongeprogrammeerde staat.

Dit veranderde in 1971 met de uitvinding van EPROM (Erasable Programmable ROM) die - naast het toevoegen van een andere letter aan het acroniem - de mogelijkheid met zich meebracht om het apparaat te wissen en terug te brengen naar een "lege" staat met behulp van een sterke UV-lichtbron. Dat klopt, je moest met een fel licht op het IC schijnen om het te herprogrammeren, hoe cool is dat? Nou, het blijkt best cool te zijn, tenzij je een ontwikkelaar bent die aan firmware werkt, in welk geval je het apparaat heel graag zou willen herprogrammeren met behulp van elektrische signalen. Dit werd uiteindelijk werkelijkheid in 1983 met de ontwikkeling van EEPROM (Electrically Erasable Programmable ROM) en daarmee komen we aan bij het huidige onpraktische acroniem.

Stap 2: Eigenaardigheden van EEPROM

Er zijn twee belangrijke nadelen aan EEPROM als methode voor gegevensopslag. In de meeste toepassingen wegen de voordelen op tegen de nadelen, maar u moet zich hiervan bewust zijn voordat u EEPROM in uw volgende ontwerp opneemt.

Ten eerste beperkt de technologie die ervoor zorgt dat EEPROM werkt, ook het aantal keren dat het kan worden herschreven. Dit heeft te maken met elektronen die vast komen te zitten in de transistors waaruit de ROM bestaat en zich opbouwen totdat het ladingsverschil tussen een "1" en een "0" onherkenbaar is. Maar maak je geen zorgen, de meeste EEPROM's hebben een maximaal herschrijfnummer van 1 miljoen of meer. Zolang u niet continu naar de EEPROM schrijft, is het onwaarschijnlijk dat u dit maximum haalt. Ten tweede wordt EEPROM niet gewist als u de stroom eruit haalt, maar het houdt uw gegevens niet voor onbepaalde tijd vast. Elektronen kunnen uit de transistoren en door de isolator drijven, waardoor de EEPROM na verloop van tijd effectief wordt gewist. Dat gezegd hebbende, gebeurt dit meestal in de loop van de jaren (hoewel het kan worden versneld door warmte). De meeste fabrikanten zeggen dat uw gegevens bij kamertemperatuur 10 jaar of langer veilig zijn op EEPROM. En er is nog iets waar u rekening mee moet houden bij het selecteren van een EEPROM-apparaat voor uw project. EEPROM-capaciteit wordt gemeten in bits en niet in bytes. Een 512K EEPROM kan 512Kbits aan data bevatten, met andere woorden, slechts 64KB.

Stap 3: Arduino Hardware Aansluiting

Oké, nu we weten wat EEPROM is, laten we er een aansluiten en kijken wat het kan doen! Om ons apparaat aan het praten te krijgen, moeten we zowel stroom als I²C-seriële lijnen aansluiten. Dit apparaat, in het bijzonder, werkt op 5VDC, dus we zullen het aansluiten op de 5V-uitgang van onze Arduino UNO. Ook hebben de I²C-lijnen pull-up-weerstanden nodig om de communicatie correct te laten verlopen. De waarde van deze weerstanden hangt af van de capaciteit van de lijnen en de frequentie waarmee u deze wilt communiceren, maar een goede vuistregel voor niet-kritieke toepassingen is om deze binnen het kΩ-bereik te houden. In dit voorbeeld gebruiken we pull-upweerstanden van 4,7 kΩ.

Er zijn drie pinnen op dit apparaat om het I²C-adres te selecteren, op deze manier kunt u meer dan één EEPROM op de bus hebben en ze elk anders adresseren. Je zou ze allemaal kunnen aarden, maar we zullen ze bedraden zodat we later in de tutorial een apparaat met een hogere capaciteit kunnen plaatsen.

We gebruiken een breadboard om alles met elkaar te verbinden. Het onderstaande diagram toont de juiste aansluiting voor de meeste I²C EEPROM-apparaten, inclusief de Microchip 24-serie EEPROM die we verkopen.

Stap 4: Lezen en schrijven

Wanneer u een EEPROM gebruikt in combinatie met een microcontroller, hoeft u meestal niet alle inhoud van het geheugen in één keer te zien. U leest en schrijft zo nodig hier en daar bytes. In dit voorbeeld gaan we echter een heel bestand naar EEPROM schrijven en vervolgens alles weer uitlezen zodat we het op onze computer kunnen bekijken. Dit zou ons vertrouwd moeten maken met het idee om EEPROM te gebruiken en ons ook een idee geven van hoeveel gegevens er echt op een klein apparaat passen.

Schrijf iets

Onze voorbeeldschets neemt eenvoudig elke byte die via de seriële poort binnenkomt en schrijft deze naar de EEPROM, waarbij we bijhouden hoeveel bytes we naar het geheugen hebben geschreven.

Het schrijven van een geheugenbyte naar de EEPROM gebeurt over het algemeen in drie stappen:

1. Stuur de meest significante byte van het geheugenadres waarnaar u wilt schrijven.
2. Stuur de minst significante byte van het geheugenadres waarnaar u wilt schrijven.
3. Verzend de databyte die u op deze locatie wilt opslaan.

Er zijn waarschijnlijk een paar sleutelwoorden die nauwelijks kunnen worden uitgelegd:

Geheugenadressen

Als je je voorstelt dat alle bytes in een 512 Kbit EEPROM op een lijn staan van 0 tot 64000 - omdat er 8 bits zijn in een byte en je dus 64000 bytes op een 512 Kbit EEPROM kunt passen - dan is een geheugenadres de plaats in regel waar u een bepaalde byte zou vinden. We moeten dat adres naar de EEPROM sturen, zodat deze weet waar de byte die we verzenden moet worden geplaatst.

Meest significante en minst significante bytes

Omdat er 32000 mogelijke plaatsen in een 256 Kbit EEPROM zijn - en omdat 255 het grootste aantal is dat je in één byte kunt coderen - moeten we dit adres in twee bytes verzenden. Eerst sturen we de Most Significant Byte (MSB) - in dit geval de eerste 8 bits. Dan sturen we de Least Significant Byte (LSB) - de tweede 8 bits. Waarom? Omdat dit is hoe het apparaat ze verwacht te ontvangen, dat is alles.

Pagina schrijven

Eén byte per keer schrijven is prima, maar de meeste EEPROM-apparaten hebben een zogenaamde "paginaschrijfbuffer", waarmee u meerdere bytes tegelijk kunt schrijven op dezelfde manier als een enkele byte. We zullen hiervan profiteren in onze voorbeeldschets. De EEPROM gebruikt een interne teller die automatisch de geheugenlocatie verhoogt met elke volgende databyte die het ontvangt. Zodra een geheugenadres is verzonden, kunnen we het volgen met maximaal 64 bytes aan gegevens. De EEPROM gaat er (terecht) van uit dat een adres van 312 gevolgd door 10 bytes byte 0 op adres 312 zal opnemen, byte 1 op adres 313, byte 2 op adres 314, enzovoort.

Lees iets

Het lezen van de EEPROM volgt in principe hetzelfde proces in drie stappen als het schrijven naar de EEPROM:

1. Stuur de meest significante byte van het geheugenadres waarnaar u wilt schrijven.
2. Stuur de minst significante byte van het geheugenadres waarnaar u wilt schrijven.
3. Vraag naar de databyte op die locatie.

Stap 5: Schema's en code

Code:

#erbij betrekken

#define eeprom 0x50 //definieert het basisadres van de EEPROM

ongeldige setup() {

Draad.begin(); // maakt een Wire-object

Serieel.begin(9600);

niet-ondertekend int-adres = 0; //eerste adres van de EEPROM

Serial.println("We schrijven de postcode 22222, een postcode"); for(adres = 0; adres< 5; adres++) writeEEPROM(eeprom, adres, '2'); // Schrijft 22222 naar de EEPROM

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

lege lus() {

/*er zit niets in de loop()-functie omdat we niet willen dat de Arduino herhaaldelijk hetzelfde naar de EEPROM schrijft. We willen alleen een eenmalige schrijfactie, dus de functie loop() wordt vermeden met EEPROM's.*/ }

// definieert de writeEEPROM-functie

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

// definieert de readEEPROM-functie

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