I2C -bus vir ATtiny en ATmega: 8 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:28

Ek is mal oor die Atmel AVR -mikrobeheerders! Sedert die bou van die Ghetto Development System wat in hierdie Instructable beskryf word, het ek geen einde gehad aan pret om met die AVR ATtiny2313 en veral die ATmega168 te eksperimenteer nie. Ek het selfs so ver gegaan as om 'n Instructable te skryf oor die gebruik van skakelaars as insette, en ek het die Ghetto Development System -konsep uitgebrei tot CPLDs. Tydens 'n onlangse projek het ek verskeie skakelaars nodig gehad om kontrolewaardes te stel. Die AVR's het nie genoeg I/O -penne nie, so ek moes aan iets dink. Ek sou 'n ingewikkelde invoerstelsel met 'n sleutelbord en skerm kon probeer, maar die ATtiny2313 sou nie meer hulpbronne gehad het nie. Gelukkig het Atmel 'n oplossing vir hierdie probleem gegee deur 'n koppelvlak in te sluit wat kan skakel na ekstra skyfies (soos geheue of I/O -poorte) met 'n eenvoudige tweedraads koppelvlak. Dit is reg, deur slegs twee I/O -penne op 'n AVR te gebruik, het ons ook toegang tot baie bykomende I/O -penne en ander hulpbronne. Hierdie tweedraads koppelvlak staan formeel bekend as die Inter-Integrated Circuit-bus, of net die I2C-bus, en is uitgevind deur NXP toe dit nog Philips Semiconductors was. As u hierdie instruksies lees, het u waarskynlik van die I2C -bus gehoor en dit moontlik selfs op 'n PIC of ander mikrobeheerder gebruik. Alhoewel dit konseptueel baie eenvoudig is en ondersteun word deur hardewarehulpbronne op die AVR's, is sagtewarebestuurders steeds nodig om die I2C -bus te gebruik. Atmel verskaf toepassingsnotas (sien die bronne later in hierdie instruksies), maar dit is onvolledig en toon geen voorbeelde nie, behalwe om met 'n ander AVR -toestel te kommunikeer. Dit is nie die doel van hierdie instruksie om iemand te leer hoe om I2C -bestuurders vir AVR's. Ek gee eerder uitgebreide weergawes van die Atmel -bestuurders vir ATtiny2313- en ATmega168 -toestelle, ek verduidelik die vereistes en beperkings wat van toepassing is by die gebruik daarvan, en ek wys u werkende voorbeelde van I2C -toestelle. Nadat u hierdie instruksies deurgewerk het, kan u die I2C -bus suksesvol gebruik in u AVR -projekte. Uiteraard kan u die bestuurders vir klein of MEGA ignoreer as u slegs in een daarvan belangstel. Vir diegene wat belangstel om meer te wete te kom oor die I2C -bus, sal ek skakels na toepaslike materiaal verskaf.

Stap 1: Wat is dit alles van hierdie I2C -goed?

