Flora y LilyPad cómo crear proyectos para Wearables con Arduino

En este artículo te voy a hablar de wearables y cómo crear tecnología que se integre con alguna parte de nuestro cuerpo o con prendas de vestir. Todo a través del ecosistema Arduino y gracias a las placas Flora y LilyPad.

En las últimas semanas he estado investigando sobre todo este tema debido a que me invitaron a dar una charla en una feria de moda. La sensación con la que me quedé tras la exposición es que el sector está todavía muy verde para adoptar este tipo de tecnologías.

Pero para eso estamos los Makers, para dar nuestro apoyo técnico a todos aquellas mentes creativas que no saben como llevar a la realidad sus proyectos. La intersección entre el mundo creativo y el mundo técnico es donde surgen los buenos proyectos.

Comenzaremos viendo el concepto de wearable para luego darte a conocer dos de sus máximos exponentes en el mundo Maker: LilyPad y Flora. Se trata de dos placas compatibles con Arduino y enfocadas al mundo de la ropa interactiva.

También te presentaré componentes eléctricos para dar funcionalidades extra a esos proyectos y así poder conseguir tus objetivos. Totalmente compatibles con Flora y LilyPad.

Por último haremos un caso práctico, un pequeño proyecto para señalizar a los ciclistas en condiciones de poca luz.

Quiero avisar que yo parto con ventaja. Desde muy pequeño me he criado entre cortinas, agujas, máquinas de coser y todo lo que envuelve a la costura. Mi madre es modista. Desde bien pequeño recuerdo el taller de costura y todas las oportunidades que he tenido dentro de ese espacio.

Para mi escribir este artículo ha sido una vuelta a mi infancia. Pasé muchas horas junto a mis primos dentro del taller inventando cosas nuevas y haciendo nuestros propios juguetes y disfraces.

Dicho esto, saca la aguja y el hilo que vamos a crear nuestro primer Wearable con Arduino.

Indice de contenidos

1 ¿Qué es un wearable?
2 Flora y LilyPad, las placas para wearables compatibles con Arduino
3 Componentes eléctricos para Flora y LilyPad
4 Ejemplo práctico con Flora: señalización para ciclistas con NeoPixel
5 Enlaces de interés para Flora y LiLyPad
6 Conclusiones wearables Flora y LilyPad

¿Qué es un wearable?

En español se puede traducir como tecnología vestible, llevable o usable es decir, que está integrada con alguna parte de nuestro cuerpo. Viene de la palabra wear que significa vestir y de ahí el juego de palabras. También se conocen como e-textiles o soft circuits (en inglés significa circuitos blandos).

Los dispositivos que han puesto en boca de todo el mundo esta tecnología son los relojes y pulseras inteligentes. Quien no conoce Fitbit, Pebble o Apple Watch. Todos estos productos son wearables.

Imagen cedida por Shutterstock

La finalidad de estos dispositivos wearables es captar alguna magnitud física entorno a nuestro cuerpo o al mundo que nos rodea y transformarla en datos digitales que podamos almacenar, visualizar y controlar.

Se utilizan en sectores como la salud, el deporte, el entretenimiento, el sector industrial o el militar. Pero todos estos dispositivos siguen un mismo patrón: la unidad central es un microcontrolador o microprocesador al que se conectan sensores y actuadores.

Los sensores nos permiten captar la información del medio físico que nos rodea. Se encargan de medir las magnitudes físicas y transformarlas en señales eléctricas capaces de ser entendidas por un microcontrolador. Podemos medir la temperatura, radiación UV, presión atmosférica, ritmo cardíaco o la geolocalización.

Los actuadores hacen el camino contrario. Parten de una señal eléctrica que se transforma en una fuerza que altera el medio físico. Por ejemplo un motor o encender una luz.

Seguro que todo esto te suena :). Efectivamente, sigue la misma arquitectura que utilizamos en muchos de nuestros proyectos Maker. De hecho, veremos como han surgido placas de desarrollo cuya finalidad es crear prototipos de wearables y que son compatibles con Arduino.

Pero claro, no podemos utilizar cualquier placa de Arduino para wearables. Estas deben tener ciertas características para que se integren con nuestra ropa y en nuestro propio cuerpo.

Características de las placas para wearables

Podemos definir tres requisitos indispensables que debe tener toda tecnología que pretenda ser un Wearable.

Lo primero es que el tamaño sí que importa. Si realmente queremos integrarlo dentro de nuestras prendas de vestir ya sea ropa, calzando o lo que sea, debe ser de un tamaño reducido.

No podemos utilizar las típicas placas de prototipado como el Arduino UNO o Arduino MEGA. Necesitamos placas cuyo tamaño sea lo suficientemente pequeño para que se integre bien en nuestro cuerpo o en prendas de vestir.

Imagen obtenida de Adafruit

La segunda características es el consumo. Las baterías han evolucionado bastante en los últimos tiempos y los wearables deben aprovecharse de este avance. Necesitamos placas y componentes cuyo consumo sea lo más reducido posible.

Es inviable hacer un dispositivo que se integra en una camiseta y que como fuente de alimentación necesite una batería de coche :).

Imagen obtenida de Adafruit

Por último la integración con las prendas de vestir y partes de nuestro cuerpo. Vamos a poner un ejemplo. Partimos de una placa como un Arduino NANO. Es pequeña y de muy bajo consumo. Sin embargo, este tipo de placas son difíciles de integrar con la ropa tradicional.

Por un lado la interfaz de los pines no nos permite utilizarlo con hilo conductivo de una forma sencilla. No está adaptado para esto.

Por otro lado no se puede acoplar de una forma cómoda en ciertas prendas de vestir. No quiero decir con ello que no se pueda utilizar. Seguramente sea un buen comienzo para hacer un prototipo, pero hay placas que se adaptan mejor.

Imagen obtenida de Adafruit

Teniendo en cuenta todo esto, vamos a ver dos placas de desarrollo, LilyPad y Flora, que cumplen estas características y son totalmente compatibles con la plataforma de Arduino.

