Pema spirale LED: 4 hapa (me fotografi)

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:10

I dua të gjitha llojet e shiritave LED. Unë bëra një dritë të bukur ylberi me ta. Edhe ato që nuk adresohen janë të dobishme. Unë kam bërë një ombrellë të ndritshme të dritës së jashtme duke i bashkangjitur në brinjët unbrella kështu që kur pema ime spirale shpërtheu vendosa të mbyll një gjatësi të shiritit led rreth tij.

Hapi 1: Kontrolluesi

Vendosa të përdor led të RGB të pa adresuar. Kjo do të thotë që unë mund të kem një efekt të programuar, por të gjitha dritat ndryshojnë ngjyrën njëkohësisht. Kjo gjithashtu do të thotë që do të nevojitet një kontrollues. Unë mund të kisha përdorur një arduino uno dhe bëra për të bërë testet fillestare duke përdorur një mburojë RGB, por përfundova duke përdorur një tabelë të vetme të personalizuar me një çip të zhveshur Atmega328. Thjesht duhej të ndërronte programuesin e synuar dhe të programonte çipin drejtpërdrejt.

Kisha shumë nga këto dërrasa të mbetura nga projektet e tjera të llambave. Mos ngurroni të përdorni një kontrollues të lirë të paraprogramuar në linjë, siç bëra në ombrellën time.

Përfundova duke përdorur një demonstrim të ngadaltë të kryqëzimit si bazë për pemën.

/** Kodi për zbehjen e 3 LED-ve, të kuqe, jeshile dhe blu (RGB) * Për të krijuar zbehje, duhet të bëni dy gjëra: * 1. Përshkruani ngjyrat që dëshironi të shfaqen * 2. Listoni rendin që dëshironi ato të zbehen në * * PESRSHKRIMI I NGJYRS: * Ngjyra është vetëm një grup prej tre përqindësh, 0-100, * duke kontrolluar LED-të e kuqe, jeshile dhe blu * * E kuqja është LED e kuqe plotësisht, blu dhe jeshile e fikur * int e kuqe = {100, 0, 0} * E bardha e zbehtë është të tre LED në 30% * int dimWhite = {30, 30, 30} * etj. * * Disa ngjyra të zakonshme janë dhënë më poshtë, ose bëni tuajat * * LISTING THE POROSIA: * Në pjesën kryesore të programit, duhet të rendisni rendin * në të cilin dëshironi të shfaqen ngjyrat, p.sh. * crossFade (e kuqe); * crossFade (jeshile); * crossFade (blu); * * Ato ngjyra do të shfaqen në atë renditje, duke u zbehur nga * një ngjyrë dhe në tjetrën * * Përveç kësaj, ka 5 cilësime opsionale që mund të rregulloni: * 1. Ngjyra fillestare është vendosur në të zezë (kështu që ngjyra e parë zbehet in), por * ju mund ta vendosni ngjyrën fillestare të jetë çdo ngjyrë tjetër * 2. Laku i brendshëm funksionon për 1020 integrime; variabla 'prit' * vendos kohëzgjatjen e përafërt të një kryqëzimi të vetëm. Në teori, * një 'pritje' prej 10 ms duhet të bëjë një CrossFade prej ~ 10 sekonda. Në praktikë *, funksionet e tjera që kodi po kryen ngadalë * deri në seconds 11 sekonda në tabelën time. YMMV. * 3. Nëse 'përsërit' është vendosur në 0, programi do të lakohet pafundësisht. * nëse është vendosur në një numër, ai do të bëjë atë numër herë, * pastaj ndalet në ngjyrën e fundit në sekuencë. (Vendosni 'kthimin' në 1, * dhe bëni ngjyrën e fundit të zezë nëse dëshironi që ajo të zbehet në fund.) * 4. Ekziston një ndryshore opsionale 'mbaj', e cila kalon programin * për 'mbaj' milisekonda kur një ngjyrë është e plotë, * por para se të fillojë ngjyra tjetër. * 5. Vendosni flamurin DEBUG në 1 nëse dëshironi që dalja e korrigjimit të dërgohet * në monitorin serik. * * Pjesët e brendshme të programit nuk janë të komplikuara, por ato * janë pak të bezdisshme - punimet e brendshme shpjegohen * poshtë lakut kryesor. * * Prill 2007, Clay Shirky *

/ Dalja

int grnPin = 9; // LED i gjelbër, i lidhur me pinin dixhital 10 int redPin = 10; // LED i kuq, i lidhur me pinin dixhital 9 int bluPin = 11; // LED blu, i lidhur me pinin dixhital 11

// Vargjet e ngjyrave

int e zezë [3] = {0, 0, 0}; int e bardhë [3] = {100, 100, 100}; int e kuqe [3] = {100, 0, 0}; int jeshile [3] = {0, 100, 0}; int blu [3] = {0, 0, 100}; int verdhë [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // etj

// Vendosni ngjyrën fillestare

int redVal = e zezë [0]; int grnVal = e zezë [1]; int bluVal = e zezë [2];

int pres = 3; // 10ms vonesë e brendshme crossFade; rritet për zbehje më të ngadalta

int mbaj = 0; // Mbaj opsionale kur një ngjyrë është e plotë, para kryqëzimit të ardhshëm int DEBUG = 0; // sportel DEBUG; nëse vendoset në 1, do të shkruajë vlerat përsëri përmes serisë int loopCount = 60; // Sa shpesh duhet të raportojë DEBUG? int përsëris = 0; // Sa herë duhet të bëjmë lak para se të ndalojmë? (0 pa ndalesë) int j = 0; // Numëruesi i lakut për përsëritje

// Filloni variablat e ngjyrave

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

// Vendosni daljet LED

void setup () {pinMode (redPin, OUTPUT); // vendos kunjat si pinMode dalëse (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

nëse (DEBUG) {// Nëse duam të shohim vlera për korrigjim…

Serial.filloj (9600); //… konfiguroni daljen serike}}

// Programi kryesor: rendit rendin e kryqëzimeve

void loop () {crossFade (e kuqe); crossFade (jeshile); crossFade (blu); crossFade (e verdhë);

nëse (përsëris) {// A lakojmë një numër të kufizuar herë?

j += 1; nëse (j> = përsëris) {// A jemi akoma atje? dalja (j); // Nëse po, ndalo. }}}

/* Poshtë KJO RREGULLI ISSHT MATA - NUK DUHET TT NDRYSHME T TO NDRYSHOJM TH KT P FORR BAZAT

* * Programi funksionon kështu: * Imagjinoni një kryqëzim që lëviz LED të kuq nga 0-10, * të gjelbër nga 0-5 dhe blu nga 10 në 7, në * dhjetë hapa. * Ne do të donim të numëronim 10 hapat dhe të rrisnim ose * ulnim vlerat e ngjyrave në rritje të barabarta. * Imagjinoni a + tregon ngritjen e një vlere me 1, dhe a - * është e barabartë me uljen e saj. Zbehja jonë me 10 hapa do të duket si: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + + G + + + + + * * B - - - * * E kuqja ngrihet nga 0 në 10 në dhjetë hapa, jeshilja nga * 0-5 në 5 hapa, dhe bluja bie nga 10 në 7 në tre hapa. * * Në programin real, përqindjet e ngjyrave konvertohen në vlerat * 0-255, dhe ka 1020 hapa (255 * 4). * * Për të kuptuar se sa i madh duhet të jetë një hap midis një shënimi lart ose * poshtë të njërës prej vlerave LED, ne e quajmë calcStep (), * i cili llogarit hendekun absolut midis vlerave të fillimit dhe mbarimit, * dhe pastaj e ndan atë hendek me 1020 për të përcaktuar madhësinë e hapit * midis rregullimeve në vlerë. */

int calcStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Cili është hendeku i përgjithshëm? nëse (hapi) {// Nëse është jo-zero, hapi = 1020/hap; // ndaj me 1020} hapin e kthimit; }

/* Funksioni tjetër është CalcVal. Kur vlera e lakut, unë, * arrin madhësinë e hapit të përshtatshëm për njërën nga ngjyrat *, rrit ose zvogëlon vlerën e asaj ngjyre me 1. * (R, G dhe B llogariten secila veç e veç.) */

int calcVal (hapi int, int val, int i) {

nëse ((hapi) && i % hap == 0) {// Nëse hapi është jo-zero dhe koha e tij për të ndryshuar një vlerë, nëse (hapi> 0) {// shtoni vlerën nëse hapi është pozitiv… val += 1; } tjetër nëse (hapi 255) {val = 255; } tjetër nëse (val <0) {val = 0; } valvula e kthimit; }

/* crossFade () konverton përqindjen e ngjyrave në a

* Gama 0-255, pastaj sythe 1020 herë, duke kontrolluar nëse * vlera duhet të përditësohet çdo herë, pastaj shkruani * vlerat e ngjyrës në kunjat e sakta. */

void crossFade (ngjyra int [3]) {

// Shndërrohuni në 0-255 int R = (ngjyra [0] * 255) / 100; int G = (ngjyra [1] * 255) / 100; int B = (ngjyra [2] * 255) / 100;

int stepR = llogaris hapin (prevR, R);

int stepG = llogaris hapin (prevG, G); int hapB = llogaris hapin (prevB, B);

për (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = llogaris Val (stepG, grnVal, i); bluVal = llogaritVal (stepB, bluVal, i);

analogWrite (redPin, redVal); // Shkruani vlerat aktuale në kunjat LED

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

vonesë (pritje); // Ndalo për 'prit' milisekonda para se të rifillosh ciklin

if (DEBUG) {// Nëse duam dalje serike, shtypeni atë në

if (i == 0 ose i % loopCount == 0) {// fillim, dhe çdo loopCount herë Serial.print ("Loop/RGB: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print (" /"); Serial.print (grnVal); Serial.print (" /"); Serial.println (bluVal); } DEBUG += 1; }} // Përditësoni vlerat aktuale për lakun tjetër prevR = redVal; prevG = grnVal; prevB = bluVal; vonesë (mbaj); // Pusho për 'pritjen' opsionale milisekonda para se të rifillosh ciklin}

Hapi 2: Mbështjellja e pemës

Kam përdorur shirita të papërshkueshëm nga uji pasi këto do të jenë jashtë. Ata u ngjitën vetë, por unë shpejt ndoqa lidhjet me tela për t'u siguruar që ata të qëndrojnë të vendosur. Hack i thjeshtë dhe i lehtë. Aftësia e fuqisë së përgjithshme të shiritit e bëri të lehtë furnizimin me energji elektrike në pjesën e poshtme dhe marrjen e energjisë nga maja në yll.

Hapi 3: Mos harroni yllin në krye

Për yllin kam përdorur një palë patate të skuqura 10W për të tërhequr vëmendjen. I bashkova në një fletë bakri si një ngrohës nxehtësie. Mund të kisha përdorur më shumë shirit pasi kishte mbetur pak.

Hapi 4: Provoni

Përpjekja e parë kishte shpejtësinë shumë të shpejtë….

Pasi e qetësova, dukej shumë mirë.