Tulipán Mecánico Perenne – Flor LED Activada por Tacto

Componentes y suministros

Arduino Nano R3	1
Micro-servomotor SG90	1
Sensor táctil TTP223	1
Alambre de latón 1 mm	1
Tubo de latón 2 mm (agujero 1,2 mm)	1
Hilo de cobre esmaltado 0,3 mm	1
LED WS2812 5050 NeoPixel	7
LED SMD 1206 blanco	30

Sobre este proyecto

Una flor eterna para un amor eterno. Un regalo perfecto no solo para San Valentín. Este tulipán mecánico florece en cualquier color imaginable con solo un toque suave de la mano. Sus seis pétalos se abren lentamente y se iluminan. Cuando están cerrados, crean una increíble luz ambiental con patrones de hojas.

¿Cómo funciona?

El tulipán consta de 6 pétalos, cada uno con 5 LEDs SMD blancos. Cada pétalo se conecta a un pin de salida del Arduino. El capullo oculta 7 LEDs NeoPixel RGB. Eléctricamente, toda la flor es masa y las "venas" de los pétalos son voltaje positivo. Los pétalos se abren mediante una varilla de empuje que recorre el tallo hasta la base, controlada por un pequeño servomotor hobby. Una pequeña hoja lateral del tallo está conectada al sensor táctil TTP223 dentro de la base, creando un panel capacitivo. La base de madera contiene el servomotor, el IC táctil y el Arduino Nano. ¡Construyamos uno!

Qué vas a necesitar

• Varilla de latón 1 mm
• Tubo de latón 2 mm con agujero 1,2 mm
• Hilo de cobre esmaltado 0,3 mm
• Madera para la base
• Arduino Nano
• Sensor táctil TTP223
• Pequeño servomotor

Conocimientos previos recomendados

• Soldar latón (artículo excelente)
• Construir con Arduino
• Usar servomotores
• Usar LEDs y NeoPixels

No doy dimensiones exactas ni forma precisa del capullo. Cada flor debe ser única.

Los pétalos (4 h)

Empezamos por la parte más satisfactoria: los pétalos. Necesitas una plantilla para el capullo. Yo la hice con yeso vertido en un molde tubular; al secar lo tallé en forma de tulipán. También se puede imprimir en 3D. El yeso es genial porque se mecaniza fácil y admite lápiz. Un pétalo ocupa 1/4 de la superficie de la plantilla, así que al final, con 6, se solapan ligeramente creando la forma exacta. Dibujo la forma del pétalo a lápiz y la tallo en el yeso para sujetar las varillas al soldar.

Cada pétalo: varilla de latón 1 mm perimetral. Dentro, 5 LEDs SMD 1206 blancos y una estructura de "venas" del mismo alambre. Primero, forma el alambre perimetral con calma. Corta un trozo de tubo y pásalo por la parte plana inferior: será el eje del pétalo. Suelda los extremos del alambre, asegurándote de no rellenar el tubo de soldadura; debe moverse libremente. Termina con LEDs y estructura venosa. Mira el video (es el único metraje que tengo de la construcción).

Ahora haz 5 más. Todos los pétalos deben ser idénticos. Es crucial; si no, no formarán un tulipán uniforme al cerrarse e incluso pueden atascarse.

El capullo (1 h)

Soldamos los 6 pétalos. La base es hexagonal (6 pétalos). Los pétalos se fijan al hexágono mediante ejes (tubos). El hexágono es ligeramente irregular; con uno regular los pétalos no pueden solaparse. Tres pétalos son más centrales (internos) y tres en ligero offset (externos). Creé una plantilla impresa en papel: la forma roja es el hexágono irregular final, hecho de dos hexágonos regulares anidados. Solda todos los ejes al hexágono. Los radios desde el centro ayudan a posicionar los pétalos correctamente: el centro de cada pétalo debe seguir la línea radial. Al cerrar los pétalos obtienes la forma final del capullo.

Tallo y varilla de empuje (1 h)

Yo hice primero el mecanismo del capullo y luego añadí el tallo; fue un error. Empieza por el tallo.

El movimiento de los pétalos lo crea una varilla de empuje de latón 1 mm deslizando libremente dentro de un tubo de latón. Los pétalos se conectan a la varilla mediante un hexágono minúsculo con ejes de 2 mm en cada lado (cabeza de la varilla). El hexágono descansa perpendicular sobre la varilla gracias a una barrita que cruza su centro. Es trabajo de relojero.

