I2C Bus para sa ATtiny at ATmega: 8 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:16

Gustung-gusto ko ang mga microcontroller ng Atmel AVR! Mula nang buuin ang Ghetto Development System na inilarawan sa Instructable na ito, wala akong katapusan sa kasiyahan na eksperimento sa AVR ATtiny2313 at sa partikular na ATmega168. Nagpunta pa ako upang sumulat ng isang Maituturo sa paggamit ng mga switch bilang mga input, at pinalawig ang konsepto ng Ghetto Development System sa mga CPLD. Sa isang kasalukuyang proyekto, kailangan ko ng maraming mga switch para sa pagtatakda ng mga halaga ng kontrol. Ang mga AVR ay walang sapat na I / O pin, kaya't may naisip ako. Maaaring sinubukan ko ang isang kumplikadong sistema ng pag-input na may isang keyboard at display, ngunit ang ATtiny2313 ay maubusan ng mga mapagkukunan. Sa kasamaang palad, nagbigay ang Atmel ng isang paraan sa paligid ng problemang ito sa pamamagitan ng pagsasama ng isang interface na maaaring mag-link sa mga karagdagang chips (tulad ng memorya o I / O port) na may isang simpleng dalawang interface ng kawad. Tama iyan, sa pamamagitan lamang ng paggamit ng dalawang mga I / O na pin sa isang AVR maaari nating ma-access ang maraming mga karagdagang I / O pin, at iba pang mga mapagkukunan. Ang dalawang interface ng kawad na ito ay pormal na kilala bilang Inter-Integrated Circuit bus, o ang I2C bus lamang at naimbento ng NXP noong Philips Semiconductors pa rin. Kung binabasa mo ang Instructable na ito marahil ay narinig mo ang tungkol sa I2C bus at maaaring ginamit mo pa ito sa isang PIC o ibang microcontroller. Habang ang konsepto ay napaka-simple, at suportado ng mga mapagkukunan ng hardware sa mga AVR, kinakailangan pa rin ang mga driver ng software na gamitin ang I2C bus. Nagbibigay ang Atmel ng Mga Tala ng Application (tingnan ang Mga Mapagkukunan sa paglaon sa Instructable na ito), ngunit ang mga ito ay hindi kumpleto at hindi nagpapakita ng anumang mga halimbawa na lampas sa pakikipag-usap sa isa pang aparatong AVR. Hindi layunin ng Instructable na ito upang turuan ang sinuman kung paano lumikha ng mga driver ng I2C para sa Mga AVR. Sa halip, magbibigay ako ng mga pinalawak na bersyon ng mga driver ng Atmel para sa mga aparato ng ATtiny2313 at ATmega168, ipapaliwanag ko ang mga kinakailangan at paghihigpit na nalalapat kapag ginagamit ang mga ito, at ipapakita ko sa iyo ang mga gumaganang halimbawa ng mga I2C device. Pagkatapos mong magawa ang Instructable na ito magagamit mong matagumpay ang I2C bus sa iyong mga proyekto sa AVR. Malinaw na, maaari mong balewalain ang mga driver para sa alinman sa maliit o MEGA kung interesado ka lamang sa isa sa mga ito. Para sa mga interesadong malaman ang higit pa tungkol sa I2C bus, magbibigay ako ng mga link sa naaangkop na materyal.

Hakbang 1: Ano ang Lahat ng Bagay na Ito I2C Pa rin?

