Az i2c használata arduino-ban: kommunikáció két arduino tábla között

Korábbi bemutatónkban megismerkedtünk az Arduino SPI kommunikációjával. Ma megismerünk egy másik soros kommunikációs protokollt: I2C (Inter Integrated Circuits). Az I2C és az SPI összehasonlításával az I2C-nek csak két vezetéke van, míg az SPI négyet használ, az I2C-ben pedig lehet több Master és Slave, míg az SPI-ben csak egy master és több slave lehet. Tehát egy projektben egynél több mikrovezérlő van, amelynek mesternek kell lennie, akkor az I2C-t kell használni. Az I2C kommunikációt általában giroszkóppal, gyorsulásmérővel, barometrikus nyomásérzékelőkkel, LED kijelzőkkel stb.

Ebben az Arduino I2C oktatóprogramban I2C kommunikációt fogunk használni két arduino tábla között, és a potenciométer segítségével elküldjük egymásnak (0 és 127 közötti) értékeket. Az értékek az Arduino mindegyikéhez csatlakoztatott 16x2-es LCD-n jelennek meg. Itt az egyik Arduino mester, egy másik pedig rabszolga lesz. Tehát kezdjük az I2C kommunikáció bevezetésével.

Mi az I2C kommunikációs protokoll?

Az IIC kifejezés az „ Inter integrált áramköröket ” jelenti. Általában I2C vagy I négyzetként jelöljük, vagy helyenként 2 vezetékes interfész protokollként (TWI) jelöljük, de mindez ugyanazt jelenti. Az I2C egy szinkron kommunikációs protokoll, vagyis mindkét információt megosztó eszköznek közös órajelet kell használnia. Csak két vezetékkel rendelkezik az információk megosztásához, amelyek közül az egyik a kakasjelre, a másik az adatok küldésére és fogadására szolgál.

Hogyan működik az I2C Communication?

Az I2C kommunikációt először Phillips vezette be. Mint korábban említettük, két huzallal rendelkezik, ezt a két vezetéket két eszközön fogják összekötni. Itt az egyik eszközt masternek , a másikat pedig slave-nek hívják. A kommunikációnak mindig két mester és egy rabszolga között kell történnie és meg kell történnie. Az I2C kommunikáció előnye, hogy egy masterhez több slave is csatlakoztatható.

A teljes kommunikáció ezen a két vezetéken, nevezetesen a soros órán (SCL) és a soros adaton (SDA) keresztül zajlik.

Soros óra (SCL): Megosztja a master által generált órajelet a slave-lel

Soros adatok (SDA): Az adatokat elküldi a Master és a Slave között és között.

A kommunikációt bármikor csak a mester kezdeményezheti. Mivel a buszon egynél több rabszolga van, a mesternek külön címet kell használnia az egyes rabszolgákra. Ha megszólítják, csak az adott címmel rendelkező rabszolga válaszol vissza az információval, míg a többiek kilépnek. Így ugyanazt a buszt használhatjuk több eszközzel való kommunikációhoz.

Az I2C feszültségszintje nincs előre meghatározva. Az I2C kommunikáció rugalmas, azt jelenti, hogy az 5 V-os feszültséggel működő eszköz 5 V-ot használhat az I2C-hez, a 3,3 V-os eszközök pedig 3 V-ot az I2C-kommunikációhoz. De mi van akkor, ha két, különböző feszültséggel működő eszköznek kommunikálnia kell az I2C segítségével? Az 5 V-os I2C busz nem csatlakoztatható 3,3 V-os eszközhöz. Ebben az esetben feszültségváltókat alkalmaznak a két I2C busz közötti feszültségszintek egyezésére.

Van néhány feltétel, amely egy tranzakciót keretbe foglal. Az átvitel inicializálása az SDA csökkenő peremével kezdődik, amelyet „START” feltételként definiálunk az alábbi ábrán, ahol a master magasra hagyja az SCL-t, miközben az SDA-t alacsonyra állítja.

Amint azt a fenti ábra mutatja, Az SDA zuhanó éle a START feltétel hardverindítója. Ezután ugyanazon a buszon lévő összes eszköz hallgatási módba vált.