Para la cabeza: dobla el alambre formando el hexágono minúsculo. Corta 6 tubitos de 2 mm y pásalos por el alambre. Suelda para cerrar el hexágono (sin soldar los tubitos al alambre). Suelda una barrita en el centro del hexágono. Remata soldando una varilla de 1 mm perpendicular al centro de la cabeza. ¡Tienes tu varilla de empuje!

Construye el tallo: corta tubo de latón a la longitud deseada. Segundo punto crucial: el tallo debe ser perfectamente perpendicular a la base hexagonal del capullo, centrado exactamente, y dejar espacio para que la cabeza de la varilla baje y cierre los pétalos. Sueldé dos alambres en un extremo del tallo formando una V; serán 2 de los 6 alambres que unen tallo a vértices del hexágono. Voltea el capullo y suelda la V a dos vértices opuestos. Verifica: si metes una varilla por el tallo, debe salir por el centro del capullo. Tómate tu tiempo para que sea perfecto. Luego suelda 4 alambres más entre los vértices restantes y la parte superior del tallo. ¡Cuidado de no soldar el agujero del tubo!

Mecanismo de pétalos (6 h)

La parte en la que te arrepentirás de haber empezado. Casi la tiro a la basura. Pero ¡tú lo clavarás! Me inspiré en máquinas de vapor: bielas, pistones, volantes.

Haz un banco de pruebas. Fija la flor con el tallo hacia arriba. Mete la varilla de empuje con la cabeza arriba. Suelda un tubo corto perpendicular al extremo inferior de la varilla y crea una biela de alambre de 1 mm para conectar servomotor y varilla (ver foto). Debes poder mover la varilla arriba/abajo con el servo. Prueba conectando el Arduino. Antes de soldar las bielas entre pétalos y cabeza de varilla, ajusta el movimiento del servo con Arduino: código que mueva la varilla arriba/abajo de modo que en posición superior la cabeza quede a ras de la base hexagonal del capullo, y en posición inferior descanse en la base en V del capullo.

Al subir la varilla, empuja las bielas y los pétalos bajan (se abren). Al bajar, arrastra las bielas y los pétalos se cierran.

Falta una pieza clave en los pétalos: el pasador del pétalo. Este eje está en una barrita soldada a cada pétalo paralela a su base. El pasador debe sobresalir de la superficie del pétalo para permitir la apertura total (ver animación). Haz una barrita con eje (tubo) y suéldala al primer pétalo. Requiere mucha experimentación con el tamaño de la barrita y su distancia a la base para que la varilla abra y cierre completamente el pétalo. Prueba y error. Suelda la barrita en posición adecuada y añade la biela entre el pasador de la varilla y el del pétalo. Si la varilla está arriba y el pétalo totalmente abierto, la distancia entre ambos pasadores es la longitud de la biela.

Mueve la varilla arriba/abajo. Si funciona sin roces y el pétalo abre/cierra, ¡listo (primer pétalo)! Si no, cambia longitud de biela o posición de barrita. Repite en los 5 pétalos restantes. Los 3 pétalos externos deben quedar un poco más bajos al abrirse para solapar correctamente a los internos al cerrarse. Al final, el capullo debe abrir y cerrar. No entres en pánico si no sale perfecto a la primera: significa que los pétalos no son idénticos. Requiere mucho afinado (longitudes de biela y posiciones de barrita ligeramente distintas). ¡Tómate tu tiempo! La recompensa está cerca.

Pistilo arcoíris (1 h)

Si llegaste aquí, eres un rey y lo más difícil pasó. Dentro del capullo pongo 7 NeoPixels para brillar desde dentro. Solo necesitan un hilo DATA y se encadenan. Soldé 6 entre dos hexágonos pequeños (otra plantilla). El hexágono inferior es masa, el superior es VCC. Suelda los terminales correspondientes de los NeoPixels a estos anillos. Los LEDs van a 45° para brillar lateralmente. Pon el séptimo LED en el centro del hexágono superior. Conecta DATA IN y OUT para crear la cadena.

