Sist gang, da jeg skrev mitt "detaljerte svar på spørsmålet" om hvordan jeg skulle sikkerhetskopiere fastvaren fra Mega, bebreidet de meg for ikke å nevne EEPROM-sikkerhetskopien. Den gangen gjorde jeg det ikke bevisst, fordi... Jeg bedømte med rette at det ikke er nødvendig å komplisere alt på stadiet av den første "tilnærmingen til prosjektilet." Faktum er at det ikke er åpenbart for alle at EEPROM ikke blinker når man kompilerer og laster opp fastvaren fra Arduino IDE. Det vil si at dette betyr at absolutt ingenting lastes opp til EEPROM når fastvaren lastes opp fra IDE. Og manipulasjoner med EEPROM (hvis bruken er aktivert i fastvaren i det hele tatt) utføres på et helt annet nivå. Og derfor å sikkerhetskopiere bar firmware uten finjusteringer, som MULIG (bare kanskje) kan lagres i EEPROM, var det nok til å lagre bare den bare firmware. Men siden spørsmålet har oppstått, hvorfor ikke "tygge" det. La oss gå gjennom det i rekkefølge. Hva er EEPROM og hvorfor snakke om det?
EEPROM - (Electrically Erasable Programmable Read-Only Memory) område av det ikke-flyktige minnet til mikrokontrolleren der informasjon kan skrives og leses. Den brukes ofte til å lagre programinnstillinger som kan endres under drift og som må lagres når strømmen slås av.

Hvordan bruker en 3D-skriver EEPROM?
La oss se på Marlin som et eksempel I Marlin Firmware ut av esken brukes ikke EEPROM Konfiguratorparametrene (Configuration.h), som inkluderer muligheten til å bruke den, kommenteres som standard.

#define EEPROM_SETTINGS
#define EEPROM_CHITCHAT

Hvis bruk av EEPROM er aktivert, kan skriveren lagre og bruke følgende innstillinger (spesifisert fra borgerskapet):

• Antall skritt per millimeter
• Maksimal/minimum matehastighet [mm/s]
• Maksimal akselerasjon [mm/s^2]
• Akselerasjon
• Akselerasjon under tilbaketrekking
• PID-innstillinger
• Forskyvning av utgangsposisjon
• Minimum matehastighet under bevegelse [mm/s]
• Minimum seksjonstid [ms]
• Maksimal hastighet hopp X-Y akser[mm/s]
• Maksimal hastighetshopp i Z-aksen [mm/s]

Du kan redigere disse innstillingene ved å bruke skriverskjermen og kontrollene. Når bruk av EEPROM er aktivert, skal menyen vise følgende elementer:

• Lagre minne
• Last inn minne
• Gjenopprett feilsikkert

Du kan også bruke GCode til å jobbe direkte (via Proninterface).

• M500 Lagrer gjeldende innstillinger i EEPROM til neste oppstart eller kommando M501.
• M501 Leser innstillinger fra EEPROM.
• M502 Tilbakestiller innstillingene til standardverdiene spesifisert i Configurations.h. Hvis du kjører M500 etter den, vil standardverdiene legges inn i EEPROM.
• M503 Viser gjeldende innstillinger - ""De som er tatt opp i EEPROM.""

Du kan lese om EEPROM i Repitier-firmware.

Hvordan lese og skrive data til EEPROM?
Ligner på metoden beskrevet i fasved å bruke nøkkelen -U. Bare i dette tilfellet, etter det, vil det være en peker som indikerer at EEPROM må leses.

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

Denne kommandoen leser EEPROM-dataene inn i filen "printer_eeprom.eep".Hvis vellykket, vil du se noe sånt som følgende på skjermen.

Opptak er heller ikke komplisert og utføres av en lignende kommando, som bare skiller seg ut i nøkkelen -U Det er ikke "r", men "w".

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

Hvis det lykkes, vil du se noe sånt som følgende melding på skjermen.

