Cómo utilizar la Fadecandy de Adafruit para controlar ledes

Descripción general

Fuente de la imagen: Adafruit

La colaboración entre Adafruit y Micah de Scanlime tuvo como resultado la presentación de Fadecandy, una placa controladora con interpolación integrada que puede ser controlada por USB. Fadecandy está compuesta tanto de hardware como de software que facilitan la creación y el control de proyectos de arte con ledes direccionables WS2811/WS2812, lo que permite diseñar proyectos más estéticos y menos exigentes con los recursos de los microcontroladores. Fadecandy es una manera fácil de comenzar para principiantes, pero también funciona como una herramienta avanzada para profesionales.

El software del servidor de Fadecandy se comunica con una placa Fadecandy o con decenas de ellas. Puede ejecutarse en los sistemas operativos Windows, Linux o Mac; o en plataformas embebidas como Raspberry Pi. El protocolo Open Pixel Control es una forma simple de obtener datos de píxeles en el servidor de Fadecandy. Cada placa controladora soporta hasta 512 ledes, colocados en grupos de 8 tiras de 64 unidades cada una, pero no soporta ledes RGBW. En el momento de la publicación de este artículo, solo soporta ledes RGB. Más adelante se analiza la programación básica.

El proyecto en cuestión utiliza 52 NeoPixels de Adafruit agrupados en ocho columnas con el fin de atraer a los jugadores a una máquina de garra, y al mismo tiempo, sirven como temporizadores visuales de cuenta regresiva. Si se utiliza una gran cantidad de ledes direccionables y librerías de Arduino tradicionales con conexión directa a la GPIO (entrada y salida de uso general), el procesador se ralentiza y se generan demoras en las funciones del juego y problemas en los tiempos de ejecución. Como una Raspberry Pi 3 ya está programada para los efectos de sonido de la máquina de garra, se agregará la comunicación de iluminación con la Fadecandy a la lista de tareas de la Pi 3.

Determinar los requisitos de alimentación

Un aspecto importante que debe considerarse al utilizar tiras de ledes es el consumo de energía. Aunque cada led de color utiliza una corriente de solo 20 miliamperios, cada NeoPixel de Adafruit, por ejemplo, cuenta con tres colores que en total suman 60 miliamperios si los tres ledes están activos. Si se multiplica esto por los 52 NeoPixels conectados en paralelo en cada tira, la corriente máxima de cada una de ellas excede los 3 amperios. Si se multiplica el número de esta corriente por 8 columnas, se obtiene como resultado un consumo de corriente potencial de 25 amperios, sin contar las otras tiras más pequeñas repartidas en todo el proyecto. Pero ¿por qué un proyecto tendría todos los ledes de cada NeoPixel encendidos al mismo tiempo durante largos períodos? La respuesta es que no los tendrían encendidos a todos juntos, por lo que elegir una fuente de alimentación se vuelve una adivinanza. Si asumimos que el 75% de los NeoPixels están encendidos en cualquier momento y que cada uno tiene solo un color, la corriente disminuye a 6 amperios aproximadamente. La única forma de saber con certeza es programar las luces y medir el consumo de corriente con un medidor.

Considerar el uso de una PCB de conexión para resolver los problemas de diseño y cableado

Antes de comenzar con la programación, se diseña una PCB (placa de circuito impreso) personalizada por medio de KiCad para interconectar las conexiones de Fadecandy a los bloques de terminales adecuados, lo que facilita la conexión y la organización de las salidas. En la máquina de garra, los ledes del lado trasero están en un canal, al igual que los de los lados izquierdo, derecho y delantero, con el fin de conservar los canales. Los ledes superiores e inferiores de la boca expendedora de premios se conectan por separado, y por si acaso, se dejan dos canales para conexiones auxiliares.

La PCB de conexión debe incorporar trazas que puedan controlar el consumo de corriente potencial del bus de alimentación. Utilizar cobre de 2 oz en la placa también ayuda a controlar grandes cantidades de corriente. En las Figuras 1 y 2, se muestra un ejemplo de una PCB creada por medio de KiCad y de la herramienta de construcción de PCB de DigiKey.

Figura 1. PCB vacía del proveedor.

Figura 2. Trazas de bus para corriente de alta potencia.

Preparar la herramienta de construcción de PCB

Una vez desarrollada por completo, se exporta la PCB personalizada con la característica Graficar que se encuentra debajo del menú Archivo de la herramienta de diseño de PCB en KiCad. En el cuadro de diálogo Graficar, haga clic en el botón Generar archivo drill para guardar un archivo drill Gerber en la carpeta que usted elija. Luego, haga clic en el botón Graficar. KiCad creará archivos Gerber adicionales y los guardará en la misma carpeta del archivo drill. Con el Administrador de archivos de Windows, navegue hasta la carpeta que contiene los archivos Gerber. Seleccione todos los archivos relacionados con la PCB; luego, haga clic con el botón derecho en el conjunto de archivos y seleccione la opción Enviar a carpeta comprimida (en zip). Se creará una nueva carpeta comprimida en la carpeta original.

