Tecnologia vestible

NeoPixel i LilyPad Pixel Board

El NeoPixel (foto de l'esquerra) és un LED RGB (és a dir, un LED tricolor) que incorpora un circuit intern que permet controlar si està encès o no i el seu color. Un NeoPixel té un diàmetre de menys de 14 mm (més petit que una moneda d'un cèntim) i un gruix inferior als 3  mm. Això facilita el seu us incorporant-los a elements tèxtils. Els NeoPixel es venen en paquets de quatre o de vint.

La LilyPad Pixel Board (foto de la dreta) és una placa per cosir de 2 cm de diàmetre que incorpora un LED RGB intel·ligent. De fet és equivalent al NeoPixel ja que porta el mateix controlador.

              [SF]

Existeixen cristalls difusors per als NeoPixels.

El control dels NeoPixels es fa des d'una única sortida digital del microcontrolador de manera que deixa totes les altres potes lliures per a altres funcions. A més, els NeoPixels es poden posar en cadena (connectant la sortida de l'un amb l'entrada del següent) i això permet controlar individualment un nombre elevat de LED fent servir una única sortida.

Per fer servir un NeoPixel cal connectar el born + (superior a la foto) al born positiu de l'alimentació, el born - (inferior a la foto) al negatiu de l'alimentació i el born amb una fletxa entrant (el de la dreta a la foto) amb una sortida digital del microcontrolador. Si fem una cadena connectarem el born marcat amb la fletxa sortint d'un amb el born marcat amb la fletxa entrant del següent.

El següent diagrama mostra com es connectarien dos NeoPixels a una placa de microcontrolador Flora. El positiu dels NeoPixels s'ha connectat al born VBATT i el negatiu al born GND. L'entrada de communicació dels NeoPixels s'ha connectat a la pota D6 del microcontrolador.

Per fer servir els NeoPixels ens caldrà la NeoPixel library. Si ja hem instal·lat la versió de l'entorn de programació Arduino que proporciona Adafruit és probable que ja tinguem aquesta biblioteca instal·lada. Podem comprovar-ho en la pestanya Sketch del menú:

Un cop ja tinguem la biblioteca, podem fer els nostres programes. A la part inicial, hem de carregar la biblioteca corresponent:

#include <Adafruit_NeoPixel.h>

A la part de declaració de variables, hem de crear un objecte Adafruit_NeoPixel per a cada cadena de LED. Considerem que formen una cadena tots els que estan connectats un després de l'altra a una mateixa sortida del microcontrolador.

Adafruit_NeoPixel cadena = Adafruit_NeoPixel(10, 6, NEO_GRB + NEO_KHZ800);

En aquest cas l'objecte s'anomena cadena i correspon a un conjunt de 10 NeoPixels (primer valor dins el parèntesi) connectats a la pota 6 del microcontrolador (segon paràmetre dins el parèntesi). El tercer paràmetre (NEO_GRB + NEO_KHZ800) indica quin tipus de NeoPixels fem servir i com es comuniquen. Els que estan actualment disponibles són els NeoPixel v2 que es corresponen amb els indicats en el programa d'exemple. Actualment hi ha també NeoPixel (especialment en combinacions) que incorporen un quart LED de color blanc. En aquests casos serà necessari posar NEO_RGBW + NEO_KHZ800 o bé NEO_GRBW + NEO_KHZ800. Si no tenim clar quina de les tres opcions és, les podem anar provant fins trobar la que dóna el resultat esperat.

Encara que no és imprescindible, es recomana inicialitzar els NeoPixels de la cadena. Això ho podem fer a la inicialització (setup) del programa amb les següents instruccions:

void setup() {
	cadena.begin();  // Inicialitza els NeoPixels				
	cadena.show();
}

El nostre programa s'encarregarà d'anar encenent els NeoPixels amb els colors desitjats. Per exemple les instruccions:

void loop() {
	cadena.setPixelColor(0, 255, 0, 0);  // Pixel 0 vermell
	cadena.setPixelColor(1, 0, 255, 0);  // Pixel 1 verd
	cadena.show(); // Actualitza
	delay(1000);  // Espera un segon
	cadena.setPixelColor(0, 0, 255, 0);  // Pixel 0 verd
	cadena.setPixelColor(1, 0, 0, 255);  // Pixel 1 blau
	cadena.show(); // Actualitza
	delay(1000);  // Espera un segon
	cadena.setPixelColor(0, 0, 0, 255);  // Pixel 0 blau
	cadena.setPixelColor(1, 255, 0, 0);  // Pixel 1 vermell
	cadena.show(); // Actualitza
	delay(1000);  // Espera un segon
}

