Pagbasa at Pagsulat ng Data sa Panlabas na EEPROM Gamit ang Arduino: 5 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:12

Ang EEPROM ay kumakatawan sa Elektrisidad na Nababura na Programmable Read-Only Memory.

Napakahalaga at kapaki-pakinabang ng EEPROM sapagkat ito ay isang hindi pabagu-bago ng anyo ng memorya. Nangangahulugan ito na kahit na naka-off ang board, pinapanatili pa rin ng EEPROM chip ang program na nakasulat dito. Kaya't kapag pinapagalitan mo ang board at pagkatapos ay pinapagana itong muli, ang program na nakasulat sa EEPROM ay maaaring patakbuhin. Kaya karaniwang, ang EEPROM ay nag-iimbak at nagpapatakbo ng isang programa kahit na ano. Nangangahulugan ito na maaari mong patayin ang isang aparato, panatilihin itong 3 araw, at bumalik at i-on ito at maaari pa rin nitong patakbuhin ang program na na-program dito. Ganito gumagana ang karamihan sa mga elektronikong aparato ng consumer.

Ang proyektong ito ay nai-sponsor ng LCSC. Gumagamit ako ng mga elektronikong sangkap mula sa LCSC.com. Ang LCSC ay may isang matibay na pangako sa pag-aalok ng isang malawak na pagpipilian ng tunay, de-kalidad na mga elektronikong sangkap sa pinakamagandang presyo na may isang pandaigdigang network sa pagpapadala sa higit sa 200 mga bansa. Mag-sign up ngayon at makakuha ng $ 8 off sa iyong unang order.

Ang EEPROM ay napakahusay din sa mga indibidwal na byte sa isang tradisyunal na EEPROM na maaaring malayang basahin, mabura, at muling isulat. Sa karamihan ng iba pang mga uri ng di-pabagu-bago na memorya, hindi ito magagawa. Pinapayagan ka ng mga serial device na EEPROM tulad ng Microchip 24-series na EEPROM na magdagdag ng higit na memorya sa anumang aparato na maaaring magsalita ng I²C.

Mga gamit

1. EEPROM - 24LC512
2. ATmega328P-PU
3. 16 MHz Crystal
4. Breadboard
5. Resistor 4.7k Ohm x 2
6. Kapasitor 22 pF x 2

Hakbang 1: Mga Pangunahing Kaalaman sa EEPROM

Ang Microchip 24LC2512 chip ay maaaring mabili sa isang 8 pin DIP package. Ang mga pin sa 24LC512 ay medyo tuwid at binubuo ng lakas (8), GND (4), proteksyon ng sulat (7), SCL / SDA (6, 5), at tatlong mga pin ng address (1, 2, 3).

Isang Maikling Kasaysayan ng ROM

Ang mga maagang uri ng "Stored-Program" na uri ng mga computer - tulad ng desk calculator at mga tagasalin ng keyboard - ay nagsimulang gumamit ng ROM sa anyo ng Diode Matrix ROM. Ito ay isang memorya na binubuo ng mga discrete na semiconductor diode na inilagay sa isang espesyal na organisadong PCB. Nagbigay daan ito sa Mask ROM sa pagkakaroon ng mga integrated circuit. Ang mask ROM ay katulad ng Diode Matrix ROM lamang ito ay ipinatupad sa isang mas maliit na sukat. Gayunpaman, nangangahulugan ito na hindi mo lamang maililipat ang isang pares ng mga diode sa paligid gamit ang isang panghinang at muling pagprogram nito. Ang Mask ROM ay dapat na program ng tagagawa at pagkatapos ay hindi mababago.

Sa kasamaang palad, ang Mask ROM ay mahal at tumagal ng mahabang panahon upang makabuo dahil ang bawat bagong programa ay nangangailangan ng isang bagong aparato upang mabuo ng isang pandayan. Gayunpaman, noong 1956, ang problemang ito ay nalutas sa pag-imbento ng PROM (Programmable ROM) na pinapayagan ang mga developer na i-program ang mga chips mismo. Nangangahulugan iyon na ang mga tagagawa ay maaaring gumawa ng milyon-milyong parehong aparato na hindi naka -ogram na ginawa itong mas mura at mas praktikal. Gayunpaman, ang PROM ay maaari lamang maisulat nang isang beses gamit ang isang aparatong may mataas na boltahe na programa. Matapos ma-program ang isang aparato ng PROM, walang paraan upang maibalik ang aparato sa hindi naka-program na estado.

Nagbago ito noong 1971 sa pag-imbento ng EPROM (Erasable Programmable ROM) na - bukod sa pagdaragdag ng isa pang liham sa akronim - nagdala ng kakayahang burahin ang aparato at ibalik ito sa isang "blangko" na estado gamit ang isang malakas na mapagkukunan ng ilaw ng UV. Tama iyan, kailangan mong magningning ng isang maliwanag na ilaw sa IC upang i-reprogram ito, kung gaano ito cool? Sa gayon, lumalabas na medyo cool ito maliban kung ikaw ay isang developer na nagtatrabaho sa firmware kung saan nais mo talagang mai-reprogram ang aparato gamit ang mga electrical signal. Ito sa wakas ay naging isang katotohanan noong 1983 sa pagbuo ng EEPROM (Electrically Erasable Programmable ROM) at kasama nito, nakarating kami sa kasalukuyang araw na hindi mabibigat na akronim.

