Actualización de luces navideñas

Encontrándonos en las fechas en las que nos hallamos, el proyecto actual no podía ir de otra cosa que no fuera la navidad.

Vamos a modificar una viejas/baratas luces de navidad añadiéndoles control para que parpadeen.

 

El juego de luces original

En este caso tenemos un juego de luces que consta de 12 leds, cada uno metido dentro de una letra que forman las palabras FELIZ NAVIDAD. Además de un porta baterías con interruptor.

 

 

La cuestión es que estos 12 leds están en paralelo y no tienen ningún tipo de control. Por lo que al activarlo lo que tenemos son 12 luces siempre encendidas, lo cual resulta un poco… soso.

 

Ingredientes

 

Lo que necesitamos es:

• El juego de luces.
• Cables.
• Macarrón termoretráctil o cinta aislante.
• Un PCB de prototipado.
• Pines y zócalos.
• Conector/es.
• 3 transistores. En este caso MUN2211.
• Tarjeta de control. En este caso la Trinket M0.
• Estaño.

 

 

También ciertas herramientas como:

• Tijera.
• Soldador.
• Etc..

 

Y, por supuesto, los siempre necesarios elementos de protección, como por ejemplo: gafas, guantes…

 

Montaje

Este, sin duda, ha sido el punto que más trabajo ha dado.

Las luces

El primer paso será recablear los leds para tener distintas ramas de control. Se decide realizar 3 ramas con los leds espaciados en ellas. Por lo que tendremos:

• Primera rama: Letras F I A y D
• Segunda rama: Letras E Z V  y A
• Tercera rama: Letras L N I  y D

Al ser LEDs , hay que distinguir entre el cable de los ánodos y el de los cátodos. El de los ánodos se dejará conectado tal y como está.

 

El cableado de los cátodos lo iremos cortando por la mitad de cada segmento dejando todo los LEDs sueltos.

Tomaremos trozos de cable y cortaremos a la distancia para unir 1 de cada 3 LEDs. En este caso pude aprovechar que el cable original era muy largo hasta empezar las letras y utilicé ese tramo, por lo que queda más bonito que si tienes que usar un cable de distinto color.

Los pelaremos y soldaremos la unión de 1 de cada 3 LEDs. Y ahora usaremos la cinta aislante para proteger las soldaduras, si usáis macarrón termoretráctil tendréis que pasarlo por el cable antes de soldar. Chapuzilla: como no tenía ni cinta aislante ni macarrón transparentes acabé utilizando celo para que no desentonara.

Una vez soldada toda la rama, podemos probar si ha funcionado.

 

Repetiremos el proceso para las 2 ramas restantes.

 

Una vez cableado todo, añadiremos un conector para unir con la tarjeta de control. O si lo queréis dejar fijo, se pueden soldar los cables directamente a la tarjeta. cuando la hayaís realizado.

 

La moraleja la podemos ver clara ahora: Este proyecto está bien de realizar si son una luces que ya tienes. El trabajo de este recableado es largo y tedioso. Si tienes que comprarlas, por un poco más las puedes comprar ya con los parpadeos y te ahorras el trabajo.

 

La tarjeta de control

El siguiente paso será preparar el PCB con los transistores para conectar las luces y la tarjeta de control.

 

Lo primero que haremos será soldar el zócalo para la tarjeta de control. Hemos elegido la tarjeta Trinket M0, de la cual ya os hablamos, muy por encima, en este artículo.

 

Los transistores

Este proyecto me sirve también de excusa para presentaros mis transistores favoritos de baja corriente para usar en conmutación. Los MUN2211 (NPN) de ON Semiconductor. Y ¿Por qué son mis transistores favoritos?…

 

Porque llevan las resistencias de polarización incluidas!!! (¿no os habíais fijado que en la lista de materiales no he incluido resistencias? ?)

 

Esto mola, porque reduce el espacio y el coste. El modelo MUN2211 tiene estas resistencias de 10K (que para conmutación a 5V y 3.3V funciona correctamente), Este código (MUN2211) cambiará para otros modelos: si las resistencias son de otros valores (el 11) o si se quiere el modelo PNP (21 en vez de 22). La pena es que solo están en SMD por lo que hay que ser algo mañoso para soldarlos (con el SOT-23 no suele haber problemas).