Hvordan og hvorfor slette EEPROM?
Til å begynne med, "hvorfor gjøre dette?" Du må slette EEPROM hvis den forrige fastvaren også brukte den, og det kan være søppel igjen i minnet. Et sted har jeg allerede støtt på folk med problemer som etter å ha byttet fra en firmware til en annen (fra Marlin til Repitier EMNIP), begynte skriveren deres å oppføre seg så å si "kreativt". Dette skyldes det faktum at forskjellig firmware lagrer dataene deres under forskjellige adresser. Og når du prøver å lese data fra feil adresse, begynner pandemonium.
Du kan slette EEPROM bare programmatisk fra fastvaren, men for å gjøre dette må du midlertidig laste opp en spesiell skisse til kontrolleren. Du kan lese mer om dette i den offisielle Arduino-dokumentasjonen.
Hvis EEPROM er slettet ikke i Arduino-brett, og i noen abstrakte kontroller, må skissekoden endres under hensyntagen til størrelsen på EEPROM i en spesifikk kontroller på brettet. For å gjøre dette, må du endre sluttbetingelsen i "For"-løkken. For eksempel, for ATmega328, som har 1kb EEPROM-minne, vil syklusen se slik ut:
Konklusjon.
Jeg har ruslet en stund, men hva er alt dette for noe? For å konkludere med at når du sikkerhetskopierer fastvaren, kan EEPROM også lagres, men bare hvis du trenger innstillingene som er lagret i den. Hvis du er klar til å ofre dem, så glem det. Hvis du endrer en fastvare til en annen, eller bytter fra en versjon til en annen, må du ikke være lat med å tømme EEPROM før du laster opp ny fastvare. Vel, samtidig lærte vi mye nytt.

Leksjon 15

Del 1

Innvendig ikke-flyktig minne EEPROM

Jeg tror kanskje ikke alle, men mange vet det i AVR-kontrollere, i tillegg til de viktigste tilfeldig tilgang minne, i tillegg til minne for lagring av fastvare, er det også ikke-flyktig minne som EEPROM. Dette minnet er laget ved hjelp av teknologien for elektrisk sletting av informasjon, som, i motsetning til forgjengeren EPROM, der sletting bare ble utført ved bruk av ultrafiolette stråler, gjorde det mulig å bruke denne typen minne nesten overalt. Som vi vet finnes det også ikke-flyktig minne som Flesh, som er mye billigere, men som også har en betydelig ulempe. Der er det umulig å slette en enkelt byte; sletting utføres bare i blokker, noe som ikke er helt praktisk i noen tilfeller, spesielt når lite informasjon må lagres, og denne informasjonen representerer små innstillingsparametere. Derfor bør vi også stoppe kl denne typen hukommelse. Og ikke bare fordi den er til stede i kontrolleren, men fordi den er veldig praktisk for å lagre noen mengder som vi trenger selv etter at kontrolleren har mistet strømmen.

Siden vi jobber med Atmega8A-kontrolleren, vil vi åpne den tekniske dokumentasjonen til denne MK og se der at vi har totalt 512 byte med slikt minne. Dette er imidlertid ikke så lite. Hvis vi for eksempel programmerer en slags vekkerklokke slik at innstillingsdataene ikke går tapt etter at strømmen slås av, kan vi enkelt henvise til dette minnet. Det sier også dokumentasjonen gitt minne er garantert å overleve 100 000 skrive-/lesesykluser.

Nå reiser dette spørsmålet. Hvordan er prosessen med å jobbe med dette minnet organisert i en mikrokontroller? AVR? Som alltid tok Atmel seg av dette og organiserte denne prosessen på maskinvarenivå, noe som er veldig gledelig fordi vi hele tiden må spare kontrollerressurser. For å kontrollere dette maskinvarenivået er det visse registre.

En av dem er et registerpar EEAR. Hvorfor et par, men fordi 512 adresser ikke vil passe inn i 8 biter, kreves en til

Vi vil se nøyaktig hvordan vi vil ta opp under programmeringsprosessen EEPROM.

Neste er dataregisteret EADR

