Tulipa Mecânica Eterna – Flor LED Ativada por Toque

Componentes e Materiais

Componente	Quantidade
Arduino Nano R3	1
Micro-servo SG90	1
Sensor de toque TTP223	1
Fio de latão 1 mm	1
Tubo de latão 2 mm (furo 1,2 mm)	1
Fio de cobre esmaltado 0,3 mm	1
LED NeoPixel WS2812 5050	7
LED SMD branco 1206	30

Sobre o Projeto

Flor eterna para seu amor eterno. Um presente perfeito não apenas para o Dia dos Namorados. Esta tulipa mecânica floresce em qualquer cor possível com apenas um toque suave da mão. Suas seis pétalas abrem-se lentamente e acendem. Quando fechadas, criam uma incrível luz ambiente com padrões de folhas.

Como Funciona?

Antes de ensinar a criar esta beleza, vamos falar brevemente sobre o funcionamento. A tulipa consiste em 6 pétalas, cada uma com 5 LEDs SMD brancos. Cada pétala conecta-se a um dos pinos de saída do Arduino. O miolo esconde 7 LEDs RGB NeoPixel. Do ponto de vista elétrico, toda a flor é terra e as veias nas pétalas são tensão positiva. As pétalas abrem-se por uma haste de empurrão que percorre todo o caule até a base. A haste é controlada pelo movimento de um pequeno servo hobby. Uma pequena folha no lado do caule conecta-se ao sensor TTP223 dentro da base e cria um touchpad capacitivo. A base de madeira contém o servo, o CI de toque e o Arduino Nano. Vamos construir uma!

O que Você Vai Precisar

• Haste de latão 1 mm
• Tubo de latão 2 mm com furo 1,2 mm
• Fio de cobre 0,3 mm com isolamento
• Madeira para o pedestal
• Arduino Nano
• Sensor de toque TTP223
• Micro-servo pequeno

O que Saber Antes de Começar

• Como soldar latão (ótimo artigo)
• Como construir com Arduino
• Como usar servos
• Como usar LEDs e NeoPixels

Não vou dar dimensões dos componentes nem formato exato do miolo. Acho que cada flor deve ser única.

As Pétalas (4h)

Vamos começar pela parte mais satisfatória — as pétalas do miolo. O número entre parênteses é o tempo estimado.

Primeiro, você precisa de um molde para o miolo. Criei o meu com gesso despejado em molde tubular. Quando secou, modelei em formato de tulipa. Você pode imprimir em 3D, mas não tenho impressora. O gesso é ótimo porque é fácil de usinar e o lápis desenha nele. Uma única pétala ocupa 1/4 da superfície do molde, então no final, com 6 pétalas, elas se sobrepõem levemente criando o visual exato de uma tulipa. Desenhei o formato da pétala na superfície do gesso com lápis. Quando satisfeito, entalhei no gesso com faca para ajudar a segurar as hastes no lugar durante a soldagem.

Cada pétala consiste em hastes de latão 1 mm contornando o formato. Dentro, 5 LEDs SMD 1206 brancos e uma estrutura de "veias" do mesmo fio. Primeiro, crie o fio circunferencial, tome seu tempo dobrando. Corte um pequeno pedaço de tubo e passe na parte inferior reta do fio — será a dobradiça onde a pétala se move. Solde as pontas do fio, certificando-se de não encher o tubo com solda; ele precisa mover-se livremente. Finalize a pétala com LEDs e estrutura venosa.

Agora faça mais 5 iguais. Todas as pétalas devem ser exatamente iguais. É crucial. Caso contrário, não formarão uma tulipa bonita e uniforme ao fechar e podem travar.

O Miolo (1h)

Hora de soldar todas as pétalas. A base do miolo é hexagonal — 6 pétalas. As pétalas fixam-se ao hexágono via dobradiças. O hexágono, porém, é ligeiramente irregular. Falhei com um regular. As pétalas precisam se sobrepor e, se o hexágono for regular, não podem. Três pétalas ficam mais próximas do centro (pétalas internas) e outras 3 em leve deslocamento (pétalas externas). Para isso, criei um molde e imprimi em papel. A forma vermelha é o hexágono irregular final feito de dois hexágonos regulares aninhados. Solde todas as dobradiças (tubos) ao hexágono. Os raios saindo do centro do molde ajudarão a soldar as pétalas na posição correta. O centro da pétala deve seguir a linha do raio saindo do centro do hexágono. No final, ao fechar as pétalas, você terá o formato final do miolo. Bonito, não?

