Minule, když jsem psal svou “podrobnou odpověď na otázku” jak zálohovat firmware z Mega, mi vyčítali, že jsem nezmínil zálohu EEPROM. Tehdy jsem to neudělal vědomě, protože... Správně jsem usoudil, že ve fázi prvotního „přiblížení ke střele“ není třeba vše komplikovat. Faktem je, že ne každému je zřejmé, že se neflashuje EEPROM při kompilaci a nahrávání firmwaru z Arduino IDE. To znamená, že při nahrávání firmwaru z IDE se do EEPROM nenahraje absolutně nic. A na úplně jiné úrovni se provádějí manipulace s EEPROM (pokud je její použití ve firmwaru vůbec povoleno). A proto zálohovat holý firmware bez jemné úpravy, který MOŽNO (jen snad) lze uložit do EEPROM, zcela stačilo uložit pouze holý firmware. Ale když vyvstala otázka, proč to „nežvýkat“. Pojďme si to projít popořadě. Co je to EEPROM a proč o tom mluvit?
EEPROM - (Electrically Erasable Programmable Read-Only Memory) oblast trvalé paměti mikrokontroléru, do které lze zapisovat a číst informace. Často se používá k uložení nastavení programu, která se mohou během provozu změnit a musí být uložena po vypnutí napájení.

Jak 3D tiskárna využívá EEPROM?
Podívejme se na Marlin jako příklad.V Marlin Firmware po vybalení se EEPROM nepoužívá.Parametry konfigurátoru (Configuration.h), které zahrnují možnost jej používat, jsou standardně zakomentovány.

#define EEPROM_SETTINGS
#define EEPROM_CHITCHAT

Pokud je povoleno použití EEPROM, tiskárna může ukládat a používat následující nastavení (specifikovaná od buržoazie):

• Počet kroků na milimetr
• Maximální/minimální rychlost posuvu [mm/s]
• Maximální zrychlení [mm/s^2]
• Akcelerace
• Zrychlení při zatahování
• Nastavení PID
• Posun výchozí pozice
• Minimální rychlost posuvu během pohybu [mm/s]
• Minimální doba úseku [ms]
• Maximální rychlostní skok osy X-Y[mm/s]
• Maximální skok rychlosti v ose Z [mm/s]

Tato nastavení můžete upravit pomocí obrazovky a ovládacích prvků tiskárny. Pokud je povoleno používání EEPROM, v nabídce by se měly zobrazit následující položky:

• Uložte paměť
• Načíst paměť
• Obnovit Failsafe

Můžete také použít GCode k přímé práci (přes Pronterface).

• M500 Uloží aktuální nastavení do EEPROM do příštího spuštění nebo příkazu M501.
• M501 Načte nastavení z EEPROM.
• M502 Obnoví nastavení na výchozí hodnoty specifikované v Configurations.h. Pokud po něm spustíte M500, budou do EEPROM vloženy výchozí hodnoty.
• M503 Zobrazuje aktuální nastavení - ""Ta, která jsou uložena v EEPROM.""

O EEPROM si můžete přečíst ve firmwaru Repitier.

Jak číst a zapisovat data do EEPROM?
Podobně jako u metody popsané v metodě zálohování firmwaru pomocí klíče -U. Pouze v tomto případě za ním bude ukazatel indikující, že je třeba načíst EEPROM.

avrdude.exe -p atmega2560 -c kabeláž -PCOM5 -b115200 -Ueeprom:r:"printer_eeprom".eep:i

Tento příkaz načte data EEPROM do souboru "printer_eeprom.eep" Pokud bude úspěšný, uvidíte na obrazovce něco jako následující.

Nahrávání také není složité a provádí se podobným příkazem, který se liší pouze tím v klávese -U Není to "r", ale "w".

avrdude.exe -p atmega2560 -c kabeláž -PCOM5 -b115200 -Ueeprom:w:"printer_eeprom".eep:i

V případě úspěchu se na obrazovce zobrazí něco jako následující zpráva.