Vi vil skrive data til dette registeret for å skrive det til en spesifikk EEPROM-minneadresse, samt å lese det fra en spesifikk adresse i samme minne.

Vel, som vanlig kan nesten ingen periferiutstyr eller teknologi organisert på maskinvarenivå klare seg uten et kontrollregister. Vårt forvaltningsregister er registeret EECR

La oss umiddelbart bli kjent med delene av dette registeret.

Bit EERE— en bit som gjør at prosessen med å lese fra EEPROM-minnet begynner. Og så snart dataene er lest og skrevet til dataregisteret, vil denne biten bli tilbakestilt. Derfor kan vi vurdere denne biten ikke bare som en kontrollbit, men også en status- eller statusbit.

Bit EEEE— en bit, hvis innstilling kommanderer kontrolleren til å skrive data fra dataregisteret til en spesifikk EEPROM-adresse. Etter at skriveprosedyren er fullført, tilbakestilles også denne biten uavhengig.

Bit EEMWE— en bit som tillater (ikke starter) opptaksprosessen.

Bit UHYGGELIG— bit som muliggjør avbrudd.

Vel, la oss nå gå videre til prosjektet. Prosjektet ble opprettet på vanlig standard måte og navngitt Test 13. Filen ble også inkludert hoved.h og filer opprettes eeprom.h Og eeprom.c.

Her kilde opprettet filer

Test13.c:

#inkludere"main.h"

inthoved-( tomrom)

{

samtidig som(1)

{

}

}

#ifndefMAIN_H_

#definereMAIN_H_

#definereF_CPU8000000UL

#inkludere

#inkludere

#inkludere

#inkludere

#inkludere

#inkludere"eeprom.h"

　

#slutt om/* MAIN_H_ */

eeprom.h

#ifndefEEPROM_H_

#definereEEPROM_H_

#inkludere"main.h"

tomromEEPROM_skriv( usignertintuiAddress, usignertrøyeucData);

usignertrøyeEEPROM_read( usignertintuiAddress);

#slutt om/* EEPROM_H_ */

eeprom.c

#inkludere"eeprom.h"

Først vil vi derfor prøve å skrive data til EEPROM-minnet. Vel, det er logisk, siden vi ikke har skrevet noe ned, men vi har heller ingenting å lese.

Vel, la oss ikke bry oss og sette inn koden for skrivefunksjonen, samt lesefunksjonen fra eksempelet i den tekniske dokumentasjonen, i filen eeprom.c og fjern de engelskspråklige kommentarene, og sett inn russiskspråklige kommentarer der. Etter alle rettelsene vil filen se slik ut

#inkludere"eeprom.h"

tomromEEPROM_skriv( usignertintuiAddress, usignertrøyeucData)

{

samtidig som( EECR& (1<< EEEE))

{}

EEAR= uiAddress; //Angi adressen

EEDR= ucData; //Vi mater data inn i registeret

EECR|= (1<< EEMWE); //Tillat opptak

EECR|= (1<< EEEE); //Skriv en byte inn i minnet

}

usignertrøyeEEPROM_read( usignertintuiAddress)

{

samtidig som( EECR& (1<< EEEE))

{} //vent til sluttflagget slippes ved siste minneoperasjon

EEAR= uiAddress; //Angi adressen

EECR|= (1<< EERE); //Start en leseoperasjon fra minnet til dataregisteret

komme tilbakeEEDR; //Returner resultatet

}

La oss skrive prototyper for disse funksjonene i en fil eeprom.h

#inkludere"main.h"

tomromEEPROM_skriv( usignertintuiAddress, usignertrøyeucData);

usignertrøyeEEPROM_read( usignertintuiAddress);

La oss nå kalle skrivefunksjonen i main()-funksjonen og derved prøve å skrive en 8-bits verdi til adresse 1. Generelt starter adressering i dette minnet fra 0

inthoved-( tomrom)

EEPROM_skriv(1, 120);

Samtidig som(1)

Vi bruker det samme feilsøkingskortet for eksperimenter, uten å koble noe til det i det hele tatt