Flora y LilyPad, las placas para wearables compatibles con Arduino

Dentro del abanico de placas compatibles con Arduino, encontramos Flora de Adafruit y LilyPad de Arduino y Sparkfun. Estas dos placas están diseñadas para crear proyectos wearables.

Así que me voy a centrar en estas dos opciones. Vamos a ver las características más importantes de cada una de ellas y cómo podemos empezar a trabajar desde la plataforma de Arduino.

LilyPad la opción de Arduino para Wearables

LilyPad es una placa desarrollada por la ingeniera, diseñadora y educadora Leah Buechley y por la empresa Sparkfun en colaboración con Arduino. Está diseñada para ser fácilmente integrada en cualquier prenda de vestir.

Su nombre significa nenúfar debido a la forma tan característica que tiene.

Tiene una forma de círculo, algo que se sale de la típica forma cuadrada a la que estamos acostumbrados en placas como Arduino UNO, Arduino MKR1000 o NodeMCU. Su tamaño es de unos 50 mm de diámetro y 0,8 mm de altura.

Imagen obtenida de Sparkfun

Gracias a su pineado (la forma que tienen los pines) se puede adaptar fácilmente a las prendas de vestir ya que se pueden coser con hilo conductivo.

Hay diferentes modelos de LilyPad que varían según la funcionalidad, según el microcontrolador que utiliza e incluso el tipo de conectores. Algunas llevan incorporado un conector JST para la batería, otras llevan un FTDI (adaptador Serie-USB) integrado en la placa e incluso hay un modelo que lleva corchetes en los pines

Elegir una placa u otra dependerá de nuestras necesidades. Yo voy a poner como ejemplo el LilyPad Arduino Simple Board. La puedes adquirir de forma individual por un precio de más o menos 30€ con gastos de envío incluidos. Pero también lo puedes adquirir en un kit con todo lo necesario para empezar a crear tus propios proyectos.

Una de sus características es que esta placa se puede lavar bajo ciertas condiciones. Arduino y Sparkfun recomiendan lavarlo con agua fría a mano y con un detergente suave. Luego hay que dejarlo escurrir y no meterlo en una secadora ni llevarlo a una lavandería. Si decides lavar una prenda con un LilyPad asegúrate de quitar antes la batería. Este componente no soporta el agua.

Características técnicas

Vamos a analizar las características más importantes que tiene esta placa. Muchas de ellas las puedes sacar de las hoja de características técnicas del microcontrolador, el ATmega328P. En la siguiente tabla te resumo las más importantes.

Característica	Valor
Microcontrolador	ATmega328P (8 MHz)
Voltaje de alimentación	2,7V a 5,5V
Consumo	Entre 0,75uA y 0,2mA
Pines digitales	9
Pines PWM	5 (5, 6, 9, 10 y 11)
Pines analógicos	4
Pin 3,3V	1
Pin GND	1
Corriente máxima pines	40 mA
Memoria Flash	32 KB
SRAM	2 KB
EEPROM	1 KB
I2C	A4 (SDA) y A5 (SCL)

El ATmega328P es un microcontrolador de bajo consumo (de entre 0,75μA a 0,2mA dependiendo el modo) de 8-bit y una frecuencia de reloj de 80 MHz. Es el mismo que utiliza el Arduino UNO. El voltaje de alimentación que admite es de entre 2,7V a 5,5V.

Aunque el ATmega328P tiene 23 pines GPIO, solo tenemos accesibles 9. Todos pueden ser utilizados como pines digitales numerados de la siguiente forma 5, 6, 9, 10, 11, A2, A3, A4 y A5.

Los pines 5, 6, 9, 10 y 11 pueden utilizarse como pines de salida PWM. Para conectar un sensor analógico podemos utilizar los pines A2, A3, A4 y A5. También nos permite utilizar el protocolo I2C a través de los pines A4 (SDA) y A5 (SCL).

Si la placa está alimentada con 5V, el voltaje lógico de los pines digitales es 5V. Sin embargo, si lo alimentas a través de una batería LiPo de 3,7V, el voltaje se reduce a 3,3V. Mucho ojo con esto por que hay que tenerlo en cuenta a la hora de conectar componentes al LilyPad.

Y como no, tenemos un pin GND que viene marcado con el símbolo «-» y un pin que suministra 3,3V, marcado con el símbolo «+».

También incluye un conector JST para conectar una batería LiPo de entre 2,7V y 5,5V. Sin embargo, esta placa no tiene incluido un adaptador Serie-USB (también llamado FTDI) aunque en el kit básico viene uno incluido.

Incorpora un interruptor para encender y apagar la placa siempre que esté alimentada con una batería. También se incluye el típico botón de reset. Como ves todo bien adaptado para poder utilizarlo con nuestros proyectos wearables.

La placa tiene integrado varios LEDs. Uno de ellos nos sirve para saber si está encendida o no. Otro lo podemos utilizar para hacer debug y es accesible a través del pin 13.

Por último cabe destacar que esta placa tiene integrado el chip MCP73831 para poder cargar la batería conectada al JST a través del conector USB.

Programando el Lilypad desde el IDE de Arduino

Resulta una tarea bastante sencilla ya que como es de la familia de Arduino, viene integrado dentro del IDE de desarrollo por defecto. Vamos a ver los pasos que tienes que seguir para utilizar esta placa.

#1 Conecta el cable USB al FTDI

Si tu placa no viene con FTDI integrado lo primero que tienes que hacer es conectar el adaptador a la placa y luego conectas el cable USB. Es muy sencillo y no tiene pérdida.

Da lo mismo que pongas el interruptor en on o en off. Siempre que lo tengas alimentado a través del USB va a estar encendido.

#2 Selecciona la placa LilyPad

Lo siguiente es seleccionar la placa LilyPad adecuada. Abre un programa en blanco y vete a Herramientas>Placa para seleccionar una opción. En la versión del IDE con la que estoy escribiendo este artículo, la 1.8.2, tienes dos opciones.