Jak a proč vymazat EEPROM?
Pro začátek: "Proč to dělat?" Musíte vymazat EEPROM, pokud ji používal i předchozí firmware a v paměti může zůstat smetí. Někde jsem už narazil na lidi s problémy, že po přechodu z jednoho firmwaru na druhý (z Marlin na Repitier EMNIP) se jejich tiskárna začala chovat takříkajíc „kreativně“. To je způsobeno tím, že různé firmwary ukládají svá data pod různé adresy. A když se pokusíte přečíst data ze špatné adresy, začne pandemonium.
EEPROM můžete vymazat pouze programově z firmwaru, ale k tomu budete muset dočasně nahrát speciální skicu do řadiče. Více si o tom můžete přečíst v oficiální dokumentaci Arduina.
Pokud je EEPROM vymazána, ne Deska Arduino a v některých abstraktních řadičích bude nutné změnit kód náčrtu s ohledem na velikost EEPROM v konkrétním řadiči na desce. Chcete-li to provést, budete muset změnit podmínku ukončení ve smyčce "Pro". Například pro ATmega328, který má 1kb EEPROM paměť, bude cyklus vypadat takto:
Závěr.
Blázním už docela dlouho, ale k čemu to všechno je? Abychom došli k závěru, že při zálohování firmwaru lze uložit i EEPROM, ale pouze pokud potřebujete nastavení v ní uložené. Pokud jste připraveni je obětovat, pak na to zapomeňte. Také, pokud změníte jeden firmware na jiný nebo přejdete z verze na jinou, nebuďte líní vymazat EEPROM před nahráním nový firmware. No a zároveň jsme se naučili spoustu nových věcí.

Náš regulátor pece je téměř připraven - prozatím však zůstává regulátorem „zlaté rybky“, který si pamatuje všechna nastavení pouze pět minut před prvním vypnutím. Pro zapamatování našeho nastavení, hodnoty nastavené teploty a kalibračních bodů i po vypnutí napájení je potřeba použít energeticky nezávislou paměť - EEPROM.
Naši přátelé napsali velmi dobře o práci s EEPROM.

Hlavní věc, kterou potřebujeme vědět, je to Paměť EEPROM Je lepší to považovat ne za „jen paměť“, ale jako samostatné interní zařízení v čipu.
EEPROM samostatný adresní prostor, který nemá nic společného s adresním prostorem procesoru (FLASH a SRAM); abyste získali přístup k datům na konkrétní adrese v energeticky nezávislé paměti, musíte provést určitou sekvenci akce pomocí řady registrů (adresní registry EEARH a EEARL, datový registr EEDR a řídicí registr EECR).
Podle datového listu, abyste zapsali bajt na konkrétní adresu do EEPROM, musíte provést následující:

1. počkejte, až bude EEPROM připravena k zápisu dat (bit EEPE registru EECR je resetován);
2. počkejte na konec zápisu do FLASH paměti (resetování bitu SELFPRGEN registru SPMCSR) - to je nutné provést, pokud je v programu přítomen bootloader;
3. zapsat nová adresa do registru EEAR (v případě potřeby);
4. zapsat datový bajt do registru EEDR (je-li to nutné);
5. nastavte bit EEMPE registru EECR na jedničku;
6. do čtyř hodinových cyklů po nastavení příznaku EEMPE zapíšeme do bitu EEPE registru EECR logickou jedničku.

Procesor poté přeskočí 2 hodinové cykly před provedením další instrukce.
Druhý bod je nutné provést, pokud je v programu bootloader - faktem je, že zápis do EEPROM nelze provádět současně se zápisem do FLASH paměti, takže před zápisem do EEPROM je třeba se ujistit, že je dokončeno programování FLASH paměti; pokud mikrokontrolér nemá bootloader, pak nikdy nemění obsah FLASH paměti (nezapomeňte, že avr má architekturu Harvard: programová paměť (FLASH) a datová paměť (SRAM) jsou odděleny).
Délka záznamového cyklu závisí na frekvenci vnitřního RC oscilátoru čipu, napájecím napětí a teplotě; obvykle u modelů ATmega48x/88x/168x je to 3,4 ms (!), u některých starších modelů – 8,5 ms (!!!).
Navíc při zápisu do EEPROM mohou nastat problémy s voláním přerušení při provádění sekvence výše uvedených akcí - proto je lepší přerušení během zápisu do EEPROM zakázat.
Čtení energeticky nezávislé paměti je o něco jednodušší:

1. počkejte, až bude EEPROM připravena ke čtení dat (vynuluje se bit EEWE registru EECR);
2. napište adresu do registru EEAR;
3. nastavte bit EERE registru EECR na jedničku;
4. čteme data z registru EEDR (ve skutečnosti, když se požadovaná data přesunou do registru dat, stane se to tvrdý restart bit EERE; ale není potřeba hlídat stav tohoto bitu, jelikož operace čtení z EEPROM probíhá vždy v jednom hodinovém cyklu).

Po nastavení bitu v EERE na jedničku procesor přeskočí 4 takty před provedením další instrukce.
Jak vidíme, práce s energeticky nezávislá paměť– proces je časově náročný; pokud často zapisujeme a čteme data z EEPROM, program se může začít zpomalovat.

Píšeme však program v prostředí IAR a máme štěstí: veškerou práci se čtením a zápisem z EEPROM provede vývojové prostředí – iar má modifikátor „__eeprom“, který vytváří proměnné v energeticky nezávislé paměti - a pak nám bude stačit číst z "trvalých" proměnných na "aktuální" (při inicializaci regulátoru), nebo zapisovat z "aktuálních" proměnných do "konstanty" - to znamená, když se změní aktuální hodnota, hodnota musí být také změněna proměnná v energeticky nezávislé paměti.
Nové proměnné budou vypadat takto:

Eeprom uint16_t EEP_MinTemperature;

Pár obecnějších slov: a přestože nepředpokládáme ukazatele na proměnné eeprom, musíme si pamatovat, že eeprom je samostatný adresní prostor, a abychom vytvořili ukazatel na eeprom (a kompilátor nám to umožňuje), musí uvádět, že se jedná o ukazatel na adresu v eeprom:

Uint16_t __eeprom *EEP_MinTemperatureAdr;

Vraťme se k ovladači kamen a EEPROM. V našem případě není žádná EEPROM virtuální stroj se samozřejmě neočekává; Navíc stojí za zvážení, zda je pro práci s energeticky nezávislou pamětí potřeba samostatná knihovna – jsou příliš „rozptýlené“ v nahrávacím programu důležitá nastavení; pokud se pokusíte vytvořit samostatnou knihovnu, budete muset provést křížové odkazy: v knihovně pro EEPROM připojte knihovny ADC, topného článku a globálního nastavení; a v těchto periferních knihovnách není připojení knihovny EEPROM příliš dobrým přístupem.
Další možností je přidat proměnnou eeprom do každé knihovny, kde potřebujete uložit nastavení, a uložit odpovídající nastavení přímo do virtuální stroje. Tuto možnost implementujeme.
Nejprve si uveďme, jaké proměnné musíme uložit do EEPROM:

1. kalibrační body
2. hodnoty maximální-minimální nastavené teploty a kroku nastavení teploty
3. nastavenou hodnotu teploty
4. Koeficienty PID regulátoru

Hodnotu kuchyňského časovače neukládáme - budeme předpokládat, že uživatel musí nastavit časovač sporáku pokaždé po vypnutí napájení.
Všechna tato nastavení nastavuje uživatel otočením enkodéru a následným krátkým stisknutím uživatelského tlačítka. Zároveň pamatujeme, že počet cyklů čtení-zápis EEPROM je stále omezený, proto nepřepisujte znovu stejné informace (např. pokud uživatel zvolil stejnou hodnotu některého nastavení, jako byla). Proto před každou změnou proměnné __eeprom zkontrolujeme, zda není potřeba ji přepsat:

//pokud se hodnota změnila, přepište ji do energeticky nezávislé paměti, pokud (ADCTemperature.atMinTemperatureValue != (uint16_t)VMEncoderCounter.ecntValue) (ADCTemperature.atMinTemperatureValue = (uint16_t)ADCTer​MencatureVCounter.EP MinTemperatureV hodnota; )

Čtení nastavení z EEPROM je také jednoduché - při inicializaci „aktuálního“ nastavení jednoduše načteme hodnotu z energeticky nezávislé paměti:

ADCTemperature.atMinTemperatureValue = EEP_MinTemperature;

Aby naše zařízení mělo hned od začátku nějaká nastavení v EEPROM, lze projekt pro první spuštění zkompilovat s inicializovanými těmito proměnnými:

Eeprom uint16_t EEP_MinTemperature = 20; ... //pole pro ukládání kalibračních bodů do energeticky nezávislé paměti __eeprom TCalibrationData EEP_CalibrationData = ((20, 1300), (300, 4092));

V tomto případě kompilátor před zahájením práce s hlavní funkcí inicializuje proměnné __eeprom. Chcete-li získat soubor s energeticky nezávislou pamětí (.eep), musíte přejít do následujících nastavení:
Project->Options..->Linker->Extra Options
Pokud není zaškrtávací políčko „Použít možnosti příkazového řádku“ zaškrtnuté, zaškrtněte jej a přidejte řádek
-Ointel-standard,(XDATA)=.eep
Nejprve zkompilujeme projekt s inicializovanými proměnnými, samostatně uložíme soubor eep; pak odstraníme inicializaci při vytváření proměnných.

To je vše - náš sporák je připraven!

Arduino je celá rodina různá zařízení pro tvorbu elektronických projektů. Mikrokontroléry se velmi pohodlně používají a snadno se s nimi naučí i začátečník. Každý mikrokontrolér se skládá z desky, programů pro obsluhu a paměti. Tento článek se podívá na energeticky nezávislou paměť používanou v Arduinu.

Popis paměti EEPROM

Arduino poskytuje svým uživatelům tři typy vestavěné paměti zařízení: stacionární RAM (paměť s náhodným přístupem nebo SRAM - statická paměť s náhodným přístupem) - nezbytná pro záznam a ukládání dat během používání; flash karty – pro ukládání již nahraných vzorů; – pro uložení a následné použití dat.