La oss sette sammen prosjektet og gå til fastvareprogrammet Avrdude.

La oss velge fastvarefilen vår der, prøv deretter å lese kontrolleren, og slett alt ved å bruke "slett alle"-knappen

Også i avrdude-programmet er det en annen linje "Eeprom". Vi kan bruke denne linjen til å skrive til dette minnet ikke programmatisk, men fra en fil. Men vi vil skrive fra programmet vårt, og vi vil bruke denne linjen til å lese EEPROM-minne inn i en fil. Du kan skrive banen i denne linjen for hånd, og filen vil bli opprettet automatisk. La oss for eksempel skrive "C:\1\11111" og klikke på "Les", og langs denne banen vil all informasjon fra EEPROM-minnet bli skrevet til den angitte filen

Du kan skrive hvilken som helst bane, så lenge mediet med den bokstaven angitt til venstre eksisterer og er skrivbart. Det er også bedre å opprette mappen på forhånd.

La oss nå finne denne filen på disken og åpne den i Notisblokk

Denne filen har omtrent samme format som fastvarefilen. Først adressen, deretter 32 byte med informasjon og deretter en kontrollsum for disse 32 bytene. Hvis vi aldri har skrevet noe til EEPROM-minnet, vil vi ha FF-er på alle adresser, det vil si at vi har en i alle minnebiter.

Vi lukker filen, prøver å flashe kontrolleren, les deretter EEPROM-minnet inn i filen og åpner filen

Vi ser at tallet "78" ble skrevet til filen, som betyr 120 i desimalformat.

La oss nå prøve å trykke på "Slett alt"-knappen, i dette tilfellet skal ikke EEPROM-minnet slettes.

Vi leser EEPROM inn i filen igjen, åpner filen og ser at minnet er slettet, vi har igjen "FF" overalt.

Hvorfor skjedde det? For du må justere sikringene. Lesesikring

La oss ta hensyn til EESAVE-biten. Når denne biten er én (som vi har, er bitene invertert), så tvinger vi EEPROM-minnet til å bli slettet når strømmen slås av, så vel som når det slettes. Og for å forhindre at dette skjer, må denne biten tilbakestilles, det vil si sette en hake i den og blinke sikringene.

Vi flasher sikringene, sletter kontrolleren, flasher kontrolleren, sletter den igjen, leser EEPROM-minnet inn i en fil og åpner den. Nå ser vi at ingenting er slettet fra oss

La oss nå prøve å koble kontrolleren fra strømforsyningen og sette på strøm igjen etter en stund. Igjen leser vi EEPROM inn i filen, alt er intakt. Flott!

I neste del av opplæringen vil vi prøve å programmatisk lese data fra EEPROM-minnet.

Se VIDEO TUTORIAL (klikk på bildet)

Innleggsvisninger: 7 259

Elektrisk slettbare EEPROM-brikker er metalloksid-halvlederdatabrikker som brukes på et trykt kretskort. Denne typen brikke kan slettes og omprogrammeres ved hjelp av et sterkt elektronisk signal. Fordi dette kan gjøres uten å fjerne brikken fra enheten den er koblet til, brukes EEPROM-brikker i mange bransjer.
EEPROM-brikken inneholder ikke-flyktig minne, så dataene går ikke tapt hvis strømforsyningen til brikken blir avbrutt. Denne typen brikke kan programmeres selektivt, noe som betyr at en del av minnet kan endres med en ny overskriving uten å påvirke resten av minnet. Informasjonen som er lagret inne i en EEPROM-brikke er permanent til den blir slettet eller omprogrammert, noe som gjør den til en verdifull komponent i datamaskiner og andre elektroniske enheter.

EEPROM-brikker er basert på transistorer med flytende port. EEPROM-brikken programmeres ved å tvinge programmerbar informasjon i form av elektroner gjennom portoksidet. Den flytende porten gir da lagring for disse elektronene. En minnecelle anses som programmert når den er ladet med elektroner, og dette er representert med en null. Hvis en minnecelle ikke er ladet, er den ikke programmert og representert av en en.