Criando o Caule e a Haste de Empurrão (1h)

Não foi assim que procedi na minha montagem. Primeiro finalizei o mecanismo dentro do miolo e depois adicionei caule e haste. Isso adicionou muita dificuldade. Quase joguei tudo fora. Da próxima vez, começarei pelo caule. Você também deveria.

O movimento das pétalas é criado por uma haste de empurrão de latão 1 mm movendo-se livremente dentro de um tubo de latão. As pétalas conectam-se à haste através de um minúsculo hexágono com pequenas dobradiças de 2 mm em cada lado — a cabeça da haste. O hexágono fica perpendicular à haste com ajuda de uma pequena barra passando pelo centro. É trabalho de relojoeiro.

Para criar a cabeça da haste, usei um segundo molde. Primeiro, dobre o fio formando o minúsculo hexágono. Corte pequenos tubos de 2 mm e passe-os no fio. Solde o fio para fechar o hexágono. Novamente, certifique-se de não soldar o tubo ao fio. Continue soldando fio no centro do hexágono. Finalize a haste soldando um fio de 1 mm perpendicular ao centro da cabeça. Pronto! Você tem sua haste de empurrão.

Construa o caule. Corte o tubo de latão no comprimento desejado. Agora a segunda parte crucial. O caule precisa ser perfeitamente perpendicular à base hexagonal do miolo, no centro exato, e com espaço suficiente para a cabeça da haste mover-se para baixo e fechar as pétalas. Primeiro, soldei dois fios em uma extremidade do caule criando uma expansão em V. Serão 2 dos 6 fios conectando o caule aos vértices da base hexagonal.

Vire o miolo de cabeça para baixo e solde a expansão em V a 2 vértices opostos da base hexagonal. Verifique o formato. Se colocar uma haste dentro do caule, ela deve sair no centro do miolo. Tenha paciência aqui para ficar perfeito. É realmente crucial. Quando estiver satisfeito, solde mais 4 fios entre os demais vértices do hexágono e o topo do caule. Cuidado para não soldar o furo interno do tubo!

Mecanismo das Pétalas (6h)

Esta é a parte em que você vai se arrepender de ter começado. Quase joguei no lixo. Mas ei, não sou o cara mais paciente. Você vai conseguir! Inspirei-me em máquinas a vapor e suas bielas, pistões e volantes.

Faça um suporte de teste. Fixe a flor com o caule para cima. Passe a haste pelo caule com a cabeça para cima. Solde um tubo curto perpendicular à extremidade inferior da haste e crie uma pequena biela de fio de latão 1 mm para conectar servo e haste (veja foto acima). Você deve conseguir mover a haste para cima e baixo usando o servo. Teste conectando seu Arduino. Antes de soldar as bielas entre pétalas e cabeça da haste, ajuste o movimento do servo com Arduino. Escreva código para mover a haste de forma que na posição mais alta a ponta da cabeça fique nivelada com a base hexagonal do miolo. Na posição mais baixa, assente na base em V do miolo.

À medida que a haste sobe, empurra a biela e as pétalas para baixo. Ao descer, puxa as bielas e as pétalas fecham.

As pétalas ainda faltam uma parte crucial — o pino da pétala. Esta dobradiça faz as pétalas moverem-se. O pino assenta em uma barra (veja imagem abaixo) soldada a cada pétala paralela à sua base. O pino precisa ficar acima da superfície da pétala para permitir abertura total, como visto na animação. Faça uma barra com dobradiça de tubo e solde na primeira pétala. Isso exigirá muita experimentação com o tamanho da barra e sua distância da base para permitir que a haste abra e feche totalmente a pétala. Use tentativa e erro. Solde a barra em posição adequada e adicione biela entre o pino da haste e o pino da pétala. Se a haste estiver na posição superior e a pétala totalmente aberta, o espaço entre os pinos é o comprimento da biela.

Agora teste movendo a haste para cima e baixo. Se funcionar sem atrito e a pétala abrir e fechar, você terminou (com a primeira pétala)! Se não, tente comprimento diferente de biela ou posição diferente da barra. Para finalizar o miolo, duplique a mesma barra e biela nas 5 pétalas restantes. As 3 pétalas externas precisam ficar um pouco mais baixas quando o miolo abre para permitir sobreposição adequada das internas ao fechar. No final, você deve conseguir fechar e abrir o miolo. Não entre em pânico se não conseguir o formato perfeito na primeira. Significa apenas que as pétalas não são perfeitamente iguais. Provavelmente levará muito ajuste fino — comprimentos ligeiramente diferentes de bielas e posições das barras. Tenha paciência! A recompensa está próxima.