Elegir una u otra dependerá de la placa que tengas entre tus manos. Si tu placa no integrada un FTDI (adaptador Serie USB) debes seleccionar LilyPad Arduino. Pero si viene con FTDI debes seleccionar LilyPad Arduino USB.

Con estos 3 pasos ya tendrías todo listo para empezara a trabajar con LilyPad de Arduino. Como último paso vamos a hacer el típico ejemplo «Hola mundo» de la programación de electrónica. Hacer parpadear un LED.

#3 Ejemplo para probar la configuración de la placa

El ejemplo que vamos a ver es muy sencillo. Vamos a hacer el típico Blink (parpadeo) de un LED. Para que resulte más fácil utilizaremos el que viene integrado dentro de la placa y al que tenemos acceso a través del pin 13.

Este sería el código.

// Pin 13
const byte pinLed13 = 13;

void setup() {
  // Modo del pin
  pinMode(pinLed13, OUTPUT);

}

void loop() {
  // Hacemos parpadear el LED rápido
  digitalWrite(pinLed13, HIGH);
  delay(300);
  digitalWrite(pinLed13, LOW);
  delay(300);
  digitalWrite(pinLed13, HIGH);
  delay(300);
  digitalWrite(pinLed13, LOW);
  delay(300);
  digitalWrite(pinLed13, HIGH);
  delay(300);
  digitalWrite(pinLed13, LOW);
  delay(300);

  // Hacemos parpadear el LED rápido
  digitalWrite(pinLed13, HIGH);
  delay(1000);
  digitalWrite(pinLed13, LOW);
  delay(1000);

}

// Pin 13

const byte pinLed13 = 13;

void setup() {

// Modo del pin

pinMode(pinLed13, OUTPUT);

}

void loop() {

// Hacemos parpadear el LED rápido

digitalWrite(pinLed13, HIGH);

delay(300);

digitalWrite(pinLed13, LOW);

delay(300);

digitalWrite(pinLed13, HIGH);

delay(300);

digitalWrite(pinLed13, LOW);

delay(300);

digitalWrite(pinLed13, HIGH);

delay(300);

digitalWrite(pinLed13, LOW);

delay(300);

// Hacemos parpadear el LED rápido

digitalWrite(pinLed13, HIGH);

delay(1000);

digitalWrite(pinLed13, LOW);

delay(1000);

}

Y el resultado sería algo parecido a esto.

Flora V3 de Adafruit

Si hasta ahora hemos visto como podemos trabajar con una placa integrada dentro de la plataforma de Arduino, ahora veremos como hacerlo con Flora V3 la placa que nos proponen desde Adafruit para crear proyectos tecnológicos con ropa.

Fue diseñada por la fundadora de Adafruit Limor Fried más conocida como Ladyada como una opción a LilyPad. Es totalmente compatible con el ecosistema de Arduino. Aunque parezca algo trivial se trata de una de sus mayores ventajas.

Solo encontramos un modelo que va evolucionando con el tiempo. Salió al mercado siendo Flora. En el año 2015 llegó la Flora V2 donde se sustituyo el puerto mini-USB por el micro-USB y se incorporó un NeoPixel dentro de la placa. En el año 2016 salió la actual Flora V3 con un cambio estético en la serigrafía y en los pines.

Sus dimensiones son parecidas a LyliPad: 45 mm de diámetro y 7 mm de altura. Los pines de la placa permiten fácilmente ser utilizados con hilo conductivo y se puede coser a la ropa.

Aunque prácticamente las funciones son las mismas, veremos como hay gran diferencias entre Flora y LilyPad en cuanto a las funciones que nos aportan cada una de ellas.

El precio como siempre oscila dependiendo el distribuidor y los gastos de envío. Podemos encontrar la placa sola por unos 19€. Pero también podemos comprar un kit bastante más caro, por unos 175€. Eso sí, viene con todo lo necesario para empezar a crear proyectos wearables e incluso con un libro para iniciarte con Flora.

Como ocurre con la placa LilyPad, Flora también puede ser lavado bajo las mismas condiciones. Incluso la propia Adafruit tiene un tutorial para lavar la electrónica de la familia Flora.

Características técnicas

Si hay algo que destaca de Adafruit es su documentación. Ellos mismos fabrican su propio hardware desde Nueva York y siguen la misma filosofía que Arduino. Si quieres que lo utilicen facilita el aprendizaje a través de tutoriales.

Seguramente hayas seguido más de un tutorial suyo sin saberlo. Como sé que no lo voy a explicar mejor que ellos, voy a hacer un resumen de lo que nos ofrece Flora V3 obtenido de la documentación técnica de Flora.

Características	Valor
Microcontrolador	ATmega32U4 (16 MHz)
Voltaje de alimentación	3,5V a 16V
Consumo	de 8mA a 20mA
Pines digitales	8 (0, 1, 2, 3, 6, 9, 10 y 12)
Pines PWM	4 (3, 6, 9 y 10)
Pines analógicos	4 (A7, A9, A10 y A11)
Pin de salida (3,3V)	2
Pin de salida (VBATT)	1
Pin toma de tierra (GND)	3
Memoria Flash	32 KB
SRAM	2,5 KB
EEPROM	1 KB
I2C	3 (SCL) y 2 (SDA)

Empezamos con el microcontrolador. Flora incorpora el ATmega32UA a 16 MHz y de 8-bit. Incorpora un conector JST para conectar una batería. Gracias a un regulador de tensión podemos alimentar esta placa entre 3,5V y 16V a través de la batería.

También tiene un interruptor para apagar y encender siempre y cuando tenga alimentación externa. Flora no incorpora un chip para cargar la batería, tendríamos que cargarla a través de un cargador o con un componente externo.

Dentro de la placa se integra el conector USB con un adaptador Serie-USB (FTDI). No hace falta ningún componente externo para programarlo.

El consumo oscila entre los 8mA y los 20mA dependiendo del uso de los componentes que vienen integrados en la placa como los LEDs y el NeoPixel.