Ang I2C bus ay isang simple, dalawang-wire na koneksyon na maaaring maiugnay ang maramihang mga aparato nang sama-sama at payagan silang makipagpalitan ng data. Sa pinakasimpleng form nito mayroong isang master device na nakikipag-usap sa maraming mga aparato ng alipin. Ang lahat ng mga aparato ay konektado kahanay sa dalawang wires ng I2C bus. Ang dalawang wires ay kilala bilang SCL at SDA. Ang SCL ay ang linya ng orasan at kinokontrol ng master device. Ang SDA ay ang linya ng data na dalawang direksyon. Upang maglipat ng data, nagpapadala ang master ng isang address ng alipin na sinamahan ng isang medyo basahin / isulat na watawat. Kung nais ang isang sulatin, magpapatuloy ang master na magpadala ng data sa naka-address na alipin. Kung ang isang pagbasa ay hiniling, ang alipin ay tutugon sa data. Upang maiugnay ang mga transaksyon, ang mga linya ng SCL at SDA ay minamanipula ng master at ng alipin upang mag-signal ng maraming mga kundisyon. Kasama rito ang SIMULA, ITIGIL, ACK (kilalanin) at NAK (walang kinikilala). Ang mga detalye ng mga kundisyong ito ay pinangangasiwaan ng mga driver. Ang totoong mga geeks sa gitna mo ay maaaring malaman ang lahat ng mga detalye sa mga link na ibinigay sa dulo ng Ituturo na ito. Ang mga kinakailangang elektrikal ay medyo simple. Ang master at ang mga alipin ay dapat gumamit ng parehong antas para sa Vcc, ang mga bakuran ay dapat na konektado, at ang mga linya ng SCL at SDA ay dapat hilahin hanggang Vcc. Ang halaga ng mga resistors na pull-up ay tiyak na natutukoy ng isang pagkalkula batay sa kabuuang kapasidad sa bus, ngunit praktikal na maaaring maging anumang halaga sa pagitan ng 1.8K at 10K. Nagsisimula ako sa 5.1K at gumagamit ng mas mababang mga halaga hanggang sa ito ay gumagana. Karaniwan itong hindi isang isyu maliban kung mayroon kang maraming mga aparato o mahabang haba ng kawad sa pagitan ng mga aparato. Ang nominal na rate ng data sa I2C bus ay 100Kbits / segundo. Ang mga rate na 400Kbits / segundo, 1Mbits / segundo, at higit pa ay posible rin, ngunit hindi sinusuportahan ng mga driver sa Instructable na ito. Ang lahat ng mga aparato ng I2C ay gagana sa 100Kbits / segundo. Ang ATtiny2313 at ang ATmega168 bawat isa ay nagpatupad ng I2C bus nang magkakaiba. Gumagamit ang ATtiny2313 ng hardware ng Universal Serial Interface (USI) - na maaari ring magamit para sa SPI bus. Ang ATmega168 ay nakatuon sa hardware para sa I2C bus na kilala bilang Two Wire Interface (TWI). Kapag nakasulat na ang mga driver, ang mga pagkakaiba na ito ay halos transparent sa gumagamit. Ang isang makabuluhang pagkakaiba ay ang software: Ang driver ng ATmega168 I2C ay nagambala sa paghimok habang iyon para sa ATtiny2313 ay hindi. Nangangahulugan ito na ang isang programa ng ATmega168 ay hindi kailangang maghintay para sa I2C data transfer na maganap, ngunit kailangan lamang maghintay bago magsimula ng isa pang paglilipat, o hanggang sa dumating ang data mula sa isang binasang operasyon. Ang mga halimbawa at talakayang susundan ay dapat linawin ito. Ang mga address ng I2C ay 7 piraso ang haba, kaya hanggang sa 127 na mga aparato ang maaaring nasa bus kung ang bawat isa ay may natatanging address. Tulad ng ipinakita sa pigura, ang 7 bit na address na ito ay inilipat sa kaliwa ng kaunti at ang hindi gaanong makabuluhang piraso ay ginagamit upang i-flag ang isang nabasa o sumulat ng aparato sa address. Sa gayon ang kumpletong address ng alipin ay isang 8 bit byte. Ang aktwal na address ay bahagyang natukoy sa loob ng aparato at hindi mababago (4 na pinaka-makabuluhang mga piraso), at bahagyang natutukoy ng mga piraso na maaaring konektado sa mga pin ng aparato (3 hindi bababa sa mga makabuluhang piraso) na maaaring itali mataas o mababa upang maitakda isang tiyak na address. Nakakalito ang tunog, ngunit isang halimbawa ang magpapalilinaw nito. Ipinapakita ng sheet ng data ng PCA8574A na ang apat na pinakamahalagang piraso ng I2C address ay palaging magiging 0111. Ang susunod na tatlong piraso ay natutukoy ng mga setting sa mga pin na AD0, AD1 at AD2. Ang mga pin na ito ay maaaring itali sa lupa o sa positibong supply ng boltahe (5 volts) upang kumatawan sa 0 o 1 ayon sa pagkakabanggit. Kaya't ang saklaw ng mga posibleng address ay 38 hanggang 3F hexadecimal, tulad ng ipinakita sa iba pang pigura mula sa PCA8574 data sheet. Kaya sa pamamagitan ng pagbabago ng mga setting ng bit address, hanggang sa 8 PCA8574As ay maaaring nasa I2C bus nang sabay. Ang bawat isa ay tutugon lamang sa tukoy nitong address ng alipin. Kung mas maraming mga I / O port ang kinakailangan, maaaring magamit ang PCA8574. Ang pagkakaiba lamang sa pagitan ng PCA8574 at ng PCA8574A ay ang saklaw ng address ng alipin ng I2C ng PCA8574 ay 20 hanggang 27 hexadecimal. Ang pagtukoy ng address ng isang naibigay na aparato ay maaaring nakalilito dahil ang ilang mga sheet ng data ay isinasaalang-alang ang basahin / sumulat ng kaunti upang maging bahagi ng address Basahing mabuti ang sheet ng data at tandaan na ang address ng alipin ay magiging 7 piraso ang haba. Ang bitayang basahin / isulat ay dapat tratuhin nang magkahiwalay. Muli, makakatulong ang isang halimbawa. Ang sheet ng data para sa 24C16 EEPROM na eksperimento namin ay nagsasabi na ang una (pinaka-makabuluhang) apat na piraso ng address ng alipin ay 1010. Ang susunod na tatlong piraso ay maaaring matukoy ng A0, A1 at A2; ngunit tandaan ang data sheet ay sumasaklaw din ng 24C01 hanggang 24C08 na mas maliit ang laki ng EEPROMs. Ipinapakita ng figure mula sa sheet ng data na ang mga setting ng mga address bit na ito ay hindi pinapansin habang tumataas ang laki at ganap na hindi pinapansin para sa 24C16. Iyon ay, ang huling tatlong piraso ay hindi mahalaga at talagang ginagamit ng 24C16 ang lahat ng mga address ng alipin ng I2C na 50 hanggang 57 hexadecimal. Ang saklaw ng mga address ng alipin ay talagang tutugunan ang iba't ibang mga seksyon sa loob ng 24C16. Ang unang 256 bytes ay nasa address na 50h, ang susunod na 256 sa 51h, at iba pa hanggang sa huling 256 sa 57h - para sa isang kabuuang 2K byte. Dahil ang address ng PCF8570 RAM na eksperimento rin namin ay nasa saklaw na ito, ang 24C16 at ang PCF8570 ay hindi maaaring magamit nang magkasama.

Hakbang 2: Mag-order ng Ilang Mga I2C Device

