Îmbunătățirea unui Arduino LED Mood Cube (simplu) (video inclus): 4 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

După ce am văzut un proiect cu LED-ul mic, creat de 'earl, am decis să fac o versiune îmbunătățită a LED-ului Mood Cube. Versiunea mea va fi mai complexă decât cea originală, deoarece va fi puțin mai mare decât cea originală, va avea încă două culori comparativ cu cubul original (adăugat galben și alb), va avea o cantitate infinită de rotație a culorilor etc. ar trebui să fie un proiect bun pentru a practica utilizarea ulterioară a luminilor LED pentru cei care au înțeles conceptul de conectare a luminilor LED cu fire.

Pasul 1: Materiale

Iată câteva materiale de care veți avea nevoie pentru a realiza acest Cub de dispoziție:

• Pană de pâine
• Arduino - (îl am aici pe Leonardo)
• Alimentare Arduino / cablu USB
• Pană de pâine
• Jumper Wires (Mulți dintre ei, am folosit 29 de fire)
• LED roșu x 2
• LED albastru x 2
• LED verde x 2
• LED galben x 2
• LED alb x 1
• 9 rezistențe
• Cutie suficient de mare pentru a se potrivi panoului (am folosit o cutie pentru pantofi)
• Cuțit utilitar
• Hârtie

Pasul 2: Cod

Câteva explicații pentru codul dat aici:

Creditul codurilor merge la sursa originală a proiectului meu, deoarece editorul proiectului a creat aceste coduri. Am îmbunătățit doar unele dintre ele făcându-le mai complexe. În unele coduri, puteți vedea // 改 la final. Aceasta înseamnă că acest cod este editat de mine, deci este diferit de sursa mea originală.

De asemenea, am o versiune a codului pe Arduino Creator.

/ * Cod pentru decolorarea încrucișată a 3 LED-uri, roșu, verde și albastru (RGB) Pentru a crea decolorări, trebuie să faceți două lucruri: 1. Descrieți culorile în care doriți să fie afișate 2. Enumerați ordinea în care doriți să se estompeze

DESCRIEREA CULORII:

O culoare este doar o gamă de trei procente, 0-100, care controlează LED-urile roșii, verzi și albastre

Roșu este LED-ul roșu la maxim, albastru și verde oprit

int roșu = {100, 0, 0} Alb alb este toate cele trei LED-uri la 30% int dimWhite = {30, 30, 30} etc.

Unele culori obișnuite sunt furnizate mai jos sau le fac proprii

ENUMERAREA COMENZII:

În partea principală a programului, trebuie să listați ordinea în care doriți să apară culorile, de ex. crossFade (roșu); crossFade (verde); crossFade (albastru);

Acele culori vor apărea în această ordine, dispărând din

o culoare și în următoarea

În plus, există 5 setări opționale pe care le puteți regla:

1. Culoarea inițială este setată la negru (deci prima culoare se estompează), dar puteți seta culoarea inițială să fie orice altă culoare 2. Bucla internă rulează pentru 1020 de interacțiuni; variabila „așteptați” setează durata aproximativă a unei singure decolorări încrucișate. În teorie, o „așteptare” de 10 ms ar trebui să facă un crossFade de ~ 10 secunde. În practică, celelalte funcții pe care le execută codul încetinesc acest lucru până la ~ 11 secunde pe placa mea. YMMV. 3. Dacă „Repetare” este setat la 0, programul va rula la nesfârșit. dacă este setat la un număr, se va bucla de acel număr de ori, apoi se va opri pe ultima culoare din secvență. (Setați „return” la 1 și faceți ultima culoare neagră dacă doriți să se estompeze la sfârșit.) 4. Există o variabilă opțională „hold”, care stabilește programul pentru „hold” milisecunde când o culoare este complet, dar înainte ca următoarea culoare să înceapă. 5. Setați semnalizatorul DEBUG la 1 dacă doriți ca ieșirea de depanare să fie trimisă pe monitorul serial.

Internele programului nu sunt complicate, dar ele

sunt puțin agitate - funcționarea interioară este explicată sub bucla principală.

Aprilie 2007, Clay Shirky

*

/ Ieșire