Všechna data v paměti RAM se vymažou, jakmile se zařízení restartuje nebo se vypne napájení. Druhé dva ukládají všechny informace před přepsáním a umožňují vám je v případě potřeby získat. Flash disky jsou v dnešní době zcela běžné. Paměti EEPROM stojí za zvážení podrobněji.

Zkratka znamená Electrically Erasable Programmable Read-Only Memory a v překladu do ruštiny doslova znamená elektricky vymazatelná programovatelná paměť pouze pro čtení. Výrobce garantuje bezpečnost informací několik desítek let od posledního výpadku proudu (obvykle se udává doba 20 let v závislosti na rychlosti snižování nabití zařízení).

Musíte však vědět, že možnost přepisu na zařízení je omezená a není více než 100 000krát. Proto se doporučuje dávat pozor na zadávané údaje a znovu je nepřepisovat.

Velikost paměti je ve srovnání s moderními médii velmi malá a liší se pro různé mikrokontroléry. Například pro:

• ATmega328 – 1kB
• ATmega168 a ATmega8 – 512 bajtů,
• a ATmega1280 – 4 kB.

Je navržen tímto způsobem, protože každý mikrokontrolér je navržen pro konkrétní objem úloh, má jiný počet kolíků pro připojení, a proto je vyžadováno jiné množství paměti. Tato částka je navíc dostatečná pro běžně vytvářené projekty.

Zápis do EEPROM vyžaduje značné množství času - cca. 3 ms. Pokud během nahrávání vypnete napájení, data se neuloží vůbec nebo mohou být zaznamenána nesprávně. Vždy je nutné dodatečně zkontrolovat zadané informace, aby nedocházelo k poruchám při provozu. Čtení dat je mnohem rychlejší a paměťové zdroje se nesnižují.

Knihovna

Práce s pamětí EEPROM se provádí pomocí knihovny, která byla speciálně vytvořena pro Arduino. Mezi hlavní patří schopnost zapisovat a číst data. aktivován příkazem #include EEPROM.h.

• Pro evidence– EEPROM.write(adresa, data);
• Pro čtení– EEPROM.read(adresa).

V těchto náčrtech: adresa – argument s daty buňky, do které se zadávají data druhého argumentu; při čtení se používá jeden argument, adresa, který udává, odkud se má informace číst.

Funkce	Účel
číst (adresa)	přečte 1 bajt z EEPROM; adresa – adresa, ze které se načítají data (buňka začínající od 0);
napsat (adresa, hodnota)	zapíše hodnotu (1 byte, číslo od 0 do 255) do paměti na adresu;
aktualizace (adresa, hodnota)	nahradí hodnotu na adrese, pokud se její starý obsah liší od nového;
získat (adresa, data)	čte data zadaného typu z paměti na adrese;
vložit (adresa, údaje)	zapisuje data zadaného typu do paměti na adresu;
EEPROM	umožňuje použít identifikátor "EEPROM" jako pole pro zápis dat a čtení z paměti.

Zápis celých čísel

Zápis celých čísel do energeticky nezávislé paměti EEPROM je poměrně jednoduchý. K zadávání čísel dochází při spuštění funkce EEPROM.write(). Požadované údaje jsou uvedeny v závorkách. V tomto případě se čísla od 0 do 255 a čísla nad 255 zapisují odlišně. První se zadávají jednoduše - jejich objem zabírá 1 bajt, tedy jednu buňku. Chcete-li zapsat druhý bajt, musíte použít operátory highByte() pro nejvyšší bajt a lowByte() pro nejnižší bajt.

Číslo se rozdělí na bajty a zapíše se samostatně do buněk. Například číslo 789 bude zapsáno do dvou buněk: první bude obsahovat faktor 3 a druhá bude obsahovat chybějící hodnotu. Výsledkem je požadovaná hodnota:

3 * 256 + 21 = 789

Pro « reunion" platí velké celé číslo funkce slova(): int val = slovo (ahoj, nízké). Musíte si přečíst, že maximální celé číslo pro záznam je 65536 (tj. 2 na 16). V buňkách, které ještě neměly jiné položky, monitor zobrazí čísla 255 v každé z nich.

Zápis čísel a řetězců s plovoucí desetinnou čárkou

Čísla s plovoucí desetinnou čárkou a řetězcová čísla jsou formou zápisu reálných čísel, kde jsou reprezentována mantisou a exponentem. Taková čísla se zapisují do energeticky nezávislé paměti EEPROM aktivací funkce EEPROM.put(), respektive čtení, – EEPROM.get().

Při programování jsou číselné hodnoty s plovoucí desetinnou čárkou označeny jako float; stojí za zmínku, že se nejedná o příkaz, ale o číslo. Typ znaku (typ znaku) – používá se k reprezentaci řetězců. Proces zápisu čísel na monitor se spouští pomocí setup(), čtení - pomocí loop().