Ngayong alam mo nang kaunti tungkol sa I2C Bus at nais mong gamitin ito, bakit hindi mag-order ng ilang mga aparato ng I2C na mag-eksperimento ngayon upang makarating sila sa iyo habang hinahanda mo ang software? Kasama sa mga naaangkop na aparato ang isang I / O Interface Expander (aking paboritong), isang Static Ram, at isang EEPROM. Marami pang iba, ngunit ito ay isang mahusay na pagsisimula. Ang mga processor na AVR na gagamitin namin ay ang ATtiny2313 at ang Atmega168 (ginamit sa Arduino). Kung bago ka sa mga ito, tingnan ang mahusay na Makatuturo na ito upang malaman ang tungkol sa mga ito at buuin ang iyong Ghetto Development System. Ang eskematiko ng ATmega168 sa kasalukuyang Instructable ay nagpapakita kung paano ipatupad ang Ghetto Development System para sa prosesor na ito. Ang parallel port cable ay pareho sa isa para sa ATtiny2313. (Hindi ko pa nasubukan ang bersyon ng USB ng Ghetto Development System, kaya hindi ako sigurado kung paano mai-access dito ang I2C bus. Parehas para sa Arduino.) Narito ang mga numero ng bahagi ng Digikey. Port Expander: IC I2C I / O EXPANDER 568-4236-5-NDRam: IC SRAM 256X8 W / I2C 568-1071-5-NDEEPROM: IC EEPROM SERIAL 16K CAT24C16LI-G-ND

Hakbang 3: Mga Driver ng I2C

Narito ang mga paglalarawan ng mga pagpapaandar ng driver para sa I2C bus. Ito ay binuo gamit ang Atmel Apps Notes para sa mga nagsisimula. Hindi ko magawa ito nang wala sila bilang isang batayan upang makabuo. Ang pag-unlad ay ginawa gamit ang WinAVR at ang gcc C compiler. Ang mga paghihigpit sa rate ng orasan ay inilarawan sa ibaba para sa bawat processor. Dahil hindi ko masubukan ang lahat ng mga kumbinasyon ng processor / rate ng orasan na posible, mananatili lamang ako sa kung ano talaga ang maaari kong subukan at subukang ipahiwatig ang mga paghihigpit at limitasyon. Narito ang mga pagpapaandar ng driver at kung paano ito gamitin. Mangyaring tingnan ang mga halimbawa para sa higit pang mga detalye at upang makita ang mga pagpapaandar na ginagamit sa kumpletong mga programa. Para sa ATtiny2313: Kinakailangan sa Clock: Ang mga driver ay idinisenyo para sa isang rate ng orasan na 1MHz (ang default rate) para sa ATtiny2313. Kung nais mong tumakbo sa iba pang mga rate, pagkatapos ay kailangan mong ayusin ang mga pare-pareho sa mga driver. I-email sa akin kung kailangan mo ng tulong sa paggawa nito. Maaari ka ring makakuha ng ilang mga pahiwatig mula sa mga tala ng apps ng Atmel sa mga link sa Hakbang ng Mga Mapagkukunan. USI_TWI_Master_Initialise () Ang pagpapaandar na ito ay nagpapasimula sa USI hardware para sa pagpapatakbo ng I2C mode. Tumawag ito nang isang beses sa simula ng iyong programa. Bumalik itong walang bisa at walang mga argumento. USI_TWI_Get_State_Info () Ang pagpapaandar na ito ay nagbabalik ng impormasyon ng error sa I2C at ginagamit kung may naganap na error sa panahon ng isang transaksyon ng I2C. Dahil nagbabalik lamang ang pagpapaandar na ito ng isang error code, ginagamit ko ang pagpapaandar TWI_Act_On_Failure_In_Last_Transmission (TWIerrorMsg) upang mag-flash ng isang error na LED. Ang mga error code ay tinukoy sa USI_TWI_Master.h. Narito kung paano ito tawagan: TWI_Act_On_Failure_In_Last_Transmission (USI_TWI_Get_State_Info ()) USI_TWI_Start_Read_Write () Ang pagpapaandar na ito ay ginagamit upang basahin at isulat ang mga solong byte sa mga I2C na aparato. Ginagamit din ito upang magsulat ng maraming byte. Mayroong 6 na hakbang upang magamit ang pagpapaandar na ito.1) Magdeklara ng isang buffer ng mensahe sa iyong programa upang hawakan ang address ng alipin at ang byte ng data na ipapadala o tatanggapin. unsigned char messageBuf (MESSAGEBUF_SIZE); 2) Ilagay ang Slave Address bilang unang byte sa buffer. Ilipat ito nang kaunti pakaliwa at O sa bit na Basahin / Isulat. Tandaan na ang Basahin / Isulat ang bit ay magiging 1 para sa isang Basahin at 0 para sa isang Sumulat. Ang halimbawang ito ay para sa isang Basahin. messageBuf (0) = (TWI_targetSlaveAddress << TWI_ADR_BITS) | (TOTOO << TWI_READ_BIT); 3) Kapag gumagawa ng isang Sumulat, ilagay ang byte upang maisulat sa susunod na lokasyon sa buffer.4) Tumawag sa pagpapaandar ng USI_TWI_Start_Read_Write kasama ang buffer ng mensahe at laki ng mensahe bilang mga argumento.temp = USI_TWI_Start_Read_Write (messageBuf, 2); 5) Ang naibalik na halaga (temp sa kasong ito) ay maaaring masubukan upang makita kung may naganap na error. Kung gayon, hahawakan ito tulad ng tinalakay sa itaas. Tingnan ang mga halimbawa sa mga programa.6) Kung ang isang Basahin ay hiniling, ang byte na basahin ay nasa pangalawang lokasyon sa buffer. Kung maraming mga byte ang naisusulat (tulad ng isang memorya ng aparato), maaaring magamit ang parehong gawain. Ang pagse-set up ng buffer at pagtawag sa routine ay bahagyang naiiba. Ang pangalawang byte sa buffer ay ang panimulang memory address kung saan susulat. Ang data na isusulat ay nasa kasunod na mga byte. Ang laki ng mensahe ay ang laki kasama ang lahat ng wastong data. Kaya't kung 6 na byte ang naisusulat, ang laki ng mensahe ay magiging 8 (address ng alipin + address ng memorya + 6 bytes ng data). USI_TWI_Start_Random_Read () Ginagamit ang pagpapaandar na ito upang mabasa ang maraming mga byte mula sa isang aparato ng I2C, karaniwang makabuluhan lamang ito para sa isang memorya ng ilang uri. Ang paggamit ng nakagawian na ito ay halos kapareho ng nakaraang gawain, na may dalawang mga pagbubukod. Ang setting ng Basahin / Isulat ang bit ay hindi mahalaga. Ang pagtawag sa gawain na ito ay palaging magiging sanhi ng isang Basahin ang operasyon. Ang messageSize ay dapat na 2 kasama ang bilang ng mga byte na babasahin. Kung walang mga error na nangyari, ang data ay nasa buffer na nagsisimula sa pangalawang lokasyon. Para sa ATmega168: Kinakailangan sa Clock: Ang ang mga driver ay dinisenyo para sa isang rate ng orasan na 4MHz para sa ATmega168. Ipinapakita ng halimbawa ng code kung paano itakda ang rate ng orasan na ito. Kung nais mong tumakbo sa iba pang mga rate, pagkatapos ay kailangan mong ayusin ang mga pare-pareho sa mga driver. I-email sa akin kung kailangan mong gawin ito. TWI_Master_Initialise () Pinasimulan ng pagpapaandar na ito ang TWI hardware para sa pagpapatakbo ng I2C mode. Tumawag ito nang isang beses sa simula ng iyong programa. Bumalik itong walang bisa at walang mga argumento. Tiyaking paganahin ang mga nakakagambala sa pamamagitan ng pagtawag sa swi () pagkatapos ng pagsisimula. TWI_Get_State_Info () Ang pagpapaandar na ito ay nagbabalik ng impormasyon ng error sa I2C at ginagamit kung may naganap na error sa panahon ng isang transaksyon ng I2C. Dahil nagbabalik lamang ang pagpapaandar na ito ng isang error code, ginagamit ko ang pagpapaandar TWI_Act_On_Failure_In_Last_Transmission (TWIerrorMsg) upang mag-flash ng isang error na LED. Ang mga error code ay tinukoy sa TWI_Master.h, ngunit binago para sa pagbibigay ng senyas sa isang error na LED. Tingnan ang halimbawa ng code para sa mga detalye. Narito kung paano ito tawagan: TWI_Act_On_Failure_In_Last_Transmission (TWI_Get_State_Info ()) Tandaan na ang pag-check ng error ay tapos na sa pamamagitan ng pagtiyak na kumpleto ang transaksyon ng I2C (inilarawan sa ibaba ang pag-andar) at pagkatapos ay pagsubok ng kaunti sa pandaigdigang salitang katayuan. ang dalawang pag-andar ay gumagana nang pareho sa mga kaukulang pag-andar na inilarawan sa itaas ngunit may ilang mga pagbubukod. Hindi nila binabalik ang anumang mga halaga ng error. Ang nabasa na data ay hindi inililipat sa buffer. Ang paggawa nito ay magagawa sa pagpapaandar na inilarawan sa susunod. Kapag tumatawag sa TWI_Start_Random_Read, ang messageSize ay dapat na bilang ng mga byte ng data na hiniling plus isa, hindi dalawa. Ang driver ng I2C para sa ATmega168 ay nagambala. Iyon ay, ang mga transaksyon sa I2C ay nagsimula at pagkatapos ay magsagawa nang nakapag-iisa habang ang pangunahing gawain ay patuloy na tumatakbo. Kapag nais ng pangunahing gawain ang data mula sa isang transaksyon ng I2C na nagsimula ito, dapat itong suriin upang makita kung ang data ay magagamit. Ang sitwasyon ay pareho para sa pag-check ng error. Ang pangunahing gawain ay dapat na siguraduhin na ang transaksyon ng I2C ay kumpleto bago suriin ang mga error. Ang susunod na dalawang pag-andar ay ginagamit para sa mga hangaring ito. TWI_Transceiver_Busy () Tumawag sa pagpapaandar na ito upang makita kung ang isang transaksyon sa I2C ay kumpleto bago suriin ang mga error. Ipinapakita ng mga halimbawa ng programa kung paano ito gagamitin. TWI_Read_Data_From_Buffer () Tumawag sa pagpapaandar na ito upang ilipat ang data mula sa pagtanggap ng buffer ng driver ng I2C sa buffer ng mensahe. Titiyakin ng pagpapaandar na ito na kumpleto ang transaksyon ng I2C bago ilipat ang data. Habang ang isang halaga ay naibalik ng pagpapaandar na ito, nahanap kong suriin ang error bit nang direkta upang mas maaasahan. Narito kung paano ito tawagan. Ang Sukat ng mensahe ay dapat na isang mas malaki kaysa sa bilang ng mga data bit na nais. Ang data ay nasa messageBuf na nagsisimula sa pangalawang lokasyon.temp = TWI_Read_Data_From_Buffer (messageBuf, messageSize);

