De ingebouwde EEPROM van uw Arduino: 6 stappen

2025 Auteur: John Day | [email protected]. Laatst gewijzigd: 2025-01-23 15:01

In dit artikel gaan we de interne EEPROM in onze Arduino-boards onderzoeken. Wat is een EEPROM die sommigen van jullie misschien zeggen? Een EEPROM is een elektrisch wisbaar programmeerbaar alleen-lezen geheugen.

Het is een vorm van niet-vluchtig geheugen dat dingen kan onthouden als de stroom is uitgeschakeld of na het resetten van de Arduino. Het mooie van dit soort geheugen is dat we gegevens die in een schets zijn gegenereerd op een meer permanente basis kunnen opslaan.

Waarom zou je de interne EEPROM gebruiken? Voor situaties waarin gegevens die uniek zijn voor een situatie een meer permanent onderkomen nodig hebben. Bijvoorbeeld het opslaan van het unieke serienummer en de fabricagedatum van een commercieel Arduino-gebaseerd project - een functie van de schets zou het serienummer op een LCD kunnen weergeven, of de gegevens kunnen worden gelezen door een 'serviceschets' te uploaden. Of misschien moet u bepaalde gebeurtenissen tellen en niet toestaan dat de gebruiker ze opnieuw instelt, zoals een kilometerteller of een bedrijfscyclusteller.

Stap 1: Wat voor soort gegevens kunnen worden opgeslagen?

Alles wat kan worden weergegeven als bytes aan gegevens. Eén byte aan gegevens bestaat uit acht gegevensbits. Een bit kan aan (waarde 1) of uit (waarde 0) zijn en is perfect voor het weergeven van getallen in binaire vorm. Met andere woorden, een binair getal kan alleen nullen en enen gebruiken om een waarde weer te geven. Dus binair is ook bekend als "base-2", omdat het slechts twee cijfers kan gebruiken.

Hoe kan een binair getal met alleen het gebruik van twee cijfers een groter getal vertegenwoordigen? Er worden veel enen en nullen gebruikt. Laten we eens kijken naar een binair getal, bijvoorbeeld 10101010. Omdat dit een getal met grondtal 2 is, vertegenwoordigt elk cijfer 2 tot de macht x, vanaf x=0 en later.

Stap 2:

Kijk hoe elk cijfer van het binaire getal een getal met grondtal 10 kan vertegenwoordigen. Dus het bovenstaande binaire getal vertegenwoordigt 85 in basis-10 - de waarde 85 is de som van de basis-10-waarden. Een ander voorbeeld - 11111111 in binair is gelijk aan 255 in basis 10.

Stap 3:

Nu gebruikt elk cijfer in dat binaire getal één 'bit' geheugen en acht bits vormen een byte. Vanwege interne beperkingen van de microcontrollers in onze Arduino-boards, kunnen we alleen 8-bits nummers (één byte) opslaan in de EEPROM.

Dit beperkt de decimale waarde van het getal tot tussen nul en 255. Het is dan aan jou om te beslissen hoe je gegevens kunnen worden weergegeven met dat nummerbereik. Laat dat je niet afschrikken - getallen die op de juiste manier zijn gerangschikt, kunnen bijna alles vertegenwoordigen! Er is één beperking waar u op moet letten: het aantal keren dat we de EEPROM kunnen lezen of schrijven. Volgens de fabrikant Atmel is de EEPROM goed voor 100.000 lees-/schrijfcycli (zie het datablad).

Stap 4:

Nu we onze bits en bytes kennen, hoeveel bytes kunnen er worden opgeslagen in de microcontroller van onze Arduino? Het antwoord varieert afhankelijk van het model van de microcontroller. Bijvoorbeeld:

• Borden met een Atmel ATmega328, zoals Arduino Uno, Uno SMD, Nano, Lilypad, etc. – 1024 bytes (1 kilobyte)
• Borden met een Atmel ATmega1280 of 2560, zoals de Arduino Mega-serie – 4096 bytes (4 kilobytes)
• Borden met een Atmel ATmega168, zoals de originele Arduino Lilypad, oude Nano, Diecimila etc – 512 bytes.

Als je het niet zeker weet, kijk dan eens in de Arduino-hardware-index of vraag het je boardleverancier. Als u meer EEPROM-opslag nodig heeft dan beschikbaar is met uw microcontroller, overweeg dan om een externe I2C EEPROM te gebruiken.

Op dit punt begrijpen we nu wat voor soort gegevens en hoeveel er kunnen worden opgeslagen in de EEPROM van onze Arduino. Nu is het tijd om dit in praktijk te brengen. Zoals eerder besproken, is er een eindige hoeveelheid ruimte voor onze gegevens. In de volgende voorbeelden gebruiken we een typisch Arduino-bord met de ATmega328 met 1024 bytes aan EEPROM-opslag.

Stap 5:

Om de EEPROM te gebruiken, is een bibliotheek vereist, dus gebruik de volgende bibliotheek in uw schetsen:

#include "EEPROM.h"

De rest is heel eenvoudig. Om een stukje data op te slaan, gebruiken we de volgende functie:

EEPROM.schrijven (a, b);

De parameter a is de positie in de EEPROM om het gehele getal (0~255) van gegevens b op te slaan. In dit voorbeeld hebben we 1024 bytes geheugenopslag, dus de waarde van a ligt tussen 0 en 1023. Om een stuk gegevens op te halen is net zo eenvoudig, gebruik:

z = EEPROM.lezen(a);

Waarbij z een geheel getal is om de gegevens van de EEPROM-positie a op te slaan. Nu om een voorbeeld te zien.

Stap 6:

Deze schets maakt willekeurige getallen tussen 0 en 255, slaat ze op in de EEPROM, haalt ze op en geeft ze weer op de seriële monitor. De variabele EEsize is de bovengrens van je EEPROM-grootte, dus (bijvoorbeeld) dit zou 1024 zijn voor een Arduino Uno, of 4096 voor een Mega.

// Arduino interne EEPROM-demonstratie

#erbij betrekken

int zz; int EEgrootte = 1024; // grootte in bytes van de EEPROM van je bord

ongeldige setup()

{ Serieel.begin (9600); randomSeed(analogRead(0)); } void loop() { Serial.println ("Writing random numbers…"); for (int i = 0; i < EEsize; i++) { zz=random(255); EEPROM.schrijven (i, zz); } Serieel.println(); for (int a=0; a < EEsize; a++) { zz = EEPROM.read(a); Serial.print ("EEPROM-positie: "); Serieafdruk(a); Serial.print(" bevat "); Serieel.println(zz); vertraging(25); } }

De uitvoer van de seriële monitor verschijnt, zoals weergegeven in de afbeelding.

Dus daar heb je het, nog een handige manier om gegevens op te slaan met onze Arduino-systemen. Hoewel het niet de meest opwindende tutorial is, is het zeker een nuttige.

Dit bericht aangeboden door pmdway.com - alles voor makers en elektronica-enthousiastelingen, met gratis levering wereldwijd.