Během procesu se na obrazovce monitoru mohou objevit hodnoty ovf, což znamená „přeplněno“ a nan, což znamená „chybějící“. číselná hodnota" To znamená, že informace zapsané do buňky nelze reprodukovat jako číslo s plovoucí desetinnou čárkou. Tato situace nenastane, pokud budete spolehlivě vědět, ve které buňce je jaký typ informace zaznamenán.

Příklady projektů a skic

Příklad č. 1

Skica zapíše až 16 znaků ze sériového portu a vyšle 16 znaků z EEPROM ve smyčce. Díky tomu se data zapisují do EEPROM a hlídá se obsah energeticky nezávislé paměti.

// kontrola fungování EEPROM #include int i, d; void setup() ( Serial.begin(9600); // inicializace portu, rychlost 9600 ) void loop() ( // čtení EEPROM a výstup 16 dat na sériový port Serial.println(); Serial.print("EEPROM = "); i= 0; while(i< 16) { Serial.print((char)EEPROM.read(i)); i++; } // проверка есть ли данные для записи if (Serial.available() != 0) { delay(50); // ожидание окончания приема данных // запись в EEPROM i= 0; while(i < 20) { d= Serial.read(); if (d == -1) d= " "; // если символы закончились, заполнение пробелами EEPROM.write(i, (byte)d); // запись EEPROM i++; } } delay(500); }

Příklad č. 2

Pro lepší pochopení si můžeme vytvořit malou skicu, která pomůže pochopit, jak pracovat s energeticky nezávislou pamětí. Počítáme všechny buňky této paměti. Pokud buňka není prázdná - výstup na sériový port. Poté vyplňte buňky mezerami. Poté zadáme text přes monitor sériového portu. Zapíšeme ji do EEPROM a přečteme ji při příštím zapnutí.

#zahrnout int adresa = 0; // adresa eeprom int read_value = 0; // data načtená z eeprom char serial_in_data; // data sériového portu int led = 6; // řádek 6 pro LED int i; void setup() ( pinMode(led, OUTPUT); // řádek 6 je nakonfigurován jako výstup Serial.begin(9600); // přenosová rychlost na sériovém portu 9600 Serial.println(); Serial.println("PŘEDCHOZÍ TEXT V EEPROM : -"); for(adresa = 0; adresa< 1024; address ++) // считываем всю память EEPROM { read_value = EEPROM.read(address); Serial.write(read_value); } Serial.println(); Serial.println("WRITE THE NEW TEXT: "); for(address = 0; address < 1024; address ++) // заполняем всю память EEPROM пробелами EEPROM.write(address, " "); for(address = 0; address < 1024;) // записываем пришедшие с последовательного порта данные в память EEPROM { if(Serial.available()) { serial_in_data = Serial.read(); Serial.write(serial_in_data); EEPROM.write(address, serial_in_data); address ++; digitalWrite(led, HIGH); delay(100); digitalWrite(led, LOW); } } } void loop() { //---- мигаем светодиодом каждую секунду -----// digitalWrite(led, HIGH); delay(1000); digitalWrite(led, LOW); delay(1000); }

Příklad č. 3

Zapíše dvě celá čísla do paměti, načte je z EEPROM a odešle je na sériový port. Čísla od 0 do 255 zabírají pomocí funkce 1 bajt paměti EEPROM.write() jsou zapsány do požadované buňky. Pro čísla větší než 255 je třeba je rozdělit na bajty pomocí highByte() A lowByte() a zapsat každý bajt do vlastní buňky. Maximální počet je v tomto případě 65536 (nebo 2 16).

#zahrnout // připojení knihovny EEPROM void setup() ( int smallNum = 123; // celé číslo od 0 do 255 EEPROM.write(0, smallNum); // zapsání čísla do buňky 0 int bigNum = 789; // rozdělení čísla > 255 x 2 bajty (max. 65536) byte hi = highByte(bigNum); // vysoký byte byte low = lowByte(bigNum); // low byte EEPROM.write(1, hi); // zápis vysokého bajtu EEPROM do buňky 1 .write(2, low); // zapsat dolní bajt do buňky 2 Serial.begin(9600); // inicializovat sériový port ) void loop() ( for (int addr=0; addr<1024; addr++) { // для всех ячеек памяти (для Arduino UNO 1024) byte val = EEPROM.read(addr); // считываем 1 байт по адресу ячейки Serial.print(addr); // выводим адрес в послед. порт Serial.print("\t"); // табуляция Serial.println(val); // выводим значение в послед. порт } delay(60000); // задержка 1 мин }

Příklad č. 4

Zápis čísel a řetězců s plovoucí desetinnou čárkou - metoda EEPROM.put(). Čtení – EEPROM.get().