Hakbang 4: Bumuo tayo

Magsimula sa pamamagitan ng pag-download ng file na I2C Schematics.zip. Maaaring gusto mong lumikha ng isang folder ng I2C sa iyong lugar ng trabaho upang hawakan ang mga iskema at ang halimbawang mga file ng programa. I-zip ang mga iskema sa direktoryong ito. Makakakita ka ng isang folder na tinatawag na I2C Schematics. Buksan ang file na pinangalanang maliit na I2C.pdf. Ipinapakita ng eskematiko na ito ang ATtiny2313 Ghetto Development System, at ang PCA8574A I / O Port Expander (ay mayroong malaking dashing box sa paligid nito). Ang Port Expander circuit ay itinayo sa isang breadboard. Tingnan ang mga larawan upang makita kung ano ang hitsura ng mga circuit na ito. Ang mga ito ay talagang simple. Ang bahagi ng ATtiny2313 ng eskematiko ay ang Ghetto Development System lamang na may tatlong mga blinkenlight (LED1, 2, at 3, kasama ang R4, 5, at 6) at isang pushbutton (S1) na naka-hook dito, kasama ang isa karagdagang detalye. Ang detalyeng iyon ay ang pagdaragdag ng mga jumper (JP4, 5, at 6) na maaaring alisin upang payagan ang koneksyon ng mga linya ng I2C SCL at SDA. Ang mga jumper ay dapat na nasa lugar para sa pag-program, pagkatapos ay tinanggal upang ang SCL at SDA ay maaaring konektado. Ipinapakita ng mga larawan ang mga jumper sa lugar at inalis. Nasa iyo ang paglalagay ng mga jumper na ito, kailangan mo lamang ilagay ang mga ito sa iyong Ghetto Development System kung nais mong gamitin ang I2C bus. Ang I2C bus ay dapat na idiskonekta at ang mga jumper ay inilalagay para sa pagprograma. Tandaan na kailangan mo lamang mag-alala sa JP4 at JP6 para sa I2C bus. Ilagay sa JP5 kung sa palagay mo ay nais mong gamitin ang SPI bus. Ang boardboarding sa PCA8574A I / O Port Expander ay napaka-simple. Magbigay ng mga koneksyon ng Vcc (+5 volts) at Gnd (ground) at ikonekta ang AD0, 1, at 2 sa ground (ginagawang 38 hex ang address ng alipin ng I2C). Pagkatapos ay ikonekta ang 4 na mga blinkenlight, at 4 na switch ng DIP. (Kung wala kang mga switch ng DIP maaari mo lamang gamitin ang mga wires. Itali sa lupa o iwanan ang lumulutang upang mag-signal o patayin ayon sa pagkakabanggit.) Panghuli, ikonekta ang mga resistor na pull-up (R11 at 12) mula sa SDA at SCL patungong Vcc. Ipinapakita ang mga ito bilang 3.3K, ngunit ang anumang halaga mula 1.8K hanggang 5.1K ay dapat na gumana (marahil hanggang sa 10K ngunit hindi ko ito nasubukan). Kapag na-program mo ang ATtiny2313 maaari mong alisin ang mga jumper at ikonekta ang SDA at SCL para sa pagsubok. Ngayon para sa ATmega168. Ang tanging kunot dito ay maaaring hindi ka nakagawa ng isang Ghetto Development System para sa prosesor na ito. Kung ganoon ang kaso, ipapakita sa iyo ng eskematiko na ibinibigay ko (MEGA I2C.pdf) kung paano. Ito ay isang permutasyon lamang ng bersyon ng ATtiny2313. Kung plano mong maaga masisiguro mong ang iyong programming cable ay magkakasya sa parehong mga system. Ang pangunahing pagkakaiba ay ang pagdaragdag ng C2 at C3. Tingnan ang mga larawan para sa paglalagay ng mga ito, dapat na malapit sila sa maliit na tilad; ang isa sa kanila ay talagang nasa ilalim ng maliit na tilad. Ang mga ito ay makakatulong na maiiwasan ang ingay sa partikular sa digital converter. Hindi mo kailangang ilagay sa mga jumper maliban kung balak mong gamitin ang SPI bus dahil hindi sila kinakailangan para sa I2C bus sa chip na ito. Tandaan na ang breadboard ng PCA8754A ay hindi mababago. Makikabit mo lang ang SDA at SCL at malayo ka! Madali, ha?