Et bredt spekter av enheter krever minne, så EEPROM-brikker har mange bruksområder innen forbrukerelektronikk. De brukes i spillsystemer, TV-er og dataskjermer. Høreapparater, digitale kameraer, Bluetooth-teknologi og spillsystemer bruker også EEPROM-brikker. De brukes i telekommunikasjons-, medisinsk- og produksjonsindustrien. Personlige og forretningsdatamaskiner inneholder EEPROM.

EEPROM-brikken har også et bredt spekter av bruksområder i bilindustrien. Den brukes i blokkeringsfrie bremsesystemer, kollisjonsputer, elektroniske stabilitetskontroller, girkasser og motorkontrollenheter. EEPROM-brikker brukes også i klimaanlegg, instrumentpanelskjermer, kroppskontrollmoduler og nøkkelfrie inngangssystemer. Disse brikkene hjelper til med å overvåke drivstofforbruket og brukes også i ulike diagnosesystemer.

Det er en grense for antall repetisjoner som kan overskrives av EEPROM-brikken. Laget inne i brikken blir gradvis skadet av mange omskrivninger. Dette er ikke et stort problem fordi noen EEPROM-brikker kan modifiseres opptil en million ganger. Ytterligere fremskritt innen teknologi vil sannsynligvis ha en positiv innvirkning på hva minnebrikker kan gjøre i fremtiden.

EEPROM er ikke-flyktig, elektrisk slettbart minne. Antall skrive-slettesykluser i disse mikrokretsene når 1 000 000 ganger. Jamming-cellene i dem, så vel som i EPROM-skriveminner, er implementert basert på flytende-port-transistorer. Den interne strukturen til denne minnecellen er vist i figur 1:

Figur 1. Elektrisk slettbar ROM (EEPROM) minnecelle

EEPROM-minnecellen er en MOS-transistor der porten er laget av polykrystallinsk silisium. Deretter, under produksjonsprosessen av brikken, oksideres denne porten og som et resultat vil den bli omgitt av silisiumoksid, et dielektrikum med utmerkede isolerende egenskaper. I en transistor med en flytende port, når ROM-en er fullstendig slettet, er det ingen ladning i den "flytende" porten, og derfor leder ikke denne transistoren strøm. Under programmering påføres en høyspenning til den andre porten, plassert over den flytende porten, og ladninger induseres inn i den på grunn av tunneleffekten. Etter at programmeringsspenningen er fjernet, forblir den induserte ladningen på den flytende porten, og dermed forblir transistoren i en ledende tilstand. Ladningen på den flytende bolten kan lagres i flere tiår.

En lignende minnecelle ble brukt i ultrafiolett slettbar ROM (EPROM). I en minnecelle med elektrisk sletting er det mulig ikke bare å skrive, men også å slette informasjon. Informasjon slettes ved å påføre en spenning motsatt opptaksspenningen til programmeringsporten. I motsetning til UV-slette ROM, er slettetiden for EEPROM-minne omtrent 10 ms.

Blokkskjemaet for ikke-flyktig minne med elektrisk sletting skiller seg ikke fra blokkskjemaet til maske-ROM. Den eneste forskjellen er at i stedet for en smeltbar jumper, brukes cellen beskrevet ovenfor. Det forenklede blokkskjemaet er vist i figur 2.

Figur 2. Forenklet EEPROM-blokkskjema

Som et eksempel på EEPROM-minnebrikker kan vi nevne innenlandske brikker 573РР3, 558РР3 og utenlandske mikrokretser fra AT28с010, AT28с040-serien fra Atmel, HN58V1001 fra Hitachi Semiconductor, X28C010 fra Intersil Corporation. EEPROM-minne lagrer oftest brukerdata i mobilenheter som ikke skal slettes når strømmen er slått av (for eksempel adressebøker), konfigurasjonsinformasjon for rutere eller mobilenheter, sjeldnere brukes disse brikkene som FPGA-konfigurasjonsminne eller DSP-data Oppbevaring. EEPROM-er er avbildet i kretsdiagrammer som vist i figur 3.

