RGB LED Matrix: 5 Hakbang

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

Maituturo ang Paghahanap, at makakahanap ka ng maraming mga proyekto ng LED matrix. Wala sa kanila ang lubos na nais ko, na tuklasin ang mga pakikipag-ugnayan ng disenyo ng hardware at software upang makabuo ng isang bagay, at makagawa ng pangwakas na produkto sa isang maayos na PCB na may driver na hayaan akong gumuhit sa "LED screen" gamit ang mataas na antas construct (hal., pagguhit ng isang linya na taliwas sa pagtatakda ng mga tukoy na pixel). Ang bahaging ito ay mahalaga sa akin, tulad ng marami sa mga driver ng LED matrix na hubad na buto at hindi nagbibigay ng malaki sa paraan ng paglikha ng isang imahe ng isang imahe o animasyon. Hindi ito nangangahulugang hindi ka makakalikha ng mga imahe at mga animasyon sa iba pang mga driver, lamang na kakailanganin mong gumawa ng mas paulit-ulit na gawain mula sa isang proyekto hanggang sa isang proyekto.

Kaya't nagtakda ako upang magawa ang aking pangitain. Ang unang hakbang ay ang disenyo ng hardware. Marahil ito ang pinaka-mapaghamong para sa akin, dahil ang aking background ay mas maraming software. Muli, maraming mga pre-baked na disenyo, at tiyak na ginamit ko ang mga ito para sa inspirasyon, ngunit nais kong matuto sa pamamagitan ng paggawa, kaya nagprotipo ako ng isang 4x4 matrix sa isang breadboard. Marami akong natutunan sa pamamagitan ng prosesong iyon, dahil ang aking unang ilang mga pag-ulit ay hindi gumana. Ngunit, gumawa ako ng disenyo ng hardware na gumana, na sa gayon ay pinapayagan akong simulan ang pagbuo ng isang driver.

Pinili ko ang Arduino bilang aking platform ng driver dahil malawak itong magagamit at maraming mga sanggunian sa online. Habang pinapayagan ako ng karanasan sa karera na makapunta sa isang gumaganang bersyon ng isang driver nang mas makinis kaysa sa aking mga pagsisikap sa hardware, mayroon pa ring maraming mga pag-ulit habang na-optimize ko ang pagganap ng driver para sa ATMega micro controller at bumuo ng isang API ng programa na gusto ko.

Ang Instructable na ito ay maaaring magdokumento ng disenyo at ilang pangunahing natututuhan mula sa aking proyekto. Ang karagdagang impormasyon tungkol sa proyektong ito ay matatagpuan sa aking website dito, kasama ang buong kit na maaari mong bilhin upang makabuo ng iyong sariling RGB LED matrix.

Hakbang 1: Disenyo ng Hardware

Ang pangunahing layunin ng aking disenyo ng hardware ay upang lumikha ng isang hanay ng mga RGB LED na maaari kong programa, ngunit hindi ko rin nais na gumastos ng maraming pera. Ang diskarte na naayos ko ay ang paggamit ng 74HC595 shift register upang makontrol ang mga LED. Upang mai-minimize ang bilang ng mga rehistro ng paglilipat na kinakailangan, inayos ko ang mga RGB LED sa isang matrix layout kung saan ang mga karaniwang anode ay nakatali magkasama sa mga hilera at ang pula, berde, at asul na mga lead ng cathode ay nakatali sa mga haligi. Para sa 4x4 matrix, ang circuit diagram ay mukhang naka-attach na diagram ng circuit.

