I2c komunikācija ar pic mikrokontrolleru pic16f877

PIC mikrokontrolleri ir spēcīga platforma, ko iegūtajiem projektiem nodrošina mikroshēma, tās daudzveidīgais raksturs ir ļāvis atrast veidus daudzās lietojumprogrammās, un fāze joprojām turpinās. Ja jūs esat sekojis mūsu PIC apmācībām, tad jūs pamanījāt, ka mēs jau esam apskatījuši plašu PIC mikrokontrolleru apmācību klāstu, sākot no pašiem pamatiem. Kopš šī brīža mēs esam apskatījuši pamatus, ar kuriem varam iepazīties interesantākās lietās, piemēram, saziņas portālā.

Plašajā iegulto lietojumprogrammu sistēmā neviens mikrokontrolleris nevar pats veikt visas darbības. Kādā laika posmā tai ir jāsazinās ar citām ierīcēm, lai koplietotu informāciju, šīs informācijas kopīgošanai ir daudz dažādu veidu sakaru protokolu, taču visbiežāk izmantotie ir USART, IIC, SPI un CAN. Katram sakaru protokolam ir savas priekšrocības un trūkumi. Tagad pievērsīsimies IIC daļai, jo tieši to mēs mācīsimies šajā apmācībā.

Kas ir I2C sakaru protokols?

Termins IIC nozīmē “ Inter Integrated Circuits ”. Parasti to dažās vietās apzīmē kā I2C vai I kvadrātu C, vai pat kā divu vadu interfeisa protokolu (TWI), bet tas viss nozīmē to pašu. I2C ir sinhrona sakaru protokola nozīme, abām ierīcēm, kas koplieto informāciju, ir jābūt kopīgam pulksteņa signālam. Tam ir tikai divi vadi informācijas apmaiņai, no kuriem vienu izmanto gailis signālam, bet otru - datu sūtīšanai un saņemšanai.

Kā darbojas I2C komunikācija?

Pirmo reizi I2C komunikāciju ieviesa Filipss. Kā minēts iepriekš, tam ir divi vadi, šie divi vadi tiks savienoti divās ierīcēs. Šeit vienu ierīci sauc par galveno, bet otru - par vergu. Saziņai vienmēr vajadzētu notikt un tā notiks starp diviem kapteiņiem un vergiem. I2C komunikācijas priekšrocība ir tā, ka vairāk nekā vienu vergu var savienot ar Master.

Pilnīga saziņa notiek caur šiem diviem vadiem, proti, seriālo pulksteni (SCL) un sērijas datiem (SDA).

Seriālais pulkstenis (SCL): koplieto galvenā signāla ģenerēto pulksteņa signālu ar vergu

Seriālie dati (SDA): nosūta datus uz galveno un vergu un no tā.

Jebkurā brīdī tikai kapteinis varēs sākt saziņu. Tā kā autobusā ir vairāk nekā viens vergs, kapteinim ir jāatsaucas uz katru vergu, izmantojot citu adresi. Ja adresē tikai salve ar konkrēto adresi, atbildēs ar informāciju, kamēr pārējie turpinās atmest. Tādā veidā mēs varam izmantot vienu autobusu, lai sazinātos ar vairākām ierīcēm.

Kur izmantot I2C sakarus?

I2C sakari tiek izmantoti tikai neliela attāluma sakariem. Tas noteikti ir uzticams zināmā mērā, jo tam ir sinhronizēts pulksteņa impulss, lai padarītu to gudru. Šo protokolu galvenokārt izmanto, lai sazinātos ar sensoru vai citām ierīcēm, kurām informācija jānosūta kapteinim. Tas ir ļoti ērti, ja mikrokontrollerim ir jāsazinās ar daudziem citiem vergu moduļiem, izmantojot vismaz tikai vadus. Ja jūs meklējat tālsatiksmes komunikāciju, jums vajadzētu izmēģināt RS232 un, ja vēlaties drošāku komunikāciju, izmēģiniet SPI protokolu.

I2C ar PIC16F877a, izmantojot XC8 kompilatoru