Figur 3. Grafisk betegnelse for en elektrisk slettbar skrivebeskyttet minneenhet

Lesing av informasjon fra parallell EEPROM-minne ligner på lesing fra maske-ROM. Først settes adressen til minnecellen som leses på adressebussen i binærkode A0...A9, deretter tilføres lesesignalet RD. CS-brikkevelgersignalet brukes vanligvis som en ekstra adresseledning for å få tilgang til brikken. Tidsdiagrammene for signalene ved inngangene og utgangene til denne typen ROM er vist i figur 4.

Figur 4. Tidsdiagrammer for signaler for lesing av informasjon fra EEPROM-minne

Figur 5 viser en tegning av et typisk hus for en parallell EEPROM-minnebrikke.

Figur 5. Tegning av det parallelle EEPROM-mikrokretshuset

Vanligvis kreves data lagret i EEPROM ganske sjelden. Lesetiden er ikke kritisk i dette tilfellet. Derfor, i noen tilfeller, blir adressen og dataene overført til brikken og tilbake gjennom den serielle porten. Dette gjør det mulig å redusere størrelsen på mikrokretser ved å redusere antall eksterne pinner. I dette tilfellet brukes to typer serielle porter - SPI-port og I2C-port (henholdsvis mikrokretser 25cXX og 24cXX-serien). Den utenlandske serien 24cXX tilsvarer den innenlandske serien av mikrokretser 558PPX.

Det interne diagrammet til 24cXX-seriens mikrokretser (for eksempel AT24C01) er vist i figur 6.

Figur 6. Intern krets av AT24C01-brikken

Slike brikker er mye brukt til å lagre TV-innstillinger, som plug and play-minne i datamaskiner og bærbare datamaskiner, FPGA-konfigurasjonsminne og signalprosessorer (DSP). Bruken av seriell EEPROM-minne har redusert kostnadene for disse enhetene betydelig og økt brukervennligheten. Et eksempel på plasseringen av denne brikken på kretskortet til et datamaskinminnekort er vist i figur 7.

Figur 7. EEPROM på kretskortet til et datamaskinminnekort

Figur 8 viser et diagram av et elektronisk kort som bruker en ekstern EEPROM-brikke.

Figur 8. Elektronisk kortkrets ved bruk av ekstern EEPROM

I dette diagrammet utveksler mikrokontrolleren PIC16F84 data med EEPROM-minnet 24LC16B. Enheter som SIM-kortet bruker ikke lenger en ekstern minnebrikke. SIM-kort til mobilenheter bruker det interne EEPROM-minnet til en enkeltbrikke mikrokontroller. Dette lar deg redusere prisen på denne enheten så mye som mulig.

Kontrollkretsen for elektrisk slettbare programmerbare ROM-er viste seg å være kompleks, så to retninger for utviklingen av disse mikrokretsene har dukket opp:

1. EEPROM - elektrisk slettbart programmerbart skrivebeskyttet minne
2. FLASH ROM

FLASH - ROM-er skiller seg fra EEPROM-er ved at sletting ikke utføres på hver celle separat, men på hele mikrokretsen som helhet eller en blokk av minnematrisen til denne mikrokretsen, slik det ble gjort i EEPROM.

Figur 9. Grafisk betegnelse av FLASH-minne

Når du får tilgang til en permanent lagringsenhet, må du først angi adressen til minnecellen på adressebussen, og deretter utføre en leseoperasjon fra brikken. Dette tidsdiagrammet er vist i figur 11.

Figur 10. Tidsdiagrammer for signaler for lesing av informasjon fra ROM

I figur 10 viser pilene rekkefølgen i hvilken styresignaler skal genereres. I denne figuren er RD lesesignalet, A er celleadressevalgsignalene (siden individuelle biter i adressebussen kan anta forskjellige verdier, vises overgangsveier til både en- og nulltilstanden), D er utgangsinformasjonen som er lest. fra valgt ROM-celle.

Litteratur:

Sammen med artikkelen "Read Only Memory Devices (ROM)" kan du lese:

Ovnskontrolleren vår er nesten klar - men foreløpig er den fortsatt en "gullfisk"-kontroller som husker alle innstillinger bare fem minutter før den første strømmen slås av. For å huske innstillingene våre, verdien av den innstilte temperaturen og kalibreringspunktene selv etter at du har slått av strømmen, må du bruke ikke-flyktig minne - EEPROM.
Våre venner har skrevet veldig bra om å jobbe med EEPROM.

Det viktigste vi trenger å vite er at EEPROM-minne bedre anses ikke som "bare minne", men som en separat intern enhet i brikken.
EEPROM separat adresseområde, som ikke har noe å gjøre med prosessorens adresserom (FLASH og SRAM); for å få tilgang til data på en bestemt adresse i ikke-flyktig minne, må du utføre en viss sekvens av handlinger ved hjelp av en rekke registre (adresseregistre EEARH og EEARL, dataregister EEDR og kontrollregister EECR).
I følge dataarket, for å skrive en byte til en bestemt adresse i EEPROM, må du gjøre følgende:

1. vente på at EEPROM er klar til å skrive data (EEPE-biten til EECR-registeret er tilbakestilt);
2. vent til slutten av skrivingen til FLASH-minnet (tilbakestilling av SELFPRGEN-biten til SPMCSR-registeret) - dette må gjøres hvis bootloaderen er til stede i programmet;
3. skriv den nye adressen til EEAR-registeret (om nødvendig);
4. skrive en databyte til EEDR-registeret (om nødvendig);
5. sett EEMPE-biten til EECR-registeret til én;
6. innen fire klokkesykluser etter innstilling av EEMPE-flagget, skriver vi en logisk en til EEPE-biten i EECR-registeret.

Prosessoren hopper deretter over 2 klokkesykluser før den utfører neste instruksjon.
Det andre punktet må utføres hvis det er en bootloader i programmet - faktum er at skriving til EEPROM ikke kan utføres samtidig med skriving til FLASH-minne, så før du skriver til EEPROM må du sørge for at programmering av FLASH-minne er fullført; hvis mikrokontrolleren ikke har en bootloader, endrer den aldri innholdet i FLASH-minnet (husk at avr har en Harvard-arkitektur: programminne (FLASH) og dataminne (SRAM) er atskilt).
Varigheten av opptakssyklusen avhenger av frekvensen til den interne RC-oscillatoren til brikken, forsyningsspenning og temperatur; vanligvis for ATmega48x/88x/168x-modeller er dette 3,4 ms (!), for noen eldre modeller - 8,5 ms (!!!).
I tillegg, når du skriver til EEPROM, kan det oppstå problemer med anropsavbrudd under utførelsen av handlingssekvensen ovenfor - så det er bedre å deaktivere avbrudd mens du skriver til EEPROM.
Å lese ikke-flyktig minne er litt enklere:

1. vente på at EEPROM er klar til å lese data (EEWE-biten til EECR-registeret er tilbakestilt);
2. skriv adressen til EEAR-registeret;
3. sett EERE-biten til EECR-registeret til én;
4. vi leser data fra EEDR-registeret (faktisk, når de forespurte dataene flyttes til dataregisteret, tilbakestilles EERE-biten av maskinvare; men det er ikke nødvendig å overvåke tilstanden til denne biten, siden leseoperasjonen fra EEPROM er alltid utført i én klokkesyklus).

Etter å ha satt en bit i EERE til én, hopper prosessoren over 4 klokkesykluser før den utfører neste instruksjon.
Som vi kan se, er det en tidkrevende prosess å jobbe med ikke-flyktig minne; hvis vi ofte skriver og leser data fra EEPROM, kan programmet begynne å avta.

