LED -spiraalipuu: 4 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:46

Ma armastan igasuguseid LED -ribasid. Tegin nendega kena vikerkaaretule. Isegi adresseerimata on kasulikud. Olen teinud ereda turuvarju välisvalgustuse, kinnitades need katmata ribide külge, nii et kui minu spiraalipuu välja puhus, otsustasin selle ümber keerata pikkusega led -riba.

Samm: kontroller

Otsustasin kasutada adresseerimata RGB-d. See tähendab, et mul võib olla programmeeritud efekt, kuid kõik LED -id muudavad samaaegselt värvi. See tähendab ka seda, et vaja on kontrollerit. Oleksin võinud kasutada arduino uno -d ja teha esialgseid katseid RGB -kilbi abil, kuid lõpuks kasutasin kohandatud ühte tahvlit palja Atmega328 kiibiga. Tuli lihtsalt sihtprogrammeerija vahetada ja kiip otse programmeerida.

Mul oli neid plaate palju muudest lambiprojektidest üle jäänud. Kasutage julgelt odavat sisseehitatud eelprogrammeeritud kontrollerit, nagu tegin oma vihmavarju peal.

Lõppkokkuvõttes kasutasin puu alusena aeglast crossfade demot.

/** Kolme LED-i, punase, rohelise ja sinise (RGB) ristuva tuhmumise kood * Tuhmumise loomiseks peate tegema kahte asja: * 1. Kirjeldage värve, mida soovite kuvada * 2. Loetlege soovitud järjekord need tuhmuvad * * VÄRVI KIRJELDAMINE: * Värv on vaid kolme protsendi massiiv, 0–100, * mis kontrollib punaseid, rohelisi ja siniseid LED-e * * Punane on punane LED täielikult, sinine ja roheline välja * int punane = {100, 0, 0} * Hämarduv valge on kõik kolm LED -i 30% juures * int dimWhite = {30, 30, 30} * jne * * Mõned levinumad värvid on toodud allpool või tehke ise * * TELLIMUS: * Programmi põhiosas peate loetlema järjekorra *, milles soovite värvida, nt * crossFade (punane); * crossFade (roheline); * crossFade (sinine); * * Need värvid ilmuvad selles järjekorras, kustudes * ühest värvist ja järgmiseks * * Lisaks on 5 valikulist sätet, mida saate reguleerida: * 1. Algvärv on seatud mustaks (nii et esimene värv tuhmub in), kuid * saate määrata algvärviks mis tahes muu värvi * 2. Sisemine silmus töötab 1020 interaktsiooni jaoks; muutuja "oota" * määrab ühe ristumise ligikaudse kestuse. Teoreetiliselt peaks * 10 -sekundiline ootamine tegema ~ 10 sekundi pikkuse risti. * Praktikas täidavad muud funktsioonid, mida kood täidab, aeglaselt, * kuni * 11 sekundini. YMMV. * 3. Kui „kordus” on seatud väärtusele 0, lülitub programm lõputult ringi. * kui see on seatud numbrile, lülitab see selle arvu kordi kokku, * siis peatub jada viimasel värvil. (Seadistage 'return' väärtuseks 1, * ja tehke viimane värv mustaks, kui soovite, et see lõpuks kustuks.) * 4. Olemas on valikuline muutuja 'hold', mis esitab * programmi "hold" millisekundiks, kui värv on valmis, * kuid enne järgmise värvi algust. * 5. Kui soovite, et silumisväljund * saadetaks jadamonitorile, määrake DEBUG lipuks 1. * * Programmi sisemus ei ole keeruline, kuid * on pisut närviline - sisemist toimimist selgitatakse * põhiahela all. * * Aprill 2007, Clay Shirky *

/ Väljund

int grnPin = 9; // Roheline LED, ühendatud digitaalse tihvtiga 10 int redPin = 10; // Punane LED, ühendatud digitaalse tihvtiga 9 int bluPin = 11; // Sinine LED, ühendatud digitaalse tihvtiga 11

// Värvimassiivid

int must [3] = {0, 0, 0}; int valge [3] = {100, 100, 100}; int punane [3] = {100, 0, 0}; int roheline [3] = {0, 100, 0}; int sinine [3] = {0, 0, 100}; int kollane [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // jne.

// Määra esialgne värv

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

int ootama = 3; // 10 ms sisemine crossFade viivitus; aeglasemate tuhmumiste korral suurendada

int hoidmine = 0; // Valikuline hoidmine, kui värv on valmis, enne järgmist crossFade int DEBUG = 0; // DEBUG counter; kui see on seatud väärtusele 1, kirjutab väärtused järjestikuse int loopCount = 60 kaudu tagasi; // Kui tihti peaks DEBUG teatama? int kordus = 0; // Mitu korda peaksime enne peatumist loopima? (0 peatumata) int j = 0; // Silmusloendur kordamiseks

// Värvimuutujate lähtestamine

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

// LED -väljundite seadistamine

void setup () {pinMode (redPin, OUTPUT); // määrab tihvtid väljundiks pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

if (DEBUG) {// Kui tahame silumisväärtusi näha …

Seriaalne algus (9600); //… seadistage seeriaväljund}}

// Põhiprogramm: loetlege ristsuhete järjekord

void loop () {crossFade (punane); crossFade (roheline); crossFade (sinine); crossFade (kollane);

if (kordus) {// Kas me loopime lõplikku arvu kordi?

j += 1; kui (j> = korda) {// Kas me oleme juba kohal? väljapääs (j); // Kui jah, siis lõpeta. }}}

/* ALLA SELLELE JÄRGI ON MATEMAATIKA - SINA EI PEAKS PÕHITEGA seda muutma

* * Programm töötab järgmiselt: * Kujutage ette risttaustamist, mis nihutab punase LED-i 0–10, * rohelise 0–5 ja sinise 10–7 sammuga. * Tahaksime lugeda 10 sammu ja suurendada või * vähendada värviväärtusi ühtlaselt sammuga. * Kujutage ette, et + tähistab väärtuse tõstmist 1 võrra ja a - * võrdub selle alandamisega. Meie 10 sammu tuhmumine näeks välja selline: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + + + * G + + + + + * B - - - * * Punane tõuseb 0–10 kümne sammuga, roheline * 0–5 5 sammuga ja sinine langeb 10–7 kolme sammuga. * * Reaalses programmis teisendatakse värviprotsendid * 0–255 väärtuseks ja on 1020 sammu (255 * 4). * * Et välja selgitada, kui suur samm peaks olema ühe LED-väärtuse ühe üles- või alla-linnukese vahel, nimetame calcStep (), * mis arvutab algus- ja lõppväärtuste vahelise absoluutse vahe, * ja seejärel jagab selle vahe 1020 -ga, et määrata sammu suurus * väärtuse korrigeerimiste vahel. */

