Ang 74HC164 Shift Rehistro at Iyong Arduino: 9 Mga Hakbang

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

Ang mga rehistro ng shift ay isang napakahalagang bahagi ng digital na lohika, kumikilos sila bilang pandikit sa pagitan ng mga parallel at serial na mundo. Binabawasan nila ang mga bilang ng kawad, paggamit ng pin at kahit na nakakatulong sa pag-load mula sa iyong cpu sa pamamagitan ng kakayahang maiimbak ang kanilang data. Dumating sila sa iba't ibang laki, na may iba't ibang mga modelo para sa iba't ibang paggamit, at iba't ibang mga tampok. Ang tatalakayin ko ngayon ay ang 74HC164 8 bit, serial in parallel out, non latched, shift register. Bakit? Sa gayon ito ay isa sa pinakamahalagang rehistro ng paglilipat doon, na ginagawang madali ang pag-aaral tungkol dito, ngunit nangyari lamang na ako lang ang nagkaroon (lol!) Sinasaklaw ng itinuturo na ito kung paano gumagana ang maliit na tilad na ito, kung paano i-wire ito, at i-interface ito sa isang arduino kasama ang ilang mga sample na sketch at pinangunahan na mga circuit. Inaasahan kong lahat ay nasisiyahan ka!

Hakbang 1: Kaya, Ano ang Mga Rehistro ng Shift?

Tulad ng nabanggit mas maaga dumating sila sa lahat ng iba't ibang mga lasa, at nabanggit ko din na gumagamit ako ng isang 74HC164 8 bit, serial sa parallel out, hindi naka-latched, shift registroo ano ang ibig sabihin ng lahat?!? Una, ang pangalang 74 - nangangahulugang bahagi nito ng 74xx na pamilya ng lohika, at dahil ang lohika nito ay hindi nito direktang makontrol ang kasalukuyang (16-20ma para sa buong maliit na maliit na tilad ay karaniwan), nagpapasa lamang ito ng mga signal sa paligid, ngunit hindi ito nangangahulugang ang senyas na iyon ay hindi pupunta sa isang transistor na maaaring lumipat ng isang mas mataas na kasalukuyang karga. Ang HC ay nangangahulugang ito ay isang mataas na bilis ng aparato na cmos, maaari mong basahin ang tungkol dito sa link sa ibaba, ngunit kung ano ang pangunahing kailangan mong malaman tungkol dito ay ito ay isang mababang aparato ng kuryente at tatakbo mula 2 hanggang 5 volts (kaya kung ang iyong paggamit ng isang 3.3 volt arduino iyong ok) Gayundin maaari itong gumana nang maayos sa mataas na bilis ang partikular na maliit na maliit na tilad na ito ay may karaniwang bilis na 78mhz, ngunit maaari kang pumunta nang mabagal o mas mabilis (hanggang sa magsimula itong mag-up up) ayon sa gusto mowww.kpsec.freeuk.com/components/74series.htm164 ang numero ng modelo para sa chip na ito, mayroong isang malaking tsart sa kanila sa wikipediaen.wikipedia.org/wiki/List_of_7400_series_integrated_circuits Susunod, 8 bit Ang isang rehistro ng paglilipat ay binubuo ng mga flip flop circuit, isang flip flop ay 1 piraso ng memorya, ang isang ito ha s 8 (o 1 byte ng memorya). Dahil ito ay memorya, kung hindi mo kailangang i-update ang rehistro maaari mo lamang ihinto ang "pakikipag-usap" dito at mananatili ito sa anumang estado na iniwan mo ito, hanggang sa "makipag-usap" muli dito o i-reset ang lakas. ang iba pang mga rehistro ng paglilipat ng serye ng 7400 na lohika ay maaaring umabot sa 16 bit na serial sa parallel out Ito ay nangangahulugang ang iyong arduino ay nagpapadala nito ng data nang serally (sa isa-isang na-off na pulso) at inilalagay ng rehistro ng shift ang bawat bit sa tamang output pin. Ang modelong ito ay nangangailangan lamang ng 2 wires upang makontrol, kaya maaari mong gamitin ang 2 digital pin sa arduino, at basagin ang 2 hanggang 8 pang digital outputse ilang iba pang mga modelo ay kahanay sa serial out, ginagawa nila ang parehong bagay ngunit bilang mga input sa arduino (halimbawa isang games na NES) na hindi naka-latched Maaaring ito ay isang pagbagsak ng maliit na tilad na ito kung kailangan mo ito. Habang pumapasok ang data sa isang rehistro ng paglilipat sa pamamagitan ng serial, nagpapakita ito sa unang output pin, kapag pumasok ang isang pulso ng orasan, ang unang bit ay lumilipat sa 1 lugar, na lumilikha ng isang epekto sa pag-scroll sa mga output, halimbawa 00000001 ay lalabas sa mga output bilang 101001000100001000001000000100000001 Kung ang pakikipag-usap mo sa iba pang mga aparato sa lohika na nagbabahagi ng parehong orasan at hindi inaasahan ito, maaari itong maging sanhi ng mga isyu. Ang mga naka-latch na rehistro ng paglilipat ay mayroong labis na hanay ng memorya, kaya't kapag natapos ang data sa pagpasok ng rehistro maaari mong i-flip ang isang switch at ipakita ang mga output, ngunit nagdaragdag ito ng isa pang kawad, software, at mga bagay na makakasabay. kinokontrol namin ang mga ipinapakitang LED, ang epekto ng pag-scroll ay nangyayari nang napakabilis na hindi mo ito nakikita (maliban kung kailan mo pa nabubuksan ang maliit na tilad), at sa sandaling ang byte ay nasa rehistro ng shift wala nang pag-scroll, at isang 16LED 4x4 dot matrix na may chip at software na ito sa arduino na gumagamit lamang ng 2 digital pin (+ power at ground)