Estos transistores tienen una corriente máxima de 100mA. Cada rama lleva 4 LEDs que pueden tener un consumo como mucho de 20mA, por lo que serían 80mA que está dentro de lo que soporta el transistor.

 

Continuamos

Bueno, pues tendremos que soldar los transistores sobre el PCB:

• La bases a pines GPIO de la tarjeta de control. Se pueden elegir pines que tengan también control de PWM para poder dar luego más juego en el software.
• Los emisores a masa (GND).
• Los colectores al conector para las luces.

Dependiendo de donde se puedan situar los transistores y los pines elegidos, puede ser necesario realizar puentes como en mi caso.

 

Hablando de puentes, veréis que el puente de la parte superior de la imagen no está centrado porque sino haría cortocircuito con el puente vertical. Estuve tentado de no hacerlo, pero examinando las líneas una es masa y la otra el colector de un transistor por lo que si se cortocircuitan lo único que pasaría es que esa rama de LEDs quedaría encendida fija, sin estropearse nada, por lo que es un riesgo asumible.

Además, podréis “no ver” los transistores ?, ya que son tan pequeños que pasan desapercibidos con el brillo del estaño.

 

Sobre el conector:

• En vez de situarlo sobre el PCB, he decidido hacerlo sobre un cable. De esta forma puedo alargarlo un poco más.
• Además de las 3 ramas de control hay que añadir un cuarto cable, para los ánodos comunes, que deberá ir conectado al pin de 3V de la tarjeta (la alimentación, que es realmente 3.3V).

 

Y una vez realizado, cortamos el PCB al tamaño adecuado. Cortarlo bien, con las herramientas adecuadas, no os pase como a mí que se me fue la mano y una esquina se rompió (pero no se estropeo nada del circuito y funciona).

 

Alimentación

Al haber desmontado las luces, hemos quitado el porta baterías. Y ahora necesitamos alimentar todo el sistema, no solo las luces, tenemos 2 opciones:

• Conector USB: a través del conector microUSB podemos alimentar todo el sistema. Podremos utilizar un powerbank (batería) o un cargador de móvil (conectado fijo a la red).
• Conector de batería LiPo: la tarjeta permite ser alimentada con una batería LiPo. Para ello lleva la huella de un conector JST por la parte inferior, el que llevan estas baterías, por lo que si queremos usarlo tendremos que comprar y soldar el conector por nuestra cuenta. En la imagen anterior se puede apreciar ligeramente dicho conector.

Programa

El programa se ha realizado en CircuitPython por varias razones:

• La tarjeta viene de fábrica directamente preparada para ello.
• Es un lenguaje sencillo, con mucha ayuda en Internet.
• No es necesario ningún elemento especial, salvo un editor de texto, para realizar el desarrollo.

El código

El código es tan corto que no me he molestado en subirlo a GitHub (sí, lo se, soy un vago ?). Así que aquí lo tenéis:

import board
import digitalio
import time

# Se apaga el led interno para ahorrar energía
import adafruit_dotstar
led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
led[0] = (0, 0, 0)


# Constantes del programa
DELAY_TIME = 0.5
TIMES = 10
PIN_SECTION_1 = board.D0
PIN_SECTION_2 = board.D2
PIN_SECTION_3 = board.D4

# Inicialización del hardware
section_1 = digitalio.DigitalInOut(PIN_SECTION_1)
section_2 = digitalio.DigitalInOut(PIN_SECTION_2)
section_3 = digitalio.DigitalInOut(PIN_SECTION_3)

section_1.direction = digitalio.Direction.OUTPUT
section_2.direction = digitalio.Direction.OUTPUT
section_3.direction = digitalio.Direction.OUTPUT

section_1.value = False
section_2.value = False
section_3.value = False


# Listas que incluyen las distintas secuencias que queramos
sequence_1 = [[True, False, False],
              [False, True, False],
              [False, False, True]]

sequence_2 = [[True, False, False],
              [True, True, False],
              [True, True, True],
              [False, True, True],
              [False, False, True],
              [False, False, False]] 


sequence_3 = [[True, True, True],
              [False, False, False]]


