Arduino vadu bibliotēka darbam ar I2C kopni. I2C teorija, EEPROM no Atmel Servo un stepper motoru bibliotēkām

Wire.requestFrom(adrese, daudzums) - izmanto kapteinis, lai pieprasītu baitus no vergu. Šos baitus var iegūt, izmantojot pieejamās () un lasīšanas () metodes. Bufera lielums ir tie paši 32 baiti.

• adrese : ierīces 7 bitu adrese, no kuras tiek pieprasīti baiti;
• daudzums: pieprasīto baitu skaits;

Wire.available()- Atgriež pieejamo baitu skaitu, ko var izgūt, izmantojot read() .

Šeit ir piemērs virknes “Hello Word” ierakstīšanai atmiņā:

#iekļauts #define EEPROM_ADDRESS 0x53 vārdu adrese = 0; char data_send = "Labdien, Word" ; void setup() ( Wire.begin(); // Serial.begin(9600); Serial.print("Rakstīt baitu EEPROM atmiņā..."); Serial.println (data_send); Wire.beginTransmission(EEPROM_ADDRESS); Wire.write(adrese >> 8); Wire.write(adrese & 0xFF); Wire.write(data_send); baita statuss= Wire.endTransmission(); if (statuss == 0)Serial.println ("Labi") ; aizkave(10); Serial.println("Nolasīt baitu no EEPROM atmiņas..."); Wire.beginTransmission(EEPROM_ADDRESS); Wire.write(adrese >> 8); Wire.write(adrese & 0xFF); status= Wire.endTransmission(); if (statuss == 0) Serial.println ("Ok"); // pārtraukt Wire.requestFrom(EEPROM_ADRESS, (baits)10) pārraidi; baitu dati = 0; for (int i=0 ; i<10 ;i++) { if (Wire.available()) { data = Wire.read(); } Serial.write (data); } } void loop() { }

Atmiņas organizācija:

Tā kā datu lapā tas teikts neskaidri. Es mēģināju to izdomāt praksē. Datu lapā teikts, ka mikroshēmas atmiņa ir organizēta kā 512 lapas pēc 64 baiti Ko tas nozīmē? Ja mēs vēlamies ierakstīt vairāk nekā 64 baitus vienlaikus, teiksim adresē 0x40 (adrese ir otrās lapas sākums), kad adrese pārsniedz lapas robežas Mikroshēmas iekšējais skaitītājs atiestatīs adresi uz lapas sākumu. Un papildu baiti tiks ierakstīti lapas augšdaļā un izdzēsīs tur ierakstītos datus.

Lasīšanai šādu ierobežojumu nav, datu lapā ir tikai teikts, ka, sasniedzot adrešu beigas, jūs automātiski tiksit pārsūtīts uz sākumu (adrese 0x00).

Tas ir viss, ko es domāju. Protams, jūs varat lejupielādēt gatavu bibliotēku EEPROM un varat rakstīt savu. Galvenais, lai mēs saprotam darbības pamatprincipu.

Arduino ir standarta mikrokontrolleris, ko plaši atzīst inženieri, amatnieki un skolotāji, pateicoties tā vienkāršībai, zemajām izmaksām un plašajam paplašināšanas paneļu klāstam. Paplašināšanas plates, kas savienojas ar galveno Arduino plati, ļauj piekļūt internetam, vadīt robotus un mājas automatizāciju.

Vienkāršus uz Arduino balstītus projektus nav grūti īstenot. Taču, ieejot teritorijā, kas nav ietverta ievadpamācībās, un palielinot savu projektu sarežģītību, jūs ātri saskarsieties ar zināšanu trūkuma problēmu, kas ir visu programmētāju ienaidnieks.

Šī grāmata ir paredzēta kā turpinājums bestselleram “Programming Arduino: Getting Started with Sketches”. Lai gan šajā grāmatā ir īsi apkopoti Arduino programmēšanas pamati, tā iepazīstinās lasītāju ar sarežģītākiem Arduino dēļu programmēšanas aspektiem.

Dažādos Arduino modeļos I2C interfeiss ir savienots ar dažādām tapām. Piemēram, Uno modelī tiek izmantotas tapas A4 un A5 – attiecīgi SDA un SCL līnijas, savukārt Leonardo modelī tiek izmantotas tapas D2 un D3. (SDA un SCL līnijas ir sīkāk aprakstītas nākamajā sadaļā.) Abos modeļos SDA un SCL līnijas tiek izvadītas arī uz bloku, kas atrodas blakus AREF kontaktam (7.3. att.).

Tabulā 7.1 ir uzskaitīti visizplatītākie Arduino plates modeļi un tapas, kas atbilst I2C interfeisam.

Rīsi. 7.3. I2C tapas uz Arduino Uno plates

7.1. tabula. I2C tapas dažādos Arduino modeļos

I2C protokols

Lai pārsūtītu un saņemtu datus, izmantojot I2C interfeisu, tiek izmantotas divas līnijas (tātad otrais nosaukums - divu vadu interfeiss, divu vadu interfeiss). Šīs divas līnijas sauc arī par sērijas pulksteņa līniju (SCL) un sērijas datu līniju (SDA). Attēlā 7.4. attēlā parādīta signāla laika diagramma, kas pārraidīta caur I2C saskarni.

Rīsi. 7.4. Ar I2C saskarni pārraidītā signāla laika diagramma

Vadītājs ģenerē pulksteņa impulsu SCL līnijā, un, kad ir pārsūtāmie dati, sūtītājs (galvenais vai slavenais) izved SDA līniju no trešā stāvokļa (uz digitālās izvades režīmu) un nosūta datus loģisku nulles formā. un tie pozitīvo pulksteņa impulsu signāla momentos. Kad pārsūtīšana ir pabeigta, pulksteņa izvadi var apturēt un SDA līnija atgriežas trešajā stāvoklī.