int calcStep (int prevValue, int endValue) {

int samm = endValue - prevValue; // Mis on üldine vahe? if (samm) {// Kui see ei ole null, siis samm = 1020/samm; // jaga 1020 -ga} tagasi samm; }

/* Järgmine funktsioon on calcVal. Kui silmuse väärtus, i, * jõuab sammu suuruseni, mis sobib ühele * värvist, suurendab või vähendab selle värvi väärtust 1 võrra. * (R, G ja B arvutatakse eraldi.) */

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

if ((samm) && i % step == 0) {// Kui samm ei ole null ja on aeg väärtust muuta, if (samm> 0) {// väärtuse suurendamine, kui samm on positiivne… val += 1; } else if (samm 255) {val = 255; } muu kui (val <0) {val = 0; } tagasivoolu val; }

/* crossFade () teisendab värvide protsendi a -ks

* Vahemik 0–255, seejärel silmuseid 1020 korda, kontrollides, kas * väärtust tuleb iga kord värskendada, seejärel kirjutades * värviväärtused õigetele tihvtidele. */

void crossFade (int värv [3]) {

// Teisenda 0-255 int R = (värv [0] * 255) / 100; int G = (värv [1] * 255) / 100; int B = (värv [2] * 255) / 100;

int sammR = arvuta samm (prevR, R);

int stepG = calcStep (prevG, G); int sammB = arvuta samm (prevB, B);

jaoks (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = arvutaVal (stepG, grnVal, i); bluVal = arvutaVal (sammB, bluVal, i);

analogWrite (redPin, redVal); // Kirjutage praegused väärtused LED -tihvtidele

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

viivitus (oota); // Paus ootamiseks millisekundiks enne silmuse jätkamist

if (DEBUG) {// Kui soovime seeriaväljundit, printige see aadressilt

if (i == 0 või i % loopCount == 0) {// algus ja iga loopCount korda Serial.print ("Loop/RGB: #"); Seeriatrükk (i); Serial.print ("|"); Serial.print (redVal); Serial.print (" /"); Serial.print (grnVal); Serial.print (" /"); Serial.println (bluVal); } DEBUG += 1; }} // Järgmise tsükli praeguste väärtuste värskendamine prevR = redVal; prevG = grnVal; prevB = bluVal; viivitus (ootel); // Paus valikulise ootamise millisekundiks enne silmuse jätkamist}

2. samm: puu mähkimine

Kasutasin veekindlaid ribasid, kuna need on väljas. Nad jäid küll iseenesest kinni, kuid jälgisin kiiresti traadiga, et veenduda, et need jäävad paigale. Lihtne ja lihtne häkkimine. Riba läbilaskevõime hõlbustas toiteallika põhja alla toomist ja ülevalt toite väljaviimist täheni.

Samm: ärge unustage tähte peal

Tähe jaoks kasutasin tähelepanu saamiseks paari 10 W kiipi. Jootsin need jahutusradiaatoriks vaskpleki külge. Oleksin võinud rohkem ribasid kasutada, kuna natuke jäi üle.

4. samm: proovige seda

Esimesel katsel oli kiirus liiga kiire …

Kui ma selle maha rahustasin, tundus see päris hea.