- Ano ang SPI Communication Protocol?
- Paano gumagana ang SPI Protocol?
- Pagkakaiba sa pagitan ng I2C at SPI Communication
- SPI na may PIC16F877A gamit ang XC8 Compiler:
- Paliwanag ng SPI Header File:
- Pangunahing programa Paliwanag:
- Ang pagtulad sa PIC na may SPI debugger:
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 ay pinagana ito upang makahanap ng mga paraan sa maraming mga application at hindi pa lumalaki ng marami. Kung sinusundan mo ang aming mga tutorial sa PIC pagkatapos ay napansin mo na nasasakop na namin ang isang malawak na hanay ng mga tutorial sa PIC microcontroller na nagsisimula mula sa mga pangunahing kaalaman. Sa parehong daloy ay nagpapatuloy kaming malaman ang mga protocol ng komunikasyon na magagamit sa PIC at kung paano ito gamitin. Natakpan na namin ang I2C ng PIC Microcontroller.
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 SPI Protocol sa ngayon dahil iyan ang matututunan natin sa tutorial na ito.
Ano ang SPI Communication Protocol?
Ang term na SPI ay nangangahulugang " Serial Peripheral Interface ". Ito ay isang pangkaraniwang protocol ng komunikasyon na ginagamit upang magpadala ng data sa pagitan ng dalawang microcontroller o upang mabasa / sumulat ng data mula sa isang sensor patungo sa isang microcontroller. Ginagamit din ito upang makipag-usap sa mga SD card, shift register, Display Controller at marami pa.
Paano gumagana ang SPI Protocol?
Ang komunikasyon ng SPI ay magkasabay na komunikasyon, nangangahulugang gumagana ito sa tulong ng isang signal ng orasan na ibinabahagi sa pagitan ng dalawang mga aparato na nagpapalitan ng data. Gayundin ito ay isang full-duplex na komunikasyon dahil maaari itong magpadala at tumanggap ng data gamit ang isang hiwalay na bus. Ang komunikasyon ng SPI ay nangangailangan ng 5 wires upang gumana. Ang isang simpleng circuit ng komunikasyon ng SPI sa pagitan ng isang master at alipin ay ipinakita sa ibaba
Ang limang wires na kinakailangan para sa komunikasyon ay ang SCK (Serial Clock), MOSI (Master Out Slave In), MISO (Master In Slave Out) at SS (Slave Select). Ang komunikasyon ng SPI ay palaging tumatagal ng mga lugar sa pagitan lamang ng isang master at alipin. Ang isang master ay maaaring magkaroon ng maraming mga alipin na konektado dito. Responsable ang master para sa pagbuo ng pulso ng orasan at pareho ang ibinabahagi sa lahat ng mga alipin. Gayundin ang lahat ng mga komunikasyon ay maaaring pasimulan lamang ng master.
Ang SCK pin (aka SCL-serial na orasan) ay nagbabahagi ng signal ng orasan na nabubuo ng master sa mga alipin. Ang pin ng MOSI (aka SDA –Serial Data Out) ay ginagamit upang maipadala ang data mula sa master hanggang sa mag-salve. Ang MISO pin (aka SDI - Serial Data In) ay ginagamit upang makuha ang data mula sa salve hanggang sa master. Maaari mo ring sundin ang marka ng arrow sa nasa itaas na pigura upang maunawaan ang paggalaw ng data / signal. Sa wakas ang SS pin (aka CS –Chip select) ay ginagamit kapag mayroong higit sa isang mga module ng alipin na nakakonekta sa master. Magagamit ito sa upang mapili ang kinakailangang alipin. Ang isang sample na circuit kung saan higit sa isang alipin ang nakakonekta sa master para sa pakikipag-usap sa SPI ay ipinapakita sa circuit sa ibaba.
Pagkakaiba sa pagitan ng I2C at SPI Communication
Nalaman na namin ang komunikasyon ng I2C sa PIC at sa gayon dapat maging pamilyar tayo sa kung paano gumagana ang I2C at kung saan natin magagamit ang mga ito tulad ng I2C ay maaaring magamit upang mai-interface ang module ng RTC. Ngunit ngayon, bakit kailangan natin ng SPI protocol kung mayroon na tayong I2C. Ang dahilan ay kapwa ang mga komunikasyon ng I2C at SPI ay mga kalamangan sa sarili nitong pamamaraan at samakatuwid ay tukoy sa aplikasyon.
Sa isang lawak ang komunikasyon ng I2C ay maaaring isaalang-alang na magkaroon ng ilang mga kalamangan kaysa sa komunikasyon ng SPI dahil ang I2C ay gumagamit ng mas kaunting bilang ng pin at mas madaling magamit ito kapag may isang malaking bilang ng mga alipin na nakakonekta sa bus. Ngunit ang sagabal ng I2C ay mayroon itong parehong bus para sa pagpapadala at pagtanggap ng data at samakatuwid ito ay medyo mabagal. Kaya't ito ay pulos batay sa aplikasyon upang magpasya sa pagitan ng SPI at I2C protocol para sa iyong proyekto.
SPI na may PIC16F877A gamit ang XC8 Compiler:
Sapat na sa mga pangunahing kaalaman, ngayon malaman natin kung paano namin magagamit ang komunikasyon sa SPI sa PIC16F877A microcontroller gamit ang MPLABX IDE at XC8 compiler. Bago namin simulang linawin na ang tutorial na ito ay nagsasalita lamang tungkol sa SPI sa PIC16F877a gamit ang XC8 compiler, ang proseso ay magiging pareho para sa iba pang mga microcontroller ngunit maaaring kailanganin ng 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 SPI, ngunit para sa PIC16F877A walang katulad na mayroon 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 iba pang mga SPI device.
Sa tutorial na ito magsusulat kami ng isang maliit na programa na gumagamit ng komunikasyon sa SPI upang magsulat at mabasa ang data mula sa SPI bus. Susuriin namin pagkatapos ang pareho gamit ang Proteus simulation. Ang lahat ng code na nauugnay sa mga rehistro ng SPI ay gagawin sa loob ng header file na tinatawag na PIC16f877a_SPI.h. Sa ganitong paraan maaari naming magamit ang header file na ito sa lahat ng aming paparating na mga proyekto kung saan kinakailangan ang komunikasyon ng SPI. At sa loob ng pangunahing programa ay gagamitin lamang namin ang mga pagpapaandar mula sa header file. Ang kumpletong code kasama ang file ng header ay maaaring ma-download mula dito.
Paliwanag ng SPI Header File:
Sa loob ng file ng header kailangan nating simulan ang komunikasyon ng SPI para sa PIC16F877a. Tulad ng lagi ang pinakamagandang lugar upang magsimula ay ang datasheet ng PIC16F877A. Ang mga rehistro na kumokontrol sa komunikasyon ng SPI para sa PIC16F8777a ay ang SSPSTAT at ang Rehistro ng SSPCON. Maaari mong tungkol sa mga ito sa pahina 74 at 75 ng datasheet.
Maraming mga pagpipilian sa mga parameter na kailangang mapili habang pinasisimulan ang komunikasyon ng SPI. Ang pinaka-karaniwang ginagamit na pagpipilian ay ang dalas ng orasan ay itatakda sa Fosc / 4 at magagawa sa gitna at ang orasan ay maitatakda bilang mababang sa perpektong estado. Gumagamit din kami ng parehong pagsasaayos para sa aming header file, madali mong mababago ang mga ito sa pamamagitan ng pagbabago ng kani-kanilang mga piraso.
SPI_Initialize_Master ()
Ang pagpapauna ng SPI na Master function ay ginagamit upang simulan ang komunikasyon ng SPI bilang master. Sa loob ng pagpapaandar na ito itinakda namin ang kani-kanilang mga pin na RC5 at RC3 bilang mga output pin. Pagkatapos ay i-configure namin ang SSPTAT at ang rehistro ng SSPCON upang buksan ang mga komunikasyon ng SPI
walang bisa SPI_Initialize_Master () { TRISC5 = 0; // SSPSTAT = 0b00000000; // pg 74/234 SSPCON = 0b00100000; // pg 75/234 TRISC3 = 0; // Itakda bilang output para sa alipin mode }
SPI_Initialize_Slave ()
Ang pagpapaandar na ito ay ginagamit upang itakda ang microcontroller upang gumana sa mode ng alipin para sa komunikasyon ng SPI. Sa panahon ng mode ng alipin ang pin RC5 ay dapat itakda bilang output at ang pin RC3 ay dapat itakda bilang input. Ang SSPSTAT at ang SSPCON ay nakatakda sa parehong paraan para sa kapwa alipin at panginoon.
walang bisa SPI_Initialize_Slave () { TRISC5 = 0; // SDO pin dapat ideklarang output SSPSTAT = 0b00000000; // pg 74/234 SSPCON = 0b00100000; // pg 75/234 TRISC3 = 1; // Itakda sa para sa master mode }
SPI_Write (papasok na char)
Ang pagpapaandar ng SPI Writing ay ginagamit upang magsulat ng data sa SPI bus. Nakukuha nito ang impormasyon mula sa gumagamit sa pamamagitan ng variable na papasok at pagkatapos ay ginagamit ito upang makapasa sa rehistro ng Buffer. Ang SSPBUF ay malilinis sa magkakasunod na pulso ng Clock at ang data ay ipapadala ng kaunti sa bus.
walang bisa SPI_Write (char papasok) { SSPBUF = papasok; // Isulat ang ibinigay na data sa gumagamit sa buffer }
SPI_Ready2Read ()
Ang pagpapaandar na handa nang Basahin ang SPI ay ginagamit upang suriin kung ang data sa SPI bus ay natanggap nang kumpleto at kung mababasa ito. Ang rehistro ng SSPSTAT ay medyo tinatawag na BF na magtatakda sa sandaling ang data ay natanggap nang kumpleto, kaya't susuriin natin kung ang bit na ito ay nakatakda kung hindi ito nakatakda kung gayon kailangan nating maghintay hanggang sa maitakda ito upang mabasa ang anumang mula sa SPI bus.
unsigned SPI_Ready2Read () { if (SSPSTAT & 0b00000001) return 1; kung hindi man bumalik 0; }
SPI_Read ()
Ginagamit ang SPI Read upang basahin ang data mula sa SPI bus papunta sa microcontroller. Ang data na naroroon sa SPI bus ay itatabi sa SSPBUF, kailangan nating maghintay hanggang ang kumpletong data ay nakaimbak sa Buffer at pagkatapos ay mabasa natin ito sa isang variable. Sinusuri namin ang bit ng BF ng rehistro ng SSPSTAT bago basahin ang buffer upang matiyak na kumpleto ang pagtanggap ng data.
char SPI_Read () // Basahin ang natanggap na data { habang (! SSPSTATbits.BF); // Hold hanggang ang BF bit ay nakatakda, upang matiyak na ang kumpletong data ay nabasa na pagbabalik (SSPBUF); // ibalik ang nabasang data }
Pangunahing programa Paliwanag:
Ang mga pagpapaandar na ipinaliwanag sa seksyon sa itaas ay magiging sa header file at maaari silang tawagan sa pangunahing c file. Kaya't magsulat tayo ng isang maliit na programa upang suriin kung gumagana ang komunikasyon ng SPI. Susulat lamang kami ng ilang data sa SPI bus at gagamitin ang proteus simulation upang suriin kung ang parehong data ay natatanggap sa SPI debugger.
Tulad ng laging simulan ang programa sa pamamagitan ng pagtatakda ng mga config bit at pagkatapos ay napakahalaga na idagdag ang file ng header na ipinaliwanag lamang namin sa programa tulad ng ipinakita sa ibaba.
# isama
Kung binuksan mo ang programa mula sa zip file na na-download sa itaas pagkatapos ay bilang default ang header file ay naroroon sa loob ng direktoryo ng file ng header ng iyong file ng proyekto. Iba pa kailangan mong idagdag ang file ng header nang manu-mano sa loob ng iyong proyekto, sa sandaling idinagdag ang iyong mga file ng proyekto ay magiging ganito sa ibaba
Sa loob ng pangunahing file kailangan nating simulan ang PIC bilang Master para sa komunikasyon ng SPI at pagkatapos ay sa loob ng isang walang hanggan habang loop magsusulat kami ng mga random na tatlong hex na halaga sa SPI bus upang suriin kung nakakatanggap kami ng pareho sa simulation.
void main () { SPI_Initialize_Master (); habang (1) { SPI_Write (0X0A); __delay_ms (100); SPI_Write (0X0F); __delay_ms (100); SPI_Write (0X15); __delay_ms (100); } }
Pansinin na ang mga random na halagang ginamit sa programa ay 0A, 0F at 15 at ang mga ito ay hex na halaga kaya dapat nating makita ang pareho sa panahon ng simulation. Iyon lang ang tapos na ang code, isang sample lamang ito ngunit maaari naming gamitin ang parehong pamamaraan upang makipag-usap sa ibang MCU o sa iba pang module ng sensor na tumatakbo sa SPI protocol.
Ang pagtulad sa PIC na may SPI debugger:
Ngayon na handa na ang aming programa maaari naming itong ipunin at pagkatapos ay magpatuloy sa simulation. Ang Proteus ay may isang mahusay na madaling gamiting tampok na tinatawag na SPI debugger , na maaaring magamit upang subaybayan ang data sa isang SPI bus. Kaya't ginagamit namin ang pareho at bumuo ng isang circuit tulad ng ipinakita sa ibaba.
Dahil mayroon lamang isang SPI aparato sa simulation hindi namin ginagamit ang SS pin at kapag hindi ginamit dapat itong saligan tulad ng ipinakita sa itaas. I-load lamang ang hex file sa PIC16F877A microcontroller at mag-click sa pindutan ng pag-play upang gayahin ang aming programa. Kapag nagsimula ang simulation makakakuha ka ng isang pop-up window na nagpapakita ng data sa SPI bus tulad ng ipinakita sa ibaba
Tingnan natin nang malapitan ang papasok na data at suriin kung pareho ito sa isinulat namin sa aming programa.
Ang data ay natanggap sa parehong pagkakasunud-sunod na isinulat namin sa aming programa at ang parehong naka-highlight para sa iyo. Maaari mo ring subukang gayahin ang isang programa upang makipag - usap sa dalawang PIC microcontroller gamit ang SPI protocol. Kailangan mong i-program ang isang PIC bilang panginoon at ang isa bilang alipin. Ang lahat ng kinakailangang mga file ng header para sa hangaring ito ay naibigay na sa header file.
Ito ay isang sulyap lamang sa kung ano ang maaaring gawin ng SPI, maaari rin itong basahin at isulat ang data sa maraming mga aparato. Masasaklaw namin ang higit pa tungkol sa SPI sa aming paparating na mga tutorial sa pamamagitan ng pag-interfaced ng iba't ibang mga module na gumagana sa SPI 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.
Kumpletong Pangunahing code ay ibinigay sa ibaba; maaari kang mag-download ng mga file ng header kasama ang lahat ng code mula rito