Populārais I2C protokols nodrošina divu vai vairāku Arduino dēļu saziņu. Uzziniet, kā tos savienot un kodēt.

Lai gan viens Arduino var veikt daudzus uzdevumus, dažos projektos var būt nepieciešams izmantot vairāk nekā vienu plati, lai apstrādātu dažādas funkcijas. Tātad, lai iespējotu datu pārsūtīšanu starp diviem mikrokontrolleriem, ir jāiestata sakaru protokols, piemēram, CAN, SPI, I2C vai UART.

Šajā rokasgrāmatā mēs apskatīsim I2C darbības pamatus, aparatūras savienojumus un programmatūras ieviešanu, kas nepieciešama, lai iestatītu divas Arduino plates kā I2C galvenās un pakārtotās ierīces.

Kas ir I2C?

Inter-Integrated Circuit (I2C) ir plaši izmantots sakaru protokols iegultās sistēmās un mikrokontrolleros, lai nodrošinātu datu pārsūtīšanu starp elektroniskām ierīcēm. Atšķirībā no SPI (Serial Peripheral Interface), I2C ļauj pieslēgt vairāk nekā vienu galveno ierīci kopnei ar vienu vai vairākām palīgierīcēm. Pirmo reizi to izmantoja Philips, un tas ir pazīstams arī kā divu vadu interfeisa (TWI) sakaru protokols.

Kā darbojas I2C komunikācija?

I2C izmanto divas divvirzienu līnijas: sērijas datus (SDA) un sērijas pulksteni (SCL), lai pārsūtītu datus un sinhronizētu saziņu starp ierīcēm. Katrai ierīcei, kas savienota ar I2C kopni, ir unikāla adrese, kas to identificē sakaru laikā. I2C protokols ļauj vairākām ierīcēm koplietot vienu kopni, un katra ierīce var darboties kā galvenā vai pakārtotā ierīce.

Komunikāciju uzsāk galvenā ierīce, un nepareiza palīgierīču adresēšana var izraisīt pārsūtīšanas kļūdas. Iepazīstieties ar mūsu padziļināto ceļvedi kā darbojas UART, SPI un I2C seriālie sakari lai sniegtu jums kādu kontekstu.

Ievērības cienīga I2C komunikācijas galvenā priekšrocība ir elastība, ko tā piedāvā enerģijas pārvaldībā. Ierīces, kas darbojas dažādos sprieguma līmeņos, joprojām var efektīvi sazināties ar sprieguma pārslēdzēju palīdzību. Tas nozīmē, ka ierīcēm, kas darbojas ar 3,3 V, ir nepieciešami sprieguma pārslēdzēji, lai izveidotu savienojumu ar 5 V I2C kopni.

Vadu bibliotēka

Wire bibliotēka ir iebūvēta Arduino bibliotēka, kas nodrošina funkcijas saziņai, izmantojot I2C. Tas izmanto divas tapas — SDA un SCL — uz Arduino plates I2C saziņai.

Arduino Uno I2C tapas:

Arduino Nano I2C tapas:

Lai izmantotu bibliotēku, jāiekļauj Vads.h galvenes failu Arduino skices sākumā.

#ietver

Wire bibliotēka nodrošina funkcijas, lai uzsāktu saziņu ar I2C ierīci, nosūtītu datus un saņemtu datus. Dažas svarīgas funkcijas, kas jums jāzina, ietver:

  • Wire.begin(): izmanto, lai pievienotos I2C kopnei un uzsāktu saziņu.
  • Wire.beginTransmission(): izmanto, lai norādītu vergu adresi un sāktu pārraidi.
  • Wire.write(): izmanto, lai nosūtītu datus uz I2C ierīci.
  • Wire.endTransmission(): izmanto, lai beigtu pārraidi un pārbaudītu, vai nav kļūdu.
  • Wire.requestFrom(): izmanto, lai pieprasītu datus no I2C ierīces.
  • Wire.available(): izmanto, lai pārbaudītu, vai dati ir pieejami lasīšanai no I2C ierīces.
  • Wire.read(): izmanto, lai nolasītu datus no I2C ierīces.

Izmantojiet Wire.beginTransmission() funkcija, lai iestatītu sensora adresi, kas tiek ievietota kā arguments. Piemēram, ja sensora adrese ir 0x68, jūs izmantotu:

Vads.startTransmission(0x68);

Arduino I2C aparatūras iestatīšana