Esta estructura necesita dos hilos hacia la base: VCC y DATA. La masa la toma de la estructura de la flor. Suelda un hilo de cobre esmaltado 0,3 mm al anillo superior (VCC) y otro al primer LED de la cadena (DATA). Hazlos al menos 3 veces la longitud del tallo. Desaisla los extremos antes de soldar (el calor no destruye el esmalte; usa cuchilla). Prueba los LEDs ahora. Ten cuidado con estos hilos finos: si pelais el aislamiento en otro sitio, ¡cortocircuito!

Último trabajo de soldadura en latón: coloca la estructura del pistilo en el centro del capullo. Desplázala ligeramente de la base hexagonal (1 cm en mi caso) para dejar espacio a las bielas de los pétalos. Une todos los vértices con varillas de latón para rigidizar. ¡La flor está hecha! Prueba que los pétalos sigan moviéndose libremente.

Raíces – cableado (2 h)

Pétalos y NeoPixels necesitan hilos de alimentación. Toda la escultura es masa, pero hay 6 pétalos y 2 hilos para NeoPixels que van al Arduino en la base. Usa hilo de cobre esmaltado 0,3 mm enrollado alrededor del tubo del tallo. Los dos hilos de NeoPixels ya están. Suelda otros 6 al alambre suelto de cada pétalo (cerca del eje) y pásalos por la estructura del capullo bajando por el tallo. Evita dobleces agudos: se romperían.

Reúne todos los hilos cerca del extremo superior del tallo y fíjalos con cinta de embalaje. No aprietes demasiado aún; deja que los hilos se deslicen. Organiza bien los hilos dentro del capullo: pétalos libres y varilla sin colisiones. ¿Listo? Aprieta la cinta.

Los hilos vuelan alrededor del tallo. Enróllalos pacientemente hacia abajo: apretados y uniformes. Me llevó al menos una hora. Al final del tallo, pon otra cinta y fija con cianocrilato. ¡No selles el tubo con la varilla dentro!

Falta la masa: suelda otro hilo de cobre al extremo inferior del tallo. Deben salir 9 hilos de la flor. Conviene conectar todos al Arduino ahora y probar que no hay cortocircuitos y todos los LEDs encienden.

La maceta (2 h)

Quería que la flor creciera de una maceta artificial que ocultara la electrónica. Usé madera torneada a cilindro (4 cm alto, 9 cm diámetro). Sin torno, usé sierra circular para forma bruta y taladro de columna como torno improvisado. Tallé una cavidad 2,5 cm profunda y 7 cm de diámetro con fresa manual para servo, Arduino Nano e IC táctil. En la base, un hueco para el puerto USB del Nano accesible lateralmente.

Si tienes la maceta, taladra un agujero del diámetro del tallo con hilos donde crecerá la flor (probablemente el centro). Encaja la flor. Cuidado con los hilos. Si los doblas en ángulo agudo, se rompen. Al final añadí un hueco grande desde el interior de la base para dar más espacio al brazo del servo y la biela.

Haz la forma de maceta que quieras, pero asegúrate de que quepa toda la electrónica.

Hoja táctil (1 h)

El tulipán necesita un elemento interactivo para hacerlo florecer. Elegí el IC TTP223 de mi proyecto Arduinoflake. ¿Dónde poner el panel táctil? Añadí una hojita lateral en el tallo que hace la flor más natural y actúa como panel capacitivo. Al tocarla, dispara el TTP223 y avisa al Arduino para abrir el capullo. Para ti será pan comido tras la escultura. Misma técnica que los pétalos, sin LEDs. También hice plantilla. Taladra otro agujero pequeño en la base junto al del tallo para sujetar la hoja.

Si no quieres/puedes usar sensor capacitivo, pon un pulsador normal en la base; hace lo mismo.

Montaje final (2 h)

¡Paso final! ¿Nervioso? Inserta el tallo en su agujero de la base. Mide dos veces antes de cortar. Abre el capullo al máximo. Corta el extremo de la varilla que sale del tallo a ras del tallo. Al cerrar el capullo, la varilla debe salir del tallo. Suelda un tubo corto perpendicular a la varilla: será el eje de la biela con el brazo del servo. Al soltar, el capullo debe quedar totalmente abierto porque el tubo actúa como tope.

Pega el tallo en la base. Asegura que el extremo del tubo quede a ras del interior de la base para maximizar espacio del brazo del servo. Usé cianocrilato. ¡No pegues la varilla al tubo del tallo! ¡Arruinarías el trabajo!