def do_sequence(sequence, delay=DELAY_TIME, times=10):
    """"Genera la secuencia pasada un número determinado de
    repeticiones. A la velocidad dependiente del retardo pasado.
    """"
    for _ in range(0, times):
        for step in sequence:
            section_1.value = step[0]
            section_2.value = step[1]
            section_3.value = step[2]
            time.sleep(delay)

# Se generan continuamente las distintas secuencias programadas
while True:
    do_sequence(sequence_1)
    do_sequence(sequence_1, DELAY_TIME / 2, TIMES * 2)
    do_sequence(sequence_1, DELAY_TIME / 4, TIMES * 4) 
    do_sequence(sequence_1, DELAY_TIME / 8, TIMES * 8)
    do_sequence(sequence_1, DELAY_TIME / 4, TIMES * 4) 
    do_sequence(sequence_1, DELAY_TIME / 2, TIMES * 2) 
    do_sequence(sequence_1)

    do_sequence(sequence_2)

    do_sequence(sequence_3)
    do_sequence(sequence_3, DELAY_TIME / 2, TIMES * 2) 

Estudiemoslo

• Se graba en la memoria de la tarjeta con el nombre de main.py.
• Habrá que comprobar que los pines (PIN_SECTION_x) corresponden con los que realmente hemos usado de la tarjeta.
• Podremos modificar/añadir las secuencias a nuestro gusto.
• Habreis visto que en el hardware hemos elegido unos pines que permitieran hacer PWM, sin embargo aquí no se ha utilizado. Realice unas pruebas y con estos LEDs no me convenció el resultado, por lo que finalmente lo rechazé (pero aún así, mejor usar esos pines por si acaso se cambia de idea).

 

Podemos dividir el programa en 4 partes:

• La inicialización y configuración de los pines.
• Las estructuras que almacenan las secuencias. Cada elemento tiene el estado de las 3 ramas para cada paso.
• la función, do_sequence(), que realiza la secuencia que se le pide.
• El bucle infinito que solicita reproducir las distintas secuencias.

 

Resultado

Bueno, el resultado ha sido lo primero que habréis visto al comienzo del artículo: Las luces parpadeando que lo encabezan. Así que no creo que sea necesario repetir ?

Extras

Ya sabéis que lo maravilloso del mundo maker es no seguir las instrucciones al 100% y orientarlas a nuestras propias ideas, así que si os animáis a realizarlo podéis:

• Usar una tarjeta de control distinta.
• Dividir los LEDs en un número distinto de ramas.
• En mi caso he dejado las luces dentro de la caja para que se lea bien FELIZ NAVIDAD (y tenerlo todo bien recogidico), las podéis sacar de la caja y distribuirlas sobre algún objeto de adorno.
• Añadir el control por PWM para realizar otro tipo de secuencias.
• Etc…

Y más extras

Y bueno, yo no soy muy navideño, pero tengo un compañero que sí y cada año buscamos realizar un nuevo adorno provisto de tecnología. Así que ya que estamos, os voy a mostrar otros proyectos que hemos realizado en años anteriores:

• Greeting Santa: un muñeco que mueve el brazo con un sensor de movimiento (en inglés): https://www.instructables.com/id/Greeting-Santa/
• Christmas Frame: Un marco con una matríz de leds que muestra imágenes navideñas, incluyendo a la nieve caer (en inglés): https://www.instructables.com/id/Chritsmas-Frame/
• Árbol de navidad: con una Circuit Playground Express y un cuerpo impreso en 3D: https://twitter.com/victormna_dev/status/1075458256879972352
• Corona navideña: De este no tenemos documentación pero os lo explico y muestro un vídeo del resultado:
  • Una corona de fieltro. Se puede comprar hecha o, si tienes habilidad, comprar los fieltros y fabricarla entera desde cero.
  • Se le añade un puñado de Neopixels.
  • Controlados por un Arduino nano.
  • El programa es simplemente tomar el ejemplo strandtest de la librería de Adafruit Neopixels.
  • Se le añadió debajo una bota de Papá Noel.
  • El secreto de esta bota es… guardar la batería!!! p.e. un powerbank.
  • Y por supuesto, cables, pegamento, silicona… para unirlo todo.

 

 

 

 

 

Bueno, y aunque sea un poco pronto, la despedida de este artículo no podría ser otra que: Feliz navidad!!!