Arborele spiralat LED: 4 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

Ador tot felul de benzi LED. Am făcut cu ei o lumină curcubeu drăguță. Chiar și cele care nu sunt adresabile sunt utile. Am realizat o umbrelă strălucitoare de lumină în aer liber, atașându-le de coastele unbrella, așa că, când arborele meu spiralat a suflat, am decis să înfășor o lungime de bandă led în jurul său.

Pasul 1: Controler

Am decis să folosesc leduri RGB neadresabile. Aceasta înseamnă că pot avea un efect programat, dar toate ledurile își schimbă culoarea simultan. Aceasta înseamnă, de asemenea, că va fi nevoie de un controler. Aș fi putut folosi un arduino uno și am făcut pentru a face testele inițiale folosind un scut RGB, dar am ajuns să folosesc o singură placă personalizată cu un cip Atmega328 gol. Trebuia doar să comutați programatorul țintă și să programați cipul direct.

Mi-au rămas destule plăci din alte proiecte de lampă. Simțiți-vă liber să utilizați un controller preprogramat ieftin în linie, așa cum am făcut pe umbrela mea.

Am ajuns să folosesc un demo încetinit încrucișat ca bază pentru copac.

/ ** Cod pentru decolorarea încrucișată a 3 LED-uri, roșu, verde și albastru (RGB) * Pentru a crea decolorări, trebuie să faceți două lucruri: * 1. Descrieți culorile pe care doriți să le afișați * 2. Enumerați ordinea dorită să se estompeze în * * DESCRIEREA O CULOARE: * O culoare este doar o matrice de trei procente, 0-100, * controlul LED-urilor roșii, verzi și albastre * * Roșu este LED-ul roșu la maxim, albastru și verde oprit * int roșu = {100, 0, 0} * Dim alb este toate cele trei LED-uri la 30% * int dimWhite = {30, 30, 30} * etc. * * Câteva culori obișnuite sunt furnizate mai jos sau creați-vă propriile * * LISTA COMANDĂ: * În partea principală a programului, trebuie să listați ordinea * în care doriți să apară culorile, de ex. * crossFade (roșu); * crossFade (verde); * crossFade (albastru); * * Aceste culori vor apărea în această ordine, decolorându-se din * o culoare și în următoarea * * În plus, există 5 setări opționale pe care le puteți regla: * 1. Culoarea inițială este setată la negru (deci prima culoare se estompează) în), dar * puteți seta culoarea inițială să fie orice altă culoare * 2. Bucla internă rulează pentru 1020 de interacțiuni; variabila „așteptați” * setează durata aproximativă a unei singure decolorări încrucișate. În teorie, * o „așteptare” de 10 ms ar trebui să facă un crossFade de ~ 10 secunde. În * practică, celelalte funcții pe care le execută codul încetinesc acest * până la ~ 11 secunde pe placa mea. YMMV. * 3. Dacă „Repetare” este setat la 0, programul va rula la nesfârșit. * dacă este setat la un număr, se va bucla de acel număr de ori, * apoi se va opri pe ultima culoare din secvență. (Setați „return” la 1, * și faceți ultima culoare neagră dacă doriți să se estompeze la sfârșit.) * 4. Există o variabilă opțională „hold”, care stabilește programul * pentru „hold” milisecunde când o culoare este completă, * dar înainte de a începe următoarea culoare. * 5. Setați semnalizatorul DEBUG la 1 dacă doriți ca ieșirea de depanare să fie * trimisă la monitorul serial. * * Internele programului nu sunt complicate, dar sunt * puțin cam agitate - funcționarea interioară este explicată * sub bucla principală. * * Aprilie 2007, Clay Shirky *

/ Ieșire

int grnPin = 9; // LED verde, conectat la pinul digital 10 int redPin = 10; // LED roșu, conectat la pinul digital 9 int bluPin = 11; // LED albastru, conectat la pinul digital 11

// Tablouri de culori