Pietiekami daudz ievadu, ļaujiet tajā iekļūt un uzzināt, kā mēs varam izmantot mikrokontrolleru I2C komunikācijas veikšanai. Pirms mēs sākam, skaidri norādiet, ka šajā apmācībā tiek runāts tikai par I2C PIC16F877a, izmantojot XC8 kompilatoru, process būs tāds pats kā citiem mikrokontrolleriem, taču var būt nepieciešamas nelielas izmaiņas. Atcerieties arī, ka progresīviem mikrokontrolleriem, piemēram, PIC18F sērijai, kompilatorā, iespējams, ir iebūvēta bibliotēka, lai izmantotu I2C funkcijas, taču PIC16F877A nekas tāds nepastāv, tāpēc izveidosim to paši. Šeit izskaidrotā bibliotēka tiks dota kā galvenes fails lejupielādei apakšā, ko var izmantot PIC16F877A, lai sazinātos ar citām I2C ierīcēm.

Kā vienmēr vislabākā vieta, lai kaut ko sāktu, ir mūsu datu lapa. Datu lapā meklējiet sīkāku informāciju par I2C un pārbaudiet, kuri reģistri ir jākonfigurē. Es neskaidrošu sīkāk, jo datu lapa to jau ir izdarījusi jūsu vietā. Tālāk es izskaidrošu galvenes failā esošās dažādās funkcijas un to atbildību programmā.

void I2C_Initialize ()

Inicializācijas funkciju izmanto, lai mikrokontrollerim pateiktu, ka izmantosim protokolu I2C. To var izdarīt, iestatot nepieciešamos bitus SSPCON un SSPCON2 reģistrā. Pirmais solis būtu IIC tapu deklarēšana par ievades tapām, šeit I2C komunikācijai jāizmanto tapas RC3 un RC4, tāpēc mēs tās deklarējam kā ievades tapas. Tālāk mums vajadzētu iestatīt SSPCON un SSPCON2, kas ir MSSP kontroles reģistri. Mēs darbinām PIC IIC galvenajā režīmā ar pulksteņa frekvenci FOSC / (4 * (SSPADD + 1)). Skatiet datu lapas lapu numurus, kas minēti komentāru rindiņās, lai saprastu, kāpēc konkrētais reģistrs ir iestatīts tā.

Tālāk mums jāiestata pulksteņa frekvence, pulksteņa frekvence dažādām lietojumprogrammām var atšķirties, tāpēc mēs saņemam izvēli no lietotāja, izmantojot mainīgo feq_k, un izmantojam to savās formulās, lai iestatītu SSPADD reģistru.

void I2C_Initialize (const unsigned long feq_K) // Sākt IIC kā galveno { TRISC3 = 1; TRISC4 = 1; // Iestatiet SDA un SCL tapas kā ievades tapas SSPCON = 0b00101000; // pg84 / 234 SSPCON2 = 0b00000000; // pg85 / 234 SSPADD = (_XTAL_FREQ / (4 * feq_K * 100)) - 1; // Pulksteņa ātruma iestatīšana pg99 / 234 SSPSTAT = 0b00000000; // pg83 / 234 }

Nav spēkā I2C_Hold ()

Nākamā svarīgā funkcija ir funkcija I2C_hold, ko izmanto, lai noturētu ierīces izpildi, līdz pašreizējā I2C darbība ir pabeigta. Mums vajadzētu pārbaudīt, vai I2C operācijas ir jāveic pirms jaunu darbību uzsākšanas. To var izdarīt, pārbaudot reģistru SSPSTAT un SSPCON2. SSPSTAT satur informāciju par I2C kopnes statusu.

Programma var šķist mazliet sarežģīta, jo tajā ir operētājsistēma “un” un “vai”. Kad jūs to salauzat kā

SSPSTAT un 0b00000100 SSPCON2 un 0b00011111

Tas nozīmē, ka mēs pārliecinoties, ka 2 ^nd mazliet par SSPSTAT ir nulle, un līdzīgā veidā biti 0-4 ir nulle uz SSPCON2. Tad mēs visus šos apvienojam, lai pārbaudītu, vai rezultāts ir nulle. Ja rezultāts ir nulle, programma turpinās, ja nē, tā turēs tur, līdz tā būs nulle, jo tā tiek izmantota īslaicīgā ciklā.

