Ang Inbuilt EEPROM ng iyong Arduino: 6 na Hakbang

2025 May -akda: John Day | [email protected]. Huling binago: 2025-01-23 15:13

Sa artikulong ito susuriin namin ang panloob na EEPROM sa aming mga board ng Arduino. Ano ang isang EEPROM na maaaring sinasabi ng ilan sa inyo? Ang isang EEPROM ay isang Eleksyong Na-Erasable na Programmable Read-Only Memory.

Ito ay isang form ng di-pabagu-bago memorya na maaaring matandaan ang mga bagay na may kapangyarihan na naka-patay, o pagkatapos i-reset ang Arduino. Ang kagandahan ng ganitong uri ng memorya ay maaari kaming mag-imbak ng data na nabuo sa loob ng isang sketch sa isang mas permanenteng batayan.

Bakit mo gagamitin ang panloob na EEPROM? Para sa mga sitwasyon kung saan ang data na kakaiba sa isang sitwasyon ay nangangailangan ng isang mas permanenteng tahanan. Halimbawa, ang pagtatago ng natatanging serial number at petsa ng pagmamanupaktura ng isang komersyal na proyekto na nakabatay sa Arduino - maaaring ipakita ng isang pagpapaandar ng sketch ang serial number sa isang LCD, o mababasa ang data sa pamamagitan ng pag-upload ng isang 'sketch ng serbisyo'. O maaaring kailanganin mong bilangin ang ilang mga kaganapan at hindi payagan ang gumagamit na i-reset ang mga ito - tulad ng isang odometer o operasyon cycle-counter.

Hakbang 1: Anong Pag-uri-uri ng Data ang Maaaring Maimbak?

Anumang bagay na maaaring kinatawan bilang mga byte ng data. Ang isang byte ng data ay binubuo ng walong piraso ng data. Ang isang bit ay maaaring alinman sa (halaga 1) o off (halagang 0), at perpekto para sa kumakatawan sa mga numero sa binary form. Sa madaling salita, ang isang binary na numero ay maaari lamang gumamit ng mga zero at isa upang kumatawan sa isang halaga. Sa gayon ang binary ay kilala rin bilang base-2 ″, dahil maaari lamang itong gumamit ng dalawang digit.

Paano ang isang numero ng binary na may paggamit lamang ng dalawang digit na kumakatawan sa isang mas malaking bilang? Gumagamit ito ng maraming mga at zero. Suriin natin ang isang binary number, sabihin 10101010. Dahil ito ay isang base-2 na numero, ang bawat digit ay kumakatawan sa 2 hanggang sa lakas ng x, mula sa x = 0 pataas.

Hakbang 2:

Tingnan kung paano ang bawat digit ng binary number ay maaaring kumatawan sa isang base-10 na numero. Kaya ang numero ng binary sa itaas ay kumakatawan sa 85 sa base-10 - ang halagang 85 ay ang kabuuan ng mga halagang base-10. Isa pang halimbawa - 11111111 sa binary ay katumbas ng 255 sa base 10.

Hakbang 3:

Ngayon ang bawat digit sa binary number na iyon ay gumagamit ng isang 'bit' na memorya, at walong piraso ang gumagawa ng isang byte. Dahil sa panloob na mga limitasyon ng mga microcontroller sa aming mga board ng Arduino, maaari lamang kaming mag-imbak ng mga 8-bit na numero (isang byte) sa EEPROM.

Nililimitahan nito ang decimal na halaga ng numero na mahuhulog sa pagitan ng zero at 255. Nasa sa iyo na magpasya kung paano maaaring kumatawan sa iyong data sa saklaw ng numero. Huwag hayaan na i-off ka - ang mga bilang na nakaayos sa tamang paraan ay maaaring kumatawan sa halos anumang bagay! Mayroong isang limitasyon na dapat pansinin - ang bilang ng mga beses na maaari nating basahin o isulat sa EEPROM. Ayon sa tagagawa ng Atmel, ang EEPROM ay mabuti para sa 100, 000 na pagbasa / pagsulat ng mga siklo (tingnan ang sheet ng data).

Hakbang 4:

Ngayon alam namin ang aming mga piraso at byte, kung gaano karaming mga byte ang maaaring maiimbak sa microcontroller ng aming Arduino? Ang sagot ay nag-iiba depende sa modelo ng microcontroller. Halimbawa:

• Mga board na may isang Atmel ATmega328, tulad ng Arduino Uno, Uno SMD, Nano, Lilypad, atbp. - 1024 bytes (1 kilobyte)
• Mga board na may isang Atmel ATmega1280 o 2560, tulad ng seryeng Arduino Mega - 4096 bytes (4 kilobytes)
• Mga board na may isang Atmel ATmega168, tulad ng orihinal na Arduino Lilypad, matandang Nano, Diecimila atbp - 512 bytes.

Kung hindi ka sigurado tingnan ang index ng hardware ng Arduino o tanungin ang iyong tagatustos ng board. Kung kailangan mo ng higit na imbakan ng EEPROM kaysa sa magagamit sa iyong microcontroller, isaalang-alang ang paggamit ng isang panlabas na I2C EEPROM.

Sa puntong ito naiintindihan na namin ngayon kung anong uri ng data at kung magkano ang maaaring maiimbak sa EEPROM ng aming Arduino. Ngayon ay oras na upang maisagawa ito. Tulad ng tinalakay nang mas maaga, mayroong isang may hangganang dami ng puwang para sa aming data. Sa mga sumusunod na halimbawa, gagamit kami ng isang tipikal na board ng Arduino na may ATmega328 na may 1024 bytes ng EEPROM na imbakan.

Hakbang 5:

Upang magamit ang EEPROM, kinakailangan ng isang library, kaya gamitin ang sumusunod na library sa iyong mga sketch:

# isama ang "EEPROM.h"

Ang natitira ay napaka-simple. Upang maiimbak ang isang piraso ng data, ginagamit namin ang sumusunod na pagpapaandar:

EEPROM. Magsulat (a, b);

Ang parameter a ay ang posisyon sa EEPROM upang maiimbak ang integer (0 ~ 255) ng data b. Sa halimbawang ito, mayroon kaming 1024 bytes ng memory storage, kaya ang halaga ng a ay nasa pagitan ng 0 at 1023. Upang makuha ang isang piraso ng data ay pantay kasing simple, gamitin ang:

z = EEPROM.read (a);

Kung saan ang z ay isang integer upang maiimbak ang data mula sa posisyon na EEPROM a. Ngayon upang makita ang isang halimbawa.

Hakbang 6:

Ang sketch na ito ay lilikha ng mga random na numero sa pagitan ng 0 at 255, iimbak ang mga ito sa EEPROM, pagkatapos ay kunin at ipakita ang mga ito sa serial monitor. Ang variable na EEsize ay ang itaas na limitasyon ng iyong laki ng EEPROM, kaya (halimbawa) ito ay magiging 1024 para sa isang Arduino Uno, o 4096 para sa isang Mega.

// Arduino panloob na pagpapakita ng EEPROM

# isama

int zz; int EEsize = 1024; // laki sa bytes ng EEPROM ng iyong board

walang bisa ang pag-setup ()

{Serial.begin (9600); randomSeed (analogRead (0)); } void loop () {Serial.println ("Sumusulat ng mga random na numero …"); para sa (int i = 0; i <EEsize; i ++) {zz = random (255); EEPROM.write (i, zz); } Serial.println (); para sa (int a = 0; a <EEsize; a ++) {zz = EEPROM.read (a); Serial.print ("Posisyon ng EEPROM:"); Serial.print (a); Serial.print ("naglalaman"); Serial.println (zz); antala (25); }}

Ang output mula sa serial monitor ay lilitaw, tulad ng ipinakita sa imahe.

Kaya't mayroon ka nito, isa pang kapaki-pakinabang na paraan upang mag-imbak ng data sa aming mga system ng Arduino. Kahit na hindi ang pinaka-kapanapanabik na tutorial, tiyak na ito ay isang kapaki-pakinabang.

Ang post na ito ay dinala sa iyo ng pmdway.com - lahat para sa mga tagagawa ng tagahanga at electronics, na may libreng paghahatid sa buong mundo.