LED-spiraalboom - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Ik ben dol op alle soorten LED-strips. Ik heb er een mooi regenbooglichtje mee gemaakt. Zelfs de niet-adresseerbare zijn nuttig. Ik heb een heldere marktparaplu buitenlamp gemaakt door ze aan de unbrella-ribben te bevestigen, dus toen mijn spiraalboom uitblies, besloot ik er een stuk ledstrip omheen te wikkelen.

Stap 1: Controller

Ik besloot om niet-adresseerbare RGB-leds te gebruiken. Dit betekent dat ik een geprogrammeerd effect kan hebben, maar alle leds veranderen tegelijkertijd van kleur. Dit betekent ook dat er een controller nodig zal zijn. Ik had een arduino uno kunnen gebruiken en deed de eerste tests met een RGB-schild, maar uiteindelijk gebruikte ik een aangepast enkel bord met een kale Atmega328-chip. Moest gewoon de doelprogrammeur wisselen en de chip rechtstreeks programmeren.

Ik had nog veel van deze planken over van andere lampprojecten. Voel je vrij om in plaats daarvan een goedkope inline voorgeprogrammeerde controller te gebruiken zoals ik deed op mijn paraplu.

Uiteindelijk gebruikte ik een langzame crossfade-demo als basis voor de boom.

/** Code voor cross-fading 3 LED's, rood, groen en blauw (RGB) * Om fades te creëren, moet u twee dingen doen: * 1. Beschrijf de kleuren die u wilt weergeven * 2. Geef de gewenste volgorde aan ze vervagen * * EEN KLEUR BESCHRIJVEN: * Een kleur is slechts een reeks van drie percentages, 0-100, * controle van de rode, groene en blauwe LED's * * Rood is de rode LED op vol, blauw en groen uit * int rood = { 100, 0, 0 } * Dim wit is alle drie de LED's op 30% * int dimWhite = {30, 30, 30} * etc. * * Enkele veelvoorkomende kleuren worden hieronder gegeven, of maak uw eigen * * LIJST DE BESTELLEN: * In het hoofdgedeelte van het programma moet u de volgorde vermelden * waarin u de kleuren wilt laten verschijnen, bijv. * crossFade (rood); * crossFade (groen); * crossFade (blauw); * * Die kleuren verschijnen in die volgorde, vervagen van * de ene kleur naar de volgende * * Daarnaast zijn er 5 optionele instellingen die u kunt aanpassen: * 1. De beginkleur is ingesteld op zwart (zodat de eerste kleur vervaagt in), maar * u kunt de beginkleur instellen op een andere kleur * 2. De interne lus loopt voor 1020 interacties; de 'wait' variabele * stelt de geschatte duur van een enkele crossfade in. In theorie zou * een 'wacht' van 10 ms een crossFade van ~10 seconden moeten opleveren. In * praktijk vertragen de andere functies die de code uitvoert dit * tot ~11 seconden op mijn bord. YMMV. * 3. Als 'repeat' op 0 staat, loopt het programma oneindig door. * als het is ingesteld op een getal, wordt dat aantal keren herhaald, * stopt dan bij de laatste kleur in de reeks. (Stel 'return' in op 1, * en maak de laatste kleur zwart als je wilt dat deze aan het einde uitdooft.) * 4. Er is een optionele 'hold'-variabele, die het *-programma voor 'hold' milliseconden een kleur is voltooid, * maar voordat de volgende kleur begint. * 5. Stel de DEBUG-vlag in op 1 als u wilt dat de foutopsporingsuitvoer * naar de seriële monitor wordt gestuurd. * * De binnenkant van het programma is niet ingewikkeld, maar * is een beetje pietluttig -- de innerlijke werking wordt uitgelegd * onder de hoofdlus. * * April 2007, Clay Shirky *

/ Uitgang

int grnPin = 9; // Groene LED, aangesloten op digitale pin 10 int redPin = 10; // Rode LED, aangesloten op digitale pin 9 int bluPin = 11; // Blauwe LED, aangesloten op digitale pin 11

// Kleurarrays

int zwart [3] = { 0, 0, 0 }; int wit [3] = { 100, 100, 100 }; int rood [3] = { 100, 0, 0 }; int groen [3] = { 0, 100, 0 }; int blauw [3] = { 0, 0, 100 }; int geel [3] = { 40, 95, 0 }; int dimWhite[3] = { 30, 30, 30 }; // enzovoort.

// Initiële kleur instellen

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

int wachten = 3; // 10ms interne crossFade-vertraging; verhogen voor langzamere fades

int vasthouden = 0; // Optioneel vasthouden wanneer een kleur voltooid is, voor de volgende crossFade int DEBUG = 0; // DEBUG-teller; indien ingesteld op 1, zal waarden terugschrijven via seriële int loopCount = 60; // Hoe vaak moet DEBUG rapporteren? int herhalen = 0; // Hoe vaak moeten we een lus maken voordat we stoppen? (0 voor geen stop) int j = 0; // Lusteller voor herhaling

// Initialiseer kleurvariabelen

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

// Stel de LED-uitgangen in

void setup () { pinMode (redPin, OUTPUT); // stelt de pinnen in als output pinMode (grnPin, OUTPUT); pinMode (bluPin, UITGANG);

if (DEBUG) { // Als we waarden voor foutopsporing willen zien…

Serieel.begin(9600); // … stel de seriële uitgang in } }

// Hoofdprogramma: geef de volgorde van crossfades weer

void loop() { crossFade(rood); crossFade(groen); crossFade (blauw); crossFade (geel);

if (repeat) { // Doen we een eindig aantal keren in een lus?

j += 1; if (j >= repeat) { // Zijn we er al? uitgang(j); // Zo ja, stop. } } }

/* ONDER DEZE REGEL IS DE WISKUNDE -- JE MOET DIT NIET VERANDEREN VOOR DE BASIS

* * Het programma werkt als volgt: * Stel je een crossfade voor die de rode LED van 0-10, * de groene van 0-5 en de blauwe van 10 naar 7 beweegt, in * tien stappen. * We willen de 10 stappen tellen en de kleurwaarden in gelijkmatig getrapte stappen verhogen of * verlagen. * Stel je voor dat een + aangeeft dat je een waarde met 1 verhoogt en dat een - * gelijk staat aan het verlagen ervan. Onze 10-staps fade zou er als volgt uitzien: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + * G + + + + + * B - - - * * Het rood stijgt van 0 tot 10 in tien stappen, de groene van * 0-5 in 5 stappen, en de blauwe valt van 10 naar 7 in drie stappen. * * In het echte programma worden de kleurpercentages geconverteerd naar * 0-255 waarden en zijn er 1020 stappen (255*4). * * Om erachter te komen hoe groot een stap moet zijn tussen een omhoog- of * omlaag-vinkje van een van de LED-waarden, noemen we calculatorStep(), * die de absolute kloof tussen de begin- en eindwaarden berekent, * en dan verdeelt die opening door 1020 om de grootte van de stap * tussen aanpassingen in de waarde te bepalen. */