Hakbang 2: Pangunahing Kable at Pagpapatakbo

Mga kable Ang 74HC164 ay isang 14 pin chip, mayroon itong 4 na mga input pin, 8 output pin, power at ground, kaya't magsimula tayo mula sa itaas. Ang Mga Pins 1 at 2 ay parehong mga serial input, naka-set up ito bilang isang lohikal AT gate, nangangahulugang pareho silang kailangang maging mataas na lohika (ibig sabihin 5 volts) upang ang bit ay makita bilang isang 1, isang mababang estado (0 volts) sa alinman ay mababasa bilang isang zero. Hindi namin talaga ito kailangan at mas madali itong makitungo sa software, kaya pumili ng isa at itali ito sa V + kaya't palaging mataas ang pagbasa nito. Pinili kong gumamit ng isang jumper mula sa pin 1 hanggang pin 14 (V +) dahil maaari mo lamang i-pop ang isang jumper ng breadboard sa ibabaw ng maliit na tilad. Ang natitirang serial input (pin 2 sa aking mga iskema) ay gagamit ng digital pin 2 ng arduino. Ang Pins 3, 4, 5, at 6 ng 74HC164 ay ang unang 4 bytes ng outputPin 7 ay kumokonekta sa groundJumping sa kanan, pin 8 ay ang pin na orasan, ito ay kung paano alam ng shift register ang susunod na serial bit ay handa na itong basahin, dapat itong konektado sa digital pin 3 sa arduino. Ang P 9 ay upang limasin ang buong rehistro nang sabay-sabay, kung mababa ito, mayroon kang pagpipilian na gamitin ito, ngunit wala sa hindi maunawaan na ito, kaya itali ito sa V + pin 10, 11 12 at 13 ang huling 4 bytes ng outputpin 14 ay ang chips power Operation Una kailangan mong itakda ang serial input ng rehistro (digital pin 2 sa arduino) mataas o mababa, susunod na kailangan mong i-flip ang orasan pin (digital pin 3) mula mababa hanggang mataas, babasahin ng shift register ang data sa serial input at ilipat ang mga output pin ng 1, ulitin ang 8 beses at naitakda mo ang lahat ng 8 output. Maaari itong gawin sa pamamagitan ng para sa mga loop at digital na pagsusulat sa arduino IDE, ngunit dahil t ang kanyang ay isang pangkaraniwang mga antas ng komunikasyon sa antas ng hardware (SPI) mayroon silang isang solong pag-andar na ginagawa ito para sa iyo. shiftOut (dataPin, clockPin, bitOrder, halaga) Sabihin lamang kung saan ang data at mga pin ng orasan ay konektado sa arduino, kung aling paraan upang maipadala ang data at kung ano ang ipapadala, at alagaan ito para sa iyo (madaling gamitin)

Hakbang 3: Mga Proyekto

