Controlando múltiples LEDs con Arduino y TLC5940NT

1

Estoy trabajando en un proyecto de bricolaje en el hogar que necesita que se iluminen aproximadamente 150 LED a diferentes niveles de brillo. También me gustaría tener estos LED encendidos en ciertos patrones, por lo que realmente necesitan ser controlados por un microcontrolador (una matriz de LED controlable, si lo desea).

Después de algunas consideraciones, comencé a incursionar con el Ardunio ya que parece ser adecuado para la tarea en cuestión y me permite multiplexar los LED, etc.

Tengo tanto el Arduino Uno como el Arduino Mega 2560. Para las pruebas utilicé el Mega, ya que tiene 15 canales PWM, por lo que puedo ajustar el brillo de cada LED, etc. sin tener que meterme con diferentes resistores de valor y enganchar suficientes LED. para darme una buena idea de lo que está pasando.

Tenía una buena prueba de concepto en funcionamiento con LED1 encendido durante 1800 microsegundos, luego lo apagué y LED2 se encendió ... y así sucesivamente para los 15 LED. Ninguno de los LED se encendió al mismo tiempo, pero dio la persistencia del efecto de visión (todos los LED aparecen encendidos al mismo tiempo) y no consumieron una gran cantidad de corriente. Esto es lo que aspiro, en una escala mayor de ~ 150 LEDs.

Entonces, a continuación, necesitaba escalar esto. La siguiente prueba de concepto llegó en la forma de utilizar el controlador TLC5940 LED después de leer algunos artículos y blogs en línea.

Conecté el TLC5940 al Arduino Uno más pequeño y conecté 16 LED a los 16 canales de salida del chip. Ejecuté un programa de prueba (creo que se desvaneció / corrió patrones a lo largo de los LED y funcionó bien).

Luego comencé a escribir un bucle que volvería a encender el primer LED, esperar una fracción de segundo, luego apagarlo y pasar al siguiente LED.

El código funcionó hasta aproximadamente 3 LED, pero tan pronto como golpeó el 4º LED, se pudo observar un parpadeo. En el momento en que se amplió a los 16 LED, había un claro patrón visible (como una onda mexicana) en los LED.

Intenté cambiar el tiempo de retardo, reduciéndolo a 1 microsegundo, pero esto tuvo poco efecto.

Mi código era algo como esto:

#include "Tlc5940.h"
int DELVAR = 1

void setup()
{
  Tlc.init(0); // initialise TLC5940 and set all channels off
}


void loop()
{
    Tlc.clear();
    Tlc.set(1, 4096);
    Tlc.update();
    delayMicroseconds(DELVAR);
    Tlc.set(1, 0);
    Tlc.update();

    Tlc.clear();
    Tlc.set(2, 4096);
    Tlc.update();
    delayMicroseconds(DELVAR);
    Tlc.set(2, 0);
    Tlc.update();

    Tlc.clear();
    Tlc.set(3, 4096);
    Tlc.update();
    delayMicroseconds(DELVAR);
    Tlc.set(3, 0);
    Tlc.update();   


    // ....and so on for all 16 channels .....   
    // (not optimal I know but at this point I'm still just getting my head around the logic)
}

¿Hay alguna limitación en la "velocidad" del TLC5940 o de los canales que está usando desde el Arduino?

¿Cómo puedo evitar esto para que todos los LED parezcan iluminados al mismo tiempo? ¿Tengo razón al pensar que el ciclo de trabajo del Arduino es de 16MHz? y si es así, ¿no debería teóricamente poder iluminar y apagar > ¿50,000 LEDs secuencialmente en menos de un segundo?

Descargo de responsabilidad: tengo un conocimiento electrónico muy básico de cuando estuve en la escuela hace unos 15 años, ¡así que esta es una curva de aprendizaje muy pronunciada para mí!