Podemos utilizar hasta 8 pines digitales (0, 1, 2, 3, 6, 9, 10 y 12) de los que se recomienda no utilizar el 0 y el 1 debido a que son RX y TX del puerto serie. 4 de estos pines pueden ser utilizados como PWM (3, 6, 9 Y 10). Para sensores analógicos tenemos los pines A7, A9, A10 y A11 que corresponden con los pines digitales 6, 9, 10 y 12.

Imagen obtenida de Adafruit

Tenemos a nuestra disposición dos pines que suministran 3,3V y 3 pines GND.

El pin VBATT puede resultar algo confuso. Se trata de un pin de salida que nos suministra el voltaje que tiene la batería. El uso más común es utilizarlo para alimentar algún componente que requiere más corriente de lo normal ya que puede suministrar hasta 150mA. Por ejemplo unos NeoPixel.

Debes tener mucho ojo porque si abusas de este pin puedes llegar a consumir la batería en un abrir y cerrar de ojos.

Dentro de la placa viene un NeoPixel integrado. Este NeoPixel es accesible desde el pin 8.

Por último, permite la utilización del protocolo I2C a través de los pines 2 (SDA) y 3 (SCL).

Programando Flora desde el IDE de Arduino

Existen dos formas de programar la placa Flora de Adafruit. En las dos se utiliza el IDE de Arduino. Debido a que se trata de un software de código abierto, cualquier persona lo puede descargar y modificar como quiera.

Adafruit ha hecho esto para facilitar el uso de la placa Flora. Puedes descargar una versión propia del IDE enfocada a la programación de la placa Flora.

En este artículo vamos a seguir el procedimiento oficial, utilizar el IDE original de Arduino. Esto evitará que tengas varias versiones de este software y puedas programar cualquier placa desde el mismo entorno de desarrollo.

#1 Instalar los drivers para Windows

Este paso es solo para usuarios de Windows. Necesitas instalar un driver que permita comunicarse a la placa con tu ordenador. Como ya vimos en el artículo donde explicaba cómo trabajar con el ESP-01 basado en el ESP8266, con algunas placas es necesario instalar el driver del FTDI.

Lo primero es descargar el driver de Adafruit para Windows. Una vez lo tengas descargado ejecútalo como administrador. Tienes que dejar la configuración por defecto así que siguiente, siguiente y siguiente …. :)

#2 Configuración del IDE de desarrollo para Flora

Doy por sentado que ya tienes instalado el IDE de desarrollo oficial de Arduino. Una vez que lo tengas arrancado tienes que ir al menú Archivo>Preferencias.

En el campo de Gestor de URLs Adicionales de Tarjetas copia la siguiente URL

https://adafruit.github.io/arduino-board-index/package_adafruit_index.json

1	https://adafruit.github.io/arduino-board-index/package_adafruit_index.json

Si quieres profundizar en el funcionamiento de GitHub entra aquí.

Puede ser que si has tenido que configurar el ESP-01 o un NodeMCU este campo ya lo tengas ocupado. En ese caso separa las URLs con una coma (,) o pulsa el símbolo que hay al lado de la caja de texto y escribe cada URL en una línea.

Le das a Ok y ya estaría listo.

#3 Instalación de los drivers de la placa Flora

Quedaría el último paso. Si accedes al menú Herramientas>Placa verás que no aparece Flora. Eso es porque hay que instalar los drives de Adafruit.

Abre el gestor de placas desde Herramientas>Placa>Gestor de tarjetas…

En la ventana que aparece selecciona en el menú desplegable que pone Tipo la opción que pone Contribución. En el campo de Filtro de búsqueda… escribe Adafruit AVR. Por último le das a instalar.

Una vez instalado ya puedes seleccionar la placa Flora.

#4 Probando el NeoPixel integrado dentro de Flora

Vamos a hacer una prueba para ver que todo está correctamente configurado en la placa Flora. La configuración que veamos en este apartado, nos servirá como ejemplo prácticos más adelante.

Antes de empezar tienes que instalar la librería NeoPixel de Adafruit. En el menú selecciona Programa>Librerías>Gestor Librerías.

Busca la librería Adafruit NeoPixel

Esto instala la librería y los ejemplos. Vamos a partir del ejemplo Simple para utilizar el NeoPixel que viene integrado dentro de la placa Flora. Abre el menú Archivo>Ejemplos>Adafruit NeoPixel>simple

Esto abre el siguiente código.

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1
#define PIN            6

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      16

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int delayval = 500; // delay for half a second

void setup() {
  // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
#if defined (__AVR_ATtiny85__)
  if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
#endif
  // End of trinket special code

  pixels.begin(); // This initializes the NeoPixel library.
}

void loop() {

  // For a set of NeoPixels the first NeoPixel is 0, second is 1, all the way up to the count of pixels minus one.

  for(int i=0;i<NUMPIXELS;i++){

    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    pixels.setPixelColor(i, pixels.Color(0,150,0)); // Moderately bright green color.

    pixels.show(); // This sends the updated pixel color to the hardware.

    delay(delayval); // Delay for a period of time (in milliseconds).

  }
}

// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library

#include <Adafruit_NeoPixel.h>

#ifdef __AVR__

#include <avr/power.h>

#endif

// Which pin on the Arduino is connected to the NeoPixels?

// On a Trinket or Gemma we suggest changing this to 1

#define PIN 6

// How many NeoPixels are attached to the Arduino?

#define NUMPIXELS 16

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.

// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest

// example for more information on possible values.

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int delayval = 500; // delay for half a second

void setup() {

// This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket

#if defined (__AVR_ATtiny85__)

if (F_CPU == 16000000) clock_prescale_set(clock_div_1);

#endif

// End of trinket special code

pixels.begin(); // This initializes the NeoPixel library.

}