Hakbang 2: Mga Quirks ng EEPROM

Mayroong dalawang pangunahing mga drawbacks sa EEPROM bilang isang paraan ng pag-iimbak ng data. Sa karamihan ng mga application, ang mga kalamangan ay mas malaki kaysa sa kahinaan, ngunit dapat mong magkaroon ng kamalayan ng mga ito bago isama ang EEPROM sa iyong susunod na disenyo.

Una sa lahat, nililimitahan din ng teknolohiya na nagpapagana sa EEPROM ang bilang ng beses na maaari itong muling maisulat. Ito ay may kinalaman sa mga electron na nagiging nakakulong sa mga transistor na bumubuo sa ROM at nagtatayo hanggang sa hindi makilala ang pagkakaiba ng singil sa pagitan ng isang "1" at isang "0". Ngunit huwag mag-alala, ang karamihan sa mga EEPROM ay may maximum na muling pagsusulat na bilang ng 1 milyon o higit pa. Hangga't hindi ka patuloy na sumusulat sa EEPROM malabong maabot mo ang maximum na ito. Pangalawa, ang EEPROM ay hindi mabubura kung aalisin mo ang kuryente mula rito, ngunit hindi ito mananatili sa iyong data nang walang katiyakan. Ang mga electron ay maaaring naaanod sa mga transistors at sa pamamagitan ng insulator, na mabisang binubura ang EEPROM sa paglipas ng panahon. Sinabi na, karaniwang nangyayari ito sa paglipas ng mga taon (bagaman maaari itong mapabilis ng init). Karamihan sa mga tagagawa ay nagsasabi na ang iyong data ay ligtas sa EEPROM sa loob ng 10 taon o higit pa sa temperatura ng kuwarto. At may isa pang bagay na dapat mong tandaan kapag pumipili ng isang EEPROM aparato para sa iyong proyekto. Ang kapasidad ng EEPROM ay sinusukat sa mga piraso at hindi mga byte. Ang isang 512K EEPROM ay magtataglay ng 512Kbits ng data, sa madaling salita, 64KB lamang.

Hakbang 3: Arduino Hardware Hookup

Okay, ngayong alam na natin kung ano ang EEPROM, mag-hook up tayo at tingnan kung ano ang magagawa nito! Upang mausap ang aming aparato, kakailanganin naming kumonekta sa kuryente pati na rin ang mga linya ng serial na I²C. Ang aparatong ito, sa partikular, ay tumatakbo sa 5VDC kaya ikonekta namin ito sa 5V na output ng aming Arduino UNO. Gayundin, ang mga linya ng I²C ay mangangailangan ng mga pull-up resistor para mangyari nang tama ang komunikasyon. Ang halaga ng mga resistors na ito ay nakasalalay sa kapasidad ng mga linya at dalas na nais mong iparating ito, ngunit ang isang mabuting tuntunin ng hinlalaki para sa mga hindi kritikal na aplikasyon ay itinatago lamang sa saklaw ng kΩ. Sa halimbawang ito, gagamitin namin ang 4.7kΩ pull-up resistors.

Mayroong tatlong mga pin sa aparatong ito upang mapili ang address na I²C, sa ganitong paraan maaari kang magkaroon ng higit sa isang EEPROM sa bus at ibigay ang bawat isa sa kanila. Maaari mo lamang silang ibagsak lahat, ngunit isasabit namin ang mga ito upang maaari kaming bumagsak sa isang aparato na may mas mataas na kapasidad sa paglaon sa tutorial.

Gumagamit kami ng isang breadboard upang ikonekta ang lahat nang magkasama. Ipinapakita ng diagram sa ibaba ang tamang pag-hookup para sa karamihan ng mga aparato ng I²C EEPROM, kabilang ang Microchip 24-series na EEPROM na ibinebenta namin.

Hakbang 4: Pagbasa at Pagsulat

Karamihan sa mga oras na gumagamit ka ng isang EEPROM kasabay ng isang microcontroller hindi mo talaga kailangang makita ang lahat ng mga nilalaman ng memorya nang sabay-sabay. Magbabasa ka lamang at magsulat ng mga byte dito at doon kung kinakailangan. Gayunpaman, sa halimbawang ito, magsusulat kami ng isang buong file sa EEPROM at pagkatapos ay basahin ang lahat ng ito upang makita natin ito sa aming computer. Dapat itong maging komportable sa amin sa ideya ng paggamit ng EEPROM at bigyan din kami ng isang pakiramdam para sa kung magkano ang maaaring magkasya ang data sa isang maliit na aparato.

Sumulat ng Bagay