#zahrnout // připojení knihovny void setup() ( int addr = 0; // adresa float f = 3.1415926f; // číslo s pohyblivou řádovou čárkou (typ float) EEPROM.put(addr, f); // zapište číslo f do adresy addr addr += sizeof(float); // vypočítat další volnou paměťovou buňku char name = "Ahoj, SolTau.ru!"; // vytvořit pole znaků EEPROM.put(addr, name); // zapsat pole do EEPROM Serial.begin (9600); // inicializace sériového portu ) void loop() ( for (int addr=0; addr<1024; addr++) { // для всех ячеек памяти (1024Б=1кБ) Serial.print(addr); // выводим адрес в послед. порт Serial.print("\t"); // табуляция float f; // переменная для хранения значений типа float EEPROM.get(addr, f); // получаем значение типа float по адресу addr Serial.print(f, 5); // выводим с точностью 5 знаков после запятой Serial.print("\t"); // табуляция char c; // переменная для хранения массива из 20 символов EEPROM.get(addr, c); // считываем массив символов по адресу addr Serial.println(c); // выводим массив в порт } delay(60000); // ждём 1 минуту }

Příklad č. 5

Použití EEPROM jako pole.

#zahrnout void setup() ( EEPROM = 11; // zápis 1. buňky EEPROM = 121; // zápis 2. buňky EEPROM = 141; // zápis 3. buňky EEPROM = 236; // zápis 4. buňky Serial .begin(9600 ); ) void loop() ( for (int addr=0; addr<1024; addr++) { Serial.print(addr); Serial.print("\t"); int n = EEPROM; // считываем ячейку по адресу addr Serial.println(n); // выводим в порт } delay(60000); }

Práce s EEPROM

Jak již bylo zmíněno, paměť EEPROM je omezená. Chcete-li prodloužit životnost energeticky nezávislé paměti, místo funkce write() je lepší použít funkci update. V tomto případě se přepis provede pouze pro ty buňky, kde se hodnota liší od nově zapsané.

Další užitečnou funkcí dotyčné paměti mikrokontroléru je schopnost používat bajtové úložné buňky jako součásti integrovaného pole EEPROM. V jakémkoli formátu použití je nutné neustále sledovat integritu zaznamenávaných dat.

Taková paměť na Arduinu standardně ukládá to nejdůležitější pro chod ovladače a zařízení. Pokud je například regulátor teploty vytvořen na takovém základě a počáteční údaje se ukáží jako chybné, zařízení bude fungovat „neadekvátně“ stávajícím podmínkám - velmi podcení nebo nadhodnotí teplotu.

Existuje několik situací, kdy EEPROM obsahuje nesprávná data:

1. Při počáteční aktivaci ještě nebyly žádné záznamy.
2. Během nekontrolovaného výpadku proudu nebudou některá nebo všechna data zaznamenána nebo budou zaznamenána nesprávně.
3. Po dokončení případných cyklů přepisu dat.

Aby se předešlo nepříjemným následkům, lze zařízení naprogramovat na několik možností akce: použít data nouzového kódu, úplně vypnout systém, signalizovat poruchu, použít dříve vytvořenou kopii nebo jiné.

Ke kontrole integrity informací se používá systémový řídicí kód. Vytváří se na základě původního záznamu dat a po ověření data přepočítá. Pokud je výsledek jiný, jedná se o chybu. Nejběžnější verzí takové kontroly je kontrolní součet – provede se jednoduchá matematická operace pro sečtení všech hodnot buněk.

Zkušení programátoři k tomuto kódu přidávají další „exkluzivní OR“, například E5h. Pokud jsou všechny hodnoty rovny nule a systém omylem resetoval původní data, tento trik odhalí chybu.

Toto jsou základní principy práce s energeticky nezávislou pamětí EEPROM pro mikrokontroléry Arduino. Pro určité projekty se vyplatí používat pouze tento typ paměti. Má to své výhody i nevýhody. Pro zvládnutí metod psaní a čtení je lepší začít s jednoduchými úkoly.

Všechny mikrokontroléry řady Mega obsahují energeticky nezávislou paměť ( EEPROM Paměť). Objem této paměti se pohybuje od 512 bajtů u modelů ATmega8x do 4 KB u starších modelů. EEPROM paměť je umístěna ve vlastním adresním prostoru a stejně jako RAM je organizována lineárně. Pracovat s EEPROM Paměť využívá tři I/O registry: adresový registr, datový registr a řídicí registr.

Registr adres

Registr adres EEPROM Paměť EEAR (registr adres EEPROM) fyzicky umístěn ve dvou RVV EEARH:EEARL, který se nachází podél
adresy $1F ($3F) a $1E ($3E). Tento registr je načten s adresou buňky, ke které se bude přistupovat. Adresový registr je zapisovatelný i čitelný. Zároveň v rejstříku EEARH jsou použity pouze nejméně významné bity (počet bitů závisí na objemu EEPROM Paměť). Nepoužité bity registru EEARH jsou pouze pro čtení a obsahují "0".