int ylwPin = 5; // LED galben, conectat la pinul digital 5 // 改 int redPin = 6; // LED roșu, conectat la pinul digital 6 // 改 int grnPin = 7; // LED verde, conectat la pinul digital 7 // 改 int bluPin = 8; // LED albastru, conectat la pinul digital 8 // 改 int whiPin = 9; // LED alb, conectat la pinul digital 9 // 改 int ylwPin2 = 10; // LED galben, conectat la pinul digital 10 // 改 int redPin2 = 11; // LED roșu, conectat la pinul digital 11 // 改 int grnPin2 = 12; // LED verde, conectat la pinul digital 12 // 改 int bluPin2 = 13; // LED albastru, conectat la pinul digital 13 // 改

// Tablouri de culori

int negru [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // white int alb [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int roșu [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int verde [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int albastru [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int galben [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int violet [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int orange [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int roz [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // etc.

// Setați culoarea inițială

int redVal = negru [0]; int grnVal = negru [1]; int bluVal = negru [2]; int ylwVal = negru [3]; // 改 int whiVal = negru [4]; // 改

int wait = 15; // 10 ms întârziere internă de decolorare încrucișată; crește pentru estompări mai lente // 改

int hold = 1; // Țineți opțional când o culoare este completă, înainte de următorul crossFade // 改 int DEBUG = 1; // contor DEBUG; dacă este setat la 1, va scrie valori înapoi prin serial int loopCount = 60; // Cât de des ar trebui să raporteze DEBUG? int repeat = 0; // De câte ori ar trebui să facem o buclă înainte de oprire? (0 fără oprire) // 改 int j = 0; // Contor buclă pentru repetare

// Inițializați variabilele de culoare

int prevR = redVal; int prevG = grnVal; int prevB = bluVal; int prevY = ylwVal; int prevW = whiVal; // 改

// Configurați ieșirile LED

setare nulă () {pinMode (redPin, OUTPUT); // setează pinii ca pinMode de ieșire (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, OUTPUT); // 改

if (DEBUG) {// Dacă vrem să vedem valori pentru depanare …

Serial.begin (9600); // … configurați ieșirea serial}}

// Programul principal: listează ordinea decolorărilor încrucișate

bucla void () {crossFade (roșu); crossFade (verde); crossFade (albastru); crossFade (galben); crossFade (alb); crossFade (roz); crossFade (violet); crossFade (portocaliu);

if (repetare) {// Buclăm un număr finit de ori?

j + = 1; if (j> = repeat) {// Suntem deja acolo? ieșire (j); // Dacă da, oprește-te. }}}

/ * MAI MULTE ACEASTA LINIE ESTE MATEMATICA - NU TREBUIE SĂ FIȚI NECESAR DE A SCHIMBA ACESTA PENTRU BAZE

Programul funcționează astfel:

Imaginați-vă o decolorare încrucișată care mută LED-ul roșu de la 0-10, verde de la 0-5 și albastru de la 10 la 7, în zece pași. Am dori să numărăm cei 10 pași și să creștem sau să micșorăm valorile culorilor în trepte uniform. Imaginați-vă că un + indică creșterea unei valori cu 1, iar a - este egal cu scăderea acesteia. Fade-ul nostru în 10 pași ar arăta astfel:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + + G + + + + + B - - -

Roșul crește de la 0 la 10 în zece pași, verde de la

0-5 în 5 pași, iar albastrul cade de la 10 la 7 în trei pași.

În programul real, procentele de culoare sunt convertite în

0-255 valori și există 1020 de pași (255 * 4).

Pentru a-ți da seama cât de mare ar trebui să existe un pas între unul în sus sau

bifând una dintre valorile LED-ului, numim calculateStep (), care calculează decalajul absolut între valorile inițiale și finale, apoi împarte acel decalaj la 1020 pentru a determina dimensiunea pasului între ajustările valorii. * /

int calculateStep (int Prevalor, int Valoare final) {

int step = endValue - prevValue; // Care este decalajul general? if (step) {// Dacă este diferit de zero, step = 1020 / step; // împărțiți la 1020} pas de întoarcere; }

/ * Următoarea funcție este calculateVal. Când valoarea buclei, i, atinge dimensiunea pasului adecvată pentru una dintre culori, crește sau scade valoarea acelei culori cu 1. (R, G și B sunt fiecare calculate separat.) * /

int calculateVal (int step, int val, int i) {

if ((pas) && i% step == 0) {// Dacă pasul este diferit de zero și este timpul să modificați o valoare, if (pas> 0) {// crește valoarea dacă pasul este pozitiv … val + = 1; } else if (pasul 255) {val = 255; } else if (val <0) {val = 0; } return val; }

/ * crossFade () convertește procentul de culori în a

0-255, apoi se repetă de 1020 de ori, verificând dacă valoarea trebuie actualizată de fiecare dată, apoi scriind valorile culorilor la pinii corecți. * /

void crossFade (int color ) {// 改

// Conversia la 0-255 int R = (culoare [0] * 255) / 100; int G = (culoare [1] * 255) / 100; int B = (culoare [2] * 255) / 100; int Y = (culoare [3] * 255) / 100; // 改 int W = (culoare [4] * 255) / 100; // 改

int stepR = calculateStep (prevR, R);

int stepG = calculateStep (prevG, G); int pasul B = calculateStep (prevB, B); int stepY = calculateStep (prevY, Y); // 改 int stepW = calculateStep (prevW, W); // 改

for (int i = 0; i <= 1020; i ++) {redVal = calculateVal (stepR, redVal, i); grnVal = calculateVal (stepG, grnVal, i); bluVal = calculateVal (stepB, bluVal, i); ylwVal = calculateVal (stepY, ylwVal, i); // 改 whiVal = calculateVal (stepW, whiVal, i); // 改

analogWrite (redPin, redVal); // Scrieți valorile curente pe pinii LED

analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal); analogWrite (ylwPin, ylwVal); // 改 analogWrite (whiPin, whiVal); // 改 analogWrite (grnPin2, grnVal); // 改 analogWrite (bluPin2, bluVal); // 改 analogWrite (ylwPin2, ylwVal); // 改 analogWrite (redPin2, redVal); // 改

întârziere (așteptați); // Întrerupeți „așteptați” milisecunde înainte de a relua bucla

if (DEBUG) {// Dacă dorim ieșire serială, tipăriți-o la

if (i == 0 sau i% loopCount == 0) {// început, și fiecare loopCount ori Serial.print ("Buclă / RGBYW: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print ("/"); Serial.print (grnVal); Serial.print ("/"); Serial.println (bluVal); Serial.print ("/"); Serial.println (ylwVal); // 改 Serial.print ("/"); // 改 Serial.println (whiVal); // 改 Serial.print ("/"); // 改} DEBUG + = 1; }} // Actualizați valorile curente pentru următoarea buclă prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 întârziere (menținere); // Pauză pentru opțiunea „așteptați” în milisecunde înainte de a relua bucla}

Pasul 3: Configurați

1. Ia panoul de verificare.

2. Demo de conectare a firelor, astfel încât o lumină LED să poată străluci:

   1. Puneți LED-ul pe panou. Plasați capătul mai lung în stânga și cel mai scurt în dreapta.
   2. Așezați un capăt al unui fir jumper pe un punct care se află pe același rând cu capătul mai lung al LED-ului. Așezați celălalt capăt pe secțiunea PWM digitală. Codul a specificat LED-urile galbene care trebuie conectate la 10 și 5, cele roșii la 6 și 11, cele albastre la 8 și 13, cele verzi la 7 și 12 și, în cele din urmă, LED-urile albe la 9.
   3. Așezați un capăt al unui rezistor pe același rând cu capătul mai scurt al LED-ului. Așezați celălalt capăt undeva aproape.
   4. Așezați un capăt al unui alt fir jumper cu același rând cu capătul rezistorului care nu se află pe același rând cu capătul mai scurt al LED-ului. Așezați celălalt capăt al firului pe rândul de încărcare negativă.
   5. Așezați un capăt al unui alt fir jumper pe rândul de încărcare negativă și plasați celălalt capăt al acestuia pe GND.
3. Repetați Pasul 2 de 8 ori, deoarece doriți să strălucească 9 LED-uri

4. Așezați panoul în cutie. Câteva reamintiri aici:

   1. Am folosit o sursă de alimentare. Creați o gaură mică pentru firele dvs. folosind un cuțit utilitar pentru a trece prin cutie și a vă conecta la panou.
   2. Asigurați-vă că cutia este ca o parte deschisă. O cutie pentru pantofi are deja o parte deschisă. Dacă cutia este complet închisă, tăiați dintr-o parte a cutiei pentru a face un spațiu deschis.
   3. Acoperiți partea cu nimic cu hârtie. Aceasta este pentru ca luminile LED să strălucească prin hârtie.