LED Spiral Tree: 4 Hakbang (na may Mga Larawan)

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

Gustung-gusto ko ang lahat ng mga uri ng mga LED strip. Gumawa ako ng isang magandang ilaw ng bahaghari sa kanila. Kahit na ang hindi matutugunan ay kapaki-pakinabang. Gumawa ako ng isang maliwanag na merkado ng payong sa labas ng merkado sa pamamagitan ng paglakip sa kanila sa mga unbrella ribs kaya nang pumutok ang aking puno ng spiral nagpasya akong balutin ang isang haba ng led strip sa paligid nito.

Hakbang 1: Controller

Nagpasya akong gumamit ng hindi matugunan na mga RGB leds. Nangangahulugan ito na maaari akong magkaroon ng isang naka-program na epekto ngunit lahat ng mga leds ay nagbabago ng kulay nang sabay-sabay. Nangangahulugan din ito na kailangan ng isang controller. Maaari kong gumamit ng isang arduino uno at ginawa upang gawin ang mga paunang pagsubok gamit ang isang kalasag na RGB ngunit nagtapos sa paggamit ng isang pasadyang solong lupon na may hubad na chip na Atmega328. Kailangan lang ilipat ang target programmer at direktang i-program ang chip.

Marami akong natitirang mga board mula sa iba pang mga proyekto sa lampara. Huwag mag-atubiling gumamit ng isang cheapie inline preprogrammed controller tulad ng ginawa ko sa aking payong sa halip.

Natapos ako gamit ang isang mabagal na demo ng crossfade bilang batayan para sa puno.

