LED -spiraltræ: 4 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

Jeg elsker alle slags LED -strips. Jeg lavede et fint regnbuelys med dem. Selv de ikke -adresserbare er nyttige. Jeg har lavet et lyst marked paraply udendørs lys ved at fastgøre dem til paraplyribberne, så da mit spiraltræ blæste ud, besluttede jeg at vikle en længde ledstrimmel rundt om det.

Trin 1: Controller

Jeg besluttede at bruge ikke-adresserbare RGB-lysdioder. Det betyder, at jeg kan have en programmeret effekt, men alle lysdioder skifter farve samtidigt. Dette betyder også, at en controller vil være nødvendig. Jeg kunne have brugt en arduino uno og lavede de første tests ved hjælp af et RGB -skjold, men endte med at bruge et brugerdefineret enkelt bord med en bar Atmega328 -chip. Var bare nødt til at skifte målprogrammerer og programmere chippen direkte.

Jeg havde masser af disse tavler tilovers fra andre lampeprojekter. Brug gerne en cheapie inline forprogrammeret controller som jeg gjorde på min paraply i stedet.

Jeg endte med at bruge en langsom crossfade -demo som base for træet.

/** Kode til krydsfading 3 lysdioder, rød, grøn og blå (RGB) * For at oprette fades skal du gøre to ting: * 1. Beskriv de farver, du vil have vist * 2. Angiv den ønskede rækkefølge dem til at falme i * * BESKRIVELSE AF EN FARVE: * En farve er bare en matrix med tre procentdele, 0-100, * styrer de røde, grønne og blå lysdioder * * Rød er den røde LED ved fuld, blå og grøn slukket * int rød = {100, 0, 0} * Dim hvid er alle tre lysdioder på 30% * int dimWhite = {30, 30, 30} * osv. * * Nogle almindelige farver findes herunder, eller lav din egen * * LISTE DEN ORDER: * I hoveddelen af programmet skal du angive den rækkefølge *, du vil have farverne til at blive vist i, f.eks. * crossFade (rød); * crossFade (grøn); * crossFade (blå); * * Disse farver vises i den rækkefølge og falmer ud af * en farve og ind i den næste * * Derudover er der 5 valgfri indstillinger, du kan justere: * 1. Den oprindelige farve er indstillet til sort (så den første farve falmer in), men * du kan indstille den oprindelige farve til en hvilken som helst anden farve * 2. Den interne sløjfe kører i 1020 interationer; variablen 'vent' * angiver den omtrentlige varighed af en enkelt krydsfade. I teorien skal * en 'ventetid' på 10 ms lave en crossFade på ~ 10 sekunder. I * praksis udfører koden de andre funktioner langsomt dette * ned til ~ 11 sekunder på mit bord. YMMV. * 3. Hvis 'repeat' er indstillet til 0, vil programmet loopes på ubestemt tid. * hvis det er indstillet til et tal, vil det sløjfe det antal gange, * derefter stoppe med den sidste farve i sekvensen. (Indstil 'return' til 1, * og gør den sidste farve sort, hvis du vil have den til at falme ud i slutningen.) * 4. Der er en valgfri 'hold' -variabel, som passerer * -programmet for 'hold' millisekunder, når en farve er færdig, * men inden den næste farve starter. * 5. Indstil DEBUG -flag til 1, hvis du vil have fejlfindingsoutput * sendt til den serielle skærm. * * Internt i programmet er ikke kompliceret, men de * er lidt nøjeregnende - det indre arbejde forklares * under hovedsløjfen. * * April 2007, Clay Shirky *

/ Output

int grnPin = 9; // Grøn LED, tilsluttet digital pin 10 int redPin = 10; // Rød LED, tilsluttet digital pin 9 int bluPin = 11; // Blå LED, tilsluttet digital pin 11

// Farve arrays

int black [3] = {0, 0, 0}; int hvid [3] = {100, 100, 100}; int rød [3] = {100, 0, 0}; int green [3] = {0, 100, 0}; int blue [3] = {0, 0, 100}; int gul [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // etc.

// Indstil startfarve

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

int vent = 3; // 10 ms intern crossFade forsinkelse; stigning ved langsommere fades

int hold = 0; // Valgfri hold, når en farve er færdig, før den næste crossFade int DEBUG = 0; // DEBUG tæller; hvis indstillet til 1, vil værdierne blive sendt tilbage via seriel int loopCount = 60; // Hvor ofte skal DEBUG rapportere? int repeat = 0; // Hvor mange gange skal vi sløjfe inden vi stopper? (0 uden stop) int j = 0; // Sløjfe tæller til gentagelse

// Initialiser farvevariabler

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

// Indstil LED -udgange

void setup () {pinMode (redPin, OUTPUT); // indstiller benene som output pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

if (DEBUG) {// Hvis vi vil se værdier til fejlfinding …

Serial.begin (9600); // … konfigurer den serielle udgang}}

// Hovedprogram: anfør rækkefølgen af krydsfader

void loop () {crossFade (rød); crossFade (grøn); crossFade (blå); crossFade (gul);

hvis (gentag) {// Sløjfer vi et begrænset antal gange?

j += 1; hvis (j> = gentag) {// Er vi der endnu? exit (j); // Stop i så fald. }}}

/* NEDENFOR DENNE LINE ER MATEN - DU BØR IKKE BEHANDLE AT ÆNDRE DETTE FOR DET GRUNDLÆGGENDE

* * Programmet fungerer sådan: * Forestil dig en krydsfade, der flytter den røde LED fra 0-10, * den grønne fra 0-5, og den blå fra 10 til 7, i * ti trin. * Vi vil gerne tælle de 10 trin og øge eller * reducere farveværdier i trinvist jævnt trin. * Forestil dig, at a + angiver at hæve en værdi med 1, og a - * er lig med at sænke den. Vores 10 -trins fade ville se sådan ud: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + * G + + + + + * B - - - * * Den røde stiger fra 0 til 10 i ti trin, den grønne fra * 0-5 i 5 trin, og den blå falder fra 10 til 7 i tre trin. * * I det virkelige program konverteres farveprocenterne til * 0-255 værdier, og der er 1020 trin (255 * 4). * * For at finde ud af, hvor stort et trin der skal være mellem en op- eller * ned-markering af en af LED-værdierne, kalder vi calcStep (), * som beregner det absolutte mellemrum mellem start- og slutværdierne, * og derefter deler dette hul med 1020 for at bestemme størrelsen af trin * mellem justeringer i værdien. */

int calcStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Hvad er det overordnede hul? hvis (trin) {// Hvis det ikke er nul, trin = 1020/trin; // divider med 1020} returtrin; }

/* Den næste funktion er calculateVal. Når loop -værdien, i, * når den trinstørrelse, der er passende for en af de * farver, øger eller formindsker værdien af den farve med 1. * (R, G og B beregnes hver for sig.) */

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

hvis ((trin) && i % step == 0) {// Hvis trin er ikke-nul, og det er tid til at ændre en værdi, hvis (trin> 0) {// øges værdien, hvis trin er positivt … val += 1; } ellers hvis (trin 255) {val = 255; } ellers hvis (val <0) {val = 0; } returværdi; }

/* crossFade () konverterer farveprocenten til a

* 0-255 område, sløjfer derefter 1020 gange, kontrollerer om * værdien skal opdateres hver gang og skriver derefter * farveværdierne til de korrekte stifter. */

void crossFade (int color [3]) {

// Konverter til 0-255 int R = (farve [0] * 255) / 100; int G = (farve [1] * 255) / 100; int B = (farve [2] * 255) / 100;

int stepR = calculStep (prevR, R);

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

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

analogWrite (redPin, redVal); // Skriv aktuelle værdier til LED -ben

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

forsinkelse (vent); // Sæt pause på 'vent' millisekunder, før sløjfen genoptages

if (DEBUG) {// Hvis vi vil have seriel output, skal du udskrive det på

hvis (i == 0 eller i % loopCount == 0) {// begyndelse, og hver loopCount gange Serial.print ("Loop/RGB: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print (" /"); Serial.print (grnVal); Serial.print (" /"); Serial.println (bluVal); } DEBUG += 1; }}} // Opdater aktuelle værdier for næste loop prevR = redVal; prevG = grnVal; prevB = bluVal; forsinkelse (hold); // Pause for valgfrie 'vent' millisekunder, før sløjfen genoptages}

Trin 2: Indpakning af træet

Jeg brugte vandtætte strimler, da disse vil være udendørs. De holdt fast på egen hånd, men jeg fulgte hurtigt op med trådbånd for at sikre, at de blev siddende. Enkelt og let hack. Strimmelens gennemføringsevne gjorde det let at føre strømforsyningen ind i bunden og få strøm ud af toppen til stjernen.

Trin 3: Glem ikke stjernen på toppen

Til stjernen brugte jeg et par 10W chips til at få lidt opmærksomhed. Jeg lodde dem til en kobberplade som en køleplade. Jeg kunne have brugt mere strimmel, da der var lidt tilovers.

Trin 4: Prøv det

Første forsøg havde hastigheden alt for hurtig….

Da jeg havde roet det ned så det ret godt ud.