Vadu bibliotēka

Iepriekš aprakstītos impulsus, protams, var ģenerēt pats, kontrolējot bitus, tas ir, programmatūrā ieslēdzot un izslēdzot digitālās izejas. Bet, lai atvieglotu mūsu dzīvi, Arduino programmatūrā ir iekļauta Wire bibliotēka, kas rūpējas par visām sinhronizācijas sarežģītībām un ļauj mums vienkārši nosūtīt un saņemt datu baitus.

Lai izmantotu Wire bibliotēku, vispirms tā jāiekļauj komandā

#iekļauts

I2C inicializācija

Vairumā gadījumu Arduino plate darbojas kā galvenā ierīce jebkurā I2C kopnē. Lai inicializētu Arduino kā galveno, iestatīšanas funkcijā ir jāizdod starta komanda, kā parādīts zemāk:

Ņemiet vērā, ka, tā kā Arduino šajā gadījumā darbojas kā galvenais, tam nav jāpiešķir adrese. Ja plate būtu konfigurēta darbam vergu režīmā, mums būtu jāpiešķir adrese diapazonā no 0 līdz 127, nododot to kā parametru, lai unikāli identificētu plati I2C kopnē.

Datu sūtīšana pēc meistara

Lai nosūtītu datus uz ierīci I2C kopnē, vispirms ir jāizpilda funkcija beginTransmission un jānosūta tai mērķa ierīces adrese:

Wire.beginTransmission(4);

Datu sūtīšanu uz ierīcēm I2C kopnē var veikt pa baitam vai pa veseliem zīmju masīviem, kā parādīts divos šādos piemēros:

Wire.send(123); // pārsūtīt baitu ar vērtību 123

Wire.send("ABC"); // rakstzīmju virknes "ABC" nodošana

Kad pārsūtīšana ir pabeigta, ir jāizsauc funkcija endTransmission:

Wire.endTransmission();

Datu saņemšana no meistara

Lai saņemtu datus no vergu, vispirms ir jānorāda gaidāmo baitu skaits, izsaucot funkciju requestFrom:

Wire.requestFrom(4, 6); // pieprasīt 6 baitus no ierīces ar adresi 4

Pirmais šīs funkcijas arguments ir pakārtotās ierīces adrese, no kuras galvenais vēlas saņemt datus, un otrais arguments ir baitu skaits, ko tā sagaida saņemt. Vergu ierīce var pārsūtīt mazāk baitu, tāpēc, lai noteiktu, vai dati ir saņemti un cik baiti faktiski ir saņemti, ir jāizmanto pieejamā funkcija. Šis piemērs (ņemts no Wire bibliotēkā iekļautās piemēru pakotnes) parāda, kā resursdatora ierīce ņem visus saņemtos datus un izvada tos seriālā porta monitorā:

#iekļauts

Wire.begin(); // izveidot savienojumu ar i2c kopni (galvenajam

// ierīces adrese nav norādīta)

Serial.begin(9600); // inicializējiet seriālā porta monitoru

Wire.requestFrom(8, 6); // pieprasiet 6 baitus no 8. pakalpojuma