int berekenStep (int prevValue, int endValue) {

int stap = endValue - prevValue; // Wat is de algemene kloof? if (step) { // Als het niet nul is, step = 1020/step; // delen door 1020 } stap terug; }

/* De volgende functie is berekenVal. Wanneer de luswaarde, i, * de stapgrootte bereikt die geschikt is voor een van de * kleuren, het verhoogt of verlaagt de waarde van die kleur met 1. * (R, G en B worden elk afzonderlijk berekend.) */

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

if ((step) && i % step == 0) { // Als step niet nul is en het tijd is om een waarde te veranderen, if (stap > 0) { // verhoog de waarde als stap positief is… val += 1; } else if (stap 255) { val = 255; } else if (val < 0) { val = 0; } retourwaarde; }

/* crossFade() converteert het percentage kleuren naar a

* Bereik van 0-255, loopt dan 1020 keer door, controleer of * de waarde elke keer moet worden bijgewerkt en schrijft * vervolgens de kleurwaarden naar de juiste pinnen. */

void crossFade (int kleur [3]) {

// Converteren naar 0-255 int R = (kleur [0] * 255) / 100; int G = (kleur [1] * 255) / 100; int B = (kleur [2] * 255) / 100;

int stepR = berekenStep(prevR, R);

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

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

analogWrite(redPin, redVal); // Schrijf huidige waarden naar LED-pinnen

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

vertraging (wacht); // Pauzeer milliseconden 'wacht' voordat je de lus hervat

if (DEBUG) { // Als we seriële uitvoer willen, print het dan op de

if (i == 0 of i % loopCount == 0) { // begin, en elke loopCount keer Serial.print ("Loop/RGB: #"); Serial.print(i); Serieel.print(" | "); Serial.print(redVal); Serieel.print(" / "); Serial.print(grnVal); Serieel.print(" / "); Serial.println(bluVal); } DEBUG += 1; } } // Update huidige waarden voor volgende lus prevR = redVal; prevG = grnVal; prevB = blauw; vertraging (vasthouden); // Pauzeer voor optionele 'wacht' milliseconden voordat de lus wordt hervat}

Stap 2: De boom inpakken

Ik heb waterdichte strips gebruikt omdat deze buiten zullen zijn. Ze bleven vanzelf plakken, maar ik volgde snel met draadbinders om ervoor te zorgen dat ze bleven zitten. Eenvoudige en gemakkelijke hack. Het doorvoervermogen van de strip maakte het gemakkelijk om de voeding naar de bodem te voeren en de stroom van de bovenkant naar de ster te krijgen.

Stap 3: Vergeet de ster bovenaan niet

Voor de ster heb ik een paar 10W-chips gebruikt om wat aandacht te krijgen. Ik heb ze op een koperen plaat gesoldeerd als koellichaam. Ik had meer strip kunnen gebruiken omdat er nog een beetje over was.

Stap 4: Het uitproberen

Eerste poging had de snelheid veel te snel ….

Toen ik het rustig aan had gedaan, zag het er best goed uit.