void loop() {

// For a set of NeoPixels the first NeoPixel is 0, second is 1, all the way up to the count of pixels minus one.

for(int i=0;i<NUMPIXELS;i++){

// pixels.Color takes RGB values, from 0,0,0 up to 255,255,255

pixels.setPixelColor(i, pixels.Color(0,150,0)); // Moderately bright green color.

pixels.show(); // This sends the updated pixel color to the hardware.

delay(delayval); // Delay for a period of time (in milliseconds).

}

Solo hay que hacer dos modificaciones. En la línea 11, sustituye el pin 6 por el 8.

#define PIN            8

1	#define PIN 8

En la línea 14 sustituye el número de píxeles de 16 a 1.

#define NUMPIXELS      1

1	#define NUMPIXELS 1

Carga el código a la placa y tendrás un resultado parecido al de la siguiente imagen.

Con esto hemos comprobado que la placa Flora está bien configurada y funciona correctamente. Por si no te has dado cuenta, Flora es mi placa favorita para wearables :)

Ahora vamos a algunos componentes que podemos conectar a nuestra placa Flora y LilyPad.

Componentes eléctricos para Flora y LilyPad

Existe una amplia diversidad de componentes para conectar a las placas Flora y LilyPad. Mi recomendación es comprar siempre productos originales ya sean de Adafruit, Arduino o Sparkfun. Dicho esto, podemos encontrar cosas parecidas en tiendas donde se venden productos chinos.

Es responsabilidad tuya si el producto adquirido no se ciñe a los requerimientos citados con anterioridad. Recuerda, deben cumplir lo siguiente:

Debe ser un componente lo más pequeño posible.
El consumo debe ser muy reducido.
Se debe adaptar a las prendas de vestir donde los vamos a instalar.

Los componentes eléctricos pueden servir tanto para LilyPad como para Flora, lo único que tendremos que tener en cuenta son las características técnicas de cada uno de ellos.

Dicho esto vamos a ver que nos ofrecen Adafruit y Sparkfun para nuestros proyectos con Flora y LilyPad.

Flora RGB Smart Neopixel

Se trata de los típicos Neopixel de Adafruit adaptados para utilizarlos con Flora. Son mis favoritos y los más utilizados en proyectos para Wearables.

Precio: 13€ un pack de 4

Cargador para baterías Lilon/LiPoly

Como ya te he comentado, Flora no puede ser utilizado para cargar una batería. Por lo tanto, necesitamos algo para poder cargarlo. Este componente nos permitirá cargarlo de una forma muy sencilla y sin riesgos.

Precio: 13€

Flora Acelerómetro y Compas LSM303

Si quieres monitorizar los movimientos de alguna persona o de alguna parte del cuerpo de una persona este es tu sensor.

Precio: 15€

Batería LiPoly 3,7V y 1200mAh

Con esta batería tendrás bastante energía como para alimentar a una placa Flora durante muchas horas. Lleva mucho ojo con este tipo de baterías, comprueba siempre que ha pasado todas las medidas de seguridad y que tiene un conector JST.

Precio: 10€

Flora Wearable GPS

Un módulo GPS compatible con Flora. Fundamental si quieres geoposicionar tus proyectos.

Precio: 71€

Hilo conductivo

Un material fundamental para Wearables. Este hilo conductivo está hecho de acero inoxidable y permite que la corriente circule por él. Es muy maleable y puede ser utilizado para coser tanto a mano como a máquina.

Precio: 14€

Flora sensor de color

Este sensor es genial. Te permite detectar el color de una superficie. Está adaptado para Flora y por lo tanto se puede coser en una prenda.

Precio: 8€

Flora Wearable Bluefruit

Si quieres que tu placa Flora tenga conexión Bluetooth este es tu componente. Utiliza BLE (Bluetooth Low Energy).

Precio: 32€

Botón LilyPad

Todo proyecto que se aprecie necesitará de un botón para poder cambiar de modo o interactuar con la placa. Este botón es una buena opción y es muy económico.

Precio: 2,8€

Ejemplo práctico con Flora: señalización para ciclistas con NeoPixel

Yo no es que sea un ciclista muy activo, más bien lo mío es correr y jugar al padel. Sin embargo, utilizo siempre que puedo la bicicleta para cuando tengo que desplazarme por mi ciudad. Al vivir en una ciudad pequeña me resulta muy cómodo y muy práctico.

Ya se que existen diferentes alternativas para señalizar a un ciclista. Desde las típicas luces que se instalan en la propia bicicleta hasta los chalecos reflectantes. Pero es que yo soy un Maker, y me gusta crear mis propios dispositivos.

El objetivo

El objetivo de este proyecto con Flora es hacer que una tira de NeoPixel con cuatro unidades se encienda en diferentes modos. Se pueden utilizar cualquier tipo de NeoPixel aunque yo he utilizado los Flora RGB.

A través de un pulsador seremos capaces de cambiar entre los diferentes modos.

Material necesario

Para seguir este tutorial vas a necesitar el siguiente material.

Placa Flora V3 de Adafruit
4 Flora Neopixel
1 Botón LilyPad
Tira de tela de 2 cm de ancho
Batería LiPo (da lo mismo los mAh)
Agujas
Hilo conductivo

Circuito eléctrico

Voy a hacer una representación con Fritzing de cómo quedarían las conexiones. Luego todos estos componentes hay que conectarlos con hilo conductivo.

Un NeoPixel Flora tiene 4 pines.

El pin donde pone el símbolo + va conectado a VBATT. El pin con el símbolo – a GND. El pin donde pone una flecha hacia arriba es por donde entran los datos. El pin con una flecha hacia abajo es por donde salen los datos.

Cosiendo los Flora Neopixel y el botón LilyPad

Esta parte es la más arte artesanal. Vas a tener que coser. Puedes decírselo a tu abuela o a tu madre para que te echen un cable, quizás quede mejor :). Como ya te he dicho yo parto con ventaja, tengo algo de experiencia aunque también he tirado de prima que es una experta :)

Tienes que coser tres filas de hilo conductivo. Este tipo de hilos es bastante maleable y resistente así que puedes utilizarlo con una aguja o con una máquina de coser. Cada uno de ellos tiene que ir conectado a un pin.