Okay, sapat na panayam at teorya, hinahayaan ang gumawa ng ilang mga nakakatuwang bagay sa chip na ito! Mayroong 3 mga proyekto upang subukan sa itinuro na ito, ang unang 2 ay madali at maaaring ma-breadboard sa ilang sandali. Ang pangatlo, ang 4x4 led matrix, ay nangangailangan ng mas maraming oras at naisip na bumuo, dahil sa pinangunahan na mga kable. Listahan ng mga bahagi Project 1: '2 Wire' bargraph LED display controller 1 * 74HC164 Shift register1 * solderless breadboard1 * arduino, o arduino katugma (5v) 1 * 330 ohm 1/4 watt risistor 8 * normal na output red LED's 12 * jumper wires Project 2: '2 Wire' 7 segment display controller 1 * 74HC164 Shift register1 * solderless breadboard1 * arduino, o arduino compatible (5v) 1 * 330 ohm 1/4 watt risistor 1 * karaniwang cathode pitong segment display9 * jumper wires Project 3: '2 Wire' 4x4 led matrix display 1 * 74HC164 Shift register1 * arduino, or arduino compatible (5v) 4 * 150 ohm 1 1/4 watt risistor8 * 1Kohm 1/8 watt risistor (o mas malaki) 8 * NpN transistor (2n3904 o mas mahusay) 16 * normal na output red LED's ay isang paraan upang maitayo ito at kinontrol ang 5 volt na lakas na maaaring hawakan 160 + ma (maaari mo i-on ang lahat ng mga LED nang sabay-sabay tulad ng isang ilaw ng preno)

Hakbang 4: Project 1 [pt 1]: '2 Wire' Bargraph LED Display Controller Hardware

I-hook up ang arduino at irehistro ang shift ayon sa eskematiko, mayroon na akong isang 10 segment na display ng bargraph na handa na para sa paggamit ng breadboard at iyon ang makikita mo sa imahe, ngunit maaari mong gawin ang parehong bagay sa mga indibidwal na led's Sa ikalawang pahina Sinabi ko na hindi ito mga aparato sa pagmamaneho, na ang mga ito ay mga aparato sa lohika, na may maliit na halaga ng kasalukuyang nakakapasa sa kanila. Sa pagkakasunud-sunod ng pagpapatakbo ng 8 LEDs, habang pinapanatili ang circuit na simple, at hindi pagluluto ng rehistro ng shift, kinakailangan na limitahan namin ang kasalukuyang medyo. Ang mga LED ay naka-wire nang kahanay at nagbabahagi ng isang karaniwang lupa (karaniwang cathode), bago pumasok sa lakas supply ground kailangan nilang dumaan sa isang 330 ohm risistor, nililimitahan ang kabuuang halaga ng kasalukuyang maaaring maaring gamitin ng lahat ng mga LED sa 10ma (sa 5 volts) Iniwan nito ang mga LED sa isang estado na may sakit ngunit lumiwanag sila at sa gayon ay nagsisilbi ang halimbawang ito, upang himukin ang LED sa kanilang tamang kasalukuyang kakailanganin mong magsingit ng isang transistor kung saan ang shift register ay maaaring i-on / i-off ang isang mas mataas na kasalukuyang mapagkukunan (tingnan ang proyekto 3) Ang Data pin ng shift register (pin 2) ay nangangailangan upang kumonekta sa arduino digital pin # 2 Ang Clock pin ng shift register (pin 8) ay kailangang kumonekta sa arduino digital pin # 3

Hakbang 5: Project 1 [pt 2]: '2 Wire' Bargraph LED Display Controller Software