Die I2C-bus is 'n eenvoudige tweedraadsverbinding wat verskeie toestelle aan mekaar kan koppel en data kan uitruil. In sy eenvoudigste vorm is daar een meester -toestel wat kommunikeer met verskeie slawe -toestelle. Alle toestelle is parallel aan die twee drade van die I2C -bus gekoppel. Die twee drade staan bekend as SCL en SDA. SCL is die kloklyn en word beheer deur die meesterapparaat. SDA is die twee-rigting data lyn. Om data oor te dra, stuur die meester 'n slawe -adres uit, gekombineer met 'n een -lees lees/skryf vlag. As 'n opskrif verlang word, sal die meester voortgaan om data na die aangesproke slaaf te stuur. As 'n lesing versoek word, sal die slaaf met data reageer. Om transaksies te koördineer, word die SCL- en SDA -lyne deur die meester en die slaaf gemanipuleer om verskeie toestande aan te dui. Dit sluit in START, STOP, ACK (erken) en NAK (geen erkenning nie). Die besonderhede van hierdie voorwaardes word deur die bestuurders hanteer. Die ware geeks onder u kan al die besonderhede in die skakels aan die einde van hierdie instruksies leer. Die elektriese vereistes is redelik eenvoudig. Die meester en die slawe moet dieselfde vlak vir Vcc gebruik, die gronde moet verbind word en die SCL- en SDA -lyne moet na Vcc getrek word. Die waarde van die optrekweerstands word presies bepaal deur 'n berekening wat gebaseer is op die totale kapasitansie op die bus, maar kan feitlik enige waarde tussen 1.8K en 10K wees. Ek begin met 5.1K en gebruik laer waardes totdat dit werk. Dit is gewoonlik nie 'n probleem nie, tensy u baie toestelle of 'n lang draad tussen toestelle het. Die nominale datatempo op die I2C -bus is 100Kbits/sekonde. Tariewe van 400Kbits/sekonde, 1Mbits/sekonde en verder is ook moontlik, maar word nie ondersteun deur die bestuurders in hierdie instruksies nie. Alle I2C -toestelle werk teen 100Kbits/sekonde. Die ATtiny2313 en die ATmega168 implementeer elk die I2C -bus anders. ATtiny2313 gebruik die Universal Serial Interface (USI) hardeware - wat ook vir die SPI -bus gebruik kan word. ATmega168 het toegewyde hardeware vir die I2C -bus, bekend as die Two Wire Interface (TWI). Sodra die bestuurders geskryf is, is hierdie verskille meestal deursigtig vir die gebruiker. Een belangrike verskil is in die sagteware: die ATmega168 I2C -bestuurder word onderbreek, terwyl dit vir die ATtiny2313 nie. Dit beteken dat 'n ATmega168 -program nie hoef te wag totdat I2C -data -oordragte plaasvind nie, maar slegs moet wag voordat 'n ander oordrag begin word, of totdat data uit 'n leesoperasie kom. Die voorbeelde en bespreking wat gevolg moet word, moet dit duidelik maak. I2C -adresse is 7 bisse lank, sodat tot 127 toestelle op die bus kan wees as elkeen 'n unieke adres het. Soos in die figuur getoon word, word hierdie 7 bis -adres een bit na links verskuif en die minste betekenisvolle bit word gebruik om 'n lees of skryf van die toestel by die adres te merk. Die volledige slawe -adres is dus 'n 8 -bits byte. Die werklike adres word gedeeltelik intern aan die toestel bepaal en kan nie verander word nie (4 belangrikste stukkies), en gedeeltelik bepaal deur stukkies wat aan apparaatpenne gekoppel kan word (3 minste bits) wat hoog of laag vasgemaak kan word om te stel 'n spesifieke adres. Dit klink verwarrend, maar 'n voorbeeld sal dit duidelik maak. Die PCA8574A -gegewensblad toon dat die vier belangrikste stukkies van die I2C -adres altyd 0111 sal wees. Die volgende drie bisse word bepaal deur die instellings op penne AD0, AD1 en AD2. Hierdie penne kan aan die grond of aan die positiewe spanningstoevoer (5 volt) gekoppel word om onderskeidelik 0 of 1 voor te stel. Die reeks moontlike adresse is dus 38 tot 3F heksadesimaal, soos getoon in die ander figuur uit die PCA8574 -gegewensblad. Dus, deur die adresbit -instellings te verander, kan tot 8 PCA8574A's tegelyk op die I2C -bus wees. Elkeen sal slegs op sy spesifieke slawe -adres reageer. As nog meer I/O -poorte nodig is, kan die PCA8574 gebruik word. Die enigste verskil tussen die PCA8574 en die PCA8574A is dat die I2C slawe adres reeks van die PCA8574 20 tot heksadesimaal is. adres. Lees die gegewensblad deeglik deur en onthou dat die slaafadres 7 biste lank sal wees. Die lees/skryf -bis moet afsonderlik behandel word. Weereens, 'n voorbeeld sal help. Die gegewensblad vir die 24C16 EEPROM waarmee ons sal eksperimenteer, sê die eerste (belangrikste) vier bisse van die slaafadres is 1010. Die volgende drie bisse kan bepaal word deur A0, A1 en A2; maar let op die gegewensblad dek ook 24C01 tot 24C08, wat kleiner EEPROM's is. Die figuur uit die gegewensblad toon dat die instellings van hierdie adresbits geïgnoreer word namate die grootte toeneem en heeltemal geïgnoreer word vir die 24C16. Dit wil sê, die laaste drie bisse maak nie saak nie en die 24C16 gebruik werklik alle I2C -slawe -adresse 50 tot 57 heksadesimaal. Die reeks slawe -adresse sal eintlik verskillende afdelings binne die 24C16 aanspreek. Die eerste 256 grepe is op adres 50h, die volgende 256 om 51h, en so aan tot die laaste 256 bytes op 57h - vir 'n totaal van 2K grepe. Aangesien die adres van die PCF8570 RAM waarmee ons ook eksperimenteer, in hierdie reeks is, kan die 24C16 en die PCF8570 nie saam gebruik word nie.

Stap 2: Bestel 'n paar I2C -toestelle