Ang isang bagay na mapapansin mo kaagad ay ang ibinigay na matrix circuit, mayroong ilang mga pag-configure ng pag-iilaw ng LED na hindi maaaring gawin sa lahat ng ninanais na LEDs nang sabay. Halimbawa, ang matrix ay hindi maaaring sabay na ilaw ng dalawang LEDs na dayagonal mula sa bawat isa dahil ang pag-powering ng parehong mga hilera at haligi ay magiging sanhi ng ilaw ng dalawang magkabaligtad na LED sa patayo na dayagonal sa nais na mga LED. Upang magtrabaho sa paligid nito, gagamit kami ng multiplexing upang i-scan ang bawat hilera. Mayroong maraming mga mapagkukunan sa web na sumasaklaw sa pamamaraan ng multiplexing, hindi ko susubukan na kopyahin ang mga ito dito.

Dahil gumagamit ako ng mga karaniwang anode LEDs, nangangahulugan iyon na ang mga hilera ay nagbibigay ng positibong lakas at ang mga haligi ay lumubog sa lupa. Ang magandang balita ay ang 74HC595 shift register ay maaaring parehong mapagkukunan at lumubog na kapangyarihan, ngunit ang masamang balita ay mayroon silang isang limitasyon sa kung magkano ang lakas na maaari nilang mapagkukunan o lumubog. Ang mga indibidwal na pin ng 74HC595 ay may max kasalukuyang gumuhit ng 70 mA, ngunit pinakamahusay na panatilihin ang mas mababa sa 20 mA. Ang mga indibidwal na kulay sa aming RGB LEDs bawat isa ay may tungkol sa isang 20 mA draw. Nangangahulugan ito na ang 74HC595 ay hindi direktang magpapagana ng isang buong hilera ng mga LED kung nais kong i-on ang lahat.

Kaya sa halip na direktang paganahin ang hilera, ang 74HC595 sa halip ay maghimok ng isang transistor para sa bawat hilera, at ang transistor ay bubuksan o patayin ang kasalukuyang pagpapatakbo ng hilera. Dahil ang disenyo ay gumagamit ng isang pangkaraniwang mga LED anod, ang switching transistor ay magiging PNP. Kung gumagamit kami ng isang karaniwang LED ng cathode, ang switching transistor ay magiging NPN. Tandaan na sa paggamit ng isang transistor ng PNP upang humimok ng isang hilera, ang setting ng shift register upang i-on ito ngayon ay nagiging mababa dahil ang isang transistor ng PNP ay nangangailangan ng isang negatibong boltahe sa pagitan ng emitter at base upang mai-on, na magpapahintulot sa positibong kasalukuyang dumaloy sa hilera

Ang isa pang bagay na dapat isaalang-alang ay ang nais na layout ng shift ng mga rehistro. Iyon ay, sa gitna ng mga rehistro ng paglilipat, kung aling mga bit ang kumokontrol kung aling mga hilera o haligi sa matrix. Ang disenyo na ipinadala ko sa kung saan ang unang bit, o "pinaka-makabuluhang piraso", na ipinadala sa daisy chaced shift registro kontrolin ang haligi ng mga pulang elemento ng LEDs, ang pangalawang bit ay kumokontrol sa berdeng elemento ng unang haligi, ang pangatlong bit ang kumokontrol sa unang haligi asul na elemento, ang pang-apat na bit ay kumokontrol sa pulang elemento ng pangalawang haligi, … ang pattern na ito ay paulit-ulit sa mga haligi sa kaliwa hanggang kanan. Pagkatapos ang susunod na ipinadala ay kumokontrol sa huling, o ibaba, hilera, ang susunod na pangalawa hanggang huling hilera, … naulit ito hanggang sa huling ipinadala, o "hindi gaanong makabuluhang bit", kinokontrol ang una, o tuktok, hilera sa matrix.