while (Wire.available()) ( // slave var sūtīt mazāk

char c = Wire.read(); // pieņemt baitu kā rakstzīmi

Wire bibliotēka automātiski buferē ienākošos datus.

I2C izmantošanas piemēri

Jebkurai I2C ierīcei ir jābūt pievienotam tehniskajam aprakstam, kurā uzskaitīti tās atbalstītie ziņojumi. Šādi apraksti ir nepieciešami, lai izveidotu ziņojumus, kas jānosūta uz pakārtotajām ierīcēm, un interpretētu to atbildes. Tomēr daudzām I2C ierīcēm, kuras var savienot ar Arduino plati, ir specializētas bibliotēkas, kas iekļauj I2C ziņojumus vienkāršās un ērtās funkcijās. Patiesībā, ja jums ir jāstrādā ar kādu ierīci, kurai nav specializētas bibliotēkas, publicējiet savu bibliotēku publiskai lietošanai un nopelniet sev dažus karmas punktus.

Pat ja konkrētai ierīcei nav pieejama pilnīga atbalsta bibliotēka, bieži vien internetā varat atrast noderīgus koda fragmentus, kas parāda, kā lietot ierīci.

VHF radio uztvērējs TEA5767

Pirmajā piemērā, kas demonstrē mijiedarbību ar I2C ierīci, bibliotēka netiek izmantota. Šeit notiek faktisko ziņojumu apmaiņa starp Arduino un TEA5767 moduli. Šo moduli var iegādāties tiešsaistē ļoti lēti, tas viegli savienojas ar Arduino plati un tiek izmantots kā VHF uztvērējs, ko kontrolē Arduino.

Sarežģītākais posms ir ierīces pievienošana. Spilventiņi ir ļoti mazi un atrodas ļoti tuvu viens otram, tāpēc daudzi cilvēki izvēlas izgatavot vai iegādāties adapteri, lai izveidotu savienojumu ar dēli.

Attēlā 7.5. attēlā parādīta shēma moduļa savienošanai ar Arduino.

Rīsi. 7.5. TEA5767 moduļa savienošana ar Arduino Uno plati, izmantojot I2C interfeisu

TEA5767 moduļa datu lapu var atrast vietnē www.sparkfun.com/datasheets/Wireless/General/TEA5767.pdf. Aprakstā ir daudz tehniskas informācijas, taču, uzmetot skatienu dokumentam, pamanīsiet sadaļu ar detalizētu ierīces atpazīto ziņojumu aprakstu. Dokumentācijā teikts, ka TEA5767 pieņem ziņojumus, kuru garums ir 5 baiti. Šis ir pilnībā funkcionējošs piemērs, kas veic frekvences regulēšanu tūlīt pēc palaišanas. Praksē parasti ir nepieciešams nedaudz atšķirīgs konfigurācijas mehānisms, piemēram, pamatojoties uz pogām un šķidro kristālu displeju.

// skice_07_01_I2C_TEA5767

#iekļauts

setFrequency(93.0); // MHz

tukša iestatītā frekvence (peldošā frekvence)

baitu frekvenceH = frekvenceB >> 8;

Wire.beginTransmission(0x60);

Wire.write(frekvenceH);

Wire.write(frekvenceL);

Wire.write(0xB0);

Wire.write(0x10);

Wire.write(0x00);

Wire.endTransmission();

Viss mūs interesējošais kods šajā piemērā atrodas funkcijā setFrequency. Tam nepieciešams reāls skaitlis - frekvence megahercos. Tas ir, ja vēlaties izveidot un izmēģināt šo projektu, noskaidrojiet vietējās radiostacijas frekvenci ar labu spēcīgu signālu un ievietojiet tās vērtību iestatīšanas funkcijā setFrequency call.

Lai pārvērstu reālu frekvences vērtību divu baitu attēlojumā, ko var nosūtīt kā daļu no piecu baitu ziņojuma, ir jāveic aritmētika. Šis fragments veic šīs darbības:

neparakstīta int frekvenceB = 4 * (biežums * 1000000 + 225000) / 32768;

baitu frekvenceH = frekvenceB >> 8;

baitu frekvenceL = frekvenceB & 0XFF;

Komanda >> pārvieto bitus pa labi, tas ir, darbība >> 8 pārvietos lielos 8 bitus uz zemākajiem 8 bitiem par 8 binārajiem cipariem. Operators & veic bitu UN operāciju, kas šajā gadījumā atiestatīs nozīmīgākos 8 bitus un atstās tikai mazāk nozīmīgos. Lai iegūtu pilnīgāku diskusiju par bitu darbībām, skatiet 9. nodaļu.

Pārējā koda daļa funkcijā setFrequency iniciē I2C ziņojuma pārsūtīšanu uz vergu ar adresi 0x60, kas ir piešķirts TEA5767 uztvērējam. Pēc tam tiek veikta 5 baitu seriālā pārraide, sākot no 2. frekvences baita.

Pēc dokumentācijas izlasīšanas jūs uzzināsit par daudzām citām iespējām, kas pieejamas, izmantojot dažādus ziņojumus, piemēram, diapazona skenēšanu, viena vai divu audio izvades kanālu izslēgšanu un mono/stereo režīma izvēli.

Pielikumā atgriezīsimies pie šī piemēra un izveidosim Arduino bibliotēku, lai atvieglotu darbu ar TEA5767 moduli.

Komunikācija starp divām Arduino plāksnēm

Otrajā piemērā tiek izmantoti divi Arduino dēļi, no kuriem viens darbojas kā I2C galvenais, bet otrs kā vergs. Galvenā ierīce nosūtīs ziņojumus uz palīgierīci, kas savukārt izvadīs tos seriālā porta monitorā, lai jūs varētu vizuāli pārbaudīt, vai ķēde darbojas.

Šī piemēra dēļa savienojuma shēma ir parādīta attēlā. 7.6. Lūdzu, ņemiet vērā, ka TEA5767 modulim ir iebūvēti uzvilkšanas rezistori uz I2C līnijām. Taču šajā gadījumā, kad divas Arduinos plates ir savienotas viena ar otru, šādu rezistoru nav, tāpēc būs jāiekļauj savas pretestības ar nominālvērtību 4,7 kOhm (7.6. att.).

Rīsi. 7.6. Divu Arduino plātņu savienošana, izmantojot I2C interfeisu

Dēļos jāielādē dažādas skices. Abas skices ir iekļautas Wire bibliotēkas piemēros. Programma Arduino galvenajai platei atrodas izvēlnē Fails->Piemērs->Wire->master_writer (Fails-> Piemēri->Wire->master_writer), savukārt vergu platei - izvēlnē Fails-> Piemērs-> Vads->slave_receiver (Fails ->Piemēri->Vads->slave_receiver).

Pēc abu plates programmēšanas atstājiet palīgierīci savienotu ar datoru, lai redzētu šīs plates izvadi seriālajā monitorā un nodrošinātu strāvu Arduino galvenajai platei.

Sāksim ar skici uz saimniekdatora:

#iekļauts

Wire.begin(); // izveidot savienojumu ar i2c kopni (galvenajai ierīcei

// adrese nav norādīta)

Wire.beginTransmission(4); // inicializēt pārsūtīšanu uz ierīci #4

Wire.write("x ir "); // nosūtīt 5 baitus

Wire.write(x); // nosūtīt 1 baitu

Wire.endTransmission(); // pārtraukt pārsūtīšanu

Šī skice ģenerē ziņojumu, piemēram, x ir 1, kur 1 ir skaitlis, kas palielinās ik pēc pussekundes. Pēc tam ziņojums tiek nosūtīts uz slaveno adresi 4, kā noteikts izsaukumā beginTransmission.

Vergu skices uzdevums ir saņemt ziņojumu no galvenā un izvadīt to seriālā porta monitoram:

#iekļauts

Wire.begin(4); // izveidot savienojumu ar i2c kopni ar adresi #4

Wire.onReceive(receiveEvent); // reģistrēt notikumu apstrādātāju

Serial.begin(9600); // atver seriālā porta monitoru

// šī funkcija tiek izsaukta vienmēr no galvenās puses

// nāk nākamie dati, šī funkcija ir reģistrēta kā apstrādātājs

// notikumi, skatiet setup()

nevar saņemtEvent(in cik daudz) (

kamēr (1< Wire.available()) { // цикл по всем принятым байтам, кроме

// Pēdējais

Serial.print(c); // izdrukā simbolu

Serial.println(x); // izdrukāt veselu skaitli

Pirmais, kas jāpamana šajā skicē, ir tas, ka funkcijai Wire.begin tiek nodots 4. parametrs. Tas norāda pakārtotās ierīces adresi I2C kopnē, šajā gadījumā 4. Tai ir jāatbilst adresei, ko galvenā ierīce izmanto, lai nosūtītu. ziņas.

PADOMS

Jūs varat savienot daudzas Arduino slave plates ar vienu divu vadu kopni, ja tām visām ir dažādas I2C adreses.

Vergu skice atšķiras no galvenās skices, jo tā izmanto pārtraukumus, lai saņemtu ziņojumus no galvenā. Ziņojumu apstrādātāja iestatīšana tiek veikta, izmantojot funkciju onReceive, ko sauc par pārtraukumu rutīnām (3. nodaļa). Šīs funkcijas izsaukums ir jāievieto iestatīšanas funkcijā, lai nodrošinātu, ka lietotāja definētā funkcija ReceiveEvent tiek izsaukta, kad tiek saņemti ienākošie ziņojumi.

Funkcija ReceiveEvent aizņem vienu parametru - lasīšanai gatavu baitu skaitu. Šajā gadījumā šis skaitlis tiek ignorēts. Cilpa while nolasa visas pieejamās rakstzīmes pēc kārtas un izvada tās uz seriālā porta monitoru. Pēc tam tiek nolasīts viens viena baita numurs ziņojuma beigās un izvadīts porta monitorā. Println izmantošana rakstīšanas vietā nodrošina, ka baita vērtība tiek drukāta kā skaitlis, nevis rakstzīme ar atbilstošo ciparu kodu (7.7. attēls).

Rīsi. 7.7. Ziņojumu izvadīšana, ko viena Arduino plate saņem no citas, izmantojot I2C interfeisu, uz porta monitoru

Dēļi ar LED indikatoriem

Vēl viens plašs I2C ierīču klāsts ir dažāda veida displeji. Tipiskākie šo ierīču pārstāvji ir Adafruit ražotās LED matricas un septiņu segmentu indikatori. Tajos ir LED displeji, kas uzstādīti uz iespiedshēmas plates, un vadības mikroshēmas, kas atbalsta I2C saskarni. Šis risinājums novērš nepieciešamību izmantot lielu skaitu I/O tapu uz Arduino plates, lai vadītu LED displeju, un ļauj jums iztikt tikai ar divām tapām, SDA un SCL.

Bibliotēkas slēpj visas I2C mijiedarbības aiz savas fasādes, ļaujot izmantot augsta līmeņa komandas, kā parādīts tālāk sniegtajā fragmentā, kas ņemts no bibliotēkai pievienotā piemēra:

#iekļauts

#include "Adafruit_LEDBackpack.h"

#include "Adafruit_GFX.h"

Adafruit_8x8matrix matrica = Adafruit_8x8matrix();

matrica.begin(0x70);

matrica.drawLine(0, 0, 7, 7, LED_RED);

matrica.writeDisplay();

Reālā laika pulkstenis DS1307

Vēl viena izplatīta I2C ierīce ir DS1307 reāllaika pulksteņa modulis. Šim modulim ir arī ērta un izturīga bibliotēka, kas atvieglo mijiedarbību ar moduli, nerisinot faktiskos I2C ziņojumus. Bibliotēku sauc par RTClib, un tā ir pieejama vietnē https://github.com/adafruit/RTClib.

Tālāk norādītie koda fragmenti ir ņemti arī no piemēriem, kas sniegti kopā ar bibliotēku:

#iekļauts

#include "RTClib.h"

Serial.begin(9600);

if (!RTC.isrunning()) (

Serial.println("RTC NEdarbojas!");

// ierakstiet datumu un laiku, kad skice tika apkopota modulī

RTC.adjust(DateTime(__DATE__, __TIME__));

Datums un laiks tagad = RTC.now();

Serial.print(tagad.gads(), DEC);

Serial.print("/");

Serial.print(tagad.mēnesis(), DEC);

Serial.print("/");

Serial.print(tagad.diena(), DEC);

Serial.print(" (");

Serial.print(daysOfThe Week);

Serial.print() ");

Serial.print(tagad.stunda(), DEC);

Serial.print(":");

Serial.print(tagad.minūte(), DEC);

Serial.print(":");

Serial.print(tagad.second(), DEC);

Serial.println();

Ja vēlaties uzzināt, kā patiesībā darbojas I2C mijiedarbība, vienkārši apskatiet bibliotēkas failus. Piemēram, RTClib bibliotēkas avota kods tiek glabāts failos RTClib.h un RTClib.cpp. Šie faili atrodas mapē bibliotēkas/RTClib.

Piemēram, failā RTClib.cpp varat atrast funkcijas tagad definīciju:

Datums un laiks RTC_DS1307::now() (

Wire.beginTransmission(DS1307_ADDRESS);

Wire.endTransmission();

Wire.requestFrom(DS1307_ADRESE, 7);

uint8_t ss = bcd2bin(Wire.read() & 0x7F);

uint8_t mm = bcd2bin(Wire.read());

uint8_t hh = bcd2bin(Wire.read());

uint8_t d = bcd2bin(Wire.read());

uint8_t m = bcd2bin(Wire.read());

uint16_t y = bcd2bin(Wire.read()) + 2000;

return DateTime(y, m, d, hh, mm, ss);

Funkcija Wire.read atgriež vērtības Binary-Coded Decimal (BCD) formātā, tāpēc tās tiek pārveidotas baitos, izmantojot bibliotēkas funkciju bcd2bin.

BCD formātā baits ir sadalīts divos 4 bitu nibblos. Katrs nibble ir viens cipars no divciparu decimālskaitļa. Tādējādi skaitlis 37 BCD formātā tiktu attēlots kā 0011 0111. Pirmie četri biti atbilst decimālajai vērtībai 3, bet otrie četri biti atbilst decimālajai vērtībai 7.

Beidzot

Šajā nodaļā jūs uzzinājāt par I2C saskarni un to, kā to izmantot, lai sazinātos ar Arduino platēm un perifērijas ierīcēm, kā arī citām Arduino platēm.

Nākamajā nodaļā mēs izpētīsim cita veida seriālo interfeisu, ko izmanto saziņai ar perifērijas ierīcēm. Tas tiek saukts 1-vads. Šo interfeisu neizmanto tik plaši kā I2C, taču to izmanto populārajā temperatūras sensorā DS18B20.

Man vajadzēja izveidot pulksteni, pamatojoties uz mikroshēmu, kurai ir I 2 C saskarne. RTC mikroshēma, ts. "reālā laika pulkstenis" PCF8583.

Mikroshēmas iekšpusē ir: pulkstenis, modinātājs, taimeris, kalendārs (līkne) un 240 baitu operatīvā atmiņa, kurā var ierakstīt jebkuru informāciju. RAM ir ļoti noderīga lieta, atšķirībā no zibatmiņas, RAM nav ierobežojumu pārrakstīšanas ciklu skaitam, un tajā var saglabāt dažus datus un iestatījumus, cik bieži vien vēlaties.

Bet bija viena problēma - es patiešām negribēju rakstīt kodu, tāpēc nolēmu internetā atrast gatavu kodu. Kā vēlāk izrādījās, to atrast vajadzēja “pašam”. Es lejupielādēju piemēru darbam ar I 2 C, izlaboju to un mirgoju mikrokontrolleri. Tas nedarbojās. Es sāku bakstīties pa kodu, meklējot iemeslu, kāpēc tas nedarbojas... un es biju šausmās!! Dažos gadījumos ierakstīšana tika veikta visā portā uzreiz, nevis konkrētiem bitiem. Tādējādi, ja portam pievienojat kaut ko citu, piemēram, displeju, visticamāk, tas nedarbosies. Arī datu nolasīšana autobusā tika ieviesta nepareizi (neģenerējot uztveršanas beigu nosacījumu vai vienkārši bez NACK). Bet tā ir puse no problēmas. Galvenā problēma ir atšķirīga. Bieži vien koda autors pieslēgvietai uzstādīja loģisku “1”, un, kā zināms, I 2 C kopne tiek vadīta, “pievelkot” SDA un SCL tapas pie kopējā vada. Un loģiskais “1” uz autobusa savukārt veidojas, pavelkot barošanas bloku uz plusu ar 4,7 kiloomu rezistoriem. Tādējādi, ja mikrokontrollera izeja ir iestatīta uz loģisku “1”, un pakārtotā ierīce “velk” šo izvadi uz kopējo vadu, tiks izveidots īssavienojums. Man tas ļoti nepatika, un es nolēmu no jauna izgudrot savu riteni un uzrakstīt savu bibliotēku, pareizāk sakot, pat 2 bibliotēkas: vienu darbam ar I 2 C kopni, bet otru tieši darbam ar PCF8583 reāllaikā. pulkstenis. Jā, starp citu, kods ir rakstīts .

Lai I 2 C bibliotēku savienotu ar projektu, jums tā jāiekļauj, izmantojot iekļaušanu, kā attēlā, kā arī jākopē bibliotēka projekta mapē.

Pēc tam jāatver fails “i2c.h” un jānorāda mikrokontrollera tapas, kas darbosies kā kopne I 2 C. Pēc noklusējuma kopne ir konfigurēta uz tapām PC0 (SCL) un PC1 (SDA). ). Un iestatīšana tiek veikta šeit:

Tas arī viss, esam pievienojuši I2C bibliotēku, konfigurējuši kājas, un bibliotēka ir gatava lietošanai. Lietošanas piemērs:

I2c_init(); // Inicializēt I2C kopni i2c_start_cond(); //sākt kopni i2c_send_byte (0xA0); // ierīces adrese, kas karājas kopnē i2c_send_byte (0x10); // datu baits, kas tiek ierakstīts ierīcē i2c_send_byte (0x10); // vēl viens datu baits, ko mēs ierakstām ierīcē i2c_stop_cond(); // stop riepas

Pēc apstāšanās nosacījuma mēs varam pārbaudīt, vai viss ir kārtībā ar autobusu I 2 C. Lai to izdarītu, mums ir jāizlasa mainīgais “i2c_frame_error”. Ja viss ir normāli, tad tas būs 0. Ja viena no kopnes tapām nav “pievilkta” pie barošanas avota, un kopnē nav uzstādīts loģiskais “1”, tad bibliotēka ģenerē kļūdu un raksta mainīgā “i2c_frame_error” numuru 1. Izlasiet mainīgo “i2c_frame_error” pēc apturēšanas nosacījuma. Tālāk esošajā attēlā es parādīšu, kā darbojas kļūdu kontrole:

Tagad savienosim PCF8583 reāllaika pulksteņu bibliotēku. Lai to izdarītu, jums jāveic tās pašas darbības. Kopēsim failu "PCF8583.h" uz projekta mapi un pievienosim to iekļaut, kā fotoattēlā:

Gatavs. PCF8583 reāllaika pulksteņu bibliotēka ir pievienota. Tam nav nepieciešami nekādi iestatījumi, tāpēc jūs varat nekavējoties sākt nolasīt laiku un datumu no mikroshēmas. Lūdzu, ņemiet vērā, ka PCF8583 bibliotēka darbojas, izmantojot I2C bibliotēku, tāpēc, ja mēs vēlamies strādāt ar PCF8583, mums ir jāsavieno abas bibliotēkas!

Bibliotēkas izmantošanas piemērs (rakstīšanas un lasīšanas laiks un datums):

// Inicializēt I2C kopni i2c_init(); // Sagatavojiet laiku un datumu rakstīšanai uz PCF8583 mikroshēmu PCF_hour=23; // 23 stundas PCF_min=59; // 59 minūtes PCF_day=31; // 31. diena PCF_month=12; // 12. mēnesis - decembris PCF_year=0; // gads (0 - nav garais gads) PCF_weekday=6; // 6. nedēļas diena (svētdiena) // Ierakstiet laiku un datumu PCF8583 mikroshēmā PCF_write_hh_mm_ss(); // Lasīt laiku un datumu no PCF8583 mikroshēmas PCF_read_hh_mm_ss(); Piemērs darbam ar RAM (rakstīšana un lasīšana): // Sagatavojiet 5 baitus rakstīšanai PCF8583 mikroshēmā PCF_data_ram_1=255; // 1. baits PCF_data_ram_2=255; // 2. baits PCF_data_ram_3=255; // 3. baits PCF_data_ram_4=255; // 4. baits PCF_data_ram_5=255; // 5. baits // Ierakstiet 5 baitus PCF8583 mikroshēmā PCF_write_ram(); // Lasīt 5 baitus no PCF8583 mikroshēmas PCF_read_ram();

Nolasīšana no mikroshēmas ir vēl vienkāršāka - vienkārši izsauciet funkcijuPCF_ lasīt_ hh_ mm_ ss() pēc tam laiks un datums parādīsies mainīgajos lielumos, no kurienes jūs tos vienkārši paņemsit. Lai lasītu RAM, mēs attiecīgi izmantojam funkcijuPCF_ lasīt_ auns() pēc tam mēs apkopojam datus mainīgajosPCF_ datus_ auns_ N

Šeit ir mainīgo lielumu saraksts, kur un kas tiek glabāts:

// laiks un datums PCF_stunda=0; // laiks, stundas (no 0 līdz 23, pārplūdes aizsardzība rakstot un lasot) PCF_min=0; // laiks, minūtes (no 0 līdz 59, aizsardzība pret pārplūdi rakstot un lasot) PCF_sec=0; // laiks, sekundes (tikai lasāms, rakstot atiestatīt uz 00) PCF_day=0; // diena (no 1 līdz 31, pārpildes aizsardzība rakstot un lasot) PCF_weekday=0 // nedēļas diena (0-pirmdiena; 6-svētdiena, pārplūdes aizsardzība rakstot un lasot) PCF_month=0; // mēnesis (no 1 līdz 12, aizsardzība pret pārplūdi rakstot un lasot) PCF_year=0; // gads (0-lēciens; 1,2,3-nelēciens, pārplūdes aizsardzība rakstot un lasot) // RAM PCF_data_ram_1; // Dati (PCF8583 RAM), 1. baits PCF_data_ram_2; // Dati (PCF8583 RAM), 2. baits PCF_data_ram_3; // Dati (PCF8583 RAM), 3. baits PCF_data_ram_4; // Dati (PCF8583 RAM), 4. baits PCF_data_ram_5; // Dati (PCF8583 RAM), 5. baits

Tagad es jums pastāstīšu par aizsardzību pret pārplūdi. Pieņemsim, ka mēs aizmirsām pievienot mikroshēmu. Nolasīsim datus no mikroshēmas, un... tiks nolasīts baits 11111111 jeb cipars 255. Lieta tāda, ka I 2 C kopne ir balstīta uz 2 uzvilkšanas rezistoriem, tāpēc tie mums dod loģiskos “vienos” ja mikroshēma nav pievienota. Lai aizsargātos pret šādiem gadījumiem, PCF8583 bibliotēkā uztaisīju pārpildes aizsardzību, kas rūpējas, lai pulkstenis tev nerāda 62 stundas 81 minūti... Pārpildes esamību var uzraudzīt, nolasot “PCF_overflow” mainīgo. Ja tas ir 0, tad pārpildes kļūdu nebija. Ja tajā ir 1 vai vairāk, tad ir pārpildes kļūdas. Pēc datuma un laika nolasīšanas funkcijas ir jāizlasa mainīgais “PCF_overflow”.PCF_ lasīt_ hh_ mm_ ss()

Skaidrības labad ir pievienots AVR Studio 6 projekts priekš ATmega32. Varat pārkompilēt jebkuram AVR. Projektā pieslēdzu arī displeju vizuālai kontrolei. Kad tiek pieslēgta strāva, mikrokontrolleris iestata 23 stundas 59 minūtes, 31. decembris, svētdiena. Un pēc minūtes tas kļūst 00 stundas 00 minūtes, 1. janvāris, pirmdiena.

Tagad es jums pastāstīšu, kāpēc es runāju par šīs mikroshēmas “greizo” kalendāru. Lieta tāda, ka mikroshēma nezina, kā saglabāt pašreizējo kalendāro gadu, bet tikai saglabā garā gada karogu. Īsumā:
0 – garais gads
1 – nav garais gads
2 – nav garais gads
3 – nav garais gads

Un tā tālāk ciklā 0-1-2-3-0-1-2-3-0...

Parasti, lai izveidotu parastu kalendāru, ir jāievieš programmatūras aprēķins un gada saglabāšana, piemēram, tajā pašā PCF8583 RAM, taču tas nav ērti. Un galvenais ir tas, ka, ja ķēde tiek atslēgta, ak, neviens nepārrakstīs atmiņu...

Raksta beigās pievienoju arī nelielu video reportāžu. Varu teikt, ka esmu iesācējs programmēšanā, lai gan programmēju jau 3 gadus (pamazām), par kodu strikti nevērtēju, ja ir kādi papildinājumi vai komentāri, rakstiet, izlabosim. Lai visiem laimīgs rokdarbs!

Radioelementu saraksts

Vadu bibliotēkas apraksts

Šī bibliotēka ļauj mijiedarboties ar I2C / TWI ierīcēm. Arduino plāksnēm ar R3 izkārtojumu (pinout 1.0) SDA (datu līnija) un SCL (pulksteņa līnija) atrodas uz tapām netālu no AREF tapas. Arduino Due ir divas I2C/TWI saskarnes: SDA1 un SCL1 atrodas netālu no AREF tapas, un papildu līnijas atrodas uz kontaktiem 20 un 21.

Tālāk esošajā tabulā parādīts, kur atrodas TWI tapas uz dažādām Arduino plāksnēm.

Kopš Arduino 1.0 šī bibliotēka pārmanto Stream funkcijas, padarot to saderīgu ar citām lasīšanas/rakstīšanas bibliotēkām. Šī iemesla dēļ send() un Receive() ir aizstāti ar read() un write() .

Piezīme

Ir 7 un 8 bitu I2C adrešu versijas. 7 biti identificē ierīci, bet 8. bits nosaka, vai ierīce tiek rakstīta vai lasīta. Wire bibliotēka izmanto 7 bitu adreses. Ja jums ir datu lapa vai koda paraugs, kurā tiek izmantota 8 bitu adrese, jums ir jāapgriež vismazāk nozīmīgais bits (t.i., jāpārvieto vērtība par vienu bitu pa labi), lai iegūtu adresi no 0 līdz 127. Taču adreses no 0 līdz 7 netiek izmantoti, jo tie ir rezervēti, tāpēc pirmā adrese, ko var izmantot, ir 8. Ņemiet vērā, ka, pievienojot SDA/SCL tapas, ir nepieciešami uzvilkšanas rezistori. Lai iegūtu sīkāku informāciju, skatiet piemērus. MEGA 2560 platei ir uzvilkšanas rezistori uz 20. un 21. tapām.

Metožu apraksts

Wire.begin()

Inicializē Wire bibliotēku un izveido savienojumu ar I2C kopni kā galveno vai pakārtoto. Parasti to vajadzētu izsaukt tikai vienu reizi.

Sintakse

Wire.begin(adrese)

Iespējas

adrese: pakārtotās ierīces 7 bitu adrese (pēc izvēles); ja nav norādīts, dēlis ir savienots ar kopni kā galvenais.

Atdeves vērtība

Piemērs

Slavierīces piemērus skatiet onReceive() un onRequest() metožu piemēros. Galvenās ierīces piemērus skatiet pārējo metožu piemēros. .

Wire.requestFrom()

To izmanto kapteinis, lai pieprasītu baitus no vergu. Šos baitus var iegūt, izmantojot pieejamās () un lasīšanas () metodes.

Ja šis arguments ir patiess, requestFrom() pēc pieprasījuma nosūta STOP ziņojumu, atbrīvojot I2C kopni.

Ja šis arguments ir nepatiess, requestFrom() pēc pieprasījuma nosūta RESTART ziņojumu. Kopne netiek atbrīvota, kas neļauj citai galvenajai ierīcei nokļūt starp ziņojumiem. Tas ļauj vienam kapteinim nosūtīt vairākus pieprasījumus, kamēr tas kontrolē kopni.

Sintakse

Wire.requestFrom(adrese, daudzums)

Wire.requestFrom(adrese, daudzums, pietura)

Iespējas

• adrese: ierīces 7 bitu adrese, no kuras tiek pieprasīti baiti;
• daudzums: pieprasīto baitu skaits;
• pietura: Būla. true pēc pieprasījuma nosūta STOP ziņojumu. false pēc pieprasījuma nosūta RESTART ziņojumu, saglabājot savienojumu aktīvu.

baits: no vergu atgriezto baitu skaits.

Piemērs

Wire.beginTransmission()

Sāk pārraidi uz I2C slave ierīci ar norādīto adresi. Pēc tam pārsūtāmo baitu secība tiek ievietota rindā, izmantojot funkciju write (), un tie tiek pārsūtīti, izmantojot izsaukumu endTransmission ().

Sintakse

Wire.beginTransmission(adrese)

Iespējas

adrese: tās ierīces 7 bitu adrese, uz kuru jāpārsūta dati.

Atdeves vērtība

Piemērs

Wire.endTransmission()

Pabeidz pārsūtīšanu uz pakārtoto ierīci, kas tika sākta ar metodi beginTransmission() un pārsūta baitus, kas tika ievietoti rindā ar metodi write().

Lai nodrošinātu saderību ar noteiktām I2C ierīcēm, kopš Arduino 1.0.1, requestFrom() pieņem Būla datu tipa argumentu, kas maina tā darbību.

Ja šis arguments ir patiess , tad requestFrom() pēc pārraides nosūta STOP ziņojumu, atbrīvojot I2C kopni.

Ja šis arguments ir nepatiess, requestFrom() pēc pārsūtīšanas nosūta RESTART ziņojumu. Kopne netiek atbrīvota, kas neļauj citai galvenajai ierīcei nokļūt starp ziņojumiem. Tas ļauj vienam kapteinim nosūtīt vairākas pārraides, kamēr tas uzrauga kopni.

Pēc noklusējuma šis arguments ir patiess.

Sintakse

Wire.endTransmission()

Wire.endTransmission(stop)

Iespējas

pietura: Būla. true pēc pārraides nosūta STOP ziņojumu. false pēc pārsūtīšanas nosūta RESTART ziņojumu, saglabājot savienojumu aktīvu.

Atdeves vērtība

baits, kas norāda pārsūtīšanas statusu:

• 0: veiksme;
• 1: dati ir pārāk gari, lai aizpildītu pārraides buferi;
• 2: NACK saņemts, pārsūtot adresi;
• 3: NACK saņemts, pārsūtot datus;
• 4: citas kļūdas.

Skatiet rakstīšanas () metodes piemēru.

Wire.write()

Raksta datus no palīgierīces, reaģējot uz galvenā servera pieprasījumu, vai sastāda baitus pārsūtīšanai no galvenā uz pakārtoto ierīci (starp izsaukumiem beginTransmission() un endTransmission()).

Sintakse

Wire.write(vērtība)

Wire.write(string)

Wire.write(dati, garums)

Iespējas

• vērtība: pārsūtāmā vērtība, viens baits.
• virkne: pārsūtāmā virkne, baitu secība.
• dati: pārsūtāmo datu masīvs, baiti.
• garums: pārsūtāmo baitu skaits.

baits: write() atgriež uzrakstīto baitu skaitu, lai gan šī skaitļa lasīšana nav nepieciešama.

Piemērs #include baits val = 0; void setup() ( Wire.begin(); // izveidot savienojumu ar i2c kopni ) void loop() ( Wire.beginTransmission(44); // pārsūtīt uz ierīci #44 (0x2c) // ierīces adrese ir norādīta vadā tehniskais apraksts. write(val); // nosūtīt vērtības baitu Wire.endTransmission(); // apturēt pārraidi val++; // palielināt vērtību if(val == 64) // ja esam sasnieguši 64. vērtību (max) ( val = 0; // sākt no sākuma ) aizkave (500); )

Wire.available()

Atgriež pieejamo baitu skaitu, ko var izgūt, izmantojot read() . Šī metode ir jāizsauc galvenajā ierīcē pēc requestFrom() izsaukšanas vai pakārtotajā apdarinātājā onReceive().

Sintakse

Wire.available()

Iespējas

Atdeves vērtība

Lasīšanai pieejamo baitu skaits.

Piemērs

Skatiet lasīt() metodes piemēru.

Wire.read()

Nolasa baitu, kas tika pārsūtīts no palīgierīces uz galveno pēc pieprasījumaFrom() izsaukšanas vai kas tika pārsūtīts no galvenā uz vergu.

Sintakse

Iespējas

Atdeves vērtība

baits: saņemts nākamais baits.

Piemērs #include baits val = 0; void setup() ( Wire.begin(); // izveidot savienojumu ar i2c kopni (galvenā adrese nav obligāta) Serial.begin(9600); // konfigurēt seriālo portu izvadei ) void loop() ( Wire.requestFrom(2) , 6); // pieprasīt 6 baitus no slave #2 while(Wire.available()) // slave var nosūtīt mazāk nekā pieprasīts ( char c = Wire.read(); // pieņemt baitu kā Serial.print rakstzīmi ( c); // izdrukāt rakstzīmi ) delay (500); )

Wire.setClock()

Maina pulksteņa frekvenci I2C kopnes komunikācijai. I2C vergiem nav minimālās darbības pulksteņa frekvences, bet parasti tiek izmantots 100 kHz.

Sintakse

Wire.setClock(pulksteņa frekvence)

Iespējas

clockFrequency: pulksteņa signāla frekvences vērtība (hercos). Pieņemamās vērtības ir 100 000 (standarta režīms) un 400 000 (ātrais režīms). Daži procesori atbalsta arī 10000 (zema ātruma režīms), 1000000 (ātrais plus režīms) un 3400000 (ātrgaitas režīms). Lai pārliecinātos, ka nepieciešamais režīms tiek atbalstīts, skatiet sava procesora tehnisko dokumentāciju.

Atdeves vērtība

Wire.onReceive()

Reģistrē funkciju, kas tiks izsaukta, kad slavenais saņems pārraidi no galvenā.

Sintakse

Wire.onReceive (apstrādātājs)

Iespējas

apdarinātājs: funkcija, kas jāizsauc, kad pakārtotā ierīce saņem datus; tam vajadzētu ņemt vienu parametru int (no galvenā nolasīto baitu skaitu) un neko neatgriezt, t.i.:

Void myHandler (int numBytes)

Atdeves vērtība

Piemērs

#iekļauts void setup() ( Wire.begin(8); // izveidot savienojumu ar i2c kopni ar adresi #8 Wire.onReceive(receiveEvent); // reģistrēt notikumu apdarinātāju Serial.begin(9600); // konfigurēt seriālo portu output ) void loop() ( delay(100); ) // funkcija, kas tiks izpildīta ikreiz, kad tiks saņemti dati no galvenā // šī funkcija ir reģistrēta kā notikumu apstrādātājs, skatiet setup() void ReceiveEvent(int howMany) ( kamēr (1< Wire.available()) // пройтись по всем до последнего { char c = Wire.read(); // принять байт как символ Serial.print(c); // напечатать символ } int x = Wire.read(); // принять байт как целое число Serial.println(x); // напечатать число }

Wire.onRequest()

Reģistrē funkciju, kas tiks izsaukta, kad galvenais pieprasīs datus no slave.

Sintakse

Wire.onRequest(apstrādātājs)

Iespējas

apdarinātājs: funkcija, kas tiks izsaukta, tai nav nepieciešami parametri un nekas netiek atgriezts, t.i.:

anulēt myHandler()

Atdeves vērtība

Piemērs

Kods Arduino platei, kas darbojas kā vergs:

#iekļauts void setup() ( Wire.begin(8); // izveidot savienojumu ar i2c kopni ar adresi #8 Wire.onRequest(requestEvent); // reģistrēt notikumu apstrādātāju ) void loop() ( delay(100); ) // funkcija, kas tiks izpildīta ikreiz, kad galvenais // pieprasa datus // šī funkcija ir reģistrēta kā notikumu apstrādātājs, skatiet setup() void requestEvent() ( Wire.write("sveiki"); // atbildiet ar ziņojumu )