Mejora de un cubo de estado de ánimo LED Arduino (simple) (video incluido): 4 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

Después de ver un pequeño proyecto de LED Mood Cube creado por 'earl, decidí hacer una versión mejorada del LED Mood Cube. Mi versión será más compleja que la original, ya que será un poco más grande que la original, tendrá dos colores más en comparación con el cubo original (agregado amarillo y blanco), tendrá una cantidad infinita de rotación de colores, etc. debería ser un buen proyecto para practicar sobre el uso posterior de luces LED para aquellos que entendieron el concepto de conectar luces LED con cables.

Paso 1: Materiales

Aquí hay algunos materiales que necesitará para hacer este Mood Cube:

• Tablero de circuitos
• Arduino - (tengo a Leonardo aquí)
• Fuente de alimentación Arduino / cable USB
• Tablero de circuitos
• Cables de puente (muchos de ellos, usé 29 cables)
• LED rojo x 2
• LED azul x 2
• LED verde x 2
• LED amarillo x 2
• LED blanco x 1
• 9 resistencias
• Caja lo suficientemente grande como para caber en la placa de pruebas (usé una caja de zapatos)
• Cuchillo de uso
• Papel

Paso 2: Código

Alguna explicación para el código dado aquí:

El crédito de los códigos va a la fuente original de mi proyecto ya que el editor del proyecto creó estos códigos. Simplemente mejoré algunos de ellos haciéndolos más complejos. En algunos códigos, es posible que vea // 改 al final. Esto significa que yo edito este código, por lo que es diferente de mi fuente original.

También tengo una versión del código en Arduino Creator.

/ * Código para desvanecimiento cruzado 3 LED, rojo, verde y azul (RGB) Para crear desvanecimientos, debe hacer dos cosas: 1. Describir los colores que desea que se muestren 2. Enumere el orden en el que desea que se desvanezcan

DESCRIBIR UN COLOR:

Un color es solo una matriz de tres porcentajes, 0-100, que controlan los LED rojo, verde y azul.

El rojo es el LED rojo al máximo, el azul y el verde están apagados.

int red = {100, 0, 0} El blanco tenue son los tres LED al 30% int dimWhite = {30, 30, 30} etc.

A continuación se proporcionan algunos colores comunes o puede crear los suyos propios.

LISTANDO EL PEDIDO:

En la parte principal del programa, debe enumerar el orden en el que desea que aparezcan los colores, p. Ej. crossFade (rojo); crossFade (verde); crossFade (azul);

Esos colores aparecerán en ese orden, desvaneciéndose de

un color y en el siguiente

Además, hay 5 configuraciones opcionales que puede ajustar:

1. El color inicial se establece en negro (por lo que el primer color se desvanece), pero puede establecer el color inicial para que sea cualquier otro color 2. El bucle interno se ejecuta durante 1020 interaciones; la variable 'esperar' establece la duración aproximada de un solo fundido cruzado. En teoría, una 'espera' de 10 ms debería hacer un crossFade de ~ 10 segundos. En la práctica, las otras funciones que realiza el código reducen la velocidad a ~ 11 segundos en mi tablero. YMMV. 3. Si 'repetir' se establece en 0, el programa se repetirá indefinidamente. si se establece en un número, se repetirá ese número de veces y luego se detendrá en el último color de la secuencia. (Establezca 'retorno' en 1 y haga que el último color sea negro si desea que se desvanezca al final.) 4. Hay una variable 'retención' opcional, que pasa el programa por milisegundos 'retención' cuando un color es completa, pero antes de que comience el siguiente color. 5. Establezca el indicador DEBUG en 1 si desea que la salida de depuración se envíe al monitor en serie.

Los aspectos internos del programa no son complicados, pero

son un poco quisquillosos: el funcionamiento interno se explica debajo del bucle principal.

Abril de 2007, Clay Shirky

*

/ Producción

int ylwPin = 5; // LED amarillo, conectado al pin digital 5 // 改 int redPin = 6; // LED rojo, conectado al pin digital 6 // 改 int grnPin = 7; // LED verde, conectado al pin digital 7 // 改 int bluPin = 8; // LED azul, conectado al pin digital 8 // 改 int whiPin = 9; // LED blanco, conectado al pin digital 9 // 改 int ylwPin2 = 10; // LED amarillo, conectado al pin digital 10 // 改 int redPin2 = 11; // LED rojo, conectado al pin digital 11 // 改 int grnPin2 = 12; // LED verde, conectado al pin digital 12 // 改 int bluPin2 = 13; // LED azul, conectado al pin digital 13 // 改

// Matrices de colores