Noudat u 'n bietjie van die I2C -bus weet en dit wil gebruik, kan u 'n paar I2C -toestelle bestel om mee te eksperimenteer, sodat hulle op pad kan wees terwyl u die sagteware gereed maak? O Interface Expander (my gunsteling), 'n Statiese Ram en 'n EEPROM. Daar is nog baie meer, maar dit is 'n goeie begin. Die AVR -verwerkers wat ons sal gebruik, is die ATtiny2313 en die Atmega168 (gebruik in Arduino). As u nog nie nuut is nie, kyk dan na hierdie wonderlike instruksies om daaroor te leer en u Ghetto -ontwikkelingstelsel te bou. Die skema van die ATmega168 in die huidige Instructable toon hoe u die Ghetto Development System vir hierdie verwerker kan implementeer. Die parallelle poortkabel is dieselfde as die vir die ATtiny2313. (Ek het nie die USB -weergawe van die Ghetto Development System probeer nie, so ek is nie seker hoe die I2C -bus daarop verkry kan word nie. Dieselfde geld vir die Arduino.) Hier is Digikey -onderdeelnommers. Poortuitbreider: 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

Stap 3: I2C -bestuurders

Hier is die beskrywings van die bestuurderfunksies vir die I2C -bus. Dit is ontwikkel met die Atmel Apps Notes om mee te begin. Ek sou dit nie sonder hulle kon doen as 'n basis om op voort te bou nie. Ontwikkeling is gedoen met behulp van WinAVR en die gcc C -samesteller. Die kloksnelheidsbeperkings word hieronder vir elke verwerker beskryf. Aangesien ek nie alle moontlike kombinasies van die verwerkergeur / kloksnelheid kan toets nie, sal ek net bybly wat ek eintlik kan toets en probeer om die beperkings en beperkings aan te dui. Hier is die bestuurderfunksies en hoe om dit te gebruik. Kyk na die voorbeelde vir meer besonderhede en om die funksies wat in volledige programme gebruik word te sien. Vir die ATtiny2313: Klokvereiste: Die bestuurders is ontwerp vir 'n kloksnelheid van 1MHz (die standaardtempo) vir ATtiny2313. As u teen ander snelhede wil hardloop, moet u konstantes in die bestuurders aanpas. Stuur 'n e -pos aan my as u hulp nodig het. U kan ook wenke kry van die Atmel -programme -notas in die skakels in die Resources Step. USI_TWI_Master_Initialise () Hierdie funksie initialiseer die USI -hardeware vir die werking van die I2C -modus. Noem dit een keer aan die begin van u program. Dit gee leegte terug en daar is geen argumente nie. USI_TWI_Get_State_Info () Hierdie funksie gee I2C -foutinligting terug en word gebruik as 'n fout tydens 'n I2C -transaksie voorkom. Aangesien hierdie funksie slegs 'n foutkode teruggee, gebruik ek die funksie TWI_Act_On_Failure_In_Last_Transmission (TWIerrorMsg) om 'n fout -LED te flits. Die foutkodes word gedefinieer in USI_TWI_Master.h. Hier is hoe u dit kan noem: TWI_Act_On_Failure_In_Last_Transmission (USI_TWI_Get_State_Info ()) USI_TWI_Start_Read_Write () Hierdie funksie word gebruik om enkele grepe na I2C -toestelle te lees en te skryf. Dit word ook gebruik om verskeie grepe te skryf. Daar is 6 stappe vir die gebruik van hierdie funksie. unsigned char messageBuf (MESSAGEBUF_SIZE); 2) Plaas die Slave -adres as die eerste byte in die buffer. Skuif dit 'n bietjie links en OF in die lees/skryf -bietjie. Let op dat die lees/skryf -bietjie 1 vir 'n lees en 0 vir 'n skryf is. Hierdie voorbeeld is vir 'n Lees. messageBuf (0) = (TWI_targetSlaveAddress << TWI_ADR_BITS) | (WAAR << TWI_READ_BIT); 3) As u 'n skryfwerk doen, plaas die byte wat in die buffer geskryf moet word, op die volgende plek in die buffer. teruggekeerde waarde (temp in hierdie geval) kan getoets word om te sien of daar 'n fout is. Indien wel, word dit hanteer soos hierbo bespreek. Sien voorbeelde in die programme. Die opstel van die buffer en roeping van die roetine is effens anders. Die tweede greep in die buffer is die begingeheue -adres waarna u moet skryf. Die data wat geskryf moet word, sal in die volgende grepe wees. Die grootte van die boodskap is die grootte, insluitend al die geldige data. As daar dus 6 grepe geskryf moet word, is die grootte van die boodskap 8 (slawe -adres + geheue -adres + 6 grepe data). USI_TWI_Start_Random_Read () Hierdie funksie word gebruik om verskeie grepe vanaf 'n I2C -toestel te lees, gewoonlik is dit slegs betekenisvol vir 'n soort herinnering. Die gebruik van hierdie roetine is baie soortgelyk aan die vorige roetine, met twee uitsonderings: die instelling van die lees/skryf -bits maak nie saak nie. Om hierdie roetine te noem, sal altyd 'n Lees -operasie veroorsaak. Die boodskap Grootte moet 2 wees plus die aantal grepe wat gelees moet word. As daar geen foute is nie, sal die data in die buffer wees wat op die tweede plek begin. Vir die ATmega168: klokvereiste: die bestuurders is ontwerp vir 'n kloksnelheid van 4MHz vir ATmega168. Die voorbeeldkode wys hoe u hierdie kloksnelheid moet stel. As u teen ander snelhede wil hardloop, moet u konstante in die bestuurders aanpas. Stuur 'n e -pos aan my as u dit moet doen. TWI_Master_Initialise () Hierdie funksie begin die TWI -hardeware vir die werking van die I2C -modus. Noem dit een keer aan die begin van u program. Dit gee leegte terug en daar is geen argumente nie. Maak seker dat u onderbrekings aktiveer deur swi () te bel nadat u dit begin het. TWI_Get_State_Info () Hierdie funksie gee I2C -foutinligting terug en word gebruik as 'n fout tydens 'n I2C -transaksie voorkom. Aangesien hierdie funksie slegs 'n foutkode teruggee, gebruik ek die funksie TWI_Act_On_Failure_In_Last_Transmission (TWIerrorMsg) om 'n fout -LED te flits. Die foutkodes word gedefinieer in TWI_Master.h, maar word aangepas om op 'n fout -LED te dui. Sien die voorbeeldkode vir besonderhede. Hier is hoe u dit kan noem: TWI_Act_On_Failure_In_Last_Transmission (TWI_Get_State_Info ()) Let daarop dat foutkontrole uitgevoer word deur seker te maak dat die I2C -transaksie voltooi is (funksie hieronder beskryf) en dan 'n bietjie te toets in die globale statuswoord. TWI_Start_Read_Write () TWI_StartR) twee funksies werk dieselfde as die ooreenstemmende funksies hierbo beskryf, maar met enkele uitsonderings. Hulle gee geen foutwaardes terug nie. Gelees data word nie na die buffer oorgedra nie. As u dit doen, sal die volgende funksie gedoen word. Wanneer u TWI_Start_Random_Read bel, moet die boodskapSize die aantal datagrepe wees, plus een, nie twee nie. Die I2C -bestuurder vir die ATmega168 word onderbreek. Dit wil sê, die I2C -transaksies word begin en word dan onafhanklik uitgevoer terwyl die hoofroetine voortgaan. As die hoofroetine data wil hê van 'n I2C -transaksie wat dit begin het, moet dit kyk of die data beskikbaar is. Die situasie is dieselfde vir foutkontrole. Die hoofroetine moet seker wees dat die I2C -transaksie voltooi is voordat daar na foute gekyk word. Die volgende twee funksies word vir hierdie doeleindes gebruik. TWI_Transceiver_Busy () Bel hierdie funksie om te sien of 'n I2C -transaksie voltooi is voordat u na foute kyk. Die voorbeeldprogramme wys hoe u dit kan gebruik. TWI_Read_Data_From_Buffer () Bel hierdie funksie om data van die ontvangbuffer van die I2C -bestuurder na die boodskapbuffer oor te dra. Hierdie funksie sal seker maak dat die I2C -transaksie voltooi is voordat die data oorgedra word. Terwyl 'n waarde deur hierdie funksie teruggegee word, vind ek die kontrole van die foutbits meer betroubaar. Hier is hoe u dit kan noem. Die boodskap Grootte moet een groter wees as die aantal data stukkies wat verlang word. Die data sal in messageBuf begin vanaf die tweede plek.temp = TWI_Read_Data_From_Buffer (messageBuf, messageSize);