Ugyanígy az SDA emelkedő széle leállítja az átvitelt, amely a fenti ábrán „STOP” állapotként jelenik meg, ahol a master magasan hagyja az SCL-t, és az SDA-t is HIGH-ra megy. Tehát az SDA emelkedő széle leállítja az átvitelt.

Az R / W bit a következő bájtok továbbításának irányát jelzi, ha HIGH, akkor azt jelenti, hogy a slave továbbít, és ha alacsony, akkor azt jelenti, hogy a master továbbít.

Minden bit minden óracikluson át kerül továbbításra, tehát egy bájt átviteléhez 8 óraciklus szükséges. Minden elküldött vagy fogadott bájt után kilencedik óraciklust tartunk az ACK / NACK számára (nyugtázva / nem nyugtázva). Ezt az ACK bitet egy szolga vagy egy master generálja a helyzettől függően. A ACK bit, SDA van beállítva, hogy az alacsony mester vagy slave 9 ^-én órajelciklusban. Tehát alacsony, ACK-nak tekintik, egyébként NACK.

Hol használható az I2C kommunikáció?

Az I2C kommunikációt csak rövid távú kommunikációra használják. Bizonyos mértékben megbízható, mivel szinkronizált impulzusokkal rendelkezik, hogy okos legyen. Ezt a protokollt főleg szenzorokkal vagy más eszközökkel való kommunikációra használják, amelyeknek információkat kell eljuttatniuk a masterhez. Nagyon hasznos, ha a mikrovezérlőnek sok más szolga modullal kell kommunikálnia, minimum csak vezetékeket használva. Ha nagy hatótávolságú kommunikációra vágyik, próbálja ki az RS232-et, és ha megbízhatóbb kommunikációt szeretne, akkor próbálja ki az SPI protokollt.

I2C Arduinóban

Az alábbi képen láthatóak az Arduino UNO-ban található I2C csapok.

I2C vonal	Tűzd be az Arduino-t
SDA	A4
SCL	A5

Mielőtt belekezdenénk az I2C programozásába két Arduino segítségével. Meg kell tanulnunk az Arduino IDE-ben használt Wire könyvtárat.

A könyvtár része a következő funkciók használatának az I2C kommunikációhoz.

1. Wire.begin (cím):

Használat: Ez a könyvtár kommunikációra szolgál az I2C eszközökkel. Ez indítsa el a Wire könyvtárat, és csatlakozzon az I2C buszhoz mint master vagy slave.

Cím: A 7 bites slave cím opcionális, és ha a cím nincs megadva, akkor ehhez hasonló mesterként csatlakozik a buszhoz.

2. Wire.read ():

Használat: Ezzel a funkcióval leolvasható egy bájt, amelyet a master vagy a slave eszköz kapott, vagy egy slave eszközről egy master eszközre továbbítva a requestFrom () hívást követően, vagy egy masterről egy slave felé továbbítva.

3. Wire.write ():

Használat: Ezzel a funkcióval adatokat írhatunk slave vagy master eszközre.

Slave to Master: A Slave adatokat ír egy masternek, amikor a Wire.RequestFrom () parancsot használják a masterben.

Master to Slave: A masterről a slave eszközre történő továbbításhoz a Wire.write () a Wire.beginTransmission () és a Wire.endTransmission () hívások között használatos .

A Wire.write () a következőképpen írható:

Wire.write (érték)

érték: egy bájtként elküldendő érték.

Wire.write (string):

string: karakterlánc, amelyet bájtsorozatként kell elküldeni.

Wire.write (adatok, hossz):

adatok: bájtként elküldendő adatsor

hossz: az átküldendő bájtok száma.

4. Wire.beginTransmission (cím):

Használat: Ezt a funkciót használjuk az I2C eszközre történő továbbítás megkezdéséhez a megadott slave címmel. Ezt követően készítsen bájtosort az átvitelhez az write () függvénnyel, majd továbbítsa őket az endTransmission () függvény meghívásával. A készülék 7 bites címét továbbítja.

5. Wire.endTransmission ();

Használat: Ez a funkció arra szolgál, hogy befejezze az átvitelt egy szolga eszközre, amelyet a startTransmission () indított el, és továbbítja a Wire.write () által sorbaállított bájtokat.

6. Wire.onRequest ();

Használat: Ezt a funkciót akkor hívják meg, amikor a mester adatokat kér a Wire.requestFrom () használatával a slave eszközről. Itt felvehetjük a Wire.write () függvényt az adatok elküldéséhez a masterhez.

7. Wire.onReceive ();

Használat: Ezt a funkciót akkor hívják meg, amikor egy rabszolga eszköz adatokat fogad a mastertől. Ide sorolható a Wire.read (); funkció a mestertől küldött adatok kiolvasására.

8. Wire.requestFrom (cím, mennyiség);

Használat: Ezt a funkciót használja a master, hogy bájtokat kérjen egy slave eszközről. A Wire.read () függvény a slave eszközről küldött adatok beolvasására szolgál.

cím: annak az eszköznek a 7 bites címe, ahonnan bájtokat kérhet

mennyiség: a kérni kívánt bájtok száma

Szükséges alkatrészek

Arduino Uno (2-Nos)
16X2 LCD kijelző modul
10K potenciométer (4-nos)
Kenyérlemez
Vezetékek csatlakoztatása

Kördiagramm

Munka magyarázat

Az I2C kommunikáció Arduino-ban történő bemutatásához itt két Arduino UNO-t használunk, amelyekhez két 16X2 LCD-kijelző tartozik, és két potenciométert használunk mindkét arduinóban, hogy meghatározzuk a küldési értékeket (0–127) mesterről rabszolgára és rabszolga mesterre a potenciométer.

Az A0 arduino tűnél a bemeneti analóg értéket (0 és 5 V) között vesszük fel a potenciométer segítségével, és analóg-digitális értékre alakítjuk (0-tól 1023-ig). Ezután ezeket az ADC értékeket tovább konvertáljuk (0-ról 127-re), mivel I2C kommunikáción keresztül csak 7 bites adatokat tudunk küldeni. Az I2C kommunikáció két vezetéken keresztül zajlik mindkét arduino A4 és A5 érintkezõjénél.

A Slave Arduino LCD-jének értékei megváltoznak a POT változtatásával a master oldalon és fordítva.

I2C programozás Arduino-ban

Ez az oktatóprogram két programmal rendelkezik, az egyik az Arduino mester számára, a másik pedig a rabszolga Arduino számára. A teljes programokat mindkét fél számára a projekt végén egy bemutató videó tartalmazza.

Master Arduino programozási magyarázat

1. Először fel kell vennünk a Wire könyvtárat az I2C kommunikációs funkciók és az LCD könyvtárat az LCD funkciók használatához. Határozzon meg LCD érintkezőket a 16x2 LCD-hez is. Itt többet tudhat meg az LCD és az Arduino összekapcsolásáról.

#include #include LiquidCrystal lcd (2, 7, 8, 9, 10, 11);

2. Üres beállításban ()

A soros kommunikációt 9600 átviteli sebességgel kezdjük.

Serial.begin (9600);

Ezután megkezdjük az I2C kommunikációt a tűn (A4, A5)

Wire.begin (); // Megkezdődik az I2C kommunikáció a tűnél (A4, A5)

Ezután inicializáljuk az LCD kijelző modult 16X2 módban, megjelenítjük az üdvözlő üzenetet, és öt másodperc múlva törlünk.

lcdbegin (16,2); // Az LCD kijelző inicializálása lcd.setCursor (0,0); // Beállítja a kurzort a Display lcd.print ("Circuit Digest") első sorában ; // A CIRCUIT DIGEST fájlt kinyomtatja az LCD lcd.setCursor (0,1) képernyőn ; // Beállítja a kurzort a Display lcd.print második sorában ("I2C 2 ARDUINO"); // I2C ARDUINO kinyomtatása LCD késleltetésben (5000); // Késleltetés 5 másodpercig lcd.clear (); // Törli az LCD kijelzőt

3. Üres hurokban ()

Először adatokat kell beszereznünk a Slave-től, így használjuk a requestFrom () -t a 8 slave címmel és egy bájtot kérünk

Wire.requestFrom (8,1);

A kapott érték beolvasása a Wire.read () használatával

byte MasterReceive = Huzal.olvasott ();

Ezután le kell olvasnunk az A0 tűhöz csatolt master arduino POT analóg értékét

int potvalue = analogRead (A0);

Ezt az értéket egy bájtban 0-ról 127-re konvertáljuk.

byte MasterSend = térkép (potvalue, 0,1023,0,127);

Ezután el kell küldenünk ezeket az átalakított értékeket, így az átvitelt Slave Arduino-val kezdjük 8 címmel

Wire.beginTransmission (8); Wire.write (MasterSend); Wire.endTransmission ();

Ezután a szolga arduino által kapott értékeket jelenítjük meg 500 mikroszekundum késéssel, és folyamatosan megkapjuk és megjelenítjük ezeket az értékeket.

lcd.setCursor (0,0); // Beállítja a Currsor-ot az LCD lcd.print (">> Master <<") egyik sorába; // Nyomatok >> Master << az LCD lcd.setCursor-on (0,1); // Beállítja a kurzort az LCD lcd.print második sorában ("SlaveVal:"); // SlaveVal nyomtatása: LCD-ben lcd.print (MasterReceive); // A MasterReceive nyomtatása a Slave- től kapott Serial.println-től ("A Slave-től kapott Master"); // Nyomtatás soros monitoron Serial.println (MasterReceive); késés (500); lcd.clear ();

Slave Arduino programozási magyarázat

1. Ugyanúgy, mint a master, először is be kell építenünk a Wire könyvtárat az I2C kommunikációs funkciók és az LCD könyvtárat az LCD funkciók használatához. Határozzon meg LCD érintkezőket a 16x2 LCD-hez is.

#include #include LiquidCrystal lcd (2, 7, 8, 9, 10, 11);

2. Üres beállításban ()

A soros kommunikációt 9600 átviteli sebességgel kezdjük.

Serial.begin (9600);

Ezután megkezdjük az I2C kommunikációt a pin (A4, A5) pin-nél, a slave címmel mint 8. Itt fontos megadni a slave címet.

Wire.begin (8);

Ezután meg kell hívnunk a függvényt, amikor a Slave értéket kap a mastertől, és amikor a Master értéket kér a Slave-től

Wire.onReceive (acceptEvent); Wire.onRequest (requestEvent);

Ezután inicializáljuk az LCD kijelző modult 16X2 módban, megjelenítjük az üdvözlő üzenetet, és öt másodperc múlva törlünk.

3. Ezután két funkciónk van: az egyik a kérés eseményre és a másik a fogadás eseményre

Kérésre esemény

Amikor a master lekérdezi a szolga értékét, akkor ez a függvény végrehajtásra kerül. Ez a funkció átveszi a Slave POT bemeneti értékét, átalakítja azt 7 bites formátumban, és elküldi az értéket a masternek.

void requestEvent () { int potvalue = analogRead (A0); bájt SlaveSend = térkép (potvalue, 0,1023,0,127); Wire.write (SlaveSend); }

A fogadó eseményhez

Amikor a Mester adatokat küld egy szolga számára, a szolga címmel (8), akkor ez a funkció végrehajtásra kerül. Ez a függvény beolvassa a master és a store által kapott értéket egy típusú byte változóban.

void acceptEvent (int howMany { SlaveReceived = Wire.read (); }

4. A Void ciklusban ():

A mestertől kapott értéket folyamatosan jelenítjük meg az LCD kijelző modulban.

void loop (void) { lcd.setCursor (0,0); // Beállítja a Currsor-ot az LCD lcd.print egyik sorában (">> Slave <<"); // Nyomtatás >> Slave << az LCD lcd.setCursor-on (0,1); // Beállítja a kurzort az LCD lcd.print második sorában ("MasterVal:"); // MasterVal nyomtatása: LCD-ben lcd.print (SlaveReceived); // SlaveReceived értéket nyomtat az LCD-n, amelyet a Master Serial.println kapott ("A Slave kapott Master-től:"); // Soros monitorban nyomtat Serial.println (SlaveReceived); késés (500); lcd.clear (); }

Az egyik oldalon forgatva a potenciométert, a másik oldalon láthatja a változó értékeket az LCD-n:

Tehát az I2C kommunikáció így zajlik az Arduino-ban, itt két Arduinót használunk arra, hogy ne csak az adatok küldését, hanem az adatok fogadását is bemutassuk az I2C kommunikáció segítségével. Tehát most bármely I2C érzékelőt összekapcsolhat az Arduino-val.

A Master és a Slave Arduino teljes kódolását alább mutatjuk be egy bemutató videóval