Hakbang 5: Code at Subukan Natin

Panahon na upang buuin ang mga driver at ang mga halimbawang programa. Magsisimula kami sa ATtiny2313 at sa breadboard ng PCA8574A na itinayo lamang namin. I-download ang file na I2C.zip sa iyong direktoryo sa trabaho ng I2C at i-unzip ito. Magkakaroon ka ng isang bagong folder na tinatawag na I2C. Sa loob nito mahahanap mo ang USI I2C (para sa ATtiny2313) at TWI I2C (para sa ATmega168). Sa USI I2C, makikita mo ang folder na I_O Port. Naglalaman ang folder na iyon ng code para sa aming unang halimbawang programa, at mga driver ng USI I2C. Gamit ang WinAVR, i-compile at i-load ang code sa ATtiny2313. Huminga ng malalim at buksan ang lakas. Narito kung ano ang aasahan: Sa power on, LED 1 sa port PD6 ng ATtiny2313 ay kumikislap ng dalawang beses. Wala nang ibang mangyayari hanggang sa itulak mo ang pindutan (S1). Sa bawat oras na pinindot ang pindutan, ang mga switch ay nababasa at ang kanilang setting ay ipapakita sa mga LED na konektado sa PCA8574A. Baguhin ang halaga ng mga switch, pindutin ang pindutan, at dapat magbago ang mga LED. Patuloy na gawin ito hanggang sa malampasan mo ang kilig ng nakikita itong gumana. Kung ang (ipinagbabawal ng Diyos!) Na mga bagay ay hindi gumagana tulad ng inaasahan, maingat na suriin ang iyong mga kable. Ang mga error sa I2C ay isenyas ng mga blink sa LED3 (PD4) at marahil ay nangangahulugang kailangan mong suriin na ang SDA at SCL ay konektado sa tamang mga pin at hinugot nang tama. Kung hindi pa rin gumagana ang mga bagay, basahin ang natitirang bahagi ng seksyong ito upang malaman ang tungkol sa pag-debug. Ngayon bumalik at tingnan natin ang code. Buksan ang file na USI_I2C_Port.c. Ito ang code para sa halimbawang programa. (Ang USI_TWI_Master.c at USI_TWI_Master.h ay naglalaman ng mga driver - maaari mong balewalain ang mga ito maliban kung gusto mong malaman.) Gumamit ng halimbawa upang gabayan ang iyong sariling mga aplikasyon ng I2C. Kadalasan, ipinapakita sa iyo ng programa kung paano simulan at gamitin ang mga driver ng I2C, kabilang ang setting pataas ang address ng alipin at ang natitirang buffer ng mensahe, at mailalabas ang data dito. Makikita mo rin kung paano ko i-debug ang pindutan at i-set up ang habang loop. Mayroong ilang mga detalye ng programa na nagkakahalaga ng pagbanggit. Tandaan na ang data mula sa mga switch ay baligtad bago ito nakasulat sa mga LED sa Port Expander. Tandaan din na ang mga input port sa Port Expander ay dapat na nakasulat bilang Mataas upang gumana nang maayos ang mga ito. Ang mga detalyeng iyon ay inilalarawan sa sheet ng data ng PCA8574A. Palaging basahin nang maingat ang mga sheet ng data! Mas maraming interes ang paggamit ng kondisyong pag-debug. Malapit sa pagsisimula ng file ng programa ay ang pahayag // # tukuyin ang DEBUG at iwisik sa buong code ang mga pahayag na #ifdef DEBUG. Hangga't hindi tinukoy ang DEBUG (ang dalawang slash ay gumawa ng linya ng isang puna at panatilihin itong mai-tinukoy), ang code sa loob ng #ifdef hanggang #endif na pahayag ay hindi maiipon. Ngunit kung hindi gagana ang mga bagay ayon sa inaasahan mo, muling pagsamahin at i-reload ang code na may #define DEBUG na hindi komportable. Makakakuha ka ng mas maraming mga blink sa mga LED na kung saan maaari mong i-decode upang sundin ang pagpapatupad ng iyong programa at tulungan ka sa paghahanap ng eksaktong kung saan nagkakamali ang mga bagay. Sa katunayan, inirerekumenda kong subukan mo ito upang makita lamang ang nangyayari. Ang makikita mo ay ang LED 2 (sa PD5) ay kumikislap habang isinasagawa ang pagpapatupad sa pamamagitan ng programa. Ang halagang binasa mula sa mga switch ay magpapikit sa LED 1 (PD6) bago ito ipakita sa mga Port Expander LEDs. Dapat mong subaybayan ang programa habang tumatakbo ito sa pamamagitan ng paggamit ng mga LED na ito. Gagana kami sa susunod na ATmega168; laktawan ang seksyong ito kung interesado ka lamang sa ATtiny2313. Nasa akin pa? Mabuti Lumipat sa folder na TWI_I2C, palitan ang iyong direktoryo sa pagtatrabaho sa IO_Port, at i-compile at i-load ang TWI_I2C_Port.c sa ATmega168. Idiskonekta ang mga linya ng SDA at SCL mula sa ATtiny2313 at ikonekta ang mga ito sa ATmega168. I-hook up ang kapangyarihan at lupa, at lakas. Ang operasyon ay dapat na pareho! Maglaro hanggang sa humina ang kilig, pagkatapos ay tingnan natin ang code. Buksan ang TWI_I2C_Port.c. Ang code ay halos magkapareho maliban sa paghawak ng error at pagtanggap ng mga driver na nakakagambala. Narito ang mga pagkakaiba: Tandaan na ang orasan ay dapat itakda sa 4MHz para gumana nang maayos ang I2C bus. Ang sei (); ang pahayag ay lumiliko sa mga nakakagambala pagkatapos ng pagsisimula ng mga driver ng I2C. Upang suriin ang mga error, nasubukan ang isang tukoy na status ng status. Sa panahon ng isang pagbasa, dapat tawagan ang pagpapaandar ng TWI_Read_Data_From_Buffer upang ilipat ang data na nabasa sa buffer ng mensahe. Sa isang pagsusulat, habang dapat gamitin ang (TWI_Transceiver_Busy ()) upang matiyak na kumpleto ang paglilipat bago suriin ang mga error. Ang huling dalawang pag-andar na ito ay inilarawan sa itaas sa paglalarawan ng mga driver. Maliban dito, ang code ay halos kapareho ng para sa ATtiny2313. Gumagana ang DEBUG ng pareho din kung nais mong mag-eksperimento sa na.