Stap 4: Kom ons bou

Laai die lêer I2C Schematics.zip af. U kan 'n I2C -lêergids in u werkarea skep om die skemas en die voorbeeldprogramlêers te bevat. Pak die skemas uit in hierdie gids. U vind 'n gids genaamd I2C Schematics. Maak die lêer met die naam klein I2C.pdf oop. Hierdie skematiese voorstelling toon die ATtiny2313 Ghetto Development System en die PCA8574A I/O Port Expander (het 'n groot boks om dit). Die Port Expander -kring is op 'n broodbord gebou. Kyk na die foto's om te sien hoe hierdie stroombane lyk. Hulle is regtig redelik eenvoudig. Die ATtiny2313 -gedeelte van die skema is slegs die Ghetto Development System met drie blinkenligte (LED1, 2 en 3, plus R4, 5 en 6) en 'n drukknop (S1) wat daaraan geheg is, plus een bykomende detail. Die detail is die byvoeging van springers (JP4, 5 en 6) wat verwyder kan word om die verbinding van die I2C -bus SCL- en SDA -lyne moontlik te maak. Die springers moet in plek wees vir programmering, dan verwyder sodat SCL en SDA verbind kan word. Die foto's toon die springers op hul plek en verwyder. Die plasing van hierdie springers is aan u; u hoef dit net op u Ghetto Development System te plaas as u die I2C -bus wil gebruik. Die I2C -bus moet ontkoppel word en die springers moet geplaas word vir programmering. Let daarop dat u slegs hoef te dink oor JP4 en JP6 vir die I2C -bus. Sluit JP5 in as u dink dat u ooit die SPI -bus wil gebruik. Verskaf Vcc (+5 volt) en Gnd (grond) verbindings en verbind AD0, 1 en 2 met die aarde (maak die I2C slaaf adres 38 hex). Koppel dan 4 blinkenlights en 4 DIP -skakelaars. (As u nie DIP-skakelaars het nie, kan u net drade gebruik. Bind vas aan die grond of laat dryf om onderskeidelik aan of uit te seine.) Koppel laastens die optrekweerstands (R11 en 12) van SDA en SCL aan Vcc. Dit word aangedui as 3.3K, maar enige waarde van 1.8K tot 5.1K behoort te werk (miskien tot 10K, maar ek het dit nie probeer nie). Nadat u die ATtiny2313 geprogrammeer het, kan u die springers verwyder en SDA en SCL aansluit vir toetsing. Nou vir die ATmega168. Die enigste rimpel hier is dat u moontlik nie 'n Ghetto Development System vir hierdie verwerker gebou het nie. As dit die geval is, sal die skema wat ek verskaf (MEGA I2C.pdf) u wys hoe. Dit is slegs 'n permutasie van die ATtiny2313 -weergawe. As u vooruit beplan, kan u seker maak dat u programmeerkabel by beide stelsels pas. Die belangrikste verskil is die toevoeging van C2 en C3. Sien die foto's vir die plasing daarvan; hulle moet baie naby die chip wees; een van hulle is eintlik onder die chip. Dit help veral om geraas uit die analoog na digitale omskakelaar te hou. U hoef nie die springers in te sit nie, tensy u van plan is om die SPI -bus te gebruik, aangesien dit nie nodig is vir die I2C -bus op hierdie chip nie. Let daarop dat die PCA8754A -broodbord onveranderd sal wees. U sluit net SDA en SCL aan en u gaan weg! Maklik, nè?

Stap 5: Kom ons kodeer en toets

Dit is tyd om die bestuurders en die voorbeeldprogramme te bou. Ons begin met die ATtiny2313 en die PCA8574A broodbord wat ons pas gebou het. Laai die lêer I2C.zip af in u I2C -werkgids en pak dit uit. U kry 'n nuwe gids genaamd I2C. Daarin vind u USI I2C (vir ATtiny2313) en TWI I2C (vir ATmega168). In USI I2C vind u die I_O Port -lêergids. Die gids bevat die kode vir ons eerste voorbeeldprogram en die USI I2C -bestuurders. Gebruik WinAVR en stel die kode saam in die ATtiny2313. Haal diep asem en skakel die krag aan. Hier is wat om te verwag: By aanskakeling knipper LED 1 op poort PD6 van die ATtiny2313 twee keer. Niks anders sal gebeur totdat u op die knoppie (S1) druk nie. Elke keer as die knoppie ingedruk word, word die skakelaars gelees en die instelling daarvan sal op die LED's wat aan die PCA8574A gekoppel is, vertoon word. Verander die waarde van die skakelaars, druk op die knoppie, en die LED's moet verander. Hou aan om dit te doen totdat u die opwinding van die werk oorkom. As (God verbode!) Dinge nie werk soos verwag nie, moet u die bedrading noukeurig nagaan. I2C -foute word aangedui deur knippies op LED3 (PD4) en beteken waarskynlik dat u moet kyk of SDA en SCL aan die regte penne gekoppel is en korrek opgetrek is. As dinge nog steeds nie werk nie, lees die res van hierdie afdeling vir meer inligting oor ontfouting. Gaan nou terug en kyk na die kode. Maak die lêer USI_I2C_Port.c oop. Dit is die kode vir die voorbeeldprogram. (USI_TWI_Master.c en USI_TWI_Master.h bevat die bestuurders - u kan dit ignoreer tensy u nuuskierig is.) Gebruik die voorbeeld om u eie I2C -toepassings te lei. Die program wys meestal hoe u die I2C -bestuurders kan initialiseer en gebruik, insluitend die instelling haal die slaafadres en die res van die boodskapbuffer op en haal die data daaruit. U sal ook sien hoe ek die knoppie losmaak en die while -lus opstel. Daar is 'n paar besonderhede van die program wat die moeite werd is om te noem. Let daarop dat die data van die skakelaars omgekeer word voordat dit aan die LED's op die poortuitbreider geskryf word. Let ook daarop dat die invoerpoorte op die poortuitbreider as hoog geskryf moet word om dit reg te laat werk. Hierdie besonderhede word beskryf in die PCA8574A -datablad. Lees altyd die gegewens deeglik deur! Die gebruik van voorwaardelike ontfouting is meer interessant. Teen die begin van die programlêer is die stelling // #definieer DEBUG en #ifdef DEBUG -stellings oor die hele kode. Solank DEBUG nie gedefinieer is nie (die twee skuinsstrepe maak van die reël 'n opmerking en voorkom dat dit gedefinieer word), sal die kode in die #ifdef tot #endif -stellings nie saamgestel word nie. Maar as dinge nie werk soos u verwag nie, herkonformeer en herlaai die kode met #define DEBUG ongekommenteer. U kry baie meer knippies op die LED's wat u kan ontsyfer om die uitvoering van u program te volg en u kan help om presies te vind waar dinge verkeerd loop. Ek beveel aan dat u dit probeer, net om te sien wat gebeur. Wat u sal sien, is dat LED 2 (op PD5) sal knipper namate die uitvoering deur die program vorder. Die waarde wat van die skakelaars gelees word, sal op LED 1 (PD6) geknip word voordat dit op die Port Expander LED's vertoon word. U moet die program kan opspoor terwyl dit werk deur hierdie LED's te gebruik. Ons werk volgende met die ATmega168; slaan hierdie afdeling oor as u slegs belangstel in die ATtiny2313. Nog steeds by my? Goed. Gaan na die TWI_I2C -lêergids, verander u werkgids na IO_Port en stel TWI_I2C_Port.c saam en laai dit in die ATmega168. Ontkoppel die SDA- en SCL -lyne van die ATtiny2313 en koppel dit aan ATmega168. Sluit krag en grond aan, en skakel aan. Die operasie moet dieselfde wees! Speel totdat die opwinding bedaar, en kyk dan na die kode. Open TWI_I2C_Port.c. Die kode is byna identies, behalwe vir die hantering van foute en die onderbrekingsbestuurde bestuurders. Hier is die verskille: Let daarop dat die klok op 4MHz moet wees sodat die I2C -bus behoorlik kan werk. Die sei (); verklaring skakel onderbrekings aan nadat die I2C -bestuurders geïnisialiseer is. Om te kyk of daar foute is, word 'n spesifieke statusbit getoets. Tydens 'n lees moet die TWI_Read_Data_From_Buffer -funksie opgeroep word om die geleesde data na die boodskapbuffer oor te dra. Tydens 'n skryf, terwyl (TWI_Transceiver_Busy ()) gebruik moet word om seker te maak dat die oordrag voltooi is voordat daar na foute gekyk word. Hierdie laaste twee funksies word hierbo beskryf in die beskrywing van die bestuurders. Anders as dit, is die kode amper dieselfde as vir die ATtiny2313. DEBUG werk dieselfde as u daarmee wil eksperimenteer.