Pega la hoja táctil. Antes, suelda un hilo de cobre para conectarla al TTP223.

Pon la flor boca abajo. ¡Cuidado con la escultura! Primero, coloca el servo en posición final. Su brazo ya está preparado del banco de pruebas. Encuentra el punto dulce donde el brazo se mueva libre dentro de la base y conecta la biela a la varilla. Para fijar el servo usé chapa y dos tornillos (flexibilidad por si falla o mal posicionamiento). Si estás seguro, pégalo.

Si usas módulo TTP223, suelda el hilo de la hoja al pad táctil original del módulo (lado opuesto a componentes). Tendrás que rascar la máscara de seda para exponer cobre. Pega el módulo táctil.

Los 6 hilos de los pétalos (LEDs) van al Arduino mediante resistencias limitadoras. Usé seis resistencias de 200 Ω en una placa perforada minúscula. Pégala.

Último componente en la base: Arduino Nano, el cerebro. Colócalo en su hueco accesible para USB y cablea todo:

• Servo data → D9 (requerido por librería Adafruit_TiCoServo)
• TTP223 data → D2 (para usar interrupción)
• NeoPixel data → A0 (cualquier salida sirve)
• Pétalos → D3, D4, D5, D6, D10, D11 (cualquier salida)
• Masa flor → GND
• NeoPixel VCC → 5V
• TTP223 GND → GND
• TTP223 VCC → 5V
• Servo GND → GND
• Servo VCC → 5V

Programación (1 h)

La parte más fácil. Ya tienes el código del servo. Solo necesitas controlar NeoPixels, LEDs de pétalos y sensor táctil. Mira mi código adjunto; te da todo lo necesario. Si usaste mi cableado, funciona directo. No olvides cambiar los valores SERVO_OPEN y SERVO_CLOSED; serán distintos.

¡Está hecho!

¡No olvides compartir tu creación! Dale like a este artículo. Considera apoyarme comprando alguno de mis productos en mi tienda Tindie. Me encuentras en Twitter con mis últimos proyectos.

Código

flower.ino (Arduino)

#include <Adafruit_NeoPixel.h>
#include <Adafruit_TiCoServo.h>
#include "SoftPWM.h"

#define NEOPIXEL_PIN A0
#define TOUCH_SENSOR_PIN 2
#define SERVO_PIN 9
//#define SERVO_OPEN 1750
#define SERVO_OPEN 1650
#define SERVO_SAFE_MIDDLE 1000
#define SERVO_CLOSED 775

#define RED 0
#define GREEN 1
#define BLUE 2
float currentRGB[] = {0, 0, 0};
float changeRGB[] = {0, 0, 0};
byte newRGB[] = {0, 0, 0};

#define MODE_SLEEPING 0
#define MODE_BLOOM 3
#define MODE_BLOOMING 4
#define MODE_BLOOMED 5
#define MODE_FADE 6
#define MODE_FADING 7
#define MODE_FADED 8
#define MODE_FALLINGASLEEP 9
#define MODE_RAINBOW 90

byte mode = MODE_FADED;
byte petalPins[] = {3, 4, 5, 6, 10, 11};

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(7, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ400);
Adafruit_TiCoServo servo;

int servoChange = 1; // open
int servoPosition = SERVO_SAFE_MIDDLE;

void setup() {
  Serial.begin(115200);
  pixels.begin();
  servo.attach(SERVO_PIN, SERVO_CLOSED, SERVO_OPEN);
  pinMode(TOUCH_SENSOR_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(TOUCH_SENSOR_PIN), _touchISR, RISING);
  randomSeed(analogRead(A7));
  SoftPWMBegin();
  pixelsUnifiedColor(pixels.Color(0, 0, 0));
  prepareCrossFade(140, 70, 0, 140);
  servo.write(servoPosition);
}

int counter = 0;
byte speed = 15;

void loop() {
  boolean done = true;
  switch (mode) {
    case MODE_BLOOM:
      prepareCrossFadeBloom(500);
      changeMode(MODE_BLOOMING);
      break;
    case MODE_BLOOMING:
      done = crossFade() && done;
      done = openPetals() && done;
      done = petalsBloom(counter) && done;
      if (done) changeMode(MODE_BLOOMED);
      break;
    case MODE_FADE:
      changeMode(MODE_FADING);
      break;
    case MODE_FADING:
      done = crossFade() && done;
      done = closePetals() && done;
      done = petalsFade(counter) && done;
      if (done) changeMode(MODE_FADED);
      break;
    case MODE_FADED:
      changeMode(MODE_FALLINGASLEEP);
      break;
    case MODE_FALLINGASLEEP:
      done = crossFade() && done;
      done = closePetals() && done;
      if (done) changeMode(MODE_SLEEPING);
      break;
    case MODE_RAINBOW:
      rainbow(counter);
      break;
  }
  counter++;
  delay(speed);
}