NOTA: * Para cualquier persona que se pregunte en qué estoy trabajando, es un mapa mundial gigante: los LED representan las principales áreas urbanas o pobladas (ciudades, etc.) tal como se ven desde el espacio durante la noche. Finalmente, me gustaría conectarlos a tiempo real para que los LED encendidos representen las áreas urbanas reales iluminadas por la noche en ese punto particular en el tiempo; aquí es donde Arduino sería muy útil.

Es un mapa artístico de cuerdas basado en uno que hice el año pasado (abajo)

Solomuchomásgrande,será8piesx4pies,progresohastaahora,losagujerosparalosLEDperforadosestánlistos:

    
pregunta Huskie69

1 respuesta

2

Tu publicación suena un poco confusa. Parece que está intentando simular PWM actualizando el TLC5940, que no es necesario.

Un TLC5940 contiene 16 canales PWM, cada canal PWM controla el brillo de un LED. Por lo tanto, solo actualice el TLC5940 cuando deba cambiarse el brillo de un LED. El resto del tiempo, el TLC5940 mantendrá el brillo establecido de cada LED utilizando sus propios canales PWM.

El tiempo entre cada actualización debe ser visible para el ojo humano, así que use delay() , que es milisegundos, y nunca delayMicroseconds() , que solo es bueno por unos pocos 10s de milisegundos.

El efecto que está viendo es probable porque la totalidad de loop () se está completando en un milisegundo más o menos.

Es probable que el código actualice el TLC5940 a menos de un ciclo de su tasa de PWM (no puedo recordar si hay lógica en el TLC594 para forzar algo más útil, pero no lo creo). Por lo tanto, es posible que veas el equivalente visual de un "ritmo" entre las dos frecuencias (actualización frente a PWM).

Podrías probar esta hipótesis rápidamente cambiando todo el
delayMicrosecond() a
delay(1000)

Actualice su pregunta si esto no lo soluciona, o si ya lo ha intentado.

Su código no necesita controlar el brillo visual de los LED, el TLC5940 lo hace por usted. Cuando configura el brillo de un LED, el TLC5940 utilizará continuamente PWM para mantener ese brillo para ese LED.

Por lo tanto, para su proyecto, es posible que esté actualizando la escena completa una vez cada pocos segundos, suponiendo que cada LED esté controlado por un solo canal, y use varios TLC5940 con hasta 16 LED en cada uno.

No he leído todo el código en esa biblioteca, pero el hardware SPI de Arduino debería poder actualizar un TLC5940 (192 bits) a aproximadamente 4Mbits (o 8Mbits con la configuración correcta).

Por lo tanto, los 16 LED en un TLC5940 deben actualizarse aproximadamente 5 veces por milisegundo. Por lo tanto, 160 LED serían 10 TLC5940 y se actualizarían cada 2 milisegundos, lo que es mucho mejor que la respuesta de visión humana.

Cada uno de esos LED está bajo control de brillo por el TLC5940, por lo que el código no tiene nada que hacer hasta que una de las 'ciudades' necesita que se cambie el brillo.

Editar:
El punto clave es que su Arduino no hace nada con respecto a PWM. Los programas Arduino envían los valores TLC5940 que son el brillo de cada LED. Eso es todo, nada más que hacer.

El TLC5940 tiene 16 canales PWM, realiza el control del brillo del LED utilizando sus canales PWM, de forma autónoma, sin la participación del Arduino.

El programa Arduino solo habla con el TLC5940 cuando uno o más LED necesitan cambiar su brillo.

Creo que es inconcebible que cambieses los LED más rápido que 50/60 cuadros / segundo (frecuencia de actualización de TV), que 10 TLC5940 sería fácilmente capaz de hacer. Entre cada cambio de brillo de LED, los TLC5940 mantendrán esos brillos establecidos.

Edit2:
¿Tal vez pensaste comprar 74HC595 registros de cambio? Son dispositivos mucho más simples. Un LED estaría encendido o apagado. Con esos, el microcontrolador anfitrión sería responsable de actualizar el 74HC595 para simular el control de brillo tipo PWM.

    
respondido por el gbulmer

Lea otras preguntas en las etiquetas