LED spirálfa: 4 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:39

Imádok mindenféle LED szalagot. Csináltam velük egy szép szivárvány fényt. Még a nem címzett is hasznos. Készítettem egy fényes piaci esernyő kültéri lámpát az esernyő nélküli bordákhoz rögzítve, így amikor a spirálfám kifújt, úgy döntöttem, hogy egy hosszú ledszalagot tekerek köré.

1. lépés: Vezérlő

Úgy döntöttem, hogy nem címezhető RGB LED-eket használok. Ez azt jelenti, hogy programozott hatást érhetek el, de az összes LED színe egyszerre változik. Ez azt is jelenti, hogy vezérlőre lesz szükség. Használhattam volna egy arduino uno -t, és megcsináltam az első teszteket RGB pajzs használatával, de végül egy egyedi kártyát használtam egy csupasz Atmega328 chipvel. Csak át kellett váltani a célprogramozót és közvetlenül programozni a chipet.

Rengeteg ilyen táblám maradt más lámpaprojektekből. Nyugodtan használjon olcsó, előre programozott vezérlőt, mint én az esernyőmön.

Végül egy lassú crossfade demót használtam a fa alapjául.

/** A három LED, piros, zöld és kék LED-ek kereszthalványításának kódja (RGB) * Az elhalványulások létrehozásához két dolgot kell tennie: * 1. Írja le a megjeleníteni kívánt színeket * 2. Sorolja fel a kívánt sorrendet elhalványulnak * * SZÍN LEÍRÁSA: * A szín csak három százalékos tömb, 0-100, * a piros, zöld és kék LED-eket vezérli * * A piros a piros LED, teljes egészében kék és zöld * int piros = {100, 0, 0} * Halvány fehér mind a három LED 30% -nál * int dimWhite = {30, 30, 30} * stb. * * Néhány általános szín az alábbiakban található, vagy készítse el saját * * RENDELÉS: * A program fő részében meg kell adnia a sorrendet *, amelyben színeket szeretne megjeleníteni, pl. * crossFade (piros); * crossFade (zöld); * crossFade (kék); * * Ezek a színek ebben a sorrendben jelennek meg, elhalványulnak * az egyik színből a másikba * * Ezen kívül 5 opcionális beállítás közül választhat: * 1. A kezdeti szín fekete (tehát az első szín elhalványul) in), de * beállíthatja a kezdeti színt bármilyen más színűvé * 2. A belső hurok 1020 interakcióhoz fut; a 'wait' változó * beállítja az egyes áthidalások hozzávetőleges időtartamát. Elméletileg * a 10 ms -os "várakozás" ~ 10 másodperc keresztfakulást eredményez. A * gyakorlatban a többi funkció, amelyet a kód lassan hajt végre, * ~ 11 másodpercig a táblán. YMMV. * 3. Ha az „ismétlés” értéke 0, a program korlátlan ideig ciklusos. * ha egy számra van állítva, akkor hányszor ciklusos lesz, * majd megáll a sorozat utolsó színén. (Állítsa a 'return' értéket 1, * értékre, és az utolsó színt feketére színezze, ha azt szeretné, hogy a végén elhalványuljon.) * 4. Van egy opcionális 'hold' változó, amely ezredmásodpercig betölti a * programot a 'hold' egy szín kész, * de mielőtt a következő szín elkezdődne. * 5. Állítsa a DEBUG jelzőt 1 -re, ha azt szeretné, hogy a hibakeresési kimenet * elküldésre kerüljön a soros monitorra. * * A program belseje nem bonyolult, de kissé nyűgös - a belső működés magyarázata * a fő hurok alatt. * * 2007. április, Clay Shirky *

/ Kimenet

int grnPin = 9; // Zöld LED, 10 -es digitális tűhöz csatlakoztatva int redPin = 10; // Piros LED, 9 -es digitális tűhöz csatlakoztatva int bluPin = 11; // Kék LED, a 11 -es digitális tűhöz csatlakoztatva

// Színes tömbök

int fekete [3] = {0, 0, 0}; int fehér [3] = {100, 100, 100}; int piros [3] = {100, 0, 0}; int zöld [3] = {0, 100, 0}; int kék [3] = {0, 0, 100}; int sárga [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // stb.

// Kezdeti szín beállítása

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

int várni = 3; // 10 ms belső crossFade delay; növelés a lassabb elhalványuláshoz

int hold = 0; // Választható tartás, ha egy szín kész, a következő crossFade előtt int DEBUG = 0; // DEBUG számláló; ha 1 -re van állítva, visszaírja az értékeket a soros int loopCount = 60 segítségével; // Milyen gyakran kell jelenteni a DEBUG -ot? int ismétlés = 0; // Hányszor kell hurkolni, mielőtt megállunk? (0 megállás nélkül) int j = 0; // Hurokszámláló ismétléshez

// Színváltozók inicializálása

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

// A LED kimenetek beállítása

void setup () {pinMode (redPin, OUTPUT); // beállítja a csapokat kimeneti pinMode -ként (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

if (DEBUG) {// Ha látni szeretnénk a hibakeresési értékeket…

Sorozat.kezdet (9600); //… a soros kimenet beállítása}}

// Fő program: sorolja fel az átfedések sorrendjét

void loop () {crossFade (piros); crossFade (zöld); crossFade (kék); crossFade (sárga);

ha (ismétlés) {// Véges számú alkalommal hurkolunk?

j += 1; ha (j> = ismétlés) {// Már ott tartunk? kijárat (j); // Ha igen, hagyd abba. }}}

/* ALÁBB EZ A VONAL A MATEMATIKA - NEM KELL VÁLTOZNOD EZT AZ ALAPVETŐKÉRT

* * A program a következőképpen működik: * Képzeljen el egy keresztfakulást, amely a piros LED-et 0-10-ről, * a zöldet 0-5-ről és a kéket 10-ről 7-re mozgatja * tíz lépésben. * Szeretnénk számolni a 10 lépést, és növelni vagy csökkenteni a színértékeket egyenletes lépésekben. * Képzeld el, hogy a + jelzi az érték 1 -es emelését, és a - * megegyezik annak csökkentésével. 10 lépéses elhalványulásunk így nézne ki: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + + + * G + + + + + * B - - - * * A piros felemelkedik Tíz lépésben 0-tól 10-ig, a zöldtől * 0-5-ig 5 lépésben, a kék pedig 10-ről 7-re esik három lépésben. * * A valódi programban a színszázalékok * 0-255 értékekké alakulnak át, és 1020 lépés van (255 * 4). * * Annak eldöntéséhez, hogy mekkora lépésnek kell lennie a LED-értékek egyik felfelé vagy lefelé történő kijelölése között, a calcStep (), * -ot hívjuk, amely kiszámítja a kezdő és a végérték közötti abszolút rést, * majd osztja ezt a rést 1020 -mal, hogy meghatározza a lépés méretét * az érték korrekciói között. */