Sa wakas, kailangan kong matukoy kung anong mga resistors ang gagamitin ko para sa bawat isa sa mga LED sa RGB LED. Habang maaari mong gamitin ang karaniwang formula na pinagsasama ang boltahe sa unahan at nais na kasalukuyang upang makalkula ang kinakailangang risistor, nalaman ko na ang pagtatakda ng kasalukuyang LED sa bawat 20 milliamp ay nagresulta sa isang puting puting kulay kapag ang lahat ng pula, berde, at asul na LEDs ay nakabukas. Kaya't sinimulan kong i-eye-ball ito. Ang sobrang pula sa puti ay nangangahulugang pagdaragdag ng risistor ng pulang LED upang mabawasan ang kasalukuyang. Inulit ko ang pagpapalit ng mga resistor ng magkakaibang mga ohm hanggang sa makahanap ako ng isang kombinasyon na gumawa ng isang puting kulay na sa palagay ko ay tama. Ang huling kumbinasyon ay 180 Ω para sa pulang LED, 220 Ω para sa berdeng LED at 100 Ω para sa asul na LED.

Hakbang 2: Konstruksiyon ng Hardware - Breadboard

Ang unang yugto ng constructer ng hardware ay ang pagsakay sa tinapay. Dito gumawa ako ng isang 4x4 matrix sa mga RGB LEDs. Ang matrix na ito ay mangangailangan ng 16 bits upang makontrol, 12 para sa mga haligi ng RGB, at 4 para sa bawat hilera. Ang dalawang 74HC595 shift register ay maaaring hawakan ang lahat ng ito. Una kong sinaliksik at dinisenyo ang isang circuit na naisip kong gagana, pagkatapos ay itinayo ito sa breadboard.

Marahil ang pinakamalaking hamon ng paggawa ng tinapay ay ang pamamahala ng lahat ng mga wire. Kinuha ko ang isang preformed wire kit para sa mga breadboard, ngunit ang kaganapan pagkatapos ay medyo hindi ito matigas. Ang isang trick na nalaman kong kapaki-pakinabang ay ang paglikha ng isang "port" para sa pagkonekta sa Arduino board. Iyon ay, sa halip na ikonekta ang mga pin sa Arduino nang direkta sa iba't ibang mga IC pin sa breadboard, italaga ang ilang mga hilera sa breadboard upang maging punto ng koneksyon para sa Arduino, at pagkatapos ay ikonekta ang mga nauugnay na mga pin ng ID sa mga hilera na iyon. Para sa proyektong ito, kailangan mo lamang ng limang mga koneksyon sa Arduino: + 5V, lupa, data, orasan, at aldaba.

Kapag tapos na ang build ng breadboard, kailangan kong subukan ito. Gayunpaman, nang walang ilang uri ng driver upang magpadala ng tamang mga signal sa mga rehistro ng shift, hindi ko masubukan upang makita kung gumana ang layout ng hardware.

Hakbang 3: Disenyo ng Driver Software

Dahil sa aking sariling karanasan sa karera sa pag-unlad ng software, ito ang bahagi ng proyekto na marahil ako ang pinaka malinaw tungkol sa isang daang tatahakin. Sinuri ko ang marami sa iba pang mga driver ng LED matrix na nakabatay sa Arduino. Habang tiyak na may mabubuting mga driver na magagamit, wala sa disenyo na nais ko. Ang aking mga layunin sa disenyo ng driver ay:

• Magbigay ng isang mataas na antas na API upang makapag-program na lumikha ng mga imahe at mga animasyon. Karamihan sa mga driver na nakita ko ay higit na nakatuon sa mga hard-code na imahe. Gayundin, dahil ako ay isang C ++ programmer sa pamamagitan ng kalakalan, nais kong gumamit ng mahusay na disenyo na nakatuon sa object upang ipatupad at pamahalaan ang mga aktibidad ng pagguhit sa LED matrix.
• Gumamit ng isang dobleng buffered na diskarte upang pamahalaan ang imahe sa screen. Ang isang buffer ay kung ano ang nakuha sa programmatically na iginuhit, habang ang iba ay kumakatawan sa estado ng mga matrix pixel sa anumang naibigay na sandali. Ang bentahe ng pamamaraang ito ay hindi ka kinakailangan na ganap na i-render ang susunod na pag-update ng frame para sa screen sa pagitan ng mga pag-update ng cycle ng multiplexing.
• Gumamit ng PWM upang payagan ang higit sa pitong mga primitive na kulay na maaaring i-render ng isang RGB sa pamamagitan ng simpleng mga kumbinasyon ng pula, berde, at asul na mga elemento.
• Isulat ang drayber na tulad nito "gagana" lamang sa iba't ibang laki ng RGB LED matrices na sumunod sa aking pangkalahatang diskarte sa disenyo ng matrix. Tandaan na habang ang aking disenyo ng hardware ay gumagamit ng mga rehistro ng shift na 74HC595, inaasahan kong gumana ang aking driver sa anumang istilo ng shift register sa / off na mekanismo na inilatag gamit ang isang katulad na layout ng bit ng aking disenyo ng hardware. Halimbawa, inaasahan kong gumana ang aking driver sa isang disenyo ng hardware na gumamit ng mga chips ng DM13A upang makontrol ang mga haligi at isang chip na 74HC595 upang makontrol ang mga hilera.

Kung nais mong dumiretso sa pagtingin sa driver code, maaari mo itong makita sa GitHub dito.

Ang unang pag-ulit ng aking driver ay isang kaunting kurba sa pag-aaral sa mga kakayahan ng platform ng Arduino. Ang pinaka-halata na limitasyon ay ang RAM, na kung saan ay 2 bytes para sa Arduino Uno at Nano. Ang paggamit ng mga bagay na C ++ sa gayong senaryo ay madalas na hindi pinapayuhan dahil sa overhead ng memorya ng mga bagay. Gayunpaman, naramdaman ko kung tama ang nagawa, ang pakinabang ng mga bagay sa C ++ ay mas malaki kaysa sa kanilang gastos (sa RAM).

Ang pangalawang pangunahing hamon ay ang pag-uunawa sa amin kung paano ipatupad ang pulso-lapad na modulasyon sa pamamagitan ng mga rehistro ng paglilipat upang makagawa ako ng higit sa pitong mga primitive na kulay ng RGB LED. Ang pagkakaroon ng naka-program sa loob ng maraming taon sa mga platform ng Linux, nasanay ako na gumagamit ng mga konstruksyon tulad ng mga thread upang pamahalaan ang mga proseso na nangangailangan ng pare-parehong tiyempo. Ang oras ng operasyon ng pag-update ng rehistro ng shift ay nagtatapos na maging kritikal kapag gumagawa ng isang driver para sa isang LED matrix na gumagamit ng multiplexing. Ang dahilan ng pagiging ay kahit na ang multiplexing ay nangyayari nang napakabilis na hindi makita ng iyong mga mata ang mga indibidwal na LED na kumikislap at naka-off, ang iyong mga ayes ay maaaring pumili ng mga pagkakaiba sa kabuuang oras ng pinagsama-sama na naka-on ang alinman sa mga LED. Kung ang isang hilera ng LEDs ay tuloy-tuloy na sa para sa isang mas mahabang tagal ng oras kaysa sa iba, ito ay magiging mas maliwanag sa panahon ng multiplexing. Maaari itong humantong sa hindi pantay na ningning sa matrix o pana-panahong pag-strobing ng matrix bilang isang kabuuan (nangyayari ito kapag mas matagal ang isang pag-update kaysa sa iba pa).

Dahil kailangan ko ng pare-parehong mekanismo ng tiyempo upang maging pahintulot ang mga pagrehistro ng shift, ngunit ang Arduino ay hindi pormal na sumusuporta sa thread, kinailangan kong lumikha ng aking sariling mekanismo na tulad ng pag-thread. Ang aking unang pag-ulit nito ay upang lumikha lamang ng isang loop timer na nakasalalay sa pagpapaandar ng Arduino loop () at magpapagana ng isang aksyon kapag ang isang isang tiyak na dami ng oras ay lumipas mula noong huling oras na ang aksyon ay natanggal. Ito ay isang form ng "kooperatiba multitasking". Mabuti ang tunog ngunit sa pagsasagawa ay napatunayan nito na hindi pantay kapag sinukat ang rate ng pagpapaputok sa mga microsecond. Ang dahilan para dito ay kung mayroon akong dalawa sa mga loop timer na ito na pupunta, ang isa sa kanilang mga aksyon ay madalas na tumagal ng sapat upang magdulot ng pangalawang aksyon upang masunog kaysa sa nais.