Halimbawa 1: Buksan ang file na "_164_bas_ex.pde" Sa loob ng arduino IDE, Ito ay isang simpleng sketch na hinahayaan kang tukuyin o i-off ang LED sa display ng bargraph. Ang unang 2 linya ay tumutukoy sa mga numero ng pin na gagamitin namin para sa data at orasan, ako gamitin ang #define over const integer, mas madali kong matandaan, at walang kalamangan sa isa o sa iba pa na naipon ang #define data 2 # tukuyin ang orasan 3 sa susunod ay ang walang bisa na pag-andar ng pag-setup, isang beses lamang itong tumatakbo, kaya't lumiliko ang arduino sa, nagtatakda ng rehistro ng shift at wala nang ibang magagawa. Sa loob ng walang bisa na pag-andar ng pag-set ay itinakda namin ang orasan at mga pin ng data bilang mga OUTPUT pin, pagkatapos ay ginagamit ang pag-andar ng shiftOut ipinapadala namin ang data sa shift register na walang bisa na pag-setup () {pinMode (orasan, OUTPUT); // gawin ang orasan na pin ng isang output pinMode (data, OUTPUT); // make the data pin an output shiftOut (data, orasan, LSBFIRST, B10101010); // ipadala ang halagang binary na ito sa rehistro ng shift} Sa pagpapaandar ng shiftOut maaari mong makita ang mga argumento nito ang data pin, orasan ay ang pin na orasan na LSBFIRST ay tumutukoy sa kung ano ang order nito, kapag isinulat ito sa binary notation (Bxxxxxxxx) ang ika-7 Ang elemento na nakaraang B ay ang Least Signifigant Bit Una, ito ay pinakain muna kaya't nagtatapos ito sa huling output sa sandaling ang lahat ng 8 bits ay pinakain sa, subukang maglaro ng iba't ibang mga halaga upang i-on o i-off ang iba't ibang mga pattern at sa wakas ay walang laman na loop na walang bisa (dahil kailangan mo ng isa kahit na hindi mo ginagamit ito) void loop () {} // walang laman na loop para sa ngayon Halimbawa 2: ang unang 8 na linya ay kapareho ng unang 8 linya ng unang halimbawa, sa katunayan hindi sila magbabago para sa alinman sa iba pang mga proyekto, kaya # tukuyin ang data 2 # tukuyin ang orasan 3void ang pag-setup () {pinMode (orasan, OUTPUT); // gawin ang orasan na pin ng isang output pinMode (data, OUTPUT); // gawin ang data pin isang output Ngunit ngayon sa walang bisa na pag-setup mayroong isang bilang ng 8 para sa loop, kumukuha ito ng isang walang laman na byte at paglilipat ng 1 bit sa bawat oras na nagsisimula mula sa kaliwang kaliwang bahagi at gumagalaw pakanan. Paatras ito mula sa unang halimbawa kung saan nagsimula kami mula sa kanang bahagi at nagtatrabaho sa kaliwa, ngunit ang paggamit ng MSBFIRST ang paglilipat ay nagpapadala ng data ng wastong paraan para sa (int i = 0; i <8; ++ i) // para sa 0 - 7 gawin {shiftOut (data, orasan, MSBFIRST, 1 << i); // bit shift isang lohika mataas (1) na halaga sa pamamagitan ng pagkaantala ko (100); // antala ang 100ms o hindi mo ito makikita}} void loop () {} // walang laman na loop para ngayon i-upload ang script at dapat mo na ngayong makita ang bargraph na nagpapaliwanag ng bawat ilaw nang paisa-isa

Hakbang 6: Project 2: '2 Wire' 7 Segment Display Controller

Tingnan ang pinout ng iyong 7 segment display (mayroon lamang akong dalawahan ngunit gumagamit lamang ng kalahati) at gamitin ang pagguhit sa ibaba upang ikonekta ang bawat segment sa tamang piraso sa shift registerbit 1 = pin 3bit 2 = pin 4bit 3 = pin 5bit 4 = pin 6bit 5 = pin 10bit 6 = pin 11bit 7 = pin 12bit 8 = pin 13 (kung nais mong gamitin ang decimal point) At ang cathode ng display sa pamamagitan ng 330ohm resistor at sa power supply groundnow buksan ang seven_seg_demo.pde sa arduino IDEFirst na nakikita mo kung saan namin tinutukoy ang mga data at mga pin ng orasan # tukuyin ang data 2 # tukuyin ang orasan 3 Susunod na itinakda namin ang lahat ng mga pattern ng charater sa binary, ito ay medyo madali, tingnan ang pagguhit sa ibaba, kung kailangan mo ang gitnang segment i-type sa isang, susunod na kailangan mo ng nangungunang segment, kung gayon mag-type sa isa pa, patuloy na gawin ito hanggang sa masakop mo ang lahat ng 8 mga segment, pansinin ang aking kanang bahagi (bit 8) ay palaging 0, dahil hindi ko kailanman binubuksan ang decimal punto. byte zero = B01111110; byte one = B00000110; byte two = B11011010; byte three = B11010110; byte four = B10100110; byte five = B11110100; byte six = B11111100; byte seven = B01000110; byte eight = B11111110; by111 = susunod sa void setup ay itinakda namin ang aming data at mga pin ng orasan sa mga output na walang bisa na pag-setup () {pinMode (orasan, OUTPUT); // gawin ang orasan na pin ng isang output pinMode (data, OUTPUT); // make the data pin an output3} pagkatapos ay sa void loop ginagamit namin ang shiftOut upang ipakita ang bawat pattern (numero) maghintay 1/2 sa isang segundo at ipakita ang susunod, 0 hanggang 9, dahil tapos na ito sa void loop function mabibilang ito 0-9 at ulitin magpakailanman. void loop () {shiftOut (data, orasan, LSBFIRST, zero); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, isa); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, dalawa); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, tatlo); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, apat); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, lima); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, anim); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, pito); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, walo); pagkaantala (500); shiftOut (data, orasan, LSBFIRST, siyam); antala (500);}