/ ** Code para sa cross-fading 3 LEDs, pula, berde at asul (RGB) * Upang lumikha ng fades, kailangan mong gumawa ng dalawang bagay: * 1. Ilarawan ang mga kulay na nais mong ipakita * 2. Ilista ang order na gusto mo ang mga ito upang mawala sa * * DESCRIBING A COLOR: * Ang isang kulay ay isang array lamang ng tatlong porsyento, 0-100, * pagkontrol sa pula, berde at asul na LEDs * * Pula ang pulang LED nang buo, asul at berde na off * int pula = {100, 0, 0} * Ang puting puti ay lahat ng tatlong LED na 30% * int dimWhite = {30, 30, 30} * atbp * * Ang ilang mga karaniwang kulay ay ibinibigay sa ibaba, o gumawa ng iyong sariling * * LISTING THE ORDER: * Sa pangunahing bahagi ng programa, kailangan mong ilista ang pagkakasunud-sunod * na nais mong kulay upang lumitaw, hal * crossFade (pula); * crossFade (berde); * crossFade (asul); * * Ang mga kulay na iyon ay lilitaw sa pagkakasunud-sunod na iyon, kumukupas sa * isang kulay at sa susunod * * Bilang karagdagan, mayroong 5 mga opsyonal na setting na maaari mong ayusin: * 1. Ang paunang kulay ay nakatakda sa itim (kaya't ang unang kulay ay kumukupas sa), ngunit * maaari mong itakda ang paunang kulay upang maging anumang iba pang kulay * 2. Ang panloob na loop ay tumatakbo para sa 1020 mga pakikipag-ugnay; ang variable na 'wait' * ay nagtatakda ng tinatayang tagal ng isang solong crossfade. Sa teorya, ang * isang 'paghihintay' na 10 ms ay dapat gumawa ng isang crossFade na ~ 10 segundo. Sa * pagsasanay, ang iba pang mga pagpapaandar ng code ay gumaganap ng mabagal na ito * pababa sa ~ 11 segundo sa aking board. YMMV. * 3. Kung ang 'ulitin' ay nakatakda sa 0, ang programa ay maiikot nang walang katapusan. * kung ito ay nakatakda sa isang numero, ito ay loop ang bilang ng mga beses, * pagkatapos ay huminto sa huling kulay sa pagkakasunud-sunod. (Itakda ang 'pagbalik' sa 1, * at gawing itim ang huling kulay kung nais mong mawala ito sa huli.) * 4. Mayroong isang opsyonal na variable na 'hold', na kung saan ay ipasa ang * programa para sa 'hold' milliseconds kapag isang kulay ay kumpleto, * ngunit bago magsimula ang susunod na kulay. * 5. Itakda ang DEBUG flag sa 1 kung nais mong i-debug ang output * maipadala sa serial monitor. * * Ang mga panloob na programa ay hindi kumplikado, ngunit ang mga ito * ay isang maliit na fussy - ipinaliwanag ang panloob na paggana * sa ibaba ng pangunahing loop. * * Abril 2007, Clay Shirky *

/ Output

int grnPin = 9; // Green LED, konektado sa digital pin 10 int redPin = 10; // Red LED, konektado sa digital pin 9 int bluPin = 11; // Blue LED, na konektado sa digital pin 11

// Mga array ng kulay

int black [3] = {0, 0, 0}; int white [3] = {100, 100, 100}; int red [3] = {100, 0, 0}; int green [3] = {0, 100, 0}; int blue [3] = {0, 0, 100}; int dilaw [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // atbp.

// Itakda ang paunang kulay

int redVal = itim [0]; int grnVal = itim [1]; int bluVal = itim [2];

int wait = 3; // 10ms panloob na pagkaantala ng crossFade; dagdagan para sa mas mabagal na pagkupas

int hold = 0; // Opsyonal na paghawak kapag ang isang kulay ay kumpleto, bago ang susunod na crossFade int DEBUG = 0; // DEBUG counter; kung nakatakda sa 1, susulat ang mga halaga pabalik sa pamamagitan ng serial int loopCount = 60; // Gaano kadalas dapat mag-ulat ang DEBUG? int ulitin = 0; // Gaano karaming beses dapat tayong mag-loop bago huminto? (0 para walang hihinto) int j = 0; // Loop counter para maulit

// Pinasimulan ang mga variable ng kulay

int prevR = redVal; int prevG = grnVal; int prevB = bluVal;

// I-set up ang mga LED output

void setup () {pinMode (redPin, OUTPUT); // nagtatakda ng mga pin bilang output pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

kung (DEBUG) {// Kung nais naming makita ang mga halaga para sa pag-debug …

Serial.begin (9600); //… i-set up ang serial ouput}}

// Pangunahing programa: ilista ang pagkakasunud-sunod ng mga crossfade

void loop () {crossFade (pula); crossFade (berde); crossFade (asul); crossFade (dilaw);

kung (ulitin) {// Nag-loop ba kami ng isang may hangganan na bilang ng mga beses?

j + = 1; kung (j> = ulitin) {// Nariyan na ba tayo? exit (j); // Kung gayon, huminto. }}}

/ * SA BAWAL NG ITO AY ANG MATH - HINDI MO DAPAT BAGAYIN ITO PARA BASICS

* * Gumagana ang programa tulad nito: * Isipin ang isang crossfade na gumagalaw sa pulang LED mula 0-10, * ang berde mula 0-5, at ang asul mula 10 hanggang 7, sa * sampung mga hakbang. * Nais naming bilangin ang 10 mga hakbang at dagdagan o * bawasan ang mga halaga ng kulay sa pantay na tumaas na mga pagtaas. * Isipin ang isang + nagpapahiwatig ng pagtaas ng isang halaga ng 1, at a - * katumbas ng pagbaba nito. Ang aming 10 step fade ay magiging hitsura ng: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + + * G + + + + + * B - - - * * Ang pula ay tumataas mula sa 0 hanggang 10 sa sampung mga hakbang, ang berde mula * 0-5 sa 5 mga hakbang, at ang asul ay nahuhulog mula 10 hanggang 7 sa tatlong mga hakbang. * * Sa totoong programa, ang mga porsyento ng kulay ay na-convert sa mga halagang * 0-255, at mayroong 1020 mga hakbang (255 * 4). * * Upang malaman kung gaano kalaki ang isang hakbang na dapat mayroong sa pagitan ng isa pataas o * down-tick ng isa sa mga halagang LED, tinatawag naming calculStep (), * na kinakalkula ang ganap na agwat sa pagitan ng mga halaga ng pagsisimula at pagtatapos, * at pagkatapos hinahati ang agwat na iyon ng 1020 upang matukoy ang laki ng hakbang * sa pagitan ng mga pagsasaayos sa halaga. * /

int calculStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Ano ang pangkalahatang puwang? kung (hakbang) {// Kung hindi non-zero, hakbang = 1020 / hakbang; // hatiin ng 1020} hakbang sa pagbabalik; }

/ * Ang susunod na pag-andar ay calculVal. Kapag ang halaga ng loop, i, * naabot ang laki ng hakbang na naaangkop para sa isa sa mga * kulay, pinapataas o binabawasan ang halaga ng kulay na iyon ng 1. * (Ang R, G, at B ay magkakalkula nang magkahiwalay.) * /

int calculVal (int step, int val, int i) {

kung ((hakbang) && i% hakbang == 0) {// Kung ang hakbang ay hindi-zero at oras nito upang baguhin ang isang halaga, kung (hakbang> 0) {// dagdagan ang halaga kung positibo ang hakbang… val + = 1; } iba pa kung (hakbang 255) {val = 255; } iba pa kung (val <0) {val = 0; } bumalik val; }

/ * Ang crossFade () ay nagko-convert ng mga kulay ng porsyento sa a

* Saklaw ng 0-255, pagkatapos ay mga loop ng 1020 beses, suriin upang makita kung * ang halaga ay kailangang i-update sa bawat oras, pagkatapos ay isulat ang * mga halaga ng kulay sa mga tamang pin. * /

void crossFade (int color [3]) {

// convert to 0-255 int R = (color [0] * 255) / 100; int G = (kulay [1] * 255) / 100; int B = (kulay [2] * 255) / 100;

int stepR = calculStep (prevR, R);

int stepG = calculStep (prevG, G); int stepB = calculStep (prevB, B);

para sa (int i = 0; i <= 1020; i ++) {redVal = calculVal (stepR, redVal, i); grnVal = calculVal (stepG, grnVal, i); bluVal = calculVal (stepB, bluVal, i);

analogWrite (redPin, redVal); // Sumulat ng kasalukuyang mga halaga sa mga LED pin

analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal);

antala (maghintay); // I-pause para sa 'wait' milliseconds bago ipagpatuloy ang loop

kung (DEBUG) {// Kung nais namin ng serial output, i-print ito sa

kung (i == 0 o i% loopCount == 0) {// simula, at bawat loopCount beses Serial.print ("Loop / RGB: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print ("/"); Serial.print (grnVal); Serial.print ("/"); Serial.println (bluVal); } DEBUG + = 1; }} // I-update ang kasalukuyang mga halaga para sa susunod na loop prevR = redVal; prevG = grnVal; prevB = bluVal; antalahin (hawakan); // I-pause para sa opsyonal na 'wait' milliseconds bago ipagpatuloy ang loop}

Hakbang 2: Pagbabalot ng Puno

Gumamit ako ng mga hindi tinatagusan ng tubig na piraso dahil ang mga ito ay nasa labas. Dumikit sila sa kanilang sarili ngunit mabilis akong sumunod sa mga kurbatang kurdon upang matiyak na mananatili silang malagay. Simple at madaling pag-hack. Ang kakayahang feed ng kapangyarihan ng strip ng strip ay ginagawang madali upang pakainin ang suplay ng kuryente sa ilalim at mailabas ang kuryente sa tuktok sa bituin.

Hakbang 3: Huwag Kalimutan ang Bituin sa Itaas

Para sa bituin ginamit ko ang isang pares ng 10W chips upang makakuha ng pansin. Inhinang ko ang mga ito sa isang sheet ng tanso bilang isang heatsink. Maaari akong gumamit ng higit pang strip dahil may kaunting natira.

Hakbang 4: Sinusubukan Ito

Ang unang pagsubok ay nagkaroon ng bilis na masyadong mabilis ….

Kapag pinakalma ko ito mukhang maganda ito.