Pistilo Arco-Íris (1h)

Se chegou aqui, você é rei e as partes mais difíceis ficaram para trás. Dentro do miolo, coloquei 7 LEDs NeoPixel para brilhar de dentro. Precisam apenas de um fio DATA e podem ser encadeados. Soldei 6 entre dois pequenos hexágonos (outro molde). O hexágono inferior é terra e o superior é tensão positiva. Solde os terminais apropriados dos NeoPixels a estes anéis. Os LEDs ficam inclinados a 45° para brilhar lateralmente. Para melhorar, coloque o sétimo LED no centro do hexágono superior. Por fim, conecte DATA IN e OUT para criar a cadeia.

Esta estrutura precisará de dois fios descendo ao pedestal — VCC e DATA. A terra vem da estrutura da flor. Solde um fio fino de cobre 0,3 mm isolado ao anel superior para VCC e o segundo ao primeiro LED da cadeia para DATA. Estes fios descerão ao pedestal. Faça-os pelo menos 3 vezes o comprimento do caule. As pontas devem ter o isolamento removido antes de soldar. Calor não destrói o isolamento. Use faca para retirar. Teste os LEDs agora. Seja gentil com estes fios de cobre. Se descascar o isolamento acidentalmente em outro local, pode causar curto-circuito!

Última soldagem em latão! Coloque a estrutura do pistilo no centro do miolo. Desloque-a ligeiramente da base hexagonal para deixar espaço para as bielas das pétalas. Para mim, foi 1 cm acima do hexágono. Conecte todos os vértices com hastes de latão para estrutura sólida. A flor está pronta! Teste agora se as pétalas ainda movem-se livremente.

Fazendo as Raízes (2h)

Tanto as pétalas quanto os NeoPixels precisam de fios de alimentação. Toda a escultura será terra, mas há 6 pétalas e 2 fios para NeoPixels que precisam conectar ao Arduino no pedestal. Para isso, fios finos de cobre 0,3 mm com isolamento transparente serão enrolados no tubo do caule. Dois fios para NeoPixels já estão prontos. Solde mais 6 ao fio solto da veia em cada pétala perto da dobradiça e passe pelo interior do miolo pelo caule. Certifique-se de não dobrar estes fios em ângulos agudos, quebrariam logo.

Junte todos os fios perto da extremidade superior do tubo do caule e prenda com fita adesiva. Não aperte demais ainda, permita que os fios deslizem. Organize bem todos os fios dentro do miolo. Certifique-se que as pétalas movem-se livremente e a haste não colide com os fios. Pronto? Agora aperte a fita.

Os fios agora voam ao redor do caule descontroladamente. Você precisa pacientemente e lentamente enrolá-los pelo caule. Firme e uniformemente. Levou-me pelo menos uma hora. Ao chegar ao fim do caule, coloque outra fita para prender os fios e use supercola transparente para fixá-los no lugar. Cuidado para não vedar o tubo com a haste!

Falta o fio de terra. Solde outro fio de cobre na extremidade inferior do caule. Deverá ter 9 fios saindo da flor. Seria sábio agora conectar todos os fios ao Arduino e testar se não há curto-circuito e todos os LEDs acendem.

O Vaso (2h)

Queria que a flor crescesse de um vaso artificial que também escondesse a eletrônica. Usei um pedaço de madeira torneado em cilindro 4 cm alto e 9 cm de diâmetro. Não tenho torno, usei serra circular para corte bruto e furadeira de coluna como torno improvisado. Entalhei uma abertura 2,5 cm funda e 7 cm de diâmetro com fresa manual para caber servo, Arduino Nano e CI de toque. Na base do cilindro, pequena abertura para encaixar precisamente a porta USB do Arduino Nano para conectar cabo lateralmente.

Se tiver seu vaso, fure com diâmetro do caule com fios onde a flor crescerá — provavelmente no centro. Tente encaixar sua flor. Cuidado com os fios. Se dobrar em ângulo agudo, quebram. No final, adicionei furo grande internamente para mais espaço para braço do servo e biela.

Pode fazer qualquer formato de vaso, só lembre-se de caber toda a eletrônica dentro.

Touchpad em Forma de Folha (1h)