La herramienta de construcción de PCB basada en web de DigiKey ayuda a realizar pedidos de PCB personalizadas y ofrece una gran variedad de opciones y proveedores. Una vez que se inicie la herramienta de construcción de PCB, haga clic en el botón Cargar archivo Gerber y después busque y seleccione la carpeta comprimida creada anteriormente. Se abrirá una ventana para ver la herramienta de PCB, en la que se mostrará una imagen de la placa y una lista de los archivos/las capas que se incluirán en la producción, tal como se muestra en la Figura 3.

Figura 3. Visualizador del constructor de PCB: el primer paso para usar la herramienta de construcción de PCB de DigiKey.

El visualizador del constructor de PCB ofrece muchas herramientas para examinar la PCB propuesta. Para acercar o alejar la imagen, debe desplazarse mientras desliza el cursor sobre la imagen de la PCB; y el cursor de mano permite mover la PCB en todas las direcciones. Se puede ver una capa en particular al activar o desactivar el ícono en forma de ojo junto a cada capa de la lista.

Haga clic en el botón Finalizar carga para avanzar al siguiente paso del pedido. La próxima ventana muestra las estadísticas de la PCB y una lista de opciones para elegir, tales como colores y grosor del cobre (ver Figura 4). Tenga en cuenta que las diferentes opciones modificarán los precios y la disponibilidad de los proveedores, quienes tal vez no ofrezcan las opciones seleccionadas. Primero seleccione una sola placa y luego marque otras opciones si lo necesita.

Figura 4. Cómo elegir especificaciones, proveedores y cantidad de PCB.

Cuando ya haya seleccionado todas las opciones que necesita y haya elegido el proveedor que prefiere, aumente la cantidad de placas de a una y observe el precio. Repita este paso hasta que el precio aumente. Este método determinará la cantidad máxima de placas que pueden producirse al menor precio. Haga clic en el botón Agregar al carrito cuando esté listo para realizar el pedido.

Ensamblar la PCB de conexión personalizada

La PCB ya terminada se puebla con bloques de terminales para tiras de ledes, bloques de terminales de alimentación y una cabecera de 16 pines. La placa Fadecandy de Adafruit se puebla con cabeceras de pines y se inserta en la cabecera de la PCB junto con un espaciador impreso en 3D para soportar la terminación USB de la placa. Vea la Figura 5.

Figura 5. Placa de conexión personalizada y poblada por completo.

Para implementar la placa y comenzar con la programación, se utiliza una plataforma de prueba formada por 8 columnas de 26 NeoPixels de Adafruit para demostrar el concepto que más tarde se cargará en los 52 NeoPixels de la verdadera máquina de garra.

Conecte las tiras de ledes a los bloques de terminales verdes prestando atención a las conexiones de alimentación y señal adecuadas. Conecte una fuente de alimentación de 5 V a los bloques de terminales negros prestando atención a las conexiones de alimentación y tierra adecuadas. La Figura 6 muestra el cableado de los NeoPixels antes de utilizar la placa de conexión, y la Figura 7 muestra las mejoras en el cableado.

Figura 6. Cableado de la plataforma de prueba antes de utilizar una placa de conexión.

Figura 7. Cableado de la plataforma de prueba organizado con la placa de conexión.

Con el hardware y el cableado en su lugar, conecte una Raspberry Pi 3 a la Fadecandy por medio de un cable USB adecuado; a continuación, conecte la Raspberry Pi a un monitor, un teclado y un mouse. Encienda el sistema para comenzar a programarlo. La Fadecandy se configura como un cliente que recibe datos vía USB desde la Pi, que actúa como un servidor. En esta configuración, la Pi también se comunica con una Arduino Mega por medio de una conexión en serie por USB. La Mega controla todas las entradas y salidas de la máquina de juego y simplemente le indica a la Pi si la máquina está ejecutando una partida. La Pi controla los efectos de luces y sonidos.

La Fadecandy puede utilizarse en una gran variedad de funciones y aplicaciones. Pueden encontrarse muchos ejemplos simples y complejos en línea, y se añaden más elementos con frecuencia. El siguiente código representa algunas funciones de multiproceso muy básicas, útiles para las necesidades específicas de iluminación de este proyecto. La Pi se programa para inundar los NeoPixels con un color base y luego añadir destellos de luz al azar para acentuar el campo. Cuando el juego está ejecutando una partida, dos de las tiras se convierten en un temporizador visual de cuenta regresiva. Vea el Video 1 como referencia. El código utilizado en este proyecto se incluye debajo (Lista 1).

Copiar#Raspberry Pi Game Machine Script
import serial
import threading
import queue
import random
import opc, time
import pygame

#Initialize the sound mixer
pygame.mixer.init(44100, 16, 2)

#Create a game start sound effect object
Start_Sound = pygame.mixer.Sound("glass.wav")
Start_Sound.set_volume(1.0)
Start_Sound.play()