Hakbang 6: Paggamit ng I2C Memory

Ngayon natutunan na nating gamitin ang I2C bus upang mabasa at magsulat ng I / O Port Expander, magpatuloy tayo sa paggamit ng mga alaala ng I2C, kapwa RAM at EEPROM. Ang pangunahing pagkakaiba ay ang maraming mga byte ay maaaring mabasa o isulat mula sa mga alaala na may isang solong utos ng I2C. Upang maghanda para sa mga eksperimentong ito, kailangan naming baguhin nang bahagya ang hardware at bumuo ng isang pares ng mga bagong circuit sa breadboard. Panatilihin ang circuit ng Port Expander dahil gagamitin namin ito upang ipakita ang ilang mga halaga ng memorya. Alisin ang mga switch ng DIP mula sa PCA8574A at ilagay ang mga blinkenlight sa mga pin na iyon. Kung wala kang sapat na mga blinkenlight, ilipat ang mga nasa P4 hanggang P7 hanggang sa P0 hanggang sa P3. (Ang mga halagang ipinapakita ay sapat na maliit.) Ngayon tingnan ang eskematiko na I2C Ram.pdf at i-hook up ang PCF8570 sa breadboard. Tingnan din ang larawan. Siguraduhing itali ang pin 7 sa Vcc. Patakbuhin ang mga wire para sa SDA at SCL mula sa PCA8574A. Walang kinakailangang karagdagang mga resistors na pull-up. Kung interesado ka rin sa EEPROM, itayo ang circuit na iyon na gumagamit din ng I2C EEPROM.pdf para sa 24C16, ngunit binalaan na ang halimbawa ay gumagamit ng ATmega168. Ang circuit na ito ay talagang simple. Tulad ng tinalakay sa itaas, ang mga bit ng address ay dapat na balewalain. I-hook up lamang ang lakas at lupa. Huwag ikonekta ang SDA at SCL dahil hindi pa namin natatapos ang pag-eksperimento sa Ram. Sisimulan namin ang aming mga eksperimento sa memorya sa ATtiny2313 na konektado sa PCA8574A Port Expander at sa PCF8570 Ram. Ang programa ay magsusulat ng ilang mga numero sa Ram, pagkatapos ay basahin itong muli at ipakita ang mga ito sa Port Expander. Baguhin ang iyong direktoryo sa pagtatrabaho sa RAM sa ilalim ng USI I2C. Gamitin ang gumawa ng file upang mag-ipon at mag-download ng USI_I2C_RAM.c. Tandaan na ang mga file ng driver ng I2C ay magkapareho sa mga ginamit namin kanina. I-hook up ang lakas at dapat mong makita ang isang solong blink sa LED 1 (PD6). Isusulat ang data sa unang 4 bytes ng memorya. Pindutin ang pindutan at ang dalawang byte ay babasahin muli at maipakita. Dapat mong makita ang isang LED light sa Port Expander (P0), isang pangalawang segundong paghinto, pagkatapos ay dalawang ilaw ng LED (P0 at P1). Ang isa pang dalawang segundong pag-pause at ang mga LED ay dapat na patayin. Pindutin muli ang pindutan upang simulang muli ang pagkakasunud-sunod. Ang pag-debug ay katulad ng pamamaraang inilarawan sa itaas. Tingnan natin ang code. Buksan ang USI_I2C_RAM.c. Dapat itong magmukhang katulad sa nakaraang code. Ang mga pangunahing pagkakaiba ay ang mga detalye ng pagbabasa at memorya ng pagsulat. Tingnan ang paraan ng pagkarga ng buffer ng mensahe bago ang tawag na talagang nagsusulat. Ang unang byte ay ang address ng alipin na may wastong nabasa / sumulat na nakatakda nang naaangkop. Ngunit ang susunod na byte ay ang memorya ng address kung saan upang simulan ang pagsulat ng data. Pagkatapos ay darating ang aktwal na mga byte ng data na sunud-sunod na mai-load sa memorya na nagsisimula sa address na tinukoy namin. Tinukoy namin ang laki ng mensahe bilang 6. Kaya't nagsisimula kaming magsulat sa address 00 at isulat ang mga halagang 01, 03, 02 at 06 sa mga lokasyon ng memorya na 00 hanggang 03. Upang mabasa ang data pabalik mula sa memorya dapat naming gamitin ang USI_TWI_Start_Random_Read function. Nakuha ng buffer ng mensahe ang address ng alipin sa unang byte at ang panimulang address sa pangalawang byte. Pagkatapos ay tawagan ang pagpapaandar na itinakda ang laki ng mensahe sa bilang ng mga byte upang basahin plus 2. Tandaan na ang pagbabasa / pagsulat ng kaunti ay hindi mahalaga dahil ang isang pagbasa ay magagawa nang alintana. Ang ibinalik na data ay magsisimula sa pangalawang lokasyon sa buffer ng mensahe. Kapag nabasa na ang data, invert ito para sa pagpapakita sa Port Expander at nakasulat ng isang byte nang paisa-isa dito na may pag-pause sa pagitan ng mga halaga. Sa wakas, naka-off ang mga Port Expander LED. Ang mga sinusulat sa Port Expander ay magkapareho sa ginawa sa mga nakaraang halimbawa. Para sa kasiyahan, maaari mong i-unsment ang pahayag na #define DEBUG tulad ng nasa itaas at makita ang maraming mga kumikislap na LED. Dagdag ng kaguluhan pagkatapos ng isa pang matagumpay na eksperimento, lumipat tayo sa ATmega168 at isang EEPROM. Baguhin ang iyong direktoryo sa pagtatrabaho sa EEPROM sa ilalim ng TWI I2C. Gamitin ang gumawa ng file upang mag-ipon at mag-download ng TWI_I2C_EEPROM.c. Tandaan na ang mga file ng driver ng I2C ay magkapareho sa mga ginamit namin kanina para sa PCA8574A. Upang subukan ang programa, idiskonekta ang ATtiny2313 at ikonekta ang ATmega168. Iwanan ang I2C bus na naka-hook sa Ram at i-power up. Ang mga resulta ay iba dahil nagsusulat kami ngayon at nagbabasa ng mas maraming data. Ang LED 1 sa PD7 ay dapat magpikit sa pagsisimula. Pindutin ang pindutan at ang data ay babasahin muli mula sa memorya at ipapakita. Ang mga LED sa PCA8574 ay dapat magpikit sa sumusunod na pagkakasunud-sunod: P1, P0 & P2, (lahat ng naka-off), P0 & P1, P1 & P2. Sa wakas ang mga Port LEDs dapat lahat patayin. Pindutin muli ang pindutan upang ulitin ito. Ay, ngunit maghintay, sasabihin mo. Hindi ba ang program na ito para sa EEPROM? Dahil nag-a-access kami ng isang aparato ng memorya sa parehong address ng I2C, gumagana ang parehong programa para sa parehong Ram at EEPROM. I-power down at ilipat ang SDA at SCL mula sa Ram patungong EEPROM at patakbuhin muli ang programa. Dapat itong gumana nang eksaktong pareho. Tandaan na ang EEPROM at ang Ram ay hindi maiugnay sa I2C bus nang sabay-sabay dahil nagbahagi sila ng parehong address. (Ang mga matalino sa iyo ay maaaring isaalang-alang ang pagbabago ng maaaring mai-program na mga piraso ng address sa Ram, ngunit hindi pa rin gagana. Ginagamit ng 24C16 ang buong bloke ng mga address na maaaring mai-program para sa Ram.) OK, tingnan natin ang huling program na ito. Buksan ang TWI_I2C_EEPROM.c. Ang unang bagay na napansin ay naipahiwatig ko kung paano tugunan ang kumpletong 24C16 EEPROM. Maaari itong ma-access sa 256 byte chunks sa 8 magkakaibang mga address ng alipin ng I2C. Tingnan kung paano tinukoy ang MEMORY_ADDR bilang panimulang address sa 50 hexadecimal; kaya pala nagtrabaho ang Ram. Kung nais mong i-access ang iba pang mga bloke ng 24C16, pagkatapos ay gamitin ang iba pang mga address tulad ng ipinahiwatig ko. Tingnan kung paano ako nag-set up upang sumulat sa memorya. Una ang address ng alipin na may set na nabasa / sumulat ay inilalagay sa buffer, pagkatapos ay ang panimulang address ng 00, pagkatapos ay 16 bytes ng data. Ang pagpapaandar na TWI_Start_Read_Write ay tinatawag upang isulat ang data (tulad ng dati) na ang laki ng mensahe ay nakatakda sa 18. Kapag pinindot ang pindutan, ginagamit namin ang TWI_Start_Random_Read at TWI_Read_Data_From_Buffer upang basahin muli ang data. Ang bawat ikatlong byte ay ipinapakita sa mga Port Expander LEDs. Sa wakas, naka-off ang mga LED upang maghintay sa susunod na pindutin ang pindutan. Maaari kang magtaka kung bakit pinili ko na magsulat ng 16 bytes. Kung binasa mong maingat ang sheet ng data, makikita mo na ang 24C16 ay gumagawa ng isang cycle ng pagsulat tuwing nakakatanggap ito ng 16 bytes kahit na maraming byte ang ipinapadala. Kaya't tila isang magandang numero ang gagamitin. Kung pipiliin mong dagdagan ito, kailangan mong baguhin ang laki ng MESSAGEBUF_SIZE. Kailangan mo ring baguhin ang halagang TWI_BUFFER_SIZE sa TWI_Master.h. Ito ay dahil kinopya ng driver ang data mula sa buffer ng mensahe para magamit ng nakagambala na gawain sa serbisyo. Binabati kita! Handa ka na ngayong gamitin ang I2C bus sa iyong sariling mga proyekto!