void changeMode(byte newMode) {
  if (mode != newMode) {
    mode = newMode;
    counter = 0;
  }
}

void _touchISR() {
  if (mode == MODE_SLEEPING) changeMode(MODE_BLOOM);
  else if (mode == MODE_BLOOMED) changeMode(MODE_FADE);
}

boolean petalsBloom(int j) {
  if (j < 250) return false;
  if (j > 750) return true;
  int val = (j - 250) / 2;
  for (int i = 0; i < 6; i++) SoftPWMSet(petalPins[i], val);
  return false;
}

boolean petalsFade(int j) {
  if (j > 510) return true;
  for (int i = 0; i < 6; i++) SoftPWMSet(petalPins[i], (510 - j) / 2);
  return false;
}

void prepareCrossFadeBloom(unsigned int duration) {
  byte color = random(0, 5);
  switch (color) {
    case 0: prepareCrossFade(140, 140, 140, duration); break; // blanco
    case 1: prepareCrossFade(140, 5, 0, duration); break;      // rojo
    case 2: prepareCrossFade(30, 70, 170, duration); break;    // azul
    case 3: prepareCrossFade(140, 0, 70, duration); break;     // rosa
    case 4: prepareCrossFade(255, 70, 0, duration); break;     // naranja
  }
}

void rainbow(int j) {
  uint16_t i;
  byte num = pixels.numPixels() - 1;
  pixels.setPixelColor(pixels.numPixels() - 1, 100, 100, 100);
  for (i = 0; i < num; i++) {
    pixels.setPixelColor(i, colorWheel(((i * 256 / num) + j) & 255));
  }
  pixels.show();
}

boolean openPetals() {
  if (servoPosition >= SERVO_OPEN) return true;
  servoPosition++;
  servo.write(servoPosition);
  return false;
}

boolean closePetals() {
  if (servoPosition <= SERVO_CLOSED) return true;
  servoPosition--;
  servo.write(servoPosition);
  return false;
}

void pixelsUnifiedColor(uint32_t color) {
  for (unsigned int i = 0; i < pixels.numPixels(); i++) pixels.setPixelColor(i, color);
  pixels.show();
}

void prepareCrossFade(byte red, byte green, byte blue, unsigned int duration) {
  float rchange = red - currentRGB[RED];
  float gchange = green - currentRGB[GREEN];
  float bchange = blue - currentRGB[BLUE];
  changeRGB[RED] = rchange / (float)duration;
  changeRGB[GREEN] = gchange / (float)duration;
  changeRGB[BLUE] = bchange / (float)duration;
  newRGB[RED] = red; newRGB[GREEN] = green; newRGB[BLUE] = blue;
}

boolean crossFade() {
  if (currentRGB[RED] == newRGB[RED] && currentRGB[GREEN] == newRGB[GREEN] && currentRGB[BLUE] == newRGB[BLUE]) return true;
  for (byte i = 0; i < 3; i++) {
    if (changeRGB[i] > 0 && currentRGB[i] < newRGB[i]) currentRGB[i] += changeRGB[i];
    else if (changeRGB[i] < 0 && currentRGB[i] > newRGB[i]) currentRGB[i] += changeRGB[i];
    else currentRGB[i] = newRGB[i];
  }
  pixelsUnifiedColor(pixels.Color(currentRGB[RED], currentRGB[GREEN], currentRGB[BLUE]));
  return false;
}

uint32_t colorWheel(byte wheelPos) {
  wheelPos = 255 - wheelPos;
  if (wheelPos < 85) return pixels.Color(255 - wheelPos * 3, 0, wheelPos * 3);
  if (wheelPos < 170) { wheelPos -= 85; return pixels.Color(0, wheelPos * 3, 255 - wheelPos * 3); }
  wheelPos -= 170; return pixels.Color(wheelPos * 3, 255 - wheelPos * 3, 0);
}