void I2C_Hold () { while ((SSPCON2 & 0b00011111) - (SSPSTAT & 0b00000100)); // pārbaudiet to reģistros, lai pārliecinātos, ka IIC nenotiek }

Atcelt I2C_Begin () un anulēt I2C_End ()

Katru reizi, kamēr mēs rakstām vai lasām datus, izmantojot I2C kopni, mums jāsāk un jāpārtrauc I2C savienojums. Lai sāktu I2C komunikāciju, mums jāiestata SEN bits un jāpārtrauc komunikācija - PEN statusa bits. Pirms pārslēgt kādu no šiem bitiem, mums arī jāpārbauda, vai I2C kopne ir aizņemta, izmantojot funkciju I2C_Hold, kā aprakstīts iepriekš.

void I2C_Begin () { I2C_Hold (); // Turiet programmu, ja I2C ir aizņemts SEN = 1; // Sākt IIC pg85 / 234 } anulēt I2C_End () { I2C_Hold (); // Turiet programmu, ja I2C ir aizņemts PEN = 1; // IIC beigas, pg85 / 234 }

Nav spēkā I2C_Write ()

Rakstīšanas funkciju izmanto, lai nosūtītu visus datus no galvenā moduļa uz salve moduli. Šo funkciju parasti izmanto pēc I2C sākuma funkcijas, un tai seko funkcija I2C End. Dati, kas jāieraksta IIC kopnei, tiek nosūtīti caur mainīgajiem datiem. Pēc tam šie dati tiek ielādēti SSPBUF bufera reģistrā, lai tos nosūtītu pa I2C kopni.

Parasti pirms datu ierakstīšanas tiks uzrakstīta adrese, tāpēc jums divreiz būs jāizmanto rakstīšanas funkcija, vienreiz adreses iestatīšanai un otru reizi faktisko datu nosūtīšanai.

void I2C_Write (neparakstīti dati) { I2C_Hold (); // Turiet programmu, ja I2C ir aizņemts SSPBUF = dati; // pg82 / 234 }

neparakstīts īss I2C_Read ()

Pēdējā funkcija, kas mums jāzina, ir funkcija I2C_Read . Šo funkciju izmanto, lai nolasītu datus, kas pašlaik atrodas I2C kopnē. To lieto pēc tam, kad vergs ir lūdzis, lai autobusam ierakstītu kādu vērtību. Saņemtā vērtība būs SSPBUF, kuru mēs varam pārsūtīt uz jebkuru mainīgo mūsu darbībai.

I2C sakaru laikā vergs pēc kapteiņa pieprasīto datu nosūtīšanas nosūtīs vēl vienu bitu, kas ir apstiprinājuma bits, arī šis bits jāpārbauda kapteinim, lai pārliecinātos, ka komunikācija bija veiksmīga. Pēc ACKDT bita pārbaudīšanas, vai tajā nav apstiprinājuma, tas jāiespējo, iestatot ACKEN bitu.

neparakstīts īss I2C_Read (neparakstīts īss ack) { neparakstīts īss ienākošs; I2C_Hold (); RCEN = 1; I2C_Hold (); ienākošais = SSPBUF; // iegūt datus, kas saglabāti SSPBUF I2C_Hold (); ACKDT = (ack)? 0: 1; // pārbaudiet, vai saņemts ack bits ACKEN = 1; // 85. lpp. / 234. lpp. atgriež ienākošo; }

Tas ir, šīm funkcijām vajadzētu būt pietiekamām, lai izveidotu I2C sakarus un ierakstītu vai lasītu datus no ierīces. Ievērojiet arī to, ka ir daudzas citas funkcijas, kuras I2C komunikācija var veikt, taču vienkāršības labad mēs tās šeit neapspriežam. Jūs vienmēr varat atsaukties uz datu lapu, lai uzzinātu, kā programma pilnībā darbojas

Pilnu kodu ar galvenes failu PIC16F877A I2C komunikācijai var lejupielādēt no saites.

Programmēšana, izmantojot I2C galvenes failus:

Tagad, kad mēs esam uzzinājuši, kā darbojas I2C komunikācija un kā mēs varam izmantot tai izveidoto galvenes failu, izveidosim vienkāršu programmu, kurā mēs izmantosim galvenes failu un ierakstīsim dažas vērtības I2C līnijās. Pēc tam mēs imitēsim šo programmu un pārbaudīsim, vai šīs vērtības tiek ierakstītas kopnē.

Kā vienmēr, programma sākas ar konfigurācijas bitu iestatīšanu un pulksteņa frekvences iestatīšanu uz 20 MHz, kā parādīts zemāk

#pragma config FOSC = HS // Oscilatora izvēles biti (HS oscilators) #pragma config WDTE = OFF // Watchdog taimera iespējošanas bits (WDT atspējots) #pragma config PWRTE = ON // Ieslēgšanas taimera iespējošanas bits (PWRT iespējots) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR iespējots) #pragma config LVP = OFF // Zemsprieguma (vienas piegādes) ķēdes sērijveida programmēšanas iespējošanas bits (RB3 ir digitāls I / O, HV ieslēgts Programmēšanai jāizmanto MCLR) #pragma config CPD = OFF // Datu EEPROM atmiņas koda aizsardzības bits (datu EEPROM koda aizsardzība izslēgta) #pragma config WRT = OFF // Flash programmas atmiņas rakstīšana Iespējot bitus (Rakstīšanas aizsardzība izslēgta; visa programmas atmiņa var rakstīt ar EECON kontroli) #pragma config CP = OFF // Flash programmas atmiņas koda aizsardzības bits (koda aizsardzība izslēgta) #define _XTAL_FREQ 20000000

Nākamais solis būtu pievienot galvenes failu, par kuru mēs tikko apspriedāmies. Galvenes faila nosaukums ir PIC16F877a_I2C.h, un to var lejupielādēt no iepriekš apspriestās saites. Pārliecinieties, ka galvenes fails ir pievienots jūsu projektu saraksta galvenes failā. Jūsu projekta faila struktūrai vajadzētu izskatīties šādi

Kad esat pārliecinājies, ka galvenes fails ir pievienots jūsu projekta failam, galvenes failu iekļaujiet galvenajā C failā

# iekļaut #include "PIC16F877a_I2C.h"

Kaut cikla iekšpusē mēs sāksim I2C komunikāciju, I2C kopnei ierakstīsim dažas nejaušas vērtības un pēc tam beigsim I2C komunikāciju. Nejaušās vērtības, kuras esmu izvēlējies, ir D0, 88 un FF. Jūs varat ievadīt visas vēlamās vērtības. Bet atcerieties šīs vērtības, kad mēs tās pārbaudīsim savā simulācijā.

kamēr (1) { I2C_Begin (); I2C_Write (0xD0); I2C_Write (0x88); I2C_Write (0xFF); I2C_End (); __kavēšanās_ms (1000); }

Pilnu programmu var atrast apakšā lapas, varat to izmantot vai lejupielādēt pilnu zip fails programmas no šejienes. Pēc programmas iegūšanas apkopojiet to un sagatavojieties simulācijai.

Proteus simulācija:

Proteus ir jauks instruments ar nosaukumu I2C atkļūdotājs, kuru var izmantot, lai nolasītu datus I2C kopnē, tāpēc izveidosim ķēdi, izmantojot to, un pārbaudīsim, vai dati tiek veiksmīgi rakstīti. Pilna shēma ir parādīta zemāk

Ielādējiet mūsu programmas ģenerēto hex failu, veicot dubultklikšķi uz mikrokontrollera. Pēc tam simulējiet programmu. Jūs pamanīsit uznirstošu logu, kurā tiks parādīta visa informācija par I2C kopni. Mūsu programmas logs ir parādīts zemāk.

Ja rūpīgi aplūkojat rakstāmos datus, varat pamanīt, ka tie ir tādi paši kā mēs rakstījām mūsu programmā. Vērtības ir D0, 88 un FF. Vērtības tiek rakstītas ik pēc 1 sekundes, tāpēc tiek atjaunināts arī laiks, kā parādīts zemāk. Zilā bultiņa norāda, ka ir rakstīts no kapteiņa uz vergu, ja tas būtu pretējā virzienā, ja citādi. Tālāk parādīts tuvāks nosūtāmo datu apskats.

Tas ir tikai ieskats I2C darbībā, tas var arī lasīt un rakstīt datus vairākās ierīcēs. Mēs vairāk aplūkosim I2C mūsu gaidāmajās apmācībās, sasaistot dažādus moduļus, kas darbojas ar I2C protokolu.

Ceru, ka sapratāt projektu un uzzinājāt no tā kaut ko noderīgu. Ja jums ir kādas šaubas, ievietojiet tos komentāru sadaļā zemāk vai izmantojiet forumus tehniskai palīdzībai.

Pilns kods ir norādīts zemāk; šeit varat lejupielādēt galvenes failus ar visu kodu.