Hakbang 7: Project 3 [pt 1]: '2 Wire' 4x4 Led Matrix Display

Ang proyekto ng 4x4 LED matrix ay medyo mas kumplikado, ngunit halos lahat sa konstruksyon, pipiliin kong gawin ang minahan na solder sa perfboard, ngunit dapat posible na magtiklop sa isang breadboard, mas maraming spaced out. naiiba sa ang rehistro ng shift ay hindi direktang pagmamaneho ng led, sa halip ang mga output ng rehistro ng shift ay ipinapadala sa pamamagitan ng isang risistor na 1Kohm sa base ng isang transistor ng NpN, kapag ang output ng bit ay mataas, hinahayaan nito ang sapat na kasalukuyang at boltahe na pumasa sa ang transistor upang ilipat ang koneksyon ay palitan ang kolektor at emitter, ang mga kolektor ay nakatali sa isang "matibay" na kinokontrol na 5 volts. Ang mga emitter ng transistors ay konektado sa 150 ohm resistors at ang resistors ay nakatali sa mga anodes ng 4 led's sa isang hilera at nililimitahan ang hilera sa 20ma, kahit na kapag ang pagguhit ng mga imahe sa display 1 lamang na humantong ay naka-on sa bawat oras, at samakatuwid malapit sa buong liwanag (malapit sa becuase lumipat sila at naka-off talagang mabilis upang mabuo ang buong imahe) Mayroong 4 na hilera at 4 mga haligi, bawat isa Ang hilera ay nakakakuha ng isang risistor at isang transistor, sa bawat haligi ng mga cathode ng LED ay nakatali magkasama, tumakbo sa kolektor ng isang transistor, na ang base ay kinokontrol din ng shift register, at sa wakas ay lumabas sa lupa. Malaking bersyon ng eskematiko www.instructables.com/files/orig/F7J/52X0/G1ZGOSRQ/F7J52X0G1ZGOSRQ.jpg

Hakbang 8: Project 3 [pt 2]: '2 Wire' 4x4 Led Matrix Display