int calcStep (int prevValue, int endValue) {

int lépés = endValue - prevValue; // Mekkora az általános rés? if (lépés) {// Ha nem nulla, lépés = 1020/lépés; // osztás 1020 -mal} visszatérési lépés; }

/* A következő függvény a calcVal. Amikor a ciklus értéke, i, * eléri az egyik * színnek megfelelő lépésméretet, 1 -gyel növeli vagy csökkenti a szín értékét. * (Az R, G és B értékeket külön számítják ki.) */

int calcVal (int lépés, int val, int i) {

if ((lépés) && i % step == 0) {// Ha a lépés nem nulla, és ideje módosítani az értéket, if (lépés> 0) {// növeli az értéket, ha a lépés pozitív… val += 1; } else if (255. lépés) {val = 255; } else if (val <0) {val = 0; } visszatérési val; }

/* crossFade () a százalékos színeket a -ra konvertálja

* 0-255 tartomány, majd 1020-szoros ciklus, ellenőrizve, hogy * az értéket minden alkalommal frissíteni kell-e, majd írja be * a színértékeket a megfelelő csapokra. */

void crossFade (int szín [3]) {

// Konvertálás 0-255-re int R = (szín [0] * 255) / 100; int G = (szín [1] * 255) / 100; int B = (szín [2] * 255) / 100;

int stepR = calcStep (prevR, R);

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

for (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = calcVal (stepG, grnVal, i); bluVal = calcVal (lépésB, bluVal, i);

analogWrite (redPin, redVal); // Írja be az aktuális értékeket a LED -es érintkezőkbe

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

késleltetés (várakozás); // Szüneteltesd a "várj" ezredmásodpercet, mielőtt folytatod a ciklust

if (DEBUG) {// Ha soros kimenetet szeretnénk, nyomtassuk ki a

if (i == 0 vagy i % loopCount == 0) {// eleje, és minden loopCount szoroz Serial.print ("Loop/RGB: #"); Sorozatnyomat (i); Soros.nyomtatás ("|"); Serial.print (redVal); Soros.nyomtatás (" /"); Serial.print (grnVal); Soros.nyomtatás (" /"); Soros.println (bluVal); } DEBUG += 1; }} // A következő ciklus aktuális értékeinek frissítése prevR = redVal; prevG = grnVal; prevB = bluVal; késleltetés (tartás); // Szünet az opcionális "várakozás" ezredmásodpercig, mielőtt folytatná a ciklust}

2. lépés: A fa betakarása

Vízálló csíkokat használtam, mivel ezek a szabadban lesznek. Maguktól ragaszkodtak, de gyorsan követtem a drótkötéseket, hogy megbizonyosodjak arról, hogy helyben maradnak. Egyszerű és könnyű hack. A szalag átáramlási képessége megkönnyítette a tápegység alulra történő betáplálását és a tetejéről a csillaghoz történő áramellátást.

3. lépés: Ne felejtsd el a csillagot a tetején

A csillaghoz egy 10 W -os chipet használtam, hogy felhívjam a figyelmet. Rézlemezre forrasztottam őket hűtőbordaként. Több csíkot is használhattam volna, mivel maradt belőle egy kevés.

4. lépés: Próbálja ki

Az első próbálkozásnál túl gyors volt a sebesség….

Miután megnyugodtam, nagyon jól nézett ki.