Lai savienotu divas Arduino plates, izmantojot I2C, jums būs nepieciešami šādi aparatūras komponenti:

  • Divi Arduino dēļi (master un slave)
  • Maizes dēlis
  • Džemperu vadi
  • Divi 4,7kΩ uzvilkšanas rezistori

Savienojiet SDA un SCL abu Arduino dēļu tapas pie maizes dēļa. Savienojiet uzvilkšanas rezistorus starp SDA un SCL tapas un 5V barošanas sliede uz maizes dēļa. Visbeidzot, savienojiet abus maizes dēļus kopā, izmantojot džemperu vadus.

Arduino Uno ķēde

Arduino nano ķēde

Attēla kredīts: Arduino I2C dokumentācija

Arduino dēļu iestatīšana kā I2C galvenās un vergu ierīces

Izmantojiet Wire.requestFrom() funkcija, lai norādītu vergu ierīces adresi, ar kuru mēs vēlamies sazināties. Pēc tam izmantojiet Wire.read() funkcija, lai iegūtu datus no vergu ierīces.

Galvenās ierīces kods:

#ietver
nederīgsuzstādīt(){
Vads.sākt(); // pievienoties i2c kopnei
Seriāls.sākt(9600); // sākt sēriju izvadei
}
nederīgssaņemtDati(){
starpt adrese = 8;
starpt bytesToRead = 6;
Vads.pieprasījumsNo(adrese, bytesToRead);
kamēr (Vads.pieejams()) {
char dati = Vads.lasīt();
Seriāls.drukāt(dati);
}
kavēšanās(500);
}
nederīgscilpa(){
saņemtDatus ();
}

The Wire.onReceive() funkcija tiek izmantota, lai norādītu, ko darīt, kad slave saņem datus no galvenās ierīces. Iepriekš minētajā kodā Wire.available() funkcija pārbauda, ​​vai dati ir pieejami, un Wire.read() funkcija nolasa galvenās ierīces nosūtītos datus.

Vergu ierīces kods:

#ietver
nederīgsuzstādīt(){
Vads.sākt(8); // pievienojieties I2C kopnei ar adresi 8
Vads.onReceive(receiveEvent); // zvanīt saņemtEvent, kad tiek saņemti dati
}
nederīgscilpa(){
kavēšanās(100);
}
nederīgssaņemtEvent(starpt baiti){
Vads.rakstīt("Sveiki "); // atbildiet ar 6 baitu ziņojumu, kā to paredzējis galvenais
}

Datu sūtīšana un saņemšana, izmantojot I2C

Šajā piemērā nolasīsim temperatūru no DHT11 temperatūras sensora, kas savienots ar vergu Arduino, un izdrukāsim to galvenā Arduino seriālajā monitorā.

Modificēsim kodu, ko rakstījām iepriekš, lai iekļautu temperatūras mērījumus, ko mēs pēc tam nosūtīsim uz galveno plati, izmantojot I2C kopni. Pēc tam galvenā plate var nolasīt mūsu nosūtīto vērtību un pēc tam parādīt to sērijas monitorā.

Galvenās ierīces kods:

#ietver
nederīgsuzstādīt(){
Vads.sākt();
Seriāls.sākt(9600);
Seriāls.println("Meistars inicializēts!");
}
nederīgscilpa(){
Vads.pieprasījumsNo(8, 1); // Pieprasīt temperatūras datus no slave
ja (Vads.pieejams()) {
baits temperatūra = Vads.lasīt(); // Nolasīt temperatūras datus no slave
Seriāls.drukāt("Temperatūra: ");
Seriāls.drukāt(temperatūra);
Seriāls.println("° C");
}
kavēšanās(2000); // Uzgaidiet 2 sekundes, pirms atkal pieprasāt temperatūru
}

Vergu ierīces kods:

#ietver
#ietver
#definēt DHTPIN 4 // Tap savienota ar DHT sensoru
#definēt DHTTIPS DHT11 // DHT sensora tips
DHT dht(DHTPIN, DHTTYPE);
baits temperatūra;


nederīgsuzstādīt(){
Vads.sākt(8); // Vergu adrese ir 8
Vads.pēc pieprasījuma(requestEvent);
dht.sākt();
}


nederīgscilpa(){
kavēšanās(2000); // Pagaidiet 2 sekundes, līdz DHT stabilizējas
temperatūra = dht.lasīt Temperatūra(); // Nolasīt temperatūru no DHT sensora
}
nederīgspieprasījumsNotikums(){
Vads.rakstīt(temperatūra); // Sūtīt temperatūras datus meistaram
}

Varat pielāgot šo kodu, lai tas atbilstu tiem sensoriem, kas jums varētu būt jūsu projektā, vai pat parādīt sensoru vērtības displeja modulī, lai izveidojiet savu telpas termometru un mitruma mērītāju.

Slave Addressing ar I2C uz Arduino

Lai šādā projektā nolasītu vērtības no komponentiem, kas pievienoti I2C kopnei, ir svarīgi, lai kodēšanas laikā iekļautu pareizo slave adresi. Par laimi Arduino piedāvā skenera bibliotēku, kas vienkāršo vergu identificēšanas procesu adreses, novēršot vajadzību izsijāt garas sensoru datu lapas un mulsināt tiešsaistē dokumentācija.

Izmantojiet šo kodu, lai identificētu jebkuras I2C kopnē esošās pakārtotās ierīces adreses.

#ietver // Iekļaujiet Wire bibliotēku I2C saziņai
nederīgsuzstādīt(){
Vads.sākt(); // Inicializējiet I2C komunikāciju
Seriāls.sākt(9600); // Inicializējiet seriālo komunikāciju ar datu pārraides ātrumu 9600
kamēr (!Seriāls); // Pagaidiet, līdz tiek izveidots seriālais savienojums
Seriāls.println("\nI2C skeneris"); // Izdrukājiet ziņojumu, kas norāda uz I2C skenēšanas sākumu
}


nederīgscilpa(){
baits kļūda, adrese; // Deklarējiet mainīgos, lai saglabātu kļūdas un ierīces adreses
starpt nIerīces; // Deklarē mainīgo, lai saglabātu atrasto ierīču skaitu


Seriāls.println("Skenē..."); // Izdrukājiet ziņojumu, kas norāda uz I2C skenēšanas sākumu


nIerīces = 0; // Iestatiet atrasto ierīču skaitu uz 0
priekš (adrese = 1; adrese < 127; adrese++) { // Atkārtojiet visas iespējamās I2C adreses
Vads.startTransmission(adrese); // Sākt pārraidi uz pašreizējo adresi
kļūda = Vads.beigas Transmisija(); // Pabeidziet pārraidi un saglabājiet visas kļūdas


ja (kļūda == 0) { // Ja kļūdas netika atrastas
Seriāls.drukāt("I2C ierīce atrasta adresē 0x"); // Izdrukājiet ziņojumu, kas norāda, ka ierīce ir atrasta
ja (adrese < 16) Seriāls.drukāt("0"); // Ja adrese ir mazāka par 16, formatēšanas nolūkos pievienojiet sākuma 0
Seriāls.drukāt(adrese, HEX); // Drukājiet adresi heksadecimālā formātā
Seriāls.println(" !"); // Izdrukājiet ziņojumu, kas norāda, ka ierīce ir atrasta
nDevices++; // Palieliniet atrasto ierīču skaitu
}
citsja (kļūda == 4) { // Ja tika atrasta kļūda
Seriāls.drukāt("Nezināma kļūda adresē 0x"); // Izdrukājiet ziņojumu, kas norāda, ka ir atrasta kļūda
ja (adrese < 16) Seriāls.drukāt("0"); // Ja adrese ir mazāka par 16, formatēšanas nolūkos pievienojiet sākuma 0
Seriāls.println(adrese, HEX); // Drukājiet adresi heksadecimālā formātā
}
}
ja (nIerīces == 0) { // Ja neviena ierīce netika atrasta
Seriāls.println("Nav atrasta neviena I2C ierīce\n"); // Izdrukājiet ziņojumu, kas norāda, ka neviena ierīce netika atrasta
}
cits { // Ja ierīces tika atrastas
Seriāls.println("pabeigts\n"); // Izdrukājiet ziņojumu, kas norāda uz I2C skenēšanas beigām
}
kavēšanās(5000); // Pirms nākamās skenēšanas sākšanas aizkavējiet 5 sekundes
}

Paplašiniet savu projektu jau šodien

Divu Arduino plātņu saskarne, izmantojot I2C sakaru protokolu, piedāvā elastīgu un efektīvu veidu, kā veikt sarežģītus uzdevumus, kurus nevar veikt ar vienu plati. Izmantojot Wire bibliotēku, saziņa starp abām plāksnēm, izmantojot I2C, ir vienkārša, ļaujot projektam pievienot vairāk komponentu.