Din Arduinos inbyggda EEPROM: 6 steg

2025 Författare: John Day | [email protected]. Senast ändrad: 2025-01-23 15:11

I denna artikel kommer vi att undersöka den interna EEPROM i våra Arduino -kort. Vad är en EEPROM som några av er kanske säger? En EEPROM är ett elektriskt raderbart programmerbart skrivskyddsminne.

Det är en form av icke-flyktigt minne som kan komma ihåg saker när strömmen stängs av eller efter att du har återställt Arduino. Det fina med denna typ av minne är att vi kan lagra data som genereras inom en skiss på en mer permanent basis.

Varför skulle du använda den interna EEPROM? För situationer där data som är unik för en situation behöver ett mer permanent hem. Till exempel att lagra det unika serienumret och tillverkningsdatumet för ett kommersiellt Arduino-baserat projekt-en funktion av skissen kan visa serienumret på en LCD-skärm, eller data kan läsas genom att ladda upp en "serviceskiss". Eller så kan du behöva räkna vissa händelser och inte tillåta användaren att återställa dem-till exempel en vägmätare eller driftscykelräknare.

Steg 1: Vilken typ av data kan lagras?

Allt som kan representeras som databyte. En byte data består av åtta bitar data. En bit kan antingen vara på (värde 1) eller av (värde 0) och är perfekt för att representera tal i binär form. Med andra ord kan ett binärt tal endast använda nollor och ettor för att representera ett värde. Således är binär också känd som bas-2 ″, eftersom det bara kan använda två siffror.

Hur kan ett binärt tal med endast två siffror representera ett större tal? Den använder många enor och nollor. Låt oss undersöka ett binärt tal, säg 10101010. Eftersom detta är ett bas-2-tal, representerar varje siffra 2 till kraften x, från x = 0 och framåt.

Steg 2:

Se hur varje siffra i det binära talet kan representera ett bas-10-tal. Så det binära talet ovan representerar 85 i bas-10-värdet 85 är summan av bas-10-värdena. Ett annat exempel - 11111111 i binär lika med 255 i bas 10.

Steg 3:

Nu använder varje siffra i det binära talet en "bit" minne, och åtta bitar gör en byte. På grund av interna begränsningar hos mikrokontrollerna i våra Arduino-kort kan vi bara lagra 8-bitars nummer (en byte) i EEPROM.

Detta begränsar decimalvärdet för siffran att falla mellan noll och 255. Det är sedan upp till dig att bestämma hur dina data kan representeras med det nummerintervallet. Låt inte det avskräcka dig - siffror ordnade på rätt sätt kan representera nästan vad som helst! Det finns en begränsning att ta hänsyn till - antalet gånger vi kan läsa eller skriva till EEPROM. Enligt tillverkaren Atmel är EEPROM bra för 100 000 läs-/skrivcykler (se databladet).

Steg 4:

Nu vet vi våra bitar och byte, hur många byte kan lagras i vår Arduinos mikrokontroller? Svaret varierar beroende på modell av mikrokontroller. Till exempel:

• Kort med en Atmel ATmega328, som Arduino Uno, Uno SMD, Nano, Lilypad, etc. - 1024 byte (1 kilobyte)
• Kort med en Atmel ATmega1280 eller 2560, till exempel Arduino Mega -serien - 4096 byte (4 kilobyte)
• Kort med en Atmel ATmega168, till exempel den ursprungliga Arduino Lilypad, gamla Nano, Diecimila etc - 512 byte.

Om du är osäker, ta en titt på Arduino hårdvaruindex eller fråga din kortleverantör. Om du behöver mer EEPROM -lagring än vad som är tillgängligt med din mikrokontroller, överväg att använda en extern I2C EEPROM.

Vid denna tidpunkt förstår vi nu vilken typ av data och hur mycket som kan lagras i vår Arduinos EEPROM. Nu är det dags att omsätta detta. Som diskuterats tidigare finns det en begränsad mängd utrymme för våra data. I följande exempel kommer vi att använda ett typiskt Arduino -kort med ATmega328 med 1024 byte EEPROM -lagring.

Steg 5:

För att använda EEPROM krävs ett bibliotek, så använd följande bibliotek i dina skisser:

#inkludera "EEPROM.h"

Resten är väldigt enkel. För att lagra en bit data använder vi följande funktion:

EEPROM.write (a, b);

Parametern a är positionen i EEPROM för att lagra heltalet (0 ~ 255) för data b. I det här exemplet har vi 1024 byte minneslagring, så värdet på a är mellan 0 och 1023. För att hämta en bit data är lika enkelt, använd:

z = EEPROM.read (a);

Där z är ett heltal för att lagra data från EEPROM -positionen a. Nu för att se ett exempel.

Steg 6:

Denna skiss kommer att skapa slumpmässiga nummer mellan 0 och 255, lagra dem i EEPROM, sedan hämta och visa dem på den seriella bildskärmen. Variabeln EEsize är den övre gränsen för din EEPROM -storlek, så (till exempel) skulle detta vara 1024 för en Arduino Uno, eller 4096 för en Mega.

// Arduino intern EEPROM -demonstration

#omfatta

int zz; int EEsize = 1024; // storlek i byte av din brädes EEPROM

void setup ()

{Serial.begin (9600); randomSeed (analogRead (0)); } void loop () {Serial.println ("Skriva slumpmässiga nummer …"); för (int i = 0; i <EEsize; i ++) {zz = random (255); EEPROM.write (i, zz); } Serial.println (); för (int a = 0; a <EEsize; a ++) {zz = EEPROM.read (a); Serial.print ("EEPROM -position:"); Serial.print (a); Serial.print ("innehåller"); Serial.println (zz); fördröjning (25); }}

Utmatningen från den seriella bildskärmen visas, som visas på bilden.

Så där har du det, ett annat användbart sätt att lagra data med våra Arduino -system. Även om det inte är den mest spännande handledningen, är det verkligen en användbar.

Det här inlägget kommer till dig av pmdway.com - allt för tillverkare och elektronikentusiaster, med gratis leverans över hela världen.