Registr dat

Registr dat EEPROM Paměť EEDR (registr dat EEPROM) na $1D ($3D). Při zápisu do tohoto registru se načtou data, která by měla být umístěna EEPROM, a při čtení se data čtou z EEPROM.

Kontrolní registr

Kontrolní registr EEPROM Paměť EECR (Řídicí registr EEPROM) se nachází na $ 1C ($ 3C). Tento registr se používá pro
Řízení přístupu EEPROM Paměť. Jeho popis je uveden v tabulce níže:

Vybít	název	Popis
7..4	-	nepoužívá se, čtěte jako "0"
3	DĚSIVÝ	Povolit přerušení z EEPROM. Tento bit řídí generování přerušení, ke kterému dojde po dokončení cyklu zápisu EEPROM. Pokud je tento bit nastaven na "1", přerušení jsou povolena (pokud je příznak I registru SREG je také nastaven na "1"). Když je bit EEWE vymazán (viz dále v tabulka) přerušení je generováno neustále
2	EEMWE	Řízení oprávnění k zápisu do EEPROM. Stav tohoto bitu určuje činnost příznaku povolení zápisu EEWE. Pokud je tento bit nastaven na „1“, pak se při zápisu do EEWE bitu „1“ zapisují data do EEPROM. Jinak nastavení EEWE na "1" nemá žádný účinek. Po instalaci softwaru je bit EEMWE resetován pomocí hardwaru přes 4 strojní cykly
1	EEWE	Povolit zápis do EEPROM. Když je tento bit nastaven na „1“, data se zapisují do EEPROM (pokud je EEMWE rovno „1“).
0	EERE	Oprávnění ke čtení z EEPROM. Po nastavení tohoto bitu na „1“ se data načtou z EEPROM. Po dokončení čtení je tento bit hardwarově resetován

K zápisu jednoho bajtu do EEPROM potřebujete:

1. Počkejte, až bude EEPROM připravena k zápisu dat (vyčkejte, dokud nebude resetován příznak EEWE registru EECR).

2. Počkejte na dokončení zápisu do paměti programu FLASH (vyčkejte, dokud nebude resetován příznak SPMEN registru SPMCR).

3. Načtěte datový bajt do registru EEDR a požadovanou adresu do registru EEAR (je-li to nutné).

4. Nastavte příznak EEMWE registru EECR na „1“.

5. Zapište protokol do bitu EEWE registru EECR. "1" pro 4 strojní cykly. Po instalaci tohoto bitu procesor
přeskočí 2 strojové cykly před provedením další instrukce.

Ke čtení jednoho bajtu z EEPROM potřebujete:

1. Zkontrolujte stav vlajky EEWE. Faktem je, že zatímco probíhá operace zápisu do paměti EEPROM (je nastaven příznak EEWE), nelze provést čtení paměti EEPROM ani změnu registru adres.

2. Načtěte požadovanou adresu do registru EEAR.

3. Nastavte bit EERE registru EECR na „1“.

Když jsou požadovaná data umístěna do datového registru EEDR, dojde k hardwarovému resetu tohoto bitu. Není však nutné sledovat stav bitu EERE, aby bylo možné určit, kdy je operace čtení dokončena, protože operace čtení z EEPROM je vždy dokončena v jednom strojovém cyklu. Navíc po nastavení bitu EERE na „1“ procesor před spuštěním další instrukce vynechá 4 strojové cykly.

Prostředí AVR Studio GCC má standardní knihovnu pro práci s EEPROM, která je umožněna připojením souboru . Hlavní funkce jsou eeprom_read_byte(), eeprom_write_byte(), eeprom_read_word(), eeprom_write_word(). Napišme si například program pro minipočítadlo od 0 do 9, kde při stisku jednoho tlačítka se přidá hodnota a dalším tlačítkem se tato hodnota uloží do paměti. Mikrokontrolér Atmega8 pracuje z interního generátoru hodin s frekvencí 8 MHz. Jednomístný sedmisegmentový indikátor se společnou anodou je připojen k portu B přes proudově omezující odpory R1-R7, společná anoda je připojena ke zdroji plus. Diagram je zobrazen níže:

Nejprve připojíme knihovny potřebné k provozu včetně EEPROM. Definujte proměnné. Proměnná "s" ukládá hodnotu pro zobrazení na indikátoru, po stisknutí tlačítka SB1 se tato hodnota zvýší o jednu, ale ne více než 10. Proměnná eeprom_var bude interagovat s EEPROM. Po zapnutí napájení se načte EEPROM, načtená data se přiřadí proměnné „s“, na základě toho se na indikátoru zobrazí určité číslo. Když stisknete SB2, data z proměnné „s“ se zapíší do EEPROM a indikátor jednou blikne.