#Create a tick-tock sound object
Tick_Sound = pygame.mixer.Sound("ticktock.wav")
Tick_Sound.set_volume(1.0)
#Tick_Sound.play(maxtime=600)

#Create an end of game sound object
End_Sound = pygame.mixer.Sound("Buzzer-sound-16.wav")
End_Sound.set_volume(1.0)
#End_Sound.play()

#Build queue objects for transfer between threads
game_q = queue.Queue(1)
users_q = queue.Queue(1)
matrix_q = queue.Queue(1)

#State the NeoPixel array for the testbed
numLEDs = 8*26
pixels = [ (0,0,0) ] * numLEDs

#Set FadeCandy meter start pixel
meterStartPix = 130

#Create a serial communication object for the Mega
serMega = serial.Serial('/dev/ttyACM0', 115200)

#Create a client object for the Open Pixel server
client = opc.Client('localhost:7890')

#Define a function for the t1 thread that reads data from the Mega
def MegaData():
        while True:
                if serMega.inWaiting() > 0:
                        GameDuration = int(serMega.readline())
                        PlayFlag = int(serMega.readline())
                        game_q.put((GameDuration, PlayFlag))
                        TotalUsers = int(serMega.readline())
                        if not users_q.full():
                                users_q.put(TotalUsers)
                                
                time.sleep(0.001)
                        
#Define a function for the t2 thread which runs the time meter Neopixels                            
def RunMeter():

        while True:
                GameDuration, PlayFlag = game_q.get()
                matrix_q.put(PlayFlag)
                SleepNum = (float(GameDuration)/100/27)
              
                if PlayFlag == 1:
                        #Quickly fill the meter with green
                        meterPix = meterStartPix
                        Start_Sound.play()
                        for i in range(0, 26):
                                pixels[meterPix] = (0, 200, 0)
                                client.put_pixels(pixels)
                                time.sleep(.02)
                                meterPix = meterPix+1
                                
                        #Fill the meter with red based on game timer
                        meterPix = meterStartPix + 25       
                        for i in range(0, 26):
                                if not game_q.empty():
                                        GameDuration, PlayFlag = game_q.get()
                                if PlayFlag == 1:
                                        pixels[meterPix] = (200, 0, 0)
                                        Tick_Sound.play(maxtime=600)
                                        client.put_pixels(pixels)
                                        time.sleep(SleepNum)
                                        meterPix = meterPix-1
                                else:
                                        break
                                
                        #Wait a tad bit
                        time.sleep(.50)
                        End_Sound.play()
                        time.sleep(.50)
                        
                        #Quickly Clear the meter with soft white
                        meterPix  = meterStartPix
                        for i in range(0, 26):

                                pixels[meterPix] = (30, 30, 30)
                                client.put_pixels(pixels)
                                time.sleep(.01)
                                meterPix = meterPix+1
                                                                
                        time.sleep(2)
                else:
                        
                        #Quickly Clear the meter with soft white
                        meterPix = meterStartPix
                        
                        for i in range(0, 26):

                                pixels[meterPix] = (30, 30, 30)
                                client.put_pixels(pixels)
                                time.sleep(.01)
                                meterPix = meterPix+1
                                
                        time.sleep(2) 
                time.sleep(0.001)
                
#Define a function for the t3 thread that controls the non-meter Neopixels               
def RunMatrix():
       
        numLEDs = 6*26
      
        while True:
                if not matrix_q.empty():
                        play_flag = matrix_q.get()
                        if play_flag == 1:
                                numLEDs = 5*26
                        else:
                                numLEDs = 6*26   

                r = random.randint(25,85)
                g = random.randint(25,85)
                b = random.randint(25,85)
                Bright = 3 
                DotNum = 10 
                              
                for j in range(5):
                        for h in range(10):
                                pixels = [ (r, g, b) ] * numLEDs

                                for g in range(DotNum):
                                        p = random.randint(0,numLEDs-1)
                                        pixels[p] = (r*Bright, g*Bright, b*Bright)
                                
                                client.put_pixels(pixels)
                                
                                if not matrix_q.empty():
                                        play_flag = matrix_q.get()
                                        if play_flag == 1:
                                                numLEDs = 5*26
                                        else:
                                                numLEDs = 6*26 
                                time.sleep(.1)

#Create thread objects                                
t1 = threading.Thread(target = MegaData)
t2 = threading.Thread(target = RunMeter)
t3 = threading.Thread(target = RunMatrix)
t1.start()
t2.start()
t3.start()

Lista 1. Código utilizado para controlar los ledes del proyecto de la máquina de garra.

Resumen

Trabajar con ledes direccionables es satisfactorio pero desafiante. A menudo, el código necesario para perfeccionar los efectos visuales puede interferir con otras funciones del microcontrolador. La placa Fadecandy, al igual que otros tipos de controladores de ledes direccionables, se utiliza para solucionar dichos problemas y abrir la puerta a una cantidad infinita de escenarios lumínicos. Junto con el controlador adecuado, las PCB personalizadas son una excelente forma de organizar entradas y salidas, y de distribuir la corriente.