Vi skriver imidlertid et program i IAR-miljøet, og vi er heldige: alt arbeidet med lesing og skriving fra EEPROM vil bli gjort av utviklingsmiljøet - iar har modifikatoren "__eeprom", som lager variabler i ikke-flyktig minne - og da trenger vi bare å lese fra "konstante" variabler til "aktuelle" (ved initialisering av kontrolleren), eller skrive fra "gjeldende" variabler til "konstante" - det vil si når gjeldende verdi endres, verdien av variabel i ikke-flyktig minne må også endres.
De nye variablene vil se slik ut:

Eeprom uint16_t EEP_MinTemperature;

Et par mer generelle ord: og selv om vi ikke antar pekere til eeprom-variabler, må vi huske at eeprom er et eget adresserom, og for å lage en peker til eeprom (og kompilatoren lar oss gjøre dette), må vi indikerer at dette er en peker til en adresse i eeprom:

Uint16_t __eeprom *EEP_MinTemperatureAdr;

La oss gå tilbake til komfyrkontrolleren og EEPROM. I vårt tilfelle er det selvfølgelig ikke antatt noen virtuell maskin for EEPROM; Dessuten er det verdt å vurdere om et eget bibliotek er nødvendig for å jobbe med ikke-flyktig minne - innspillingen av viktige innstillinger er for "spredt" over programmet; hvis du prøver å lage et eget bibliotek, må du lage kryssreferanser: i biblioteket for EEPROM, koble til bibliotekene til ADC, varmeelement og globale innstillinger; og i disse perifere bibliotekene er det ikke en veldig god tilnærming å koble til EEPROM-biblioteket.
Et annet alternativ er å legge til en eeprom-variabel til hvert bibliotek der du må lagre innstillinger, og lagre de tilsvarende innstillingene direkte i de virtuelle maskinene. Vi vil implementere dette alternativet.
Først, la oss liste hvilke variabler vi trenger å lagre i EEPROM:

1. kalibreringspunkter
2. verdier for maksimum-minimum innstilt temperatur og temperaturinnstillingstrinn
3. innstilt temperaturverdi
4. PID-kontroller koeffisienter

Vi lagrer ikke verdien av kjøkkentimeren - vi vil anta at brukeren må stille inn komfyrtimeren hver gang etter at strømmen er slått av.
Alle disse innstillingene stilles inn av brukeren ved å vri på koderen og deretter et kort trykk på brukerknappen. Samtidig husker vi at antallet EEPROM-lese-skrivesykluser fortsatt er begrenset, så ikke overskriv den samme informasjonen igjen (for eksempel hvis brukeren valgte samme verdi av en innstilling som den var). Derfor, før hver endring av __eeprom-variabelen, sjekker vi om den må skrives om:

//hvis verdien er endret, overskriv den i ikke-flyktig minne hvis (ADCTemperature.atMinTemperatureValue != (uint16_t)VMEncoderCounter.ecntValue) ( ​​atureV alue; )

Å lese innstillinger fra EEPROM er også enkelt - når vi initialiserer de "gjeldende" innstillingene, leser vi bare verdien fra ikke-flyktig minne:

ADCTemperature.atMinTemperatureValue = EEP_MinTemperature;

For at enheten vår skal ha noen innstillinger i EEPROM helt fra begynnelsen, kan prosjektet for den første oppstarten kompileres med disse variablene initialisert:

Eeprom uint16_t EEP_MinTemperature = 20; ... //array for lagring av kalibreringspunkter i ikke-flyktig minne __eeprom TCalibrationData EEP_CalibrationData = ((20, 1300), (300, 4092));

I dette tilfellet initialiserer kompilatoren __eeprom-variabler før du starter arbeidet med hovedfunksjonen. For å få en fil med ikke-flyktig minne (.eep), må du gå inn i følgende innstillinger:
Prosjekt->Alternativer..->Linker->Ekstra alternativer
Hvis avmerkingsboksen "Bruk kommandolinjealternativer" ikke er merket, merker du av for den og legger til linjen
-Ointel-standard,(XDATA)=.eep
Først kompilerer vi prosjektet med initialiserte variabler, lagre eep-filen separat; så fjerner vi initialisering når vi lager variabler.

Det er alt - komfyren vår er klar!