Nalaman ko na ang solusyon sa problemang ito ay ang paggamit ng mekanismo ng katutubong relo ng Arduino. Pinapayagan ka ng mekanismong ito na magpatakbo ng isang maliit na code sa mga pare-pareho na agwat. Kaya dinisenyo ko ang driver code sa paligid ng elemento ng disenyo ng paggamit ng isang orasan makagambala upang ma-trigger ang code para sa pagpapadala ng paglilipat ng matrix ng rehistro sa susunod na pag-update sa multiplex cycle. Upang magawa ito at pahintulutan ang mga pag-update na maganap sa imahe ng screen upang hindi makagambala sa isang aktibong pagtapon sa mga rehistro ng shift (isang bagay na tatawagin namin na isang "kundisyon ng lahi"), gumamit ako ng isang diskarte sa pagkakaroon ng mga kambal buffer para sa shift register bits, isa para sa pagsusulat at isa para sa pagbabasa. Kapag ang gumagamit ay ina-update ang imahe ng matrix, ang mga pagpapatakbo na ito ay nangyayari sa pagsulat buffer. Kapag nakumpleto ang mga pagpapatakbo na iyon, pansamantalang nasuspinde ang mga pagkagambala (nangangahulugan ito na ang paggambala ng orasan ay hindi maaaring mag-apoy) at ang buffer ng pagsulat ay napalitan ng nakaraang nabasa na buffer at hindi ito ang bagong nabasa na buffer, kung gayon ang mga interpret ay muling pinagana. Pagkatapos, kapag ang orasan ay nakakagambala sa apoy na nagpapahiwatig na oras na upang ipadala ang susunod na pagsasaayos ng bit sa mga rehistro ng shift, ang impormasyong iyon ay nabasa mula sa kasalukuyang nabasa na buffer. Sa ganitong paraan, walang pagsulat na naganap sa isang buffer na maaaring kasalukuyang binabasa mula sa isang oras na nakakagambala, na maaaring masira ang impormasyong ipinadala sa mga rehistro ng shift.

Ang pagdidisenyo ng natitirang driver ay isang direktang kaso ng disenyo na nakatuon sa object. Halimbawa, lumikha ako ng isang bagay upang pamahalaan ang shift register bit na imahe para sa anumang naibigay na estado ng screen. Sa pamamagitan ng pag-encapsulate ng code na nauugnay sa pamamahala ng kaunting imahe, ang paglikha ng nabanggit na kambal na mga buffer na diskarte ay isang direktang ehersisyo. Ngunit hindi ko ito isinulat na Makatuturo upang maitaas ang mga birtud ng disenyo na nakatuon sa object. Ang iba pang elemento ng disenyo ay may kasamang konsepto ng isang Glyph at isang RGB Image. Ang Glyph ay isang pangunahing pagbuo ng imahe na walang likas na impormasyon sa kulay. Maaari mong isipin ito bilang isang itim at puting imahe. Kapag ang Glyph ay iginuhit sa LED screen, ang impormasyon sa kulay ay ibinibigay upang ipahiwatig kung paano dapat kulay ang "puting" mga pixel. Ang isang RGB Image ay isang imahe kung saan ang bawat pixel ay mayroong sariling impormasyon sa kulay.

Hinihimok ko kayo na suriin ang mga halimbawa ng sketch ng Arduino at suriin ang dokumentasyon ng header ng driver upang maging pamilyar sa kung paano gamitin ang driver upang lumikha ng mga imahe at mga animasyon sa isang RGB LED matrix.