Stap 6: Gebruik I2C -geheue

Noudat ons geleer het om die I2C -bus te gebruik om 'n I/O -poortuitbreider te lees en te skryf, gaan ons verder met die gebruik van I2C -geheue, beide RAM en EEPROM. Die belangrikste verskil is dat verskeie grepe met 'n enkele I2C -opdrag voorgelees of geskryf kan word uit geheue. Om gereed te wees vir hierdie eksperimente, moet ons die hardeware effens aanpas en 'n paar nuwe stroombane op die broodbord bou. Hou die Port Expander -kring, aangesien ons dit sal gebruik om geheuewaardes te vertoon. Verwyder die DIP -skakelaars van die PCA8574A en sit blinkenligte op die penne. As u nie genoeg blinkerligte het nie, skuif die een op P4 tot P7 na P0 tot P3. (Waardes wat vertoon moet word, is klein genoeg.) Kyk nou na die skematiese I2C Ram.pdf en koppel die PCF8570 aan op die broodbord. Kyk ook na die prentjie. Maak seker dat u pen 7 aan Vcc vasmaak. Dra drade vir SDA en SCL vanaf die PCA8574A. Geen ekstra optrekweerstands is nodig nie. As u ook belangstel in die EEPROM, bou dan die kring ook met I2C EEPROM.pdf vir die 24C16, maar wees gewaarsku dat die voorbeeld die ATmega168 gebruik. Hierdie kring is regtig eenvoudig. Soos hierbo bespreek, moet die adresstukke geïgnoreer word. Sluit net krag en grond aan. Koppel nog nie SDA en SCL nie, aangesien ons nog nie klaar is met die Ram nie. Ons begin met ons geheue -eksperimente met die ATtiny2313 wat gekoppel is aan die PCA8574A Port Expander en aan die PCF8570 Ram. Die program skryf 'n paar nommers aan die Ram, lees dit dan terug en vertoon dit op die Port Expander. Verander u werkgids in RAM onder USI I2C. Gebruik die maak -lêer om USI_I2C_RAM.c op te stel en af te laai. Let daarop dat die I2C -bestuurderlêers identies is aan dié wat ons vroeër gebruik het. Sluit die krag aan, en u sal 'n enkele knippering op LED 1 (PD6) sien. Data word na die eerste 4 grepe geheue geskryf. Druk die knoppie en twee grepe word teruggelees en vertoon. U behoort een LED -lig op die Port Expander (P0) te sien, 'n pouse van twee sekondes en dan twee LED's (P0 en P1). Nog twee sekondes pouse en die LED's moet afskakel. Druk weer op die knoppie om die volgorde oor te begin. Ontfouting is soortgelyk aan die metode hierbo beskryf. Kom ons kyk na die kode. Maak USI_I2C_RAM.c oop. Dit moet baie soortgelyk aan die vorige kode lyk. Die belangrikste verskille is die besonderhede van lees- en skryfgeheue. Kyk na die manier waarop die boodskapbuffer gelaai word voor die oproep wat eintlik skryf. Die eerste byte is die slawe -adres met die lees/skryf -bit op die regte manier. Maar die volgende greep is die geheue -adres waarop data begin skryf. Dan kom die werklike databytes wat opeenvolgend in die geheue gelaai sal word vanaf die adres wat ons gespesifiseer het. Ons spesifiseer die boodskapgrootte as 6. Dus begin ons skryf by adres 00 en skryf die waardes 01, 03, 02 en 06 in die geheue -plekke 00 tot 03. Om die data uit die geheue terug te lees, moet ons die USI_TWI_Start_Random_Read -funksie gebruik. Die boodskapbuffer kry die slawe -adres in die eerste byte en die beginadres in die tweede byte. Bel dan die funksie met die boodskapgrootte wat ingestel is op die aantal grepe wat gelees moet word plus 2. Let daarop dat die lees/skryf -stukkie nie saak maak nie, aangesien 'n lesing ongeag gedoen sal word. Die teruggestuurde data begin op die tweede plek in die boodskapbuffer. Sodra die data ingelees is, word dit omgekeer om op die poortuitbreider te vertoon en een byte op 'n slag daarby geskryf met 'n pouse tussen die waardes. Uiteindelik is die Port Expander -LED's afgeskakel. Die skrywe aan die Port Expander is identies aan wat in die vorige voorbeelde gedoen is. Vir die plesier, kan u die #define DEBUG -verklaring soos hierbo ontbloot en baie knipperende LED's sien spoel, opgewonde van opgewondenheid na nog 'n suksesvolle eksperiment, laat ons na die ATmega168 en 'n EEPROM gaan. Verander u werkgids in EEPROM onder TWI I2C. Gebruik die maak -lêer om TWI_I2C_EEPROM.c op te stel en af te laai. Let daarop dat die I2C -bestuurderlêers identies is aan dié wat ons vroeër vir die PCA8574A gebruik het. Ontkoppel die ATtiny2313 en koppel die ATmega168 om die program te toets. Laat die I2C -bus aan die Ram vasgehaak word en skakel aan. Die resultate is anders, aangesien ons nou meer data skryf en lees. LED 1 op PD7 behoort te knipper by die inisialisering. Druk op die knoppie en data word uit die geheue teruggelees en vertoon. Die LED's op die PCA8574 moet die volgende volgorde knip: P1, P0 & P2, (almal af), P0 & P1, P1 en P2. Uiteindelik moet die poort -LED's almal afgaan. Druk weer op die knoppie om dit te herhaal. Ag, maar wag, sê jy. Is hierdie program nie vir die EEPROM nie? Aangesien ons toegang kry tot 'n geheue -toestel op dieselfde I2C -adres, werk dieselfde program vir beide die Ram en die EEPROM. Skakel af en skuif SDA en SCL van die Ram na die EEPROM en voer die program weer uit. Dit moet presies dieselfde werk. Let daarop dat die EEPROM en die Ram nie op dieselfde tyd aan die I2C -bus gekoppel kan word nie, aangesien hulle dieselfde adres deel. (Die slimmes onder julle kan dit oorweeg om die programmeerbare adresstukkies op die Ram te verander, maar dit sal steeds nie werk nie. Die 24C16 gebruik die hele blok adresse wat vir die Ram geprogrammeer kan word.) OK, kom ons kyk na hierdie laaste program. Maak TWI_I2C_EEPROM.c oop. Die eerste ding om op te let is dat ek aangedui het hoe om die volledige 24C16 EEPROM aan te spreek. Dit kan verkry word in 256 byte stukke by 8 verskillende I2C slawe adresse. Kyk hoe MEMORY_ADDR gedefinieer word as die beginadres by 50 heksadesimaal; daarom het die Ram gewerk. As u toegang tot ander blokke van die 24C16 wil verkry, gebruik dan die ander adresse soos ek aangedui het. Kyk hoe ek ingestel het om na die geheue te skryf. Eers word die slawe -adres met die lees/skryf -bitset in die buffer geplaas, dan die beginadres van 00, dan 16 grepe data. Die funksie TWI_Start_Read_Write word opgeroep om die data (soos voorheen) te skryf met die boodskapgrootte op 18. As die knoppie ingedruk word, gebruik ons TWI_Start_Random_Read en TWI_Read_Data_From_Buffer om die data terug te lees. Elke derde greep word op die Port Expander LED's vertoon. Uiteindelik word die LED's afgeskakel om te wag vir die volgende druk op die knoppie. U wonder miskien hoekom ek gekies het om 16 grepe te skryf. As u die datablad noukeurig lees, sal u sien dat die 24C16 'n skryf siklus doen wanneer dit 16 grepe ontvang, selfs al word meer grepe gestuur. Dit was dus 'n goeie nommer om te gebruik. As u besluit om dit te verhoog, moet u die grootte van MESSAGEBUF_SIZE verander. U moet ook die waarde TWI_BUFFER_SIZE in TWI_Master.h verander. Dit is omdat die bestuurder die data uit die boodskapbuffer kopieer vir gebruik deur die onderbrekingsdiensroetine. Baie geluk! U is nou gereed om die I2C -bus in u eie projekte te gebruik!

