Millora d’un cub d’humor LED Arduino (senzill) (vídeo inclòs): 4 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:12

Després de veure un petit projecte de cub d'ànim LED creat per 'earl, vaig decidir fer una versió millorada del LED Mood Cube. La meva versió serà més complexa que l’original, ja que serà una mica més gran que l’original, tindrà dos colors més en comparació amb el cub original (afegit groc i blanc), tindrà una infinitat de rotació de colors, etc. hauria de ser un bon projecte per practicar sobre l'ús addicional de llums LED per a aquells que van entendre el concepte de connectar llums LED amb cables.

Pas 1: materials

Aquí teniu alguns materials que necessitareu per fer aquest cub d’humor:

• Taula de pa
• Arduino - (Tinc Leonardo aquí)
• Alimentació Arduino / cable USB
• Taula de pa
• Jumper Wires (molts d’ells, he utilitzat 29 cables)
• LED vermell x 2
• LED blau x 2
• LED verd x 2
• LED groc x 2
• LED blanc x 1
• 9 resistències
• Caixa prou gran com per adaptar-se a la taula de treball (he utilitzat una caixa de sabates)
• Ganivet utilitari
• Paper

Pas 2: Codi

Alguna explicació del codi que es dóna aquí:

El mèrit dels codis va a la font original del meu projecte, ja que l’editor del projecte va crear aquests codis. Simplement he millorat alguns d’ells fent-los més complexos. En alguns codis, és possible que vegeu // 改 al final. Això significa que jo edito aquest codi, de manera que és diferent de la meva font original.

També tinc una versió del codi a Arduino Creator.

/ * Codi per a la decoloració creuada de 3 LEDs, vermell, verd i blau (RGB). Per crear fades, heu de fer dues coses: 1. Descriviu els colors que voleu que es mostrin. 2. Enumereu l'ordre en què voleu que s'esvaeixin.

DESCRIPCIÓ D’UN COLOR:

Un color és només un conjunt de tres percentatges, 0-100, que controlen els LED vermells, verds i blaus

El vermell és el LED vermell complet, el blau i el verd apagats

int red = {100, 0, 0} El blanc fi és els tres LED al 30% int dimWhite = {30, 30, 30}, etc.

A continuació, es proporcionen alguns colors habituals o els podeu fer propis

LLISTANT DE LA COMANDA:

A la part principal del programa, heu d’enumerar l’ordre en què voleu que apareguin els colors, p. Ex. crossFade (vermell); crossFade (verd); crossFade (blau);

Aquests colors apareixeran en aquest ordre, desapareixent

d'un color i cap al següent

A més, hi ha cinc opcions opcionals que podeu ajustar:

1. El color inicial es defineix en negre (de manera que el primer color s'esvaeix), però podeu configurar el color inicial per ser qualsevol altre color 2. El bucle intern té una durada de 1020 interaccions; la variable "espera" estableix la durada aproximada d'un sol atenuament creuat. En teoria, una "espera" de 10 ms hauria de fer un crossFade de ~ 10 segons. A la pràctica, les altres funcions que realitza el codi ho fan lent fins a ~ 11 segons al meu tauler. YMMV. 3. Si "Repeteix" s'estableix a 0, el programa es farà un bucle indefinidament. si s'estableix en un número, farà un bucle aquest nombre de vegades i, a continuació, s'aturarà en l'últim color de la seqüència. (Estableix "retorna" a 1 i fes que l'últim color sigui negre si voleu que s'esvaeixi al final.) 4. Hi ha una variable "retenir" opcional, que perdura el programa per "retenir" mil·lisegons quan un color és complet, però abans que comenci el color següent. 5. Establiu el senyal DEBUG a 1 si voleu que la sortida de depuració s'enviï al monitor sèrie.

Les funcions internes del programa no són complicades, però sí

són una mica exigents: el funcionament intern s’explica a sota del bucle principal.

Abril de 2007, Clay Shirky

*

/ Sortida

int ylwPin = 5; // LED groc, connectat al pin digital 5 // 改 int redPin = 6; // LED vermell, connectat al pin digital 6 // 改 int grnPin = 7; // LED verd, connectat al pin digital 7 // 改 int bluPin = 8; // LED blau, connectat al pin digital 8 // 改 int whiPin = 9; // LED blanc, connectat al pin digital 9 // 改 int ylwPin2 = 10; // LED groc, connectat al pin digital 10 // 改 int redPin2 = 11; // LED vermell, connectat al pin digital 11 // 改 int grnPin2 = 12; // LED verd, connectat al pin digital 12 // 改 int bluPin2 = 13; // LED blau, connectat al pin digital 13 // 改

// Matrius de colors

int negre [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int blanc [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int vermell [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int verd [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blau [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int groc [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int morat [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int taronja [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int rosa [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // etc.

// Estableix el color inicial

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

int espera = 15; // 10 ms de retard creuament intern; augmenta per esvaits més lents // 改

int hold = 1; // Mantenir opcional quan es completa un color, abans del següent crossFade // 改 int DEBUG = 1; // comptador DEBUG; si s'estableix a 1, tornarà a escriure els valors mitjançant la sèrie int loopCount = 60; // Amb quina freqüència s’ha d’informar DEBUG? int repeteix = 0; // Quantes vegades hauríem de fer un bucle abans d’aturar-nos? (0 per a cap parada) // 改 int j = 0; // Comptador de bucles per repetir

// Inicialitzar variables de color

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

// Configureu les sortides LED

void setup () {pinMode (redPin, OUTPUT); // estableix els pins com a sortida pinMode (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) {// Si volem veure valors per a la depuració …

Serial.begin (9600); // … configureu la sortida de sèrie}}

// Programa principal: llista de l'ordre dels esvaits creuats

bucle buit () {crossFade (vermell); crossFade (verd); crossFade (blau); crossFade (groc); crossFade (blanc); crossFade (rosa); crossFade (porpra); crossFade (taronja);

if (repetir) {// Fem un bucle un nombre finit de vegades?

j + = 1; if (j> = repetir) {// Ja hi som? sortida (j); // Si és així, atureu-vos. }}}

/ * A CONTINUACIÓ AQUESTA LÍNIA ÉS LA MATÈNIA: NO HI HAURIA DE CANVIAR-HO PER ELS BÀSICS

El programa funciona així:

Imagineu un atenuament creuat que mou el LED vermell de 0-10, el verd de 0-5 i el blau de 10 a 7, en deu passos. Volem comptar els 10 passos i augmentar o disminuir els valors de color en increments de graons uniformes. Imagineu que un + indica augmentar un valor en 1, i a - equival a baixar-lo. El nostre fade de 10 passos tindria el següent aspecte:

1 2 3 4 5 6 7 8 9 10

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

El vermell puja de 0 a 10 en deu passos, el verd de

0-5 en 5 passos i el blau cau de 10 a 7 en tres passos.

Al programa real, els percentatges de color es converteixen a

0-255 valors i hi ha 1020 passos (255 * 4).

Per esbrinar el gran pas que hi hauria d’haver entre un o més

marqueu cap avall un dels valors del LED, anomenem calculateStep (), que calcula la bretxa absoluta entre els valors inicial i final i, a continuació, divideix aquest buit per 1020 per determinar la mida del pas entre els ajustos del valor. * /

int calculateStep (intValor previ, intValor final) {

int step = EndValue - PreValor; // Quina és la bretxa general? if (pas) {// Si no és nul, pas = 1020 / pas; // divideix per 1020} pas de retorn; }

/ * La següent funció és calculateVal. Quan el valor del bucle, i, arriba a la mida de pas adequada per a un dels colors, augmenta o disminueix el valor d'aquest color en 1. (R, G i B es calculen cadascun per separat) * /

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

if ((pas) && i% step == 0) {// Si el pas és diferent de zero i és hora de canviar un valor, if (pas> 0) {// incrementar el valor si el pas és positiu … val + = 1; } else if (pas 255) {val = 255; } else if (val <0) {val = 0; } retorn val; }

/ * crossFade () converteix el percentatge de colors a

0-255, després fa 1020 vegades, comprova si cal actualitzar el valor cada vegada i escrivint els valors de color als pins correctes. * /

void crossFade (int color ) {// 改

// Converteix a 0-255 int R = (color [0] * 255) / 100; int G = (color [1] * 255) / 100; int B = (color [2] * 255) / 100; int Y = (color [3] * 255) / 100; // 改 int W = (color [4] * 255) / 100; // 改

int stepR = calculateStep (prevR, R);

int stepG = calculateStep (prevG, G); int pas 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); // Escriviu els valors actuals als pins 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); // 改

retard (esperar); // Pausa durant "milersegons" d'espera abans de reprendre el bucle

if (DEBUG) {// Si volem una sortida en sèrie, imprimiu-la al fitxer

if (i == 0 o i% loopCount == 0) {// inici, i cada loopCount vegades Serial.print ("Loop / 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; }} // Actualitza els valors actuals del següent bucle prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 retard (retenció); // Posa en pausa els mil·lisegons "espera" opcionals abans de reprendre el bucle}

Pas 3: configureu

1. Aconseguiu el taulell de revisió.

2. Demostració de cables de connexió perquè una llum LED pugui brillar:

   1. Col·loqueu el LED a la pissarra. Col·loqueu l'extrem més llarg a l'esquerra i l'extrem més curt a la dreta.
   2. Col·loqueu un extrem d'un cable de pont en un punt que es troba a la mateixa fila amb l'extrem més llarg del LED. Col·loqueu l’altre extrem a la secció PWM digital. El codi especificava els LED grocs que es connectarien a 10 i 5, els vermells a 6 i 11, els blaus a 8 i 13, els verds a 7 i 12 i, finalment, els LED blancs a 9.
   3. Col·loqueu un extrem d’una resistència a la mateixa fila amb l’extrem més curt del LED. Col·loqueu l’altre extrem en algun lloc proper.
   4. Col·loqueu un extrem d'un altre cable de pont amb la mateixa fila amb l'extrem de la resistència que no es troba a la mateixa fila amb l'extrem més curt del LED. Col·loqueu l’altre extrem del cable a la fila de càrrega negativa.
   5. Col·loqueu un extrem d’un altre cable de pont a la fila de càrrega negativa i col·loqueu l’altre extrem a GND.
3. Repetiu el pas 2 durant 8 vegades, ja que voleu que brillin 9 LEDs

4. Col·loqueu el taulell de pa dins de la caixa. Alguns recordatoris aquí:

   1. Vaig utilitzar una font d'alimentació. Creeu un petit forat per als vostres cables mitjançant un ganivet utilitzat per passar per la caixa i connectar-lo a la placa.
   2. Assegureu-vos que la caixa estigui oberta a un costat. Una caixa de sabates ja té una cara oberta. Si la caixa està completament tancada, talleu-la per un costat per fer un espai obert.
   3. Cobriu el costat sense res amb paper. Això és perquè les llums LED brillin a través del paper.