Hakbang 4: LED Ghosting

Sa isang LED matrix, ang "ghosting" ay ang kababalaghan ng isang LED sa matrix na kumikinang kapag hindi ito ninanais, karaniwang isang napakababang antas. Ang aking orihinal na disenyo ng hardware ay madaling kapitan sa ghosting, higit sa lahat sa huling hilera. Ang sanhi nito ay dahil sa dalawang bagay: ang mga transistor ay hindi kaagad na patayin at parasitiko capacitance sa RGB LEDs.

Tulad ng pag-scan namin sa mga hilera, dahil sa ang katunayan na ang mga transistor ay hindi kaagad naka-off, ang naunang hilera sa ikot ng pag-scan ay bahagyang pinapagana pa rin kapag na-on ang susunod na hilera. Kung ang isang naibigay na haligi na naka-off sa naunang hilera ay bagong pag-on kapag ang bagong hilera ay pinalakas, ang LED ng haligi na iyon sa naunang hilera ay mamula sa isang maliit na habang habang ang switching transistor ng naunang hilera ay nasa proseso pa rin ng pag-on off Ang nagiging sanhi ng transistor na kumuha ng isang kapansin-pansin na dami ng oras upang patayin ay saturation sa base ng transistor. Ito ay sanhi ng transistor collector-emiter path na magpatuloy sa pag-uugali kapag ang kasalukuyang tinanggal mula sa base, kahit na hanggang sa mawala ang saturation. Dahil sa aming multiplexing cycle ng pag-update ay nagdudulot ng mga hilera na sadyang nasa para sa tagal ng oras na sinusukat sa microseconds, ang dami ng oras na ang saturated transistor ng naunang hilera ay maaaring maging isang kapansin-pansin na bahagi nito. Bilang isang resulta, mahahalata ng iyong mata ang napakaliit na oras ng oras na nakabukas ang naunang LED na hilera.

Upang ayusin ang problema sa saturation ng transistor, ang isang Schottky diode ay maaaring idagdag sa transistor sa pagitan ng base at ng kolektor upang maging sanhi ng kaunting kasalukuyang pabalik sa base kapag nakabukas ang transistor, pinipigilan ang transistor na maging saturated. Ito naman ang magiging sanhi ng transistor upang mas mabilis na patayin kapag ang kasalukuyang tinanggal mula sa base. Tingnan ang artikulong ito para sa isang malalim na paliwanag ng epektong ito. Tulad ng nakikita mo mula sa larawan sa seksyong ito, nang walang diode ang ghosting ay kapansin-pansin, ngunit ang pagdaragdag ng diode sa circuit para sa bawat hilera ay makabuluhang tinanggal ang ghosting.

Ang mga RGB LEDs ay madaling kapitan sa isa pang kababalaghan na tinatawag na parasitiko na kapasidad. Ang pangunahing sanhi nito ay ang katunayan na ang bawat isa sa tatlong mga kulay ng LED sa RGB LED unit bawat isa ay may iba't ibang mga voltages sa pasulong. Ang pagkakaiba-iba sa mga pasulong na voltages ay maaaring maging sanhi ng epekto ng de-koryenteng kapasidad sa pagitan ng bawat isa sa mga indibidwal na mga kulay na LED. Dahil ang isang singil na elektrikal ay naitayo sa LED unit kapag pinapatakbo, kapag ang lakas ay tinanggal, ang parasitiko capacitance ay kailangang maalis. Kung ang LED na haligi ay sa kabilang banda ay para sa paggana ng isa pang hilera, ang singil ng parasitiko ay lalabas sa pamamagitan ng mga haligi na LED at maging sanhi ito upang mamula ng maikling. Ang epektong ito ay ipinaliwanag nang maayos sa artikulong ito. Ang solusyon ay upang magdagdag ng isang landas ng paglabas para sa pagsingil ng parasitiko na ito bukod sa pamamagitan ng LED mismo, at pagkatapos ay bigyan ang oras ng LED upang maalis bago muling mapagana ang haligi. Sa aking disenyo ng hardware, nagagawa ito sa pamamagitan ng pagdaragdag ng isang risistor sa linya ng kuryente ng bawat hilera na nag-uugnay sa lakas sa lupa. Magdudulot ito ng mas maraming kasalukuyang iguhit gamit ang hilera na pinapagana, ngunit nagbibigay ng isang landas ng paglabas para sa capacitance ng parasitiko kapag hindi pinalakas ang hilera.