Stap 7: Webbronne

Hier is die skakels na die gegewensblaaie vir die dele wat vir die eksperimente gebruik is. U moet dit beslis kry as u niks anders kry nie. Port ExpanderRamEEPROM Omdat hy die skepper van I2C is, het NXP (Philips) baie wonderlike dinge. (Hulle hou daarvan om vierkantige hakies in hul URL's te gebruik, dus ek kan dit nie behoorlik hier insluit nie. Jammer.] Om by die I2C -gebied uit te kom, kies Interface uit die lys produkte. U kan na hul I2C -webwerf kom en toegang tot alle gegewensblaaie en toepassingsnotas wat hulle aanbied. Die I2C -busbeskrywing en veral tegniese besonderhede is hier. Kry die ATtiny2313- en ATmega168 -gegewensblaaie (databoeke?) van Atmel. Die Atmel -toepassingsnotas is hier. Kyk na AVR310 en AVR315. Gryp ook die kode. Kyk hier vir nog baie meer I2C -goed.

Stap 8: Notas vir Geeks

Hier is 'n paar dinge om in gedagte te hou vir die ware geek wat die besonderhede wil weet:- Die metode om 'n I2C-toestel aan te spreek en te beheer, is nie deel van die spesifikasie nie! Behalwe die slawe -adres en lees/skryf -bit, word opdragte, modusse, ens. Nie gespesifiseer nie en is dit spesifiek vir 'n gegewe toestel. Om dit baie duidelik te maak, let op dat die skema wat in die Atmel-voorbeeld gebruik word, slegs op die voorbeeld van toepassing is en feitlik nie-standaard is.- Die USI-implementering verskil op 'n paar belangrike maniere van die TWI-implementering. + Met USI word klokslag deur sagteware verskaf; met TWI word dit verskaf deur 'n Bit Rate Generator. + Die USI -metode gebruik nie onderbrekings nie; die TWI doen. Dit het 'n sekere sin, aangesien die Mega -gesin (wat TWI gebruik) baie ander dinge kan doen en nie deur I2C -oordragte gehinder moet word nie. 'N Onderbrekingsgedrewe weergawe vir USI is beslis moontlik; dit is net nie geïmplementeer in hierdie instruksies nie. + Die USI -hardeware is nie geoptimaliseer vir I2C nie en kan slegs 8 -bit -oordragte hanteer. Dit beteken dat twee oordragte nodig is om die negende bietjie (NACK of ACK) te stuur. Die TWI -hardeware hanteer dit outomaties. Dit maak die implementering van die USI -bestuurder 'n bietjie ingewikkelder. + Foutopsporing vir die TWI word in hardeware hanteer. Die USI vereis hantering in sagteware wat dinge ietwat bemoeilik. + Die TWI -hardeware beheer die konfigurasie van die poort direk. Die USI -hardeware vereis dat die poortbits gekonfigureer word voordat die poort gebruik kan word. U sal dit sien in die Master_Initialize-roetine vir die USI.-Atmel beweer dat dit moontlik is om AVR-poortoptrekkings te gebruik vir die I2C-busoptrekkings. Ek het nie 'n manier uitgevind om hierdie benadering te laat werk nie. Die gebruik van twee eksterne weerstande lyk na 'n redelik eenvoudige skema, so ek het nie baie tyd hieraan bestee nie.