A tulipa mecânica precisa de elemento interativo para fazê-la florescer. Escolhi o CI TTP223 do meu projeto Arduinoflake. Mas onde colocar o touchpad? Decidi adicionar uma folha no lado do caule que tornaria a flor mais natural e funcionaria como touchpad capacitivo. Ao tocar, acionaria o TTP223 e diria ao Arduino para abrir o miolo. Será moleza para você agora que terminou uma escultura tão complexa. Use a mesma técnica das pétalas, apenas omita os LEDs. Também criei um molde. Fure outro pequeno furo no pedestal ao lado do furo do caule para prender a folha.

Se não quiser ou não puder usar sensor capacitivo, pode adicionar botão normal no pedestal. Fará o mesmo trabalho.

Montagem Final (2h)

Passo final da montagem! Está nervoso? Insira o caule da flor no furo do pedestal novamente. Passo importante: meça duas vezes antes de cortar! Abra o miolo totalmente. Corte a extremidade da haste saindo do caule nivelada com o caule. Ao fechar o miolo novamente, a haste deve sair do caule. Solde um tubo curto perpendicularmente à haste. Será dobradiça para a biela com o braço do servo. Ao soltar o miolo e a haste, deve parar totalmente aberto porque o tubo atuará como batente.

Agora cole o caule no pedestal. Certifique-se que a extremidade do tubo do caule fique nivelada com o interior do pedestal para deixar máximo espaço para o braço do servo. Usei supercola. Certifique-se de não colar a haste com o tubo do caule. Isso arruinaria seu trabalho!

Em seguida, cole a folha-touchpad. Antes, solde um fio de cobre a ela para conectar ao sensor TTP223.

Vire a flor de cabeça para baixo. Cuidado com a escultura, não a quebre agora! Seria tanto desperdício! Primeiro, coloque o servo na posição final. Seu braço já deve estar preparado do suporte de teste. Encontre o ponto ideal onde o braço do servo mova-se livremente dentro do pedestal e conecte a biela à haste. Para fixar o servo, usei chapa metálica e dois parafusos. Quis flexibilidade em caso de quebra ou má colocação. Mas se confia, pode colar.

Se tem módulo TTP223, solde o fio da folha no touchpad original do módulo (lado oposto aos componentes). Precisará raspar a máscara de seda protetora para expor a camada de cobre. Cole o módulo de toque.

Fios das pétalas (6 no total) conectam-se ao Arduino via resistores limitadores de corrente. As pétalas são basicamente LEDs. Usei seis resistores de 200 ohms soldados em pequena placa perfurada. Cole no lugar.

Último componente no pedestal: o Arduino Nano como cérebro da tulipa. Coloque-o na abertura do pedestal para poder conectar ao computador e faça a fiação:

• Fio de dados do servo → D9 (necessário para biblioteca Adafruit_TiCoServo)
• Dados do sensor TTP223 → D2 (para usar interrupção)
• Dados NeoPixel → A0 (qualquer pino de saída serve)
• Pétalas → D3, D4, D5, D6, D10, D11 (quaisquer pinos de saída)
• Fio terra da flor → GND
• Fio VCC NeoPixel → 5V
• GND TTP223 → GND
• VCC TTP223 → 5V
• GND Servo → GND
• VCC Servo → 5V

Programação (1h)

A programação é a parte mais fácil. Você já tem o código do servo. Agora só precisa controlar NeoPixels, LEDs das pétalas e sensor de toque. Veja meu código anexado. Ele dá tudo que você precisa. Se usou minha fiação, pode usar direto. Mas não esqueça de alterar os valores SERVO_OPEN e SERVO_CLOSED. Serão definitivamente diferentes.

Está Pronto!

Não esqueça de compartilhar sua criação! Curta este artigo. Considere também me apoiar comprando alguns dos meus produtos na minha loja Tindie.

Pode me encontrar e ver meus últimos projetos no meu Twitter.

Código

flower.ino

#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; // branco
    case 1: prepareCrossFade(140, 5, 0, duration); break;     // vermelho
    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;    // laranja
  }
}

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;
  Serial.print(newRGB[RED]); Serial.print(" "); Serial.print(newRGB[GREEN]); Serial.print(" "); Serial.print(newRGB[BLUE]); Serial.print(" ("); Serial.print(changeRGB[RED]); Serial.print(" "); Serial.print(changeRGB[GREEN]); Serial.print(" "); Serial.print(changeRGB[BLUE]); Serial.println(")");
}

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);
}