Gayunpaman, mahalagang tandaan na sa pagsasagawa ay nahanap ko ang epekto ng kapasidad ng parasitiko na maging halos hindi kapansin-pansin (kung hahanapin mo ito, mahahanap mo ito), at sa gayon ay isasaalang-alang ko ang pagdaragdag ng labis na risistor na ito upang maging opsyonal. Ang epekto ng mabagal na oras para sa mga puspos na transistors ay isang mas malakas at kapansin-pansin. Gayunpaman, kung susuriin mo ang tatlong mga larawang ibinigay sa seksyong ito, maaari mong makita na ang mga resistor ay ganap na aalisin ang anumang ghosting na nangyayari pa rin na lampas sa mabagal na transistor sa mga oras.

Hakbang 5: Pangwakas na Paggawa at Mga Susunod na Hakbang

Ang huling yugto ng proyektong ito ay para sa akin upang lumikha ng isang naka-print na circuit board (PCB). Ginamit ko ang bukas na mapagkukunang programa na Fritzing upang idisenyo ang aking PCB. Habang mayroong maraming mga paulit-ulit na gawain upang makamit sa layout ng 100 LEDs sa isang 10x10 board, talagang natagpuan ko ang yugtong ito ng proyekto na kakaibang nasiyahan. Ang pag-alam kung paano ilalagay ang bawat linya ng elektrisidad ay tulad ng isang palaisipan, at ang paglutas sa palaisipan na iyon ay lumikha ng isang pakiramdam ng tagumpay. Dahil hindi ako naka-set up upang makagawa ng mga circuit board, ginamit ko ang isa sa maraming mga mapagkukunan sa online na gumagawa ng maliit na pagpapatakbo ng pasadyang PCB. Ang paghihinang ng mga bahagi nang magkakasama ay medyo tuwid pasulong dahil ginamit ng aking disenyo ang lahat ng mga bahagi na butas.

Sa oras ng pagsulat ng Instructable na ito, mayroon akong mga sumusunod na plano para sa aking aking mga proyekto sa RGB LED Matrix:

1. Patuloy na pagbutihin ang driver sa layer ng API upang paganahin ang higit na mataas na antas na pag-andar sa programmer, lalo na ang pag-scroll sa teksto.
2. Lumikha ng mas malaking mga disenyo ng matrix, tulad ng 16x16 o kahit 16x32.
3. Galugarin ang paggamit ng MOSFETs sa halip na BJTs para sa switch ng power row
4. Galugarin ang paggamit ng DM13As pare-pareho ang kasalukuyang mga driver kaysa sa 74HC595s para sa paglipat ng haligi
5. Lumikha ng mga driver para sa iba pang mga micro control platform, tulad ng Teensy, ODROID C2, o Raspberry Pi.

Tandaan na ang parehong disenyo ng hardware at driver ay pinakawalan sa ilalim ng lisensya ng open source ng GPL v3 sa GitHub repository na ito. Bukod dito, dahil kahit na ang paggawa ng PCB ay "maliit na nagpapatakbo" ng aking disenyo ng PCB, nakakakuha pa rin ako ng higit sa aking personal na kailangan. Kaya't nagbebenta ako ng buong mga kit para sa aking iba't ibang mga disenyo ng RGB LED matrix (kasama ang PCB at lahat ng mga bahagi) mula sa aking website dito.