Hakbang 7: Mga Mapagkukunang Web

Narito ang mga link sa mga datasheet para sa mga bahagi na ginamit para sa mga eksperimento. Tiyak na makukuha mo ang mga ito kung wala kang ibang makukuha. Port ExpanderRamEEPROMMaging tagalikha ng I2C, ang NXP (Philips) ay may maraming toneladang magagaling na bagay. (Gusto nilang gumamit ng mga square bracket sa kanilang mga URL, kaya hindi ko ito maisama nang maayos. Paumanhin.] Upang makapunta sa lugar ng I2C, piliin ang Interface mula sa listahan ng Mga Produkto. Makakapunta ka sa kanilang I2C site at pag-access sa lahat ng mga tala ng datasheet at app na inaalok nila. Ang paglalarawan ng I2C bus at partikular na mga detalye sa teknikal ay narito. Kunin ang mga datteteet ng ATtiny2313 at ATmega168 (mga libro ng data?) Mula sa Atmel. Ang mga tala ng aplikasyon ng Atmel ay narito. Tingnan ang AVR310 at AVR315. Grab din ang code. Magkaroon ng isang pagtingin dito para sa maraming mga bagay-bagay I2C.

Hakbang 8: Mga Tala para sa Geeks

Para sa totoong geek na nais malaman ang mga detalye, narito ang ilang mga bagay na dapat tandaan kung titingnan mo ang Atmel Apps Notes at driver code: - Ang pamamaraan ng pagtugon at pag-utos ng isang aparato ng I2C ay hindi bahagi ng detalye! Maliban sa address ng alipin at basahin / isulat ang kaunti, ang mga utos, mode, atbp ay hindi tinukoy at tukoy sa isang naibigay na aparato. Upang linawin itong napakalinaw, tandaan na ang pamamaraan na ginamit sa halimbawa ng Atmel ay nalalapat lamang sa halimbawang iyon, at medyo hindi pamantayan.- Ang pagpapatupad ng USI ay naiiba sa pagpapatupad ng TWI sa ilang mahahalagang paraan. + Sa USI, ang orasan ay ibinibigay ng software; sa TWI ito ay ibinigay ng isang Bit Rate Generator. + Ang pamamaraan ng USI ay hindi gumagamit ng mga nakakagambala; ginagawa ng TWI. Gumagawa ito ng isang tiyak na halaga dahil ang Mega pamilya (gamit ang TWI) ay maaaring gumawa ng maraming iba pang mga bagay at hindi dapat hogged ng I2C transfer. Ang isang nakakaabala na hinihimok na bersyon para sa USI ay tiyak na posible, hindi lamang ito ipinatupad sa Instructable na ito. + Ang hardware ng USI ay hindi na-optimize para sa I2C at mahahawakan lamang ang 8 bit transfer. Nangangahulugan ito na ang dalawang paglilipat ay kinakailangan upang maipadala ang ikasiyam na bit (alinman sa NACK o ACK). Awtomatikong hinahawakan ito ng hardware ng TWI. Ginagawa nitong medyo mas kumplikado ang pagpapatupad ng driver ng USI. + Ang pagtuklas ng error para sa TWI ay pinangangasiwaan sa hardware. Nangangailangan ang USI ng paghawak sa software na medyo kumplikado ng mga bagay. + Kinokontrol ng TWI hardware ang pagsasaayos ng port nang direkta. Kinakailangan ng hardware ng USI na mai-configure ang mga port bit bago magamit ang port. Makikita mo ito sa gawain ng Master_Initialize para sa USI.- Inaangkin ni Atmel na posibleng gumamit ng AVR port pull-up para sa mga pull-up ng bus ng I2C. Hindi ko naisip ang isang paraan upang maisagawa ang diskarte na iyon. Ang paggamit ng dalawang panlabas na resistor ay tila isang simpleng pamamaraan, kaya't hindi ako gumugol ng maraming oras dito.