Paano gamitin ang i2c sa arduino: komunikasyon sa pagitan ng dalawang arduino board

Sa aming nakaraang tutorial natutunan tungkol sa SPI komunikasyon sa Arduino. Ngayon ay malalaman natin ang tungkol sa isa pang Serial Communication Protocol: I2C (Inter Integrated Circuits). Sa paghahambing ng I2C sa SPI, ang I2C ay may dalawang wires lamang habang ang SPI ay gumagamit ng apat at ang I2C ay maaaring magkaroon ng Maramihang Master at Alipin, habang ang SPI ay maaaring magkaroon lamang ng isang master at maraming alipin. Kaya mayroong higit sa isang microcontroller sa isang proyekto na kailangang maging masters pagkatapos magamit ang I2C. Ang komunikasyon ng I2C ay karaniwang ginagamit upang makipag-usap sa Gyroscope, accelerometer, barometric pressure sensors, LED display atbp.

Sa Arduino I2C tutorial na ito ay gagamitin namin ang I2C na komunikasyon sa pagitan ng dalawang arduino board at magpapadala ng (0 hanggang 127) na mga halaga sa bawat isa sa pamamagitan ng paggamit ng potentiometer. Ipapakita ang mga halaga sa 16x2 LCD na konektado sa bawat Arduino. Dito ang isang Arduino ay gaganap bilang Master at ang isa pa ay gaganap bilang Alipin. Kaya't magsimula tayo sa pagpapakilala tungkol sa komunikasyon ng I2C.

Ano ang I2C Communication Protocol?

Ang term na IIC ay nangangahulugang " Inter Integrated Circuits ". Karaniwan itong tinukoy bilang I2C o In-square ko ang C o kahit na bilang 2-wire interface protocol (TWI) sa ilang mga lugar ngunit pareho ang ibig sabihin nito. Ang I2C ay isang magkasabay na protocol ng komunikasyon na nangangahulugang, kapwa ang mga aparato na nagbabahagi ng impormasyon ay dapat magbahagi ng isang karaniwang signal ng orasan. Mayroon lamang itong dalawang wires upang magbahagi ng impormasyon kung saan alin ang ginagamit para sa signal ng titi at ang iba pa ay ginagamit para sa pagpapadala at pagtanggap ng data.

Paano gumagana ang I2C Communication?

Ang komunikasyon ng I2C ay unang ipinakilala ni Phillips. Tulad ng sinabi nang mas maaga mayroon itong dalawang mga wires, ang dalawang wires na ito ay maiugnay sa dalawang mga aparato. Dito ang isang aparato ay tinawag na master at ang iba pang aparato ay tinawag bilang alipin. Ang komunikasyon ay dapat at laging magaganap sa pagitan ng dalawa isang Master at isang Alipin. Ang bentahe ng komunikasyon sa I2C ay ang higit sa isang alipin na maaaring konektado sa isang Master.

Ang kumpletong komunikasyon ay nagaganap sa pamamagitan ng dalawang wires na ito na, Serial Clock (SCL) at Serial Data (SDA).

Serial Clock (SCL): Ibinabahagi ang signal ng orasan na nabuo ng master sa alipin

Serial Data (SDA): Ipinapadala ang data papunta at mula sa pagitan ng Master at alipin.

Sa anumang naibigay na oras ang master lamang ang maaaring makapagsimula ng komunikasyon. Dahil mayroong higit sa isang alipin sa bus, kailangang sumangguni ang master sa bawat alipin na gumagamit ng ibang address. Kapag tinutugunan lamang ang alipin na may partikular na address na iyon ay tutugon kasama ang impormasyon habang ang iba naman ay patuloy na umalis. Sa ganitong paraan maaari naming magamit ang parehong bus upang makipag-usap sa maraming mga aparato.

Ang mga antas ng boltahe ng I2C ay hindi pa natukoy. Ang komunikasyon ng I2C ay may kakayahang umangkop, nangangahulugang ang aparato na pinalakas ng 5v volt, maaaring gumamit ng 5v para sa I2C at ang mga 3.3v na aparato ay maaaring gumamit ng 3v para sa komunikasyon ng I2C. Ngunit paano kung ang dalawang aparato na tumatakbo sa iba't ibang mga voltages, kailangang makipag-usap gamit ang I2C? Ang isang 5V I2C bus ay hindi maaaring konektado sa 3.3V aparato. Sa kasong ito, ginagamit ang mga boltahe na shifter upang tumugma sa mga antas ng boltahe sa pagitan ng dalawang mga bus na I2C.

Mayroong ilang mga hanay ng mga kundisyon na nag-frame ng isang transaksyon. Ang pagsisimula ng paghahatid ay nagsisimula sa isang bumabagsak na gilid ng SDA, na tinukoy bilang kundisyon na 'MAGSIMULA' sa ibaba ng diagram kung saan mataas ang iwan ng master ng SCL habang mababa ang setting ng SDA.

Tulad ng ipinakita sa diagram sa itaas sa ibaba, Ang pagbagsak ng gilid ng SDA ay ang nagpapalitaw ng hardware para sa kundisyon ng SIMULA. Pagkatapos nito ang lahat ng mga aparato sa parehong bus ay pumunta sa mode ng pakikinig.

Sa parehong pamamaraan, ang tumataas na gilid ng SDA ay tumitigil sa paghahatid na ipinapakita bilang kundisyon na 'STOP' sa diagram sa itaas, kung saan ang master ay umalis sa SCL na mataas at naglalabas din ng SDA upang pumunta sa TAAS. Kaya't ang tumataas na gilid ng SDA ay tumitigil sa paghahatid.

Ipinapahiwatig ng R / W bit ang direksyon ng paghahatid ng mga sumusunod na byte, kung ito ay TAAS nangangahulugang ang alipin ay magpapadala at kung ito ay mababa ay nangangahulugang ang master ay magpapadala.

Ang bawat bit ay ipinapadala sa bawat pag-ikot ng orasan, kaya't tumatagal ng 8 cycle ng orasan upang makapagpadala ng isang byte. Matapos ang bawat byte na ipadala o natanggap, ikasiyam na ikot ng orasan ay gaganapin para sa ACK / NACK (kinikilala / hindi kinikilala). Ang ACK bit na ito ay nabuo ng alinman sa alipin o master depende sa sitwasyon. Para sa ACK bit, ang SDA ay nakatakda sa mababang ng master o alipin sa ^ika- 9 na ikot ng orasan. Kaya't mababa ito ay isinasaalang-alang bilang ACK kung hindi man NACK.

Saan gagamitin ang komunikasyon ng I2C?

Ang komunikasyon ng I2C ay ginagamit lamang para sa komunikasyon sa maikling distansya. Tiyak na maaasahan ito sa isang lawak dahil mayroon itong isang naka-synchronize na pulso ng orasan upang gawin itong matalino. Pangunahing ginagamit ang protokol na ito upang makipag-ugnay sa sensor o iba pang mga aparato na kailangang magpadala ng impormasyon sa isang master. Napaka-madaling gamiting kapag ang isang microcontroller ay kailangang makipag-usap sa maraming iba pang mga module ng alipin na gumagamit ng isang minimum na mga wire lamang. Kung naghahanap ka para sa isang mahabang hanay ng komunikasyon dapat mong subukan ang RS232 at kung naghahanap ka para sa mas maaasahang komunikasyon dapat mong subukan ang SPI protocol.

I2C sa Arduino

Ipinapakita ng imahe sa ibaba ang mga I2C na pin na naroroon sa Arduino UNO.

I2C Line	I-pin sa Arduino
SDA	A4
SCL	A5

Bago kami magsimula sa pag-program ng I2C gamit ang dalawang Arduino. Kailangan nating malaman ang tungkol sa Wire library na ginamit sa Arduino IDE.

Ang silid-aklatan ay kasama sa programa para sa paggamit ng mga sumusunod na pagpapaandar para sa komunikasyon ng I2C.

1. Wire.begin (address):

Paggamit: Ginagamit ang library na ito para sa pakikipag-usap sa mga aparatong I2C. Pasimulan ito sa Wire library at sumali sa I2C bus bilang isang master o alipin.

Address: Ang 7-bit na address ng alipin ay opsyonal at kung ang address ay hindi tinukoy, sumali ito sa bus bilang isang master na tulad nito.

2. Wire.read ():

Paggamit: Ang pagpapaandar na ito ay ginagamit upang basahin ang isang byte na natanggap mula sa panginoon o aparato ng alipin, alinman sa naihatid mula sa isang aparato ng alipin sa isang master aparato pagkatapos ng isang tawag upang humiling Mula sa () o ipinadala mula sa isang panginoon sa isang alipin

3. Wire.write ():

Paggamit: Ang pagpapaandar na ito ay ginagamit upang magsulat ng data sa isang alipin o master device.

Slave to Master: Si Slave ay nagsusulat ng data sa isang master kapag ang Wire.RequestFrom () ay ginagamit sa master.

Master to Slave: Para sa paghahatid mula sa isang master hanggang sa alipin na aparato Wire.write () ay ginagamit sa pagitan ng mga tawag sa Wire.beginTransmission () at Wire.endTransmission ().

Ang Wire.write () ay maaaring isulat bilang:

Wire.write (halaga)

halaga: isang halaga upang ipadala bilang isang solong byte.

Wire.write (string):

string: isang string upang ipadala bilang isang serye ng mga byte.

Wire.write (data, haba):

data: isang hanay ng data upang ipadala bilang mga byte

haba: ang bilang ng mga byte upang maipadala.

4. Wire.beginTransmission (address):

Paggamit: Ang pagpapaandar na ito ay ginagamit upang masimulan ang isang paghahatid sa aparato ng I2C na may ibinigay na address ng alipin. Kasunod, bumuo ng pila ng mga byte para sa paghahatid na may function na magsulat () at pagkatapos ay ihatid ang mga ito sa pamamagitan ng pagtawag sa endTransmission () na pagpapaandar. Ang 7-bit na address ng aparato ay naipadala.

5. Wire.endTransmission ();

Paggamit: function na ito ay ginagamit upang tapusin ang isang transmisyon na isang alipin aparato na sinimulan ng beginTransmission () at nagpapadala ng mga bytes na naka-queue sa pamamagitan Wire.write ().

6. Wire.onRequest ();

Paggamit: Ang pagpapaandar na ito ay tatawagin kapag ang isang master ay humiling ng data gamit ang Wire.requestFrom () mula sa aparato ng alipin. Dito maaari naming isama ang pagpapaandar ng Wire.write () upang magpadala ng data sa master.

7. Wire.onReceive ();

Paggamit: Ang pagpapaandar na ito ay tatawagin kapag ang isang aparato ng alipin ay tumatanggap ng isang data mula sa isang master. Dito maaari nating isama ang Wire.read (); pagpapaandar upang basahin ang data na ipinadala mula sa master.

8. Wire.requestFrom (address, dami);

Paggamit: Ang pagpapaandar na ito ay ginagamit sa master upang humiling ng mga byte mula sa isang aparato ng alipin. Ang pagpapaandar na Wire.read () ay ginagamit upang basahin ang data na ipinadala mula sa aparato ng alipin.

address: ang 7-bit address ng aparato upang humiling ng mga byte mula sa

dami: ang bilang ng mga byte na hihilingin

Kinakailangan ang Mga Bahagi

Arduino Uno (2-Nos)
16X2 LCD module ng pagpapakita
10K Potensyomiter (4-Nos)
Breadboard
Mga Koneksyon sa Mga Wires

Diagram ng Circuit

Paggawa ng Paliwanag

Dito para sa pagpapakita ng komunikasyon ng I2C sa Arduino, ginagamit namin ang Dalawang Arduino UNO na may Dalawang 16X2 LCD display na nakakabit sa bawat isa at gumagamit ng dalawang potentiometers sa parehong arduino upang matukoy ang pagpapadala ng mga halaga (0 hanggang 127) mula sa master to slave at alipin sa master sa pamamagitan ng pag-iba-iba ng potensyomiter.

Kinukuha namin ang halaga ng input ng analog sa arduino pin A0 mula sa (0 hanggang 5V) sa pamamagitan ng paggamit ng potentiometer at i-convert ang mga ito sa Analog hanggang sa Digital na halaga (0 hanggang 1023). Pagkatapos ang mga halagang ADC na ito ay karagdagang nai-convert sa (0 hanggang 127) dahil maaari lamang kaming magpadala ng 7-bit na data sa pamamagitan ng komunikasyon ng I2C. Ang komunikasyon ng I2C ay nagaganap sa pamamagitan ng dalawang wires sa pin A4 & A5 ng parehong arduino.

Ang mga halaga sa LCD ng Slave Arduino ay mababago sa pamamagitan ng pag-iiba ng POT sa master side at kabaligtaran.

I2C Programming sa Arduino

Ang tutorial na ito ay may dalawang programa isa para sa master Arduino at iba pa para sa alipin na Arduino. Ang mga kumpletong programa para sa magkabilang panig ay ibinibigay sa pagtatapos ng proyektong ito na may isang demonstrasyong Video.

Paliwanag ng Master Arduino Programming

1. Una sa lahat kailangan nating isama ang Wire library para sa paggamit ng mga pagpapaandar ng komunikasyon ng I2C at LCD library para sa paggamit ng mga LCD function. Tukuyin din ang mga pin ng LCD para sa 16x2 LCD. Dagdagan ang nalalaman tungkol sa interfacing LCD sa Arduino dito.

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

2. Sa void setup ()

Nagsisimula Kami ng Serial Communication sa Baud Rate 9600.

Serial.begin (9600);

Susunod na simulan namin ang komunikasyon ng I2C sa pin (A4, A5)

Wire.begin (); // Nagsisimula ang komunikasyon sa I2C sa pin (A4, A5)

Susunod na isinisinisula namin ang module ng pagpapakita ng LCD sa 16X2 mode at ipakita ang maligayang mensahe at i-clear pagkatapos ng limang segundo.

lcd.begin (16,2); // Initilize LCD display lcd.setCursor (0,0); // Sets Cursor sa unang linya ng Display lcd.print ("Circuit Digest"); // Prints CIRCUIT DIGEST sa LCD lcd.setCursor (0,1); // Sets Cursor sa pangalawang linya ng Display lcd.print ("I2C 2 ARDUINO"); // Prints I2C ARDUINO sa pagkaantala ng LCD (5000); // Delay ng 5 segundo lcd.clear (); // Nilinaw ang LCD display

3. Sa void loop ()

Una kailangan naming makakuha ng data mula sa Alipin kaya gumagamit kami ng requestFrom () sa address ng alipin 8 at humiling kami ng isang byte

Wire.requestFrom (8,1);

Ang natanggap na halaga ay binabasa gamit ang Wire.read ()

byte MasterReceive = Wire.read ();

Susunod na kailangan naming basahin ang halaga ng analog mula sa master arduino POT na nakakabit sa pin A0

int potvalue = analogRead (A0);

Ina-convert namin ang halagang iyon sa mga tuntunin ng isang byte na 0 hanggang 127.

byte MasterSend = mapa (potvalue, 0,1023,0,127);

Susunod na kailangan namin upang ipadala ang mga na-convert na halaga upang simulan namin ang paghahatid sa alipin arduino na may 8 address

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

Susunod na ipinapakita namin ang mga natanggap na halagang mula sa alipin arduino na may pagkaantala ng 500 microseconds at patuloy kaming tumatanggap at nagpapakita ng halagang iyon.

lcd.setCursor (0,0); // Nagtatakda ng Currsor sa linya ng isa sa LCD lcd.print (">> Master <<"); // Prints >> Master << sa LCD lcd.setCursor (0,1); // Sets Cursor sa linya na dalawa sa LCD lcd.print ("SlaveVal:"); // Prints SlaveVal: sa LCD lcd.print (MasterReceive); // Prints MasterReceive sa LCD na natanggap mula sa Slave Serial.println ("Natanggap ang Master Mula sa Alipin"); // Prints in Serial Monitor Serial.println (MasterReceive); pagkaantala (500); lcd.clear ();

Paliwanag ng Slave Arduino Programming

1. Parehas bilang master, una sa lahat kailangan namin upang isama ang Wire library para sa paggamit ng mga pagpapaandar ng komunikasyon ng I2C at LCD library para sa paggamit ng mga LCD function. Tukuyin din ang mga pin ng LCD para sa 16x2 LCD.

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

2. Sa void setup ()

Nagsisimula Kami ng Serial Communication sa Baud Rate 9600.

Serial.begin (9600);

Susunod na sinisimulan namin ang komunikasyon ng I2C sa pin (A4, A5) na may address ng alipin bilang 8. Dito mahalagang tukuyin ang address ng alipin.

Wire.begin (8);

Susunod na kailangan naming tawagan ang pagpapaandar kapag ang Alipin ay tumatanggap ng halaga mula sa master at kapag ang halaga ng kahilingan ng Master mula sa Alipin

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

Susunod na isinisinisula namin ang module ng pagpapakita ng LCD sa 16X2 mode at ipakita ang maligayang mensahe at i-clear pagkatapos ng limang segundo.

3. Susunod mayroon kaming dalawang mga pagpapaandar isa para sa kahilingan sa kaganapan at isa para sa pagtanggap ng kaganapan

Para sa kahilingan sa Kaganapan

Kapag ang halaga ng kahilingan ng Master mula sa alipin ang pagpapaandar na ito ay naisasagawa. Ang pagpapaandar na ito ay tumatagal ng halaga ng pag-input mula sa Slave POT at i-convert ito sa mga tuntunin ng 7-bit at ipadala ang halagang iyon sa master.

void requestEvent () { int potvalue = analogRead (A0); byte SlaveSend = mapa (potvalue, 0,1023,0,127); Wire.write (SlaveSend); }

Para Makatanggap ng Kaganapan

Kapag nagpapadala ang Master ng data sa alipin na may address ng alipin (8) ang pagpapaandar na ito ay naisasagawa. Binabasa ng pagpapaandar na ito ang natanggap na halaga mula sa master at store sa isang variable ng uri ng byte .

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

4. Sa Void loop ():

Ipinapakita namin ang natanggap na halaga mula sa master nang tuluy-tuloy sa LCD display module.

void loop (void) { lcd.setCursor (0,0); // Nagtatakda ng Currsor sa linya ng isa sa LCD lcd.print (">> Alipin <<"); // Prints >> Alipin << sa LCD lcd.setCursor (0,1); // Sets Cursor sa linya ng dalawang LCD lcd.print ("MasterVal:"); // Prints MasterVal: sa LCD lcd.print (SlaveReceived); // Prints SlaveReceished halaga sa LCD na natanggap mula sa Master Serial.println ("Natanggap na Alipin Mula sa Master:"); // Prints in Serial Monitor Serial.println (SlaveReceived); pagkaantala (500); lcd.clear (); }

Sa pamamagitan ng pag- ikot ng Potentiometer sa isang gilid, makikita mo ang iba't ibang mga halaga sa LCD sa isa pang panig:

Kaya't ganito nagaganap ang komunikasyon ng I2C sa Arduino, narito ginamit namin ang dalawang Arduino upang ipakita hindi lamang ang pagpapadala ng data ngunit tumatanggap din ng data gamit ang komunikasyon ng I2C. Kaya ngayon maaari mong i-interface ang anumang sensor ng I2C sa Arduino.

Ang kumpletong pag-coding para sa Master at Slave Arduino ay ibinibigay sa ibaba na may isang demonstration video