Kinokontrol ng shift register ang parehong anode at ang mga cathode ng LED sa isang format na YX, tingnan ang sumusunodbitbit 1 = haligi 1 (kanan) bit 2 = haligi 2bit 3 = haligi 3bit 4 = haligi 4bit 5 = hilera 1 (pinakamataas) na bit 6 = row 2bit 7 = row 3bit 8 = row 4 Upang makagawa ng isang imahe gumuhit ng isang 4x4 square sa graph paper at punan kung alin ang nais mong ipakita, susunod na gumawa ng isang talahanayan ng YX. Sa ibaba makikita mo ang isang pagmamapa para sa isang simile, pati na rin ang pinakamahusay na magagawa sa 4x4 "pixel" Para sa bawat napunan sa seksyon ay isinusulat ko kung aling haligi (Y) ito ay nasa, pagkatapos kung aling hilera ito ay nasa (X) Ngayon buksan ang _4x4.pde file sa arduino IDE makikita mo ang aming dating 2 kaibigan #define data 2 # tukuyin ang orasan 3 pagkatapos ng isang hanay ng mga integers int img = {1, 1, 4, 1, 1, 3, 4, 3, 2, 4, 3, 4}; Kung titingnan mo ito ay isang listahan lamang ng aking nakasulat na mga coordinate ng YX, magiging isang malaking sakit sa puwit ang pag-convert ng mga halagang iyon sa pamamagitan ng kamay, at mayroon kaming isang computer … hayaan itong gawin! Ang paglipat sa doon ay walang bisa na pag-set up kung saan ginagawa namin ang aming orasan at data pin ay OUTPUTS walang bisa setup () {pinMode (orasan, OUTPUT); // gawin ang orasan na pin ng isang output pinMode (data, OUTPUT); // make the data pin an output3} At isang nakalilito na mukhang void loop, upang simulan ang mga bagay na kailangan namin upang ideklara ang ilang mga lokal na variable na void loop () {int Y; int X; byte out; Pagkatapos ng isang para sa loop, ang loop na ito ay kailangang kasing haba ng dami ng mga entry sa img array, para sa imaheng ito Gumamit lamang ako ng 6 na mga pixel, kaya't gumagawa ng 12 YX na mga coordinate. Ginagawa kong laktawan ang bawat iba pang numero sa pamamagitan ng paggamit ng i + = 2, dahil nabasa namin ang 2 mga coordinate bawat loop para sa (int i = 0; i <12; i + = 2) // bilang ng mga puntos sa img array, ang kasong ito 12 {Ngayon binasa namin ang Y entery sa sa array, at binabawas ang isa mula sa halaga nito, dahil ang mga byte ay hindi nagsisimula sa isa, nagsisimula sila sa zero, ngunit binibilang namin mula sa 1 // makuha ang unang pares ng mga YX cords Y = (img - 1); // ibawas ang isa dahil nagsimula ang bilang ng bit sa 0 Susunod na nabasa namin ang X entery sa [i + 1] sa array, at ibawas ang isa mula sa halaga nito, dahil sa parehong dahilan X = (img [i + 1] - 1); Matapos magkaroon kami ng mga halagang YX ng pixel, gumawa kami ng kaunti o matematika at paglilipat sa kaliwa. Una kailangan naming basahin ang X na halaga, at anuman ang halaga nito ay ilipat ito na maraming mga lugar + 4 na natitira, kaya't kung ang X ay 4 at idagdag ang 4 na ito ay bit 8 (MSB), pagtingin muli sa tsart … bit 1 = haligi 1 (kanan) bit 2 = haligi 2bit 3 = haligi 3bit 4 = haligi 4bit 5 = hilera 1 (pinakamataas) na bit 6 = hilera 2bit 7 = row 3bit 8 = row 4Bit 8 ay ang huling hilera Susunod na ang halaga ng Y ay inilipat din sa kaliwa, sa oras na ito sa sarili lamang nito, walang idinagdag. Sa wakas ang dalawa ay naisaayos sa isang 1 byte sa halip na 2 kalahating byte (nibbles), gamit ang bitwise o (ang simbolo |) ay tumatagal ng dalawang byte at pangunahing idinadagdag ang mga ito, hinahayaan na X = 10000000Y = 00000001 -------------------- O = 10000001row 4 na haligi 1 out = 1 << (X + 4) | 1 << Y; At sa wakas shiftOut upang maipakita ang kasalukuyang larawan, at patuloy na gawin iyon hanggang wala na kaming data sa array … antala ang isang sandali at loop magpakailanman, dahil binabago namin ang data sa kaliwa at kailangan namin ang MSB na nasa huling output pin ng shift register ipalabas muna ito. shiftOut (data, orasan, MSBFIRST, palabas); // shift the byte out to our register delay (1); // antalahin ito sa abit upang magkaroon ito ng pagkakataong mag-iwan ng isang ilaw ng iyong mga mata Huwag mag-atubiling gumawa ng iyong sariling mga imahe, at mga epekto, Mayroong 3 sample na mga file, ang nakangiting mukha at isang checkerboard (na parang mga guhitan), at sa wakas isang random sparkle maker

Hakbang 9: Konklusyon

Higit sa lahat ito ay isang madaling gamiting maliit na maliit na maliit na maliit na tilad, at natutuwa akong inalis ko ito sa isang lumang piraso ng electronics na nagtungo sa basurahan. Maaari itong magamit para sa iba pang mga bagay bukod sa mga display system, ngunit lahat ay may gusto ng mga ilaw at instant na puna ng nakikita ano ang nangyayari ay lubos na kapaki-pakinabang para sa mga visual thinker tulad ko. Mangyaring patawarin ang aking code, mayroon lamang akong arduino mula noong ikatlong linggo ng Oktubre, at ito ay naging isang malaking kurso sa pag-crash. Ngunit iyon ang mahusay na bagay tungkol sa system, kung nakaupo ka at nagtatrabaho kasama nito, puno ito ng mga maayos na tampok na ginagawang mas madaling gawin ang pagkontrol sa mundo gamit ang isang 8 bit microcontroller. Tulad ng palaging tinatanggap ang mga katanungan at puna, at salamat sa sa pagbabasa, sana marami kang natutunan