Uno de los extremos a GND, el otro extremo a VBATT. El tercer hiló irá conectado al pin #12.

El pulsador no tiene misterio. Un pin a GND y otro al pin #10.

Ten paciencia al principio al coser. Muchas veces las conexiones fallan y tienes que repasar de nuevo las costuras.

Programando la placa Flora

Ahora llega la parte divertida. Hasta ahora lo que hemos hecho son conexiones que más o menos son fáciles. Salvo la fase de coser el resto es sencillo.

Ya tenemos todo listo para crear el programa. Vamos a ir viendo por partes.

#1 Importación de librería y declaración de variables

Vamos a ver el código y luego te lo explico.

#include <Adafruit_NeoPixel.h>

// Constantes
#define PINEO 12
#define PINBOTON 10
#define NUMNEO 4

// Clase Neopixel
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMNEO, PINEO, NEO_GRB + NEO_KHZ800);

// Retardos y colores por modo
int delayModo1 = 100;
int delayModo2 = 300;
int delayModo3 = 500;

uint32_t colorModo1;
uint32_t colorModo2;
uint32_t colorModo3;
uint32_t colorApagado;

// Modo de funcionamiento
byte modoActual = 1;

#include <Adafruit_NeoPixel.h>

// Constantes

#define PINEO 12

#define PINBOTON 10

#define NUMNEO 4

// Clase Neopixel

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMNEO, PINEO, NEO_GRB + NEO_KHZ800);

// Retardos y colores por modo

int delayModo1 = 100;

int delayModo2 = 300;

int delayModo3 = 500;

uint32_t colorModo1;

uint32_t colorModo2;

uint32_t colorModo3;

uint32_t colorApagado;

// Modo de funcionamiento

byte modoActual = 1;

En la primera línea incluimos la librería Adafruit_NeoPixel.h. Ya hemos visto en la sección de configuración de Flora cómo añadir dicha librería.

Luego definimos 3 constantes. PINEO almacena el pin donde hemos conectado los NeoPixel (#12). PINBOTON almacena el pin del botón (#10) y NUMNEO indica el número de píxeles con los que vamos a trabajar.

Para utilizar los NeoPixel hay que crear una instancia a la clase Adafruit_NeoPixel. Al objeto lo llamamos pixels. Como argumentos pasamos el número de píxeles (NUMNEO), el pin donde se han conectado los NeoPixel y el modo en el que funcionan.

En las siguientes lineas se declaran las variables que almacenan el tiempo de retado y el color para cada modo. En total vamos a tener tres modos de funcionamiento.

Por último, la variable modoActual almacena el modo en el que se encuentra el dispositivo.

#2 Función setup

En función de configuración escribimos lo siguiente.

#include <Adafruit_NeoPixel.h>

// Constantes
#define PINEO 12
#define PINBOTON 10
#define NUMNEO 4

// Clase Neopixel
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMNEO, PINEO, NEO_GRB + NEO_KHZ800);

// Retardos y colores por modo
int delayModo1 = 100;
int delayModo2 = 300;
int delayModo3 = 500;

uint32_t colorModo1;
uint32_t colorModo2;
uint32_t colorModo3;
uint32_t colorApagado;

// Modo de funcionamiento
byte modoActual = 1;

#include <Adafruit_NeoPixel.h>

// Constantes

#define PINEO 12

#define PINBOTON 10

#define NUMNEO 4

// Clase Neopixel

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMNEO, PINEO, NEO_GRB + NEO_KHZ800);

// Retardos y colores por modo

int delayModo1 = 100;

int delayModo2 = 300;

int delayModo3 = 500;

uint32_t colorModo1;

uint32_t colorModo2;

uint32_t colorModo3;

uint32_t colorApagado;

// Modo de funcionamiento

byte modoActual = 1;

Comenzamos la función setup configurando el modo del pin del pulsador. Los típicos modos son INPUT y OUTPUT. Pero existe un tercer modo que nos permite activar una resistencia interna pull-up. Esto evita que tengamos que poner una resistencia de este tipo den nuestro circuito.

Sin embargo, al poner una resistencia pull-up el funcionamiento del pulsador sera diferente. Siempre que no esté pulsado tendremos un estado HIGH y siempre que se pulse el estado será LOW.

Luego iniciamos lo NeoPixel con la función pixels.begin().

El siguiente paso es configurar los colores para cada modo. Puedes elegir los que quieras.

Por último apagamos todos los píxeles con un bucle que recorre cada uno de ellos.

#3 Función loop

La función loop() es donde implementamos la lógica. El objetivo es leer el pulsador y activar el modo correspondiente.

void loop() {
  // Lectura pin boton
  int boton = digitalRead(PINBOTON);

  // Si se ha pulsado
  if (boton == LOW)
  {
    // Siguiente modo
    modoActual++;

    // Detecta final de modo
    if (modoActual == 4) {
      modoActual = 1;
    }

    delay(500);

  }

  // Activamos modo
  switch (modoActual) {
    case 1:
      activarModo1();
      break;
    case 2:
      activarModo2();
      break;
    default:
      activarModo3();
      break;
  }
}