Ang aming halimbawa ng sketch ay kukuha lamang ng anumang byte na darating sa serial port at isusulat ito sa EEPROM, na sinusubaybayan ang paraan ng kung gaano karaming mga byte ang isinulat namin sa memorya.

Ang pagsulat ng isang byte ng memorya sa EEPROM ay karaniwang nangyayari sa tatlong mga hakbang:

1. Ipadala ang Pinakamakahalagang Byte ng address ng memorya na nais mong isulat.
2. Ipadala ang Least Significant Byte ng memorya ng address na nais mong isulat.
3. Ipadala ang byte ng data na nais mong itabi sa lokasyon na ito.

Marahil ay may ilang mga pangunahing salita doon na hubad na nagpapaliwanag:

Mga Memory Address

Kung naisip mo ang lahat ng mga byte sa isang 512 Kbit EEPROM na nakatayo sa isang linya mula 0 hanggang 64000 - dahil mayroong 8 piraso sa isang byte at samakatuwid maaari kang magkasya sa 64000 bytes sa isang 512 Kbit EEPROM - kung gayon ang isang address ng memorya ay ang lugar sa linya kung saan makakahanap ka ng isang partikular na byte. Kailangan naming ipadala ang address na iyon sa EEPROM upang malaman nito kung saan ilalagay ang byte na ipinapadala namin.

Karamihan sa Makabuluhang at Pinakakaunting Makabuluhang Bytes

Dahil mayroong 32000 posibleng mga lugar sa isang 256 Kbit EEPROM - at dahil 255 ang pinakamalaking bilang na maaari mong i-encode sa isang byte - kailangan naming ipadala ang address na ito sa dalawang byte. Una, ipinapadala namin ang Most Significant Byte (MSB) - ang unang 8 piraso sa kasong ito. Pagkatapos ipadala namin ang Least Significant Byte (LSB) - ang pangalawang 8 bits. Bakit? Dahil ganito ang inaasahan ng aparato na matanggap ang mga ito, iyon lang.

Pagsulat ng Pahina

Ang pagsulat ng isang byte nang paisa-isa ay mabuti, ngunit ang karamihan sa mga aparatong EEPROM ay may tinatawag na "pahina na sumulat ng buffer" na nagbibigay-daan sa iyo upang sumulat ng maraming byte nang sabay-sabay sa paraang gagawin mo sa isang solong byte. Sasamantalahin namin ito sa aming halimbawa ng sketch. Gumagamit ang EEPROM ng isang panloob na counter na awtomatikong nagdaragdag ng lokasyon ng memorya sa bawat sumusunod na data byte na natanggap nito. Kapag naipadala na ang isang address ng memorya maaari naming sundin ito hanggang sa 64 bytes ng data. Ipinapalagay ng EEPROM (nang tama) na ang isang address na 312 na sinusundan ng 10 byte ay magtatala ng byte 0 sa address na 312, byte 1 sa address na 313, byte 2 sa address na 314, at iba pa.

Basahin ang Isang bagay

Ang pagbabasa mula sa EEPROM ay karaniwang sumusunod sa parehong proseso ng tatlong hakbang bilang pagsulat sa EEPROM:

1. Ipadala ang Pinakamakahalagang Byte ng address ng memorya na nais mong isulat.
2. Ipadala ang Least Significant Byte ng memorya ng address na nais mong isulat.
3. Humingi ng byte ng data sa lokasyon na iyon.

Hakbang 5: Schematics at Code

Code:

# isama

#define eeprom 0x50 // tumutukoy sa base address ng EEPROM

walang bisa ang pag-setup () {

Wire.begin (); // Lumilikha ng isang Wire object

Serial.begin (9600);

unsigned int address = 0; // unang address ng EEPROM

Serial.println ("Isusulat namin ang zip code 22222, isang zip code"); para sa (address = 0; address <5; address ++) writeEEPROM (eeprom, address, '2'); // Nagsusulat ng 22222 sa EEPROM

para sa (address = 0; address <5; address ++) {Serial.print (readEEPROM (eeprom, address), HEX); }}

void loop () {

/ * walang nasa loop () na pag-andar dahil hindi namin nais ang arduino na paulit-ulit na isulat ang parehong bagay sa EEPROM nang paulit-ulit. Gusto lang namin ng isang beses na pagsulat, kaya maiiwasan ang pagpapaandar ng loop () sa mga EEPROM. * /}

// tumutukoy sa pagpapaandar ng writeEEPROM

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

// tumutukoy sa pagpapaandar ng readEEPROM

byte readEEPROM (int deviceaddress, unsigned int eeaddress) {byte rdata = 0xFF; Wire.beginTransmission (aparatoaddress); Wire.write ((int) (eeaddress >> 8)); // nagsusulat ng MSB Wire.write ((int) (eeaddress & 0xFF)); // nagsusulat ng LSB Wire.endTransmission (); Wire.requestFrom (deviceaddress, 1); kung (Wire.available ()) rdata = Wire.read (); ibalik ang rdata; }