int negro [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int blanco [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int rojo [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int verde [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int azul [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int amarillo [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int violeta [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int naranja [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int rosa [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // etc.

// Establecer color inicial

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

int espera = 15; // Retardo interno de crossFade de 10 ms; aumentar para desvanecimientos más lentos // 改

int hold = 1; // Mantener opcional cuando un color está completo, antes del próximo crossFade // 改 int DEBUG = 1; // Contador DEBUG; si se establece en 1, volverá a escribir los valores a través de serial int loopCount = 60; // ¿Con qué frecuencia debe informar DEBUG? int repetir = 0; // ¿Cuántas veces deberíamos hacer un bucle antes de detenernos? (0 para no parar) // 改 int j = 0; // Contador de bucles para repetir

// Inicializar variables de color

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

// Configurar las salidas LED

configuración vacía () {pinMode (redPin, SALIDA); // establece los pines como salida pinMode (grnPin, OUTPUT); pinMode (bluPin, SALIDA); pinMode (ylwPin, SALIDA); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, SALIDA); // 改 pinMode (bluPin2, SALIDA); // 改 pinMode (ylwPin2, SALIDA); // 改 pinMode (redPin2, SALIDA); // 改

if (DEBUG) {// Si queremos ver valores para depurar…

Serial.begin (9600); //… configura la salida serial}}

// Programa principal: enumera el orden de los fundidos cruzados

bucle vacío () {crossFade (rojo); crossFade (verde); crossFade (azul); crossFade (amarillo); crossFade (blanco); crossFade (rosa); crossFade (violeta); crossFade (naranja);

if (repeat) {// ¿Hacemos un bucle un número finito de veces?

j + = 1; if (j> = repeat) {// ¿Ya llegamos? salida (j); // Si es así, deténgase. }}}

/ * DEBAJO DE ESTA LÍNEA ESTÁ LAS MATEMÁTICAS: NO DEBE NECESITAR CAMBIAR ESTO POR LO BÁSICO

El programa funciona así:

Imagine un fundido cruzado que mueve el LED rojo de 0 a 10, el verde de 0 a 5 y el azul de 10 a 7, en diez pasos. Querríamos contar los 10 pasos y aumentar o disminuir los valores de color en incrementos escalonados de manera uniforme. Imagine que un + indica aumentar un valor en 1 y un - equivale a reducirlo. Nuestro desvanecimiento de 10 pasos se vería así:

1 2 3 4 5 6 7 8 9 10

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

El rojo sube de 0 a 10 en diez pasos, el verde de

0-5 en 5 pasos, y el azul cae de 10 a 7 en tres pasos.

En el programa real, los porcentajes de color se convierten a

0-255 valores, y hay 1020 pasos (255 * 4).

Para averiguar qué tan grande debe haber un paso entre uno hacia arriba o

tick hacia abajo de uno de los valores de LED, lo llamamos calculateStep (), que calcula la brecha absoluta entre los valores inicial y final, y luego divide esa brecha por 1020 para determinar el tamaño del paso entre los ajustes en el valor. * /

int calculateStep (int prevValue, int endValue) {

int paso = endValue - prevValue; // ¿Cuál es la brecha general? if (paso) {// Si no es cero, paso = 1020 / paso; // dividir por 1020} return paso; }

/ * La siguiente función es calculateVal. Cuando el valor del bucle, i, alcanza el tamaño de paso apropiado para uno de los colores, aumenta o disminuye el valor de ese color en 1. (R, G y B se calculan cada uno por separado). * /

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

if ((paso) && i% paso == 0) {// Si el paso es distinto de cero y es hora de cambiar un valor, if (paso> 0) {// incrementa el valor si el paso es positivo… val + = 1; } else if (paso 255) {val = 255; } más si (val <0) {val = 0; } return val; }

/ * crossFade () convierte el porcentaje de colores en un

Rango 0-255, luego se repite 1020 veces, verificando si el valor debe actualizarse cada vez, luego escribe los valores de color en los pines correctos. * /

void crossFade (int color ) {// 改

// Convertir 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 stepB = calculateStep (prevB, B); int stepY = calculateStep (prevY, Y); // 改 int stepW = calculateStep (prevW, W); // 改

para (int i = 0; i <= 1020; i ++) {redVal = calculateVal (stepR, redVal, i); grnVal = calculateVal (pasoG, grnVal, i); bluVal = calculateVal (pasoB, bluVal, i); ylwVal = calculateVal (pasoY, ylwVal, i); // 改 whiVal = calculateVal (pasoW, whiVal, i); // 改

analogWrite (redPin, redVal); // Escribe los valores actuales en los pines 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); // 改

retrasar (esperar); // Pausa durante milisegundos de 'espera' antes de reanudar el ciclo

if (DEBUG) {// Si queremos una salida en serie, imprímala en el

if (i == 0 o i% loopCount == 0) {// comienzo, y cada loopCount veces 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 ("/"); // 改} DEPURAR + = 1; }} // Actualiza los valores actuales para el siguiente ciclo prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 retrasar (mantener); // Pausa por milisegundos de 'espera' opcionales antes de reanudar el ciclo}

Paso 3: configurar

1. Consigue la placa de pruebas.

2. Demostración de la conexión de cables para que brille una luz LED:

   1. Coloque el LED en la placa de pruebas. Coloque el extremo más largo a la izquierda y el más corto a la derecha.
   2. Coloque un extremo de un cable de puente en un lugar que esté en la misma fila con el extremo más largo del LED. Coloque el otro extremo en la sección Digital PWM. El código especificaba que los LED amarillos se conectarían a 10 y 5, rojos a 6 y 11, azules a 8 y 13, verdes a 7 y 12, y finalmente LED blanco a 9.
   3. Coloque un extremo de una resistencia en la misma fila con el extremo más corto del LED. Coloque el otro extremo en algún lugar cercano.
   4. Coloque un extremo de otro cable de puente con la misma fila con el extremo de la resistencia que no está en la misma fila con el extremo más corto del LED. Coloque el otro extremo del cable en la fila de carga negativa.
   5. Coloque un extremo de otro cable de puente en la fila de carga negativa y coloque su otro extremo en GND.
3. Repita el paso 2 8 veces ya que desea que brillen 9 LED

4. Coloque la placa de pruebas dentro de la caja. Algunos recordatorios aquí:

   1. Usé una fuente de alimentación. Crea un pequeño orificio para tus cables con un cuchillo para uso general para pasar a través de la caja y conectarlo a la placa de pruebas.
   2. Asegúrese de que la caja tenga un lado que esté abierto. Una caja de zapatos ya tiene un lado que está abierto. Si la caja está completamente cerrada, corte un lado de la caja para hacer un espacio abierto.
   3. Cubra el lado sin nada con papel. Esto es para que las luces LED brillen a través del papel.