void loop() {

// Lectura pin boton

int boton = digitalRead(PINBOTON);

// Si se ha pulsado

if (boton == LOW)

{

// Siguiente modo

modoActual++;

// Detecta final de modo

if (modoActual == 4) {

modoActual = 1;

}

delay(500);

}

// Activamos modo

switch (modoActual) {

case 1:

activarModo1();

break;

case 2:

activarModo2();

break;

default:

activarModo3();

break;

}

Lo primero que hacemos nada más empezar la función loop() es obtener el estado del pulsador con digitalRead(). Luego comprobamos si se ha pulsado (recuerda que el funcionamiento del pulsador está invertido debido a la resistencia pull-up).

Si se ha pulsado cambiamos de modo. Para cambiar de un modo a otro es sencuencial: primero modo1, segundo modo2, tercero modo3 y volveríamos al principio.

Esto se hace con if donde detecta si la variable modoActual es 4 (este modo no existe). En ese caso volvemos al principio.

Por último dentro del if donde se detecta la activación del pulsador añadimos un retardo de 500ms. Esto evitará que detecte dobles pulsaciones en el circuito.

Para activar el modo correcto utilizo un switch que no es más que una sentencia condicional por casos. Dependiendo de la variable modoActual activamos un modo u otro.

#4 Activar el modo 1

El modo 1 hace un barrido de izquierda a derecha encendiendo y apagando cada píxel de la tira NeoPixel.

void activarModo1() {
  // Parpadeo en un sentido
  for (int i = 0; i < NUMNEO; i++) {
    delay(delayModo1);
    pixels.setPixelColor(i, colorModo1);
    pixels.show();
    delay(delayModo1);
    pixels.setPixelColor(i, colorApagado);
    pixels.show();
  }

  // Parpadeo en otro sentido
  for (int i = NUMNEO - 2; i >= 0; i--) {
    delay(delayModo1);
    pixels.setPixelColor(i, colorModo1);
    pixels.show();
    delay(delayModo1);
    pixels.setPixelColor(i, colorApagado);
    pixels.show();
  }
}

void activarModo1() {

// Parpadeo en un sentido

for (int i = 0; i < NUMNEO; i++) {

delay(delayModo1);

pixels.setPixelColor(i, colorModo1);

pixels.show();

delay(delayModo1);

pixels.setPixelColor(i, colorApagado);

pixels.show();

}

// Parpadeo en otro sentido

for (int i = NUMNEO - 2; i >= 0; i--) {

delay(delayModo1);

pixels.setPixelColor(i, colorModo1);

pixels.show();

delay(delayModo1);

pixels.setPixelColor(i, colorApagado);

pixels.show();

}

Con dos bucles somos capaces de recorrer los NeoPixel en un sentido y en otro.

En el primer bucle recorremos de 0 a 3 los píxeles haciendo parpadear cada uno de ellos.

En el segundo bucle recorremos de 2 a 0 los píxeles haciendo parpadear cada uno de ellos. El píxel 3 no se recorre en este bucle para evitar la repetición del parpadeo.

#5 Activar modo 2

El modo 2 hace parpadear de dos en dos los píxeles.

void activarModo2() {
  // Recorremos de dos en dos
  for (int i = 0; i < NUMNEO; i = i + 2) {
    delay(delayModo2);
    pixels.setPixelColor(i, colorModo2);
    pixels.show();
    pixels.setPixelColor(i + 1, colorModo2);
    pixels.show();
    delay(delayModo2);
    pixels.setPixelColor(i, colorApagado);
    pixels.setPixelColor(i + 1, colorApagado);
    pixels.show();
  }
}

void activarModo2() {

// Recorremos de dos en dos

for (int i = 0; i < NUMNEO; i = i + 2) {

delay(delayModo2);

pixels.setPixelColor(i, colorModo2);

pixels.show();

pixels.setPixelColor(i + 1, colorModo2);

pixels.show();

delay(delayModo2);

pixels.setPixelColor(i, colorApagado);

pixels.setPixelColor(i + 1, colorApagado);

pixels.show();

}

En el modo 2 solo hay un bucle que recorre de dos en dos los NeoPixel y los hace parpadear.

#6 Activar el modo 3

El modo 3 hace parpadear los cuatro píxeles a la vez.

void activarModo3() {
  // Encendemos los neopixel
  for (int i = 0; i < NUMNEO; i++) {
    pixels.setPixelColor(i, colorModo3);
    pixels.show();
  }

  delay(delayModo3);

  // Apagamos los neopixel
  for (int i = 0; i < NUMNEO; i++) {
    pixels.setPixelColor(i, colorApagado);
    pixels.show();
  }

  delay(delayModo3);
}

void activarModo3() {

// Encendemos los neopixel

for (int i = 0; i < NUMNEO; i++) {

pixels.setPixelColor(i, colorModo3);

pixels.show();

}

delay(delayModo3);

// Apagamos los neopixel

for (int i = 0; i < NUMNEO; i++) {

pixels.setPixelColor(i, colorApagado);

pixels.show();

}

delay(delayModo3);

}

En el modo 3 hago parpadear los 4 píxeles a la vez. Como no pongo ningún delay dentro del bucle, se ejecutan tan rápido que el tiempo de respuesta no es perceptible por el ojo humano.

El parpadeo lo hago entre cada bucle poniendo un delay.

Código completo

A continuación te dejo el código completo.

#include <Adafruit_NeoPixel.h>

// Constantes
#define PINEO 12
#define PINBOTON 10
#define NUMNEO 4

// Clase Neopixel
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMNEO, PINEO, NEO_GRB + NEO_KHZ800);

// Retardos y colores por modo
int delayModo1 = 100;
int delayModo2 = 300;
int delayModo3 = 500;

uint32_t colorModo1;
uint32_t colorModo2;
uint32_t colorModo3;
uint32_t colorApagado;

// Modo de funcionamiento
byte modoActual = 1;

void setup() { 
  // Modo boton
  pinMode(PINBOTON, INPUT_PULLUP);

  // Iniciamos los neopixel
  pixels.begin();

  // Colores por defecto
  colorModo1 = pixels.Color(150, 0, 0);
  colorModo2 = pixels.Color(246, 126, 10);
  colorModo3 = pixels.Color(0, 150, 0);
  colorApagado = pixels.Color(0, 0, 0);

  // Los apagamos todos
  for (int i = 0; i < NUMNEO; i++) {
    pixels.setPixelColor(i, colorApagado);
    pixels.show();
  }
}

void loop() {
  // Lectura pin boton
  int boton = digitalRead(PINBOTON);

  // Si se ha pulsado
  if (boton == LOW)
  {
    // Siguiente modo
    modoActual++;

    // Detecta final de modo
    if (modoActual == 4) {
      modoActual = 1;
    }

    delay(500);

  }

  // Activamos modo
  switch (modoActual) {
    case 1:
      activarModo1();
      break;
    case 2:
      activarModo2();
      break;
    default:
      activarModo3();
      break;
  }
}

void activarModo1() {
  // Parpadeo en un sentido
  for (int i = 0; i < NUMNEO; i++) {
    delay(delayModo1);
    pixels.setPixelColor(i, colorModo1);
    pixels.show();
    delay(delayModo1);
    pixels.setPixelColor(i, colorApagado);
    pixels.show();
  }

  // Parpadeo en otro sentido
  for (int i = NUMNEO - 2; i >= 0; i--) {
    delay(delayModo1);
    pixels.setPixelColor(i, colorModo1);
    pixels.show();
    delay(delayModo1);
    pixels.setPixelColor(i, colorApagado);
    pixels.show();
  }
}

void activarModo2() {
  // Recorremos de dos en dos
  for (int i = 0; i < NUMNEO; i = i + 2) {
    delay(delayModo2);
    pixels.setPixelColor(i, colorModo2);
    pixels.show();
    pixels.setPixelColor(i + 1, colorModo2);
    pixels.show();
    delay(delayModo2);
    pixels.setPixelColor(i, colorApagado);
    pixels.setPixelColor(i + 1, colorApagado);
    pixels.show();
  }
}

void activarModo3() {
  // Encendemos los neopixel
  for (int i = 0; i < NUMNEO; i++) {
    pixels.setPixelColor(i, colorModo3);
    pixels.show();
  }

  delay(delayModo3);

  // Apagamos los neopixel
  for (int i = 0; i < NUMNEO; i++) {
    pixels.setPixelColor(i, colorApagado);
    pixels.show();
  }

  delay(delayModo3);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

#include <Adafruit_NeoPixel.h>

// Constantes

#define PINEO 12

#define PINBOTON 10

#define NUMNEO 4

// Clase Neopixel

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMNEO, PINEO, NEO_GRB + NEO_KHZ800);

// Retardos y colores por modo

int delayModo1 = 100;

int delayModo2 = 300;

int delayModo3 = 500;

uint32_t colorModo1;

uint32_t colorModo2;

uint32_t colorModo3;

uint32_t colorApagado;

// Modo de funcionamiento

byte modoActual = 1;

void setup() {

// Modo boton

pinMode(PINBOTON, INPUT_PULLUP);

// Iniciamos los neopixel

pixels.begin();

// Colores por defecto

colorModo1 = pixels.Color(150, 0, 0);

colorModo2 = pixels.Color(246, 126, 10);

colorModo3 = pixels.Color(0, 150, 0);

colorApagado = pixels.Color(0, 0, 0);

// Los apagamos todos

for (int i = 0; i < NUMNEO; i++) {

pixels.setPixelColor(i, colorApagado);

pixels.show();

}

void loop() {

// Lectura pin boton

int boton = digitalRead(PINBOTON);

// Si se ha pulsado

if (boton == LOW)

{

// Siguiente modo

modoActual++;

// Detecta final de modo

if (modoActual == 4) {

modoActual = 1;

}

delay(500);

}

// Activamos modo

switch (modoActual) {

case 1:

activarModo1();

break;

case 2:

activarModo2();

break;

default:

activarModo3();

break;

}

void activarModo1() {

// Parpadeo en un sentido

for (int i = 0; i < NUMNEO; i++) {

delay(delayModo1);

pixels.setPixelColor(i, colorModo1);

pixels.show();

delay(delayModo1);

pixels.setPixelColor(i, colorApagado);

pixels.show();

}

// Parpadeo en otro sentido

for (int i = NUMNEO - 2; i >= 0; i--) {

delay(delayModo1);

pixels.setPixelColor(i, colorModo1);

pixels.show();

delay(delayModo1);

pixels.setPixelColor(i, colorApagado);

pixels.show();

}

void activarModo2() {

// Recorremos de dos en dos

for (int i = 0; i < NUMNEO; i = i + 2) {

delay(delayModo2);

pixels.setPixelColor(i, colorModo2);

pixels.show();

pixels.setPixelColor(i + 1, colorModo2);

pixels.show();

delay(delayModo2);

pixels.setPixelColor(i, colorApagado);

pixels.setPixelColor(i + 1, colorApagado);

pixels.show();

}

void activarModo3() {

// Encendemos los neopixel

for (int i = 0; i < NUMNEO; i++) {

pixels.setPixelColor(i, colorModo3);

pixels.show();

}

delay(delayModo3);

// Apagamos los neopixel

for (int i = 0; i < NUMNEO; i++) {

pixels.setPixelColor(i, colorApagado);

pixels.show();

}

delay(delayModo3);

}

Enlaces de interés para Flora y LiLyPad

Conclusiones wearables Flora y LilyPad

Como sucede con todo en la vida, tenemos favoritos y no tan favoritos. En este caso, si tengo que elegir me quedo con Flora de Adafruit. Se trata de una placa muy accesible para todos los niveles y podemos encontrar mucha documentación de proyectos y componentes.

Mientras que con Flora solo tenemos un modelo, con LilyPad podemos encontrar varios modelos. Flora es más económico que LilyPad aunque podemos encontrar placas que se aproximen dependiendo de las funcionalidades que integren.

Si nos fijamos en el consumo LilyPad está más optimizada debido a que en algunos modelos no integra todos los componentes. Por este lado es una ventaja pero podemos verlo como una desventaja a la hora de programar.

Lo más importante de todo es que son totalmente compatibles con Arduino lo que supone que podemos programar y crear proyectos a través de su ecosistema. Hay que dar importancia a todo esto y seguir apoyando, en la medida de lo posible, el proyecto de Open Hardware/Software más popular del mundo.

¿Has hecho algún proyecto con Flora o LilyPad?

¿Cómo crees que está el mercado de los wearables con hardware abierto?

Cualquier comentario aquí abajo, muchas gracias :)

Gracias a Shutterstock por ceder la imagen.