LED -spiraalboom: 4 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:24

Ek hou van allerhande LED -stroke. Ek het 'n lekker reënbooglig saam met hulle gemaak. Selfs diegene wat nie aangespreek kan word nie, is nuttig. Ek het 'n helder buitenshuise lig op die mark gemaak deur dit aan die ribbes te heg, toe my spiraalboom uitblaas, besluit ek om 'n lengte ledstrook om dit te draai.

Stap 1: Beheerder

Ek het besluit om nie-aanspreekbare RGB-leds te gebruik. Dit beteken dat ek 'n geprogrammeerde effek kan hê, maar alle LED's verander gelyktydig van kleur. Dit beteken ook dat 'n beheerder nodig sal wees. Ek kon 'n arduino uno gebruik het om die eerste toetse te doen met 'n RGB -skild, maar ek het uiteindelik 'n pasgemaakte enkele bord met 'n kaal Atmega328 -chip gebruik. Moes net die doelprogrammeerder skakel en die chip direk programmeer.

Ek het baie van hierdie borde oorgebly van ander lampprojekte. Gebruik gerus 'n goedkoop voorafgeprogrammeerde kontroleerder soos ek op my sambreel gedoen het.

Uiteindelik gebruik ek 'n stadige crossfade -demo as die basis vir die boom.

/** Kode vir kruisverbleking van 3 LED's, rooi, groen en blou (RGB) * Om vervaagings te skep, moet u twee dinge doen: * 1. Beskryf die kleure wat u wil vertoon * 2. Lys die volgorde wat u wil hê hulle vervaag in * * 'N KLEUR BESKRYF: * 'n Kleur is slegs 'n skikking van drie persentasies, 0-100, * die beheer van die rooi, groen en blou LED's * * Rooi is die rooi LED vol, blou en groen af * int rooi = {100, 0, 0} * Dim wit is al drie LED's teen 30% * int dimWhite = {30, 30, 30} * ens. * * 'n Paar algemene kleure word hieronder verskaf, of maak u eie * * LYS DIE BESTELLING: * In die hoofdeel van die program moet u die volgorde lys * waarin u die kleure wil vertoon, bv. * crossFade (rooi); * crossFade (groen); * crossFade (blou); * * Die kleure verskyn in die volgorde, vervaag uit * een kleur en in die volgende * * Boonop is daar 5 opsionele instellings wat u kan aanpas: * 1. Die aanvanklike kleur is op swart gestel (sodat die eerste kleur vervaag) in), maar * u kan die aanvanklike kleur op enige ander kleur stel * 2. Die interne lus loop vir 1020 interasies; die 'wag' -veranderlike * stel die geskatte duur van 'n enkele kruisverf. In teorie moet 'n 'wag' van 10 ms 'n crossFade van ~ 10 sekondes maak. In die praktyk verrig die ander funksies, die kode, stadig * tot ~ 11 sekondes op my bord. YMMV. * 3. As 'herhaal' op 0 is, loop die program onbepaald. * as dit op 'n getal gestel is, sal dit die aantal kere herhaal, * dan stop met die laaste kleur in die ry. (Stel 'terugkeer' op 1, * en maak die laaste kleur swart as u aan die einde wil vervaag.) * 4. Daar is 'n opsionele 'hou' -veranderlike, wat die * program vir' hou 'millisekondes deurskakel wanneer 'n kleur is voltooi, * maar voordat die volgende kleur begin. * 5. Stel die DEBUG -vlag op 1 as u wil hê dat die ontfoutingsuitset * na die seriële monitor gestuur moet word. * * Die binnekant van die program is nie ingewikkeld nie, maar dit is 'n bietjie kieskeurig - die innerlike werking word verduidelik * onder die hooflus. * * April 2007, Clay Shirky *

/ Uitset

int grnPin = 9; // Groen LED, gekoppel aan digitale pen 10 int redPin = 10; // Rooi LED, gekoppel aan digitale pen 9 int bluPin = 11; // Blou LED, gekoppel aan digitale pen 11

// Kleurskikkings

int swart [3] = {0, 0, 0}; int wit [3] = {100, 100, 100}; int rooi [3] = {100, 0, 0}; int groen [3] = {0, 100, 0}; int blou [3] = {0, 0, 100}; int geel [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // ens.

// Stel die aanvanklike kleur in

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

int wag = 3; // 10ms interne crossFade vertraging; toename vir stadiger vervaag

int hou = 0; // Opsioneel hou wanneer 'n kleur voltooi is, voor die volgende crossFade int DEBUG = 0; // DEBUG -toonbank; as dit op 1 gestel is, sal dit waardes terugskryf via seriële int loopCount = 60; // Hoe gereeld moet DEBUG rapporteer? int herhaal = 0; // Hoeveel keer moet ons loop voordat ons stop? (0 vir geen stop) int j = 0; // Lusteller vir herhaling

// Initialiseer kleurveranderlikes

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

// Stel die LED -uitsette op

ongeldige opstelling () {pinMode (redPin, OUTPUT); // stel die penne in as output pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

if (DEBUG) {// As ons waardes vir ontfouting wil sien …

Serial.begin (9600); // … stel die reeksopstelling op}}

// Hoofprogram: lys die volgorde van kruisverf

leemte -lus () {crossFade (rooi); crossFade (groen); crossFade (blou); crossFade (geel);

as (herhaal) {// Loop ons 'n eindige aantal kere?

j += 1; if (j> = herhaal) {// Is ons al daar? uitgang (j); // As dit so is, stop. }}}

/* HIERONDER IS HIERDIE REËL DIE WISKUNDE - U hoef dit nie te verander vir die basiese beginsels nie

* * Die program werk so: * Stel jou voor 'n kruisverf wat die rooi LED van 0-10, die groen van 0-5 en die blou van 10 na 7 in * tien stappe beweeg. * Ons wil die 10 stappe tel en kleurwaardes in eweredige trappe verhoog of * verlaag. * Stel jou voor a + dui op die verhoging van 'n waarde met 1, en a - * is gelyk aan die verlaging daarvan. Ons vervaag van 10 stappe sal soos volg lyk: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + * G + + + + + * B - - - * * Die rooi styg van 0 tot 10 in tien stappe, die groen van * 0-5 in 5 stappe, en die blou val van 10 tot 7 in drie stappe. * * In die regte program word die kleurpersentasies omgeskakel na * 0-255 waardes, en daar is 1020 stappe (255 * 4). * * Om uit te vind hoe groot 'n stap tussen een op- of * af-afmerk van een van die LED-waardes moet wees, noem ons calculeStep (), * wat die absolute gaping tussen die begin- en eindwaardes bereken, * en dan verdeel die gaping met 1020 om die grootte van die stap * tussen die aanpassings in die waarde te bepaal. */

int calculeerStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Wat is die algehele gaping? as (stap) {// As dit nie-nul is nie, stap = 1020/stap; // deel met 1020} terugstap; }

/* Die volgende funksie is calculateVal. Wanneer die luswaarde, i, * bereik die trapprootte wat geskik is vir een van die * kleure, dit verhoog of verminder die waarde van die kleur met 1. * (R, G en B word elkeen afsonderlik bereken.) */

int berekenVal (int stap, int val, int i) {

if ((stap) && i % step == 0) {// As stap nie-nul is en dit tyd is om 'n waarde te verander, as (stap> 0) {// die waarde verhoog as stap positief is … val += 1; } anders as (stap 255) {val = 255; } anders as (val <0) {val = 0; } terugkeer val; }

/* crossFade () skakel die persentasie kleure om na a

* 0-255 reeks, loop dan 1020 keer, kyk of * die waarde elke keer bygewerk moet word, en skryf dan die kleurwaardes na die korrekte penne. */

void crossFade (int color [3]) {

// Skakel om na 0-255 int R = (kleur [0] * 255) / 100; int G = (kleur [1] * 255) / 100; int B = (kleur [2] * 255) / 100;

int stepR = bereken Step (prevR, R);

int stepG = bereken Step (prevG, G); int stapB = bereken stap (prevB, B);

vir (int i = 0; i <= 1020; i ++) {redVal = calcuVal (stepR, redVal, i); grnVal = calculeerVal (stapG, grnVal, i); bluVal = berekenVal (stapB, bluVal, i);

analogWrite (redPin, redVal); // Skryf huidige waardes na LED -penne

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

vertraag (wag); // Wag vir 'wag' millisekondes voordat die lus hervat word

if (DEBUG) {// As ons seriële uitvoer wil hê, druk dit by die

if (i == 0 of i % loopCount == 0) {// begin, en elke loopCount keer Serial.print ("Loop/RGB: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print (" /"); Serial.print (grnVal); Serial.print (" /"); Serial.println (bluVal); } DEBUG += 1; }}} // Werk huidige waardes op vir volgende lus prevR = redVal; prevG = grnVal; prevB = bluVal; vertraag (hou); // Wag vir opsionele 'wag' millisekondes voordat die lus hervat word}

Stap 2: Wikkel die boom

Ek het waterdigte stroke gebruik, want dit sal buite wees. Hulle het op hul eie vasgesteek, maar ek het vinnig 'n band vasgemaak om seker te maak dat hulle bly. Eenvoudige en maklike hack. Die deurvoerkragvermoë van die strook het dit maklik gemaak om die kragtoevoer onderin te voer en krag uit die bokant na die ster te kry.

Stap 3: Moenie die ster bo -op vergeet nie

Vir die ster het ek 'n paar 10W -skyfies gebruik om aandag te trek. Ek het hulle aan 'n koperplaat gesoldeer as 'n heatsink. Ek kon meer strook gebruik het, aangesien daar 'n bietjie oor was.

Stap 4: probeer dit

Die eerste poging was te vinnig …

Toe ek dit eers bedaar het, het dit redelik goed gelyk.