int negru [3] = {0, 0, 0}; alb alb [3] = {100, 100, 100}; roșu int [3] = {100, 0, 0}; int verde [3] = {0, 100, 0}; albastru int [3] = {0, 0, 100}; galben int [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // etc.

// Setați culoarea inițială

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

int wait = 3; // 10 ms întârziere internă de decolorare încrucișată; crește pentru estompări mai lente

int hold = 0; // Țineți opțional când o culoare este completă, înainte de următorul crossFade int DEBUG = 0; // contor DEBUG; dacă este setat la 1, va scrie valori înapoi prin serial int loopCount = 60; // Cât de des ar trebui să raporteze DEBUG? int repeat = 0; // De câte ori ar trebui să facem o buclă înainte de oprire? (0 pentru fără oprire) int j = 0; // Contor buclă pentru repetare

// Inițializați variabilele de culoare

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

// Configurați ieșirile LED

setare nulă () {pinMode (redPin, OUTPUT); // setează pinii ca pinMode de ieșire (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

if (DEBUG) {// Dacă vrem să vedem valori pentru depanare …

Serial.begin (9600); // … configurați ieșirea serial}}

// Programul principal: listează ordinea decolorărilor încrucișate

bucla void () {crossFade (roșu); crossFade (verde); crossFade (albastru); crossFade (galben);

if (repetare) {// Buclăm un număr finit de ori?

j + = 1; if (j> = repeat) {// Suntem deja acolo? ieșire (j); // Dacă da, oprește-te. }}}

/ * MAI MULTE ACEASTA LINIE ESTE MATEMATICA - NU TREBUIE SĂ FIȚI NECESAR DE A SCHIMBA ACESTA PENTRU BAZE

* * Programul funcționează astfel: * Imaginați-vă o decolorare încrucișată care mută LED-ul roșu de la 0-10, * verde de la 0-5 și albastru de la 10 la 7, în * zece pași. * Am dori să numărăm cei 10 pași și să creștem sau * să reducem valorile culorilor în trepte uniform. * Imaginați-vă că un + indică creșterea unei valori cu 1, iar a - * este egal cu scăderea acesteia. Fade-ul nostru în 10 pași ar arăta astfel: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + + * G + + + + + * B - - - * * Roșu crește din De la 0 la 10 în zece pași, verde de la * 0-5 în 5 pași, iar albastrul cade de la 10 la 7 în trei pași. * * În programul real, procentele de culoare sunt convertite în valori * 0-255 și există 1020 de pași (255 * 4). * * Pentru a afla cât de mare ar trebui să existe un pas între o bifare în sus sau în jos a uneia dintre valorile LED-ului, numim calculateStep (), * care calculează decalajul absolut între valorile de început și de sfârșit, * și apoi împarte acest decalaj la 1020 pentru a determina mărimea pasului * între ajustările valorii. * /

int calculateStep (int Prevalor, int Valoare final) {

int step = endValue - prevValue; // Care este decalajul general? if (step) {// Dacă este diferit de zero, step = 1020 / step; // împărțiți la 1020} pas de întoarcere; }

/ * Următoarea funcție este calculateVal. Când valoarea buclei, i, * atinge dimensiunea pasului adecvată pentru una dintre * culorile, crește sau scade valoarea acelei culori cu 1. * (R, G și B sunt calculate fiecare separat.) * /

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

if ((pas) && i% step == 0) {// Dacă pasul este diferit de zero și este timpul să modificați o valoare, if (pas> 0) {// crește valoarea dacă pasul este pozitiv … val + = 1; } else if (pasul 255) {val = 255; } else if (val <0) {val = 0; } return val; }

/ * crossFade () convertește procentul de culori în a

* Interval 0-255, apoi bucle de 1020 de ori, verificând dacă * valoarea trebuie actualizată de fiecare dată, apoi scriind * valorile culorilor pe pinii corecți. * /

void crossFade (int color [3]) {

// Conversia la 0-255 int R = (culoare [0] * 255) / 100; int G = (culoare [1] * 255) / 100; int B = (culoare [2] * 255) / 100;

int stepR = calculateStep (prevR, R);

int stepG = calculateStep (prevG, G); int pasul B = calculateStep (prevB, B);

for (int i = 0; i <= 1020; i ++) {redVal = calculateVal (stepR, redVal, i); grnVal = calculateVal (stepG, grnVal, i); bluVal = calculateVal (stepB, bluVal, i);

analogWrite (redPin, redVal); // Scrieți valorile curente pe pinii LED

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

întârziere (așteptați); // Întrerupeți „așteptați” milisecunde înainte de a relua bucla

if (DEBUG) {// Dacă dorim ieșire serială, tipăriți-o la

if (i == 0 sau i% loopCount == 0) {// început și fiecare loopCount ori Serial.print ("Buclă / RGB: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print ("/"); Serial.print (grnVal); Serial.print ("/"); Serial.println (bluVal); } DEBUG + = 1; }} // Actualizați valorile curente pentru următoarea buclă prevR = redVal; prevG = grnVal; prevB = bluVal; întârziere (menținere); // Pauză pentru opțiunea „așteptați” în milisecunde înainte de a relua bucla}

Pasul 2: Înfășurarea copacului

Am folosit benzi impermeabile, deoarece acestea vor fi în aer liber. Au rămas singuri, dar am urmărit rapid cu legături de sârmă pentru a mă asigura că rămân pe loc. Hack simplu și ușor. Capacitatea de alimentare a benzii a facilitat alimentarea sursei de energie în partea inferioară și scoaterea energiei de sus către stea.

Pasul 3: Nu uitați de stea deasupra

Pentru vedetă am folosit o pereche de cipuri de 10W pentru a atrage atenția. Le-am lipit pe o foaie de cupru ca radiator. Aș fi putut folosi mai multe benzi, deoarece mai rămăsese puțin.

Pasul 4: Încercați-l

Prima încercare a avut viteza mult prea rapidă …

Odată ce l-am calmat, a arătat destul de bine.