Les dues primeres instruccions serveixen per indicar el color d'un Pixel concret. El primer paràmetre és el número de Pixel (0 és el més proper al microcontrolador, 1 el segon, etc.) i els altres tres són la codificació RGB del color, és a dir les quantitats de vermell, verd i blau desitjades (valors entre 0, apagat, i 255). La tercera instrucció transfereix de cop tots els canvis; d'aquesta manera, tots els Pixels canviaran simultàniament. Després d'un segon, es modifiquen els colors seguint una seqüència.

Aquest mètode és senzill però implica anar definint els colors cada cop a base de tres nombres. Hi ha una altra manera més compacta que consisteix en definir una variable d'un tipus específic que guardi un color concret.

#include <Adafruit_NeoPixel.h>

Adafruit_NeoPixel cadena = Adafruit_NeoPixel(10, 6, NEO_GRB + NEO_KHZ800);   // Deu NeoPixel a la pota 6
uint32_t groc = cadena.Color(255, 255, 0);  // Defineix el color groc

void setup() {
	cadena.begin();  // Inicialitza els NeoPixels				
	cadena.show();
}

void loop() {
	cadena.setPixelColor(0, 255, 0, 0);  // Pixel 0 vermell
	cadena.setPixelColor(1, 0, 255, 0);  // Pixel 1 verd
	cadena.show(); // Actualitza
	delay(1000);  // Espera un segon
	cadena.setPixelColor(0, 0, 255, 0);  // Pixel 0 verd
	cadena.setPixelColor(1, 0, 0, 255);  // Pixel 1 blau
	cadena.show(); // Actualitza
	delay(1000);  // Espera un segon
	cadena.setPixelColor(0, 0, 0, 255);  // Pixel 0 blau
	cadena.setPixelColor(1, groc);  // Pixel 1 groc
	cadena.show(); // Actualitza
	delay(1000);  // Espera un segon
	cadena.setPixelColor(0, groc);  // Pixel 0 groc
	cadena.setPixelColor(1, 255, 0, 0);  // Pixel 1 vermell
	cadena.show(); // Actualitza
	delay(1000);  // Espera un segon
}

El programa següent fa una cosa similar en CircuitPithon:

import board
import neopixel
import time

cadena = neopixel.NeoPixel(board.D2, 2, brightness=0.3)  # Dos NeoPixel a la pota D2

groc = (255, 255, 0)

while True:
    cadena[0] = (255, 0, 0)    # Pixel 0 vermell
    cadena[1] = (0, 255, 0)    # Pixel 1 verd
    time.sleep(1)
    cadena[0] = (0, 255, 0)    # Pixel 0 verd
    cadena[1] = (0, 0, 255)    # Pixel 1 blau
    time.sleep(1)
    cadena[0] = (0, 0, 255)    # Pixel 0 blau
    cadena[1] = groc           # Pixel 1 groc
    time.sleep(1)
    cadena[0] = groc           # Pixel 0 groc
    cadena[1] = (255, 0, 0)    # Pixel 1 vermell
    time.sleep(1)

Fixem-nos que podem ajustar la brillantor entre 0 i 1. En qualsevol moment podem modificar la brillantor:

    cadena.brightness = 0.8

Si volem posar tots els NeoPixel del mateix color podem fer servir la funció fill, com en aquests casos:

    cadena.fill((255, 0, 0))
    cadena.fill(groc)

En CircuitPithon, en principi, els NeoPixel s'actualitzen en el mateix moment en el que se'ls canvia el color. Això es pot desactivar afegint una opció quan es defineix l'objecte:

cadena = neopixel.NeoPixel(board.D2, 2, brightness=0.3, auto_write=False)

Llavors podem controlar quan s'envia el color als NeoPixel amb les funcions write o show, totes dues fan el mateix.

while True:
    cadena[0] = (255, 0, 0)    # Pixel 0 vermell
    cadena.write()
    time.sleep(1)
    cadena[0] = (0, 255, 0)    # Pixel 0 verd
    cadena.show()
    time.sleep(1)

A més dels NeoPixels que podem connectar, a la placa Circuit Playground Express disposem de 10 NeoPixel connectats a D8.

En aquest web, les fotografies marcades amb [AF] són del web d'Adafruit, les marcades amb [SF] del web d'Sparkfun i les marcades amb [AU] del web d'Arduino.

Aquesta obra d'Oriol Boix està llicenciada sota una llicència no importada Reconeixement-NoComercial-SenseObraDerivada 3.0.