#zahrnout #zahrnout #zahrnout #define d0 ~(0x3F) // 0 #define d1 ~(0x06) // 1 #define d2 ~(0x5B) // 2 #define d3 ~(0x4F) // 3 #define d4 ~(0x66) // 4 #define d5 ~(0x6D) // 5 #define d6 ~(0x7D) // 6 #define d7 ~(0x07) // 7 #define d8 ~(0x7F) // 8 #define d9 ~(0x6F) // 9 unsigned char s; unsigned char eeprom_var EEMEM; // definujte proměnnou v EEPROM int main (void) ( DDRB = 0xFF; // Port B pro výstup PORTB = 0xFF; DDRD = 0x00; // Port D pro vstup PORTD = 0xFF; // Zapněte pull-up rezistory s = eeprom_read_byte(&eeprom_var ); // přečte bajt z EEPROM a vloží jej do "s" while(1) ( if((PIND&(1)<< PD0)) == 0) // если кнопка SB1 нажата { while((PIND&(1 << PD0)) == 0){} // ждем отпускания кнопки s++; // увеличиваем "s" на единицу _delay_ms(200); } if(s == 10) // Когда дойдет до 10 обнуляем "s" { s = 0; } if((PIND&(1 << PD1)) == 0) // если кнопка SB2 нажата { while((PIND&(1 << PD1)) == 0){} // ждем отпускания кнопки DDRB = 0xFF; // мигаем индикатором _delay_ms(200); DDRB = 0x00; _delay_ms(200); DDRB = 0xFF; eeprom_write_byte(&eeprom_var, s); // записываем "s" в EEPROM _delay_ms(200); } if(s==0) // Выводим цифры на индикатор PORTB = d0; if(s==1) PORTB = d1; if(s==2) PORTB = d2; if(s==3) PORTB = d3; if(s==4) PORTB = d4; if(s==5) PORTB = d5; if(s==6) PORTB = d6; if(s==7) PORTB = d7; if(s==8) PORTB = d8; if(s==9) PORTB = d9; } }

Komentáře

0 AntonChip 5. 2. 2013 22:15

Cituji Maxe:

Možná něco pletu, ale pokud máte indikátor s OA, tak stačí jeden rezistor na vedení 5V.Proč za prvkem, který mají chránit před vysokým proudem instalovat odpory omezující proud??

Jen si představte, co se stane, když se jeden segment indikátoru uzavře s tímto a dalším schématem zapojení odporu.

0 AntonChip 15.05.2013 11:16

Cituji gydok:

Jak zapsat dvourozměrné pole do eeprom?

Kód:
#zahrnout // Zahrnout knihovnu

EEMEM unsigned char colors=((1, 2, 3), // Deklarace pole v EEPROM
{4, 5, 6}};

eeprom_write_byte(&barvy, 1); // Zápis prvků pole do EEPROM
eeprom_write_byte(&barvy, 2);
eeprom_write_byte(&barvy, 3);
eeprom_write_byte(&barvy, 4);
eeprom_write_byte(&barvy, 5);
eeprom_write_byte(&barvy, 6);

unsigned char temp;
temp = eeprom_read_byte(&barvy); // Extrahujte prvek pole z EEPROM, 2. řádek(), 1. sloupec(), tzn. číslo 4

Resetování paměti EEPROM

Příklad prochází všechny paměťové buňky a zapisuje do nich nuly.

// Připojení knihovny pro práci s EEPROM. #include "EEPROM.h" void setup() ( // Projděte všechny buňky (bajty) a zapište do nich nuly. for (int i = 0; i< EEPROM.length(); i++) EEPROM.update(i, 0); } void loop() { // Пустой цикл... }

Obnovení továrního nastavení

Pokud chcete paměť vrátit do továrního nastavení, je potřeba 0 nahradit 255, tzn. nezapisujte nuly, ale číslo 255. V budoucnu je tedy možné pomocí funkce isNaN() zkontrolovat, zda byl zápis do paměti EEPROM proveden či nikoliv.

// Připojení knihovny pro práci s EEPROM. #include "EEPROM.h" void setup() ( // Projděte všechny buňky (bajty) a napište do nich čísla 255. for (int i = 0; i< EEPROM.length(); i++) EEPROM.update(i, 255); } void loop() { // Пустой цикл... }

Řekněte nám o nás

Zpráva

Pokud máte zkušenosti s prací s Arduinem a skutečně máte čas na kreativitu, zveme všechny, aby se stali autory článků publikovaných na našem portálu. Mohou to být lekce nebo příběhy o vašich experimentech s Arduinem. Popis různých senzorů a modulů. Rady a návody pro začátečníky. Pište a zveřejňujte své články