- Ano ang I2C Communication Protocol?
- Paano gumagana ang I2C Communication?
- Saan gagamitin ang komunikasyon ng I2C?
- I2C na may PIC16F877a gamit ang XC8 Compiler
- Programming gamit ang mga file ng header ng I2C:
- Proteus Simulation:
Ang PIC Microcontrollers ay isang malakas na platform na ibinigay ng microchip para sa mga naka-embed na proyekto, ang maraming nalalaman na likas na katangian na ito ay ginawa upang makahanap ng mga paraan sa maraming mga application at ang yugto ay patuloy pa rin. Kung sinusundan mo ang aming mga tutorial sa PIC pagkatapos ay napansin mo na sakop na namin ang malawak na hanay ng mga tutorial sa PIC microcontroller na nagsisimula mula sa mga pangunahing kaalaman. Mula ngayon, natakpan namin ang mga pangunahing kaalaman na maaari naming makuha sa mas kawili-wiling mga bagay tulad ng portal ng komunikasyon.
Sa malawak na sistema ng mga naka-embed na application, walang microcontroller ang maaaring gumanap ng lahat ng mga aktibidad nang mag-isa. Sa ilang yugto ng oras kailangang makipag-usap sa iba pang mga aparato upang makapagbahagi ng impormasyon, maraming iba't ibang mga uri ng mga protocol sa komunikasyon upang maibahagi ang mga impormasyong ito, ngunit ang pinaka ginagamit ay USART, IIC, SPI at CAN. Ang bawat komunikasyon protocol ay may sariling kalamangan at kawalan. Ituon natin ang bahagi ng IIC sa ngayon dahil iyan ang matututunan natin sa tutorial na ito.
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 tinugunan lamang ang salve na may partikular na address na iyon ay magrereply kasama ang impormasyon habang ang iba ay patuloy na umalis. Sa ganitong paraan maaari naming magamit ang parehong bus upang makipag-usap sa maraming mga aparato.
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 na may PIC16F877a gamit ang XC8 Compiler
Sapat na sa mga pagpapakilala, hinahayaan na makapunta dito at alamin kung paano kami makakagamit ng isang microcontroller para sa pagsasagawa ng komunikasyon sa I2C. Bago namin simulang linawin na ang tutorial na ito ay nagsasalita lamang tungkol sa I2C sa PIC16F877a gamit ang XC8 compiler, ang proseso ay magiging pareho para sa iba pang mga microcontroller ngunit maaaring kailanganin ang kaunting mga pagbabago. Tandaan din na para sa mga advanced na microcontroller tulad ng serye ng PIC18F ang tagatala mismo ay maaaring magkaroon ng ilang in-built na library upang magamit ang mga tampok na I2C, ngunit para sa PIC16F877A walang katulad na umiiral kaya't bumuo tayo ng isa sa ating sarili. Ipinaliwanag dito ang silid-aklatan ay ibibigay bilang isang header file para sa pag-download sa ibaba na maaaring magamit para sa PIC16F877A upang makipag-usap sa ibang mga I2C device.
Tulad ng lagi ang pinakamagandang lugar upang magsimula ng anumang bagay ay ang aming datasheet. Maghanap ng mga detalye tungkol sa I2C sa datasheet at suriin kung aling mga rehistro ang kailangang mai-configure. Hindi ko ipaliwanag sa mga detalye dahil nagawa na ng datasheet para sa iyo. Malayo sa ibaba ay ipapaliwanag ko ang iba't ibang mga pag-andar na naroroon sa header file at ang kanilang responsibilidad sa programa.
walang bisa I2C_Initialize ()
Ginagamit ang pagpapauna sa pagpapaandar upang sabihin sa microcontroller na gagamitin namin ang I2C protocol. Maaari itong magawa sa pamamagitan ng pagtatakda ng mga kinakailangang piraso sa rehistro ng SSPCON at SSPCON2. Ang unang hakbang ay upang ideklara ang mga IIC pin bilang mga input pin, narito ang mga pin na RC3 at RC4 ay dapat gamitin para sa komunikasyon ng I2C kaya idineklara namin ang mga ito bilang mga input pin. Susunod na dapat nating itakda ang SSPCON at SSPCON2 na isang rehistro ng kontrol ng MSSP. Pinapatakbo namin ang PIC sa IIC master mode na may dalas ng orasan ng FOSC / (4 * (SSPADD + 1)). Sumangguni sa mga numero ng pahina ng datasheet na nabanggit sa mga linya ng komento sa ibaba upang maunawaan kung bakit itinakda sa ganoong paraan ang partikular na rehistro.
Kaya sa susunod ay itatakda natin ang dalas ng orasan, ang dalas ng orasan para sa iba't ibang mga application ay maaaring magkakaiba, samakatuwid nakukuha namin ang pagpipilian mula sa gumagamit sa pamamagitan ng variable feq_k at gamitin ito sa aming mga formula upang maitakda ang rehistro ng SSPADD.
walang bisa I2C_Initialize (const unsigned long feq_K) // Simulan ang IIC bilang master { TRISC3 = 1; TRISC4 = 1; // Itakda ang mga pin ng SDA at SCL bilang mga input pin SSPCON = 0b00101000; // pg84 / 234 SSPCON2 = 0b00000000; // pg85 / 234 SSPADD = (_XTAL_FREQ / (4 * feq_K * 100)) - 1; // Setting Clock Speed pg99 / 234 SSPSTAT = 0b00000000; // pg83 / 234 }
Walang bisa I2C_Hold ()
Ang susunod na mahalagang pagpapaandar ay ang pagpapaandar ng I2C_hold na ginagamit upang hawakan ang pagpapatupad ng aparato hanggang sa makumpleto ang kasalukuyang operasyon ng I2C. Susuriin namin kung ang I2C na operasyon ay dapat na gaganapin bago simulan ang anumang bagong operasyon. Maaari itong magawa sa pamamagitan ng pagsuri sa rehistro ng SSPSTAT at SSPCON2. Naglalaman ang SSPSTAT ng impormasyon tungkol sa katayuan ng I2C bus.
Ang programa ay maaaring mukhang medyo kumplikado dahil nagsasangkot ito ng isang "at" at isang "o" operator. Kapag sinira mo ito bilang
SSPSTAT & 0b00000100 SSPCON2 & 0b00011111
Nyawang
Nangangahulugan ito na tinitiyak namin na ang 2 nd bit sa SSPSTAT ay zero at katulad na mga piraso mula 0 hanggang 4 ay zero sa SSPCON2. Pagkatapos ay pinagsasama namin ang lahat ng ito upang suriin ang resulta ay zero. Kung ang resulta ay zero ang programa ay magpapatuloy kung hindi mananatili ito hanggang sa makakuha ng zero dahil ginamit ito sa isang habang loop.
walang bisa I2C_Hold () { habang ((SSPCON2 & 0b00011111) - (SSPSTAT & 0b00000100)); // suriin ito sa mga rehistro upang matiyak na ang IIC ay wala sa isinasagawa }
Walang bisa I2C_Begin () at walang bisa I2C_End ()
Sa tuwing nagsusulat o nagbabasa kami ng anumang data gamit ang I2C bus dapat naming simulan at Tapusin ang koneksyon sa I2C. Upang simulan ang isang komunikasyon sa I2C kailangan nating itakda ang SEN bit at upang wakasan ang komunikasyon na kailangan nating maitakda ang katayuan ng PEN. Bago ang pag-toggle ng alinman sa mga bits na ito dapat din nating suriin kung ang I2C bus ay abala sa pamamagitan ng paggamit ng function na I2C_Hold tulad ng tinalakay sa itaas.
walang bisa I2C_Begin () { I2C_Hold (); // Hold the program is I2C is busy SEN = 1; // Start IIC pg85 / 234 } void I2C_End () { I2C_Hold (); // Hold the program is I2C is busy PEN = 1; // End IIC pg85 / 234 }
Walang bisa I2C_Write ()
Ang function ng pagsulat ay ginagamit upang magpadala ng anumang data mula sa master module sa salve module. Ang pagpapaandar na ito ay karaniwang ginagamit pagkatapos ng isang pagsisimula ng pag-andar ng I2C at sinusundan ng isang pag-andar ng I2C End. Ang data na kailangang isulat sa IIC bus ay naipasa sa variable data. Pagkatapos ay nai-load ang data na ito sa rehistro ng buffer ng SSPBUF upang maipadala ito sa I2C bus.
Karaniwan bago magsulat ng isang data ang isang address ay isusulat upang kailangan mong gumamit ng function ng pagsulat nang dalawang beses, isang beses para sa pagtatakda ng address at sa iba pang oras para sa pagpapadala ng aktwal na data.
void I2C_Write (unsigned data) { I2C_Hold (); // Hold the program is I2C is busy SSPBUF = data; // pg82 / 234 }
unsigned maikling I2C_Read ()
Ang pangwakas na pag-andar na dapat nating malaman tungkol sa ay ang pagpapaandar ng I2C_Read . Ang pagpapaandar na ito ay ginagamit upang basahin ang data na kasalukuyang nasa I2C bus. Ginagamit ito pagkatapos humiling ng isang alipin na sumulat ng ilang halaga sa bus. Ang natanggap na halaga ay nasa SSPBUF maaari naming ilipat ang halagang iyon sa anumang variable para sa aming operasyon.
Sa panahon ng isang komunikasyon sa I2C, ang alipin pagkatapos magpadala ng data na hiniling ng Master ay magpapadala ng isa pang piraso na kung saan ay ang pagkilala, ang bit na ito ay dapat ding suriin ng master upang matiyak na ang komunikasyon ay matagumpay. Matapos suriin ang ACKDT bit para sa pagkilala dapat itong paganahin sa pamamagitan ng pagtatakda ng ACKEN na bit.
unsigned maikling I2C_Read (unsigned maikling ack) { unsigned maikling papasok; I2C_Hold (); RCEN = 1; I2C_Hold (); papasok = SSPBUF; // makuha ang nai-save na data sa SSPBUF I2C_Hold (); ACKDT = (ack)? 0: 1; // check if ack bit natanggap ACKEN = 1; // pg 85/234 bumalik na papasok; }
Iyon lang, ang mga pagpapaandar na ito ay dapat sapat upang mag-set up ng isang komunikasyon sa I2C at magsulat o magbasa ng data mula sa isang aparato. Tandaan din na maraming iba pang mga pagpapaandar na maaaring gampanan ng komunikasyon ng I2C ngunit alang-alang sa pagiging simple hindi namin tinatalakay ang mga ito dito. Maaari mong palaging i-refer ang datasheet upang malaman ang kumpletong pagtatrabaho ng
Ang kumpletong code na may header file para sa komunikasyon na PIC16F877A I2C ay maaaring ma-download mula sa link.
Programming gamit ang mga file ng header ng I2C:
Ngayon natutunan namin kung paano gumagana ang isang komunikasyon sa I2C at kung paano namin magagamit ang file ng header na nilikha para dito, gumawa tayo ng isang simpleng programa kung saan gagamitin namin ang header file at magsulat ng ilang mga halaga sa mga linya ng I2C. Susubukan naming gayahin ang program na ito at suriin kung ang mga halagang ito ay nakasulat sa bus.
Tulad ng dati ay nagsisimula ang programa sa pag-set up ng mga Configuration bits at pagtatakda ng dalas ng orasan sa 20 MHz tulad ng ipinakita sa ibaba
#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Paganahin ang bit (hindi pinagana ang WDT) #pragma config PWRTE = ON // Power-up Timer Paganahin ang bit (pinagana ang PWRT) # pragma config BOREN = ON // Brown-out Reset Paganahin ang bit (pinagana ang BOR) #pragma config LVP = OFF // Mababang Boltahe (Single-Supply) In-Circuit Serial Programming Paganahin ang bit (ang RB3 ay digital I / O, HV sa Dapat gamitin ang MCLR para sa pagprograma) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Proteksyon ang Data EEPROM code) #pragma config WRT = OFF // Flash Program Memory Sumulat Paganahin ang mga bits (Isulat ang proteksyon; lahat ng memorya ng programa maaaring nakasulat sa pamamagitan ng kontrol ng EECON) #pragma config CP = OFF // Flash Program Memory Code ng Proteksyon ng kaunti (Code protection off) #define _XTAL_FREQ 20000000
Ang susunod na hakbang ay upang idagdag ang file ng header na tinalakay lamang tungkol sa. Ang header file ay pinangalanan bilang PIC16F877a_I2C.h at maaaring ma-download mula sa link na tinalakay sa itaas. Tiyaking idinagdag ang header file sa header file ng iyong listahan ng proyekto, dapat ganito ang hitsura ng istraktura ng file ng iyong proyekto
Matapos matiyak na ang header file ay naidagdag sa iyong proyekto ng file isama ang header file sa pangunahing C file
# isama
Sa loob ng loop habang magsisimula kami ng komunikasyon ng I2C magsulat ng ilang mga random na halaga sa I2C bus at pagkatapos Tapusin ang komunikasyon ng I2C. Ang mga random na halagang napili ko ay D0, 88 at FF. Maaari kang maglagay ng anumang mga halagang nais mo. Ngunit tandaan ang mga halagang iyon habang ino-verify namin ang mga ito sa aming simulation.
habang (1) { I2C_Begin (); I2C_Write (0xD0); I2C_Write (0x88); I2C_Write (0xFF); I2C_End (); __delay_ms (1000); }
Ang kumpletong programa ay matatagpuan sa ilalim ng pahina, maaari mong gamitin iyon o i-download ang kumpletong zip file ng programa mula dito. Matapos makuha ang programa ay ipunin ito at maghanda para sa simulation.
Proteus Simulation:
Ang Proteus ay may magandang instrumento na tinatawag na I2C debugger na maaaring magamit upang mabasa ang data sa isang I2C bus, kaya't bumuo tayo ng isang circuit gamit ito at suriin kung ang data ay matagumpay na nakasulat. Ang kumpletong diagram ng circuit ay ipinapakita sa ibaba
I-load ang hex file na nabuo ng aming programa sa pamamagitan ng pag-double click sa Microcontroller. Pagkatapos gayahin ang programa. Mapapansin mo ang isang window pop up na magpapakita ng lahat ng impormasyon tungkol sa I2C bus. Ang window para sa aming programa ay ipinapakita sa ibaba.
Kung titingnan mo nang mabuti ang data na nakasulat maaari mong mapansin na pareho ang mga ito na isinulat namin sa aming programa. Ang mga halaga ay D0, 88 at FF. Ang mga halaga ay nakasulat para sa bawat 1 sec kaya ang oras ay ina-update din tulad ng ipinakita sa ibaba. Ipinapahiwatig ng asul na arrow na nakasulat ito mula sa isa hanggang sa alipin na tumuturo ito sa kabaligtaran na direksyon kung hindi man. Ang isang mas malapit na pagtingin sa data na ipinapakita ay ipinapakita sa ibaba.
Ito ay isang sulyap lamang sa kung ano ang magagawa ng I2C, maaari din itong basahin at isulat ang data sa maraming mga aparato. Masasaklaw namin ang higit pa tungkol sa I2C sa aming paparating na mga tutorial sa pamamagitan ng pag-interfaced ng iba't ibang mga module na gumagana sa I2C protocol.
Inaasahan kong naintindihan mo ang proyekto at natutunan ang isang bagay na kapaki-pakinabang mula rito. Kung mayroon kang anumang pagdududa i-post ang mga ito sa seksyon ng komento sa ibaba o gamitin ang mga forum para sa panteknikal na tulong.
Ang kumpletong code ay ibinigay sa ibaba; maaari kang mag-download ng mga file ng header kasama ang lahat ng code mula rito.