Tulipe mécanique éternelle – Fleur LED à activation tactile

Composants et fournitures

Composant	Quantité
Arduino Nano R3	1
Moteur servo SG90	1
Capteur tactile TTP223	1
Fil de laiton 1 mm	1
Tuyau de laiton 2 mm	1
Fil de cuivre isolé 0,3 mm	1
LED WS2812 5050 NeoPixel	7
LED SMD blanche 1206	30

À propos de ce projet

Une fleur éternelle pour un amour éternel. Un cadeau parfait, pas seulement pour la Saint-Valentin, pour votre bien-aimé(e). Cette tulipe mécanique s'épanouit dans n'importe quelle couleur d'une simple touche de la main. Ses six pétales s'ouvrent lentement et s'illuminent. Fermés, ils créent une incroyable lumière d'ambiance avec des motifs de feuilles.

Comment ça marche ?

Avant de vous expliquer la construction, voyons le principe. La tulipe comporte 6 pétales, chacun avec 5 LEDs SMD blanches. Chaque pétale est connecté à une broche de sortie de l'Arduino. Le cœur cache 7 LEDs RGB NeoPixel. Électriquement, toute la fleur est la masse et les « veines » des pétales sont le positif. Les pétales s'ouvrent via une tige de poussée qui descend le long de la tige jusqu'à la base, actionnée par un petit servo. Une petite feuille sur le côté de la tige est connectée au capteur TTP223 à l'intérieur de la base, créant un pavé tactile capacitif. La base en bois contient le servo, le circuit tactile et l'Arduino Nano. Construisons-en une !

Matériel nécessaire

• Tige de laiton 1 mm
• Tuyau de laiton 2 mm (trou 1,2 mm)
• Fil de cuivre isolé 0,3 mm
• Du bois pour le piédestal
• Arduino Nano
• Capteur tactile TTP223
• Petit servo

Prérequis

• Savoir souder du laiton (excellent article)
• Savoir construire avec Arduino
• Savoir utiliser des servos
• Savoir utiliser LEDs et NeoPixels

Je ne donne pas les dimensions exactes ni la forme précise du cœur : chaque fleur doit être unique.

Les pétales (4h)

Commençons par la partie la plus satisfaisante : les pétales. Le chiffre entre parenthèses indique le temps estimé.

Il faut d'abord un gabarit pour le cœur. J'ai créé le mien en coulant du plâtre dans un moule tubulaire. Une fois sec, je l'ai façonné en tulipe. Vous pouvez aussi l'imprimer en 3D. Le plâtre est pratique car facile à usiner et on peut y dessiner au crayon. Un pétale représente 1/4 de la surface du gabarit, ainsi les 6 pétales se chevauchent légèrement pour former une vraie tulipe. Je dessine la forme au crayon, puis je la grave au couteau pour maintenir les tiges en place lors du soudage.

Un pétale comprend : une tige de laiton 1 mm suivant le contour, 5 LEDs SMD 1206 blanches à l'intérieur, et une structure de « veines » en fil de laiton. D'abord, créez le fil périphérique, prenez votre temps pour le plier. Coupez un petit morceau de tuyau et passez-le sur la partie plate du bas – ce sera la charnière. Soudez les extrémités, sans remplir le tuyau de soudure (il doit bouger librement). Terminez avec les LEDs et la structure veineuse. Regardez la vidéo pour la fabrication d'un pétale (seule séquence filmée).

Maintenant, faites 5 autres pétales identiques. C'est crucial : sinon ils ne formeront pas une tulipe régulière une fois fermés et risquent de se bloquer.

Le cœur (1h)

Il faut maintenant souder les 6 pétales ensemble. La base est hexagonale mais légèrement irrégulière : un hexagone régulier n'autorise pas le chevauchement. Trois pétales sont plus proches du centre (pétales intérieurs), trois autres en décalage (extérieurs). J'ai créé un gabarit papier : la forme rouge est l'hexagone final fait de deux hexagones réguliers imbriqués. Soudez toutes les charnières (tuyaux) sur l'hexagone. Les rayons partant du centre aident à positionner correctement les pétales. Le centre de chaque pétale doit suivre le rayon correspondant. Une fois fermés, vous obtenez la forme finale. Joli, non ?

Tige et tige de poussée (1h)

Dans ma construction, j'ai fait le mécanisme du cœur avant la tige, ce qui a ajouté beaucoup de difficultés. La prochaine fois, je commencerai par la tige. Vous devriez faire de même.

Le mouvement des pétales est créé par une tige de poussée en laiton 1 mm coulissant librement dans un tuyau de laiton. Les pétales sont connectés à la tige via un minuscule hexagone avec de petites charnières de 2 mm de chaque côté – la tête de tige. L'hexagone est perpendiculaire à la tige grâce à une petite barre traversant son centre. C'est du travail d'horloger.

Pour créer la tête : pliez le fil pour former le petit hexagone. Coupez 6 tuyaux de 2 mm et passez-les sur le fil. Soudez pour fermer l'hexagone (sans souder les tuyaux au fil). Soudez un fil au centre de l'hexagone. Terminez en soudant un fil de 1 mm perpendiculaire au centre de la tête. Voilà votre tige de poussée !

Construisez la tige : coupez le tuyau à la longueur voulue. Point crucial : la tige doit être parfaitement perpendiculaire à la base hexagonale du cœur, exactement au centre, avec assez d'espace pour que la tête descende et ferme les pétales. J'ai d'abord soudé deux fils à une extrémité pour créer un évasement en V – ce seront 2 des 6 fils reliant la tige aux sommets de l'hexagone.

Retournez le cœur et soudez l'évasement en V sur deux sommets opposés. Vérifiez : si vous insérez une tige dans le tuyau, elle doit sortir au centre du cœur. Prenez votre temps pour que ce soit parfait. C'est crucial. Une fois satisfait, soudez les 4 fils restants entre les autres sommets et le haut de la tige. Attention à ne pas souder l'intérieur du tuyau !

Mécanisme des pétales (6h)

C'est l'étape où vous regretterez d'avoir commencé. J'ai failli tout jeter. Mais vous y arriverez ! Inspiré par les machines à vapeur : bielles, pistons, volants.

Fabriquez un banc d'essai. Fixez la fleur tige en l'air. Insérez la tige de poussée tête en haut. Soudez un court tuyau perpendiculaire à l'extrémité basse de la tige et créez une bielle en fil de laiton 1 mm pour relier le servo et la tige (voir photo). Vous devez pouvoir bouger la tige haut/bas avec le servo. Testez en branchant l'Arduino. Avant de souder les biellettes entre pétales et tête de tige, réglez le mouvement du servo : en position haute, l'extrémité de la tête doit être au ras de la base hexagonale ; en position basse, elle doit toucher le fond de la base en V.

Quand la tige monte, elle pousse les biellettes et les pétales s'ouvrent. Quand elle descend, elle les tire et les pétales se ferment.

Il manque un élément crucial aux pétales : l'axe de charnière. Cette charnière repose sur une barre soudée à chaque pétale, parallèle à sa base. L'axe doit dépasser de la surface pour permettre l'ouverture complète (voir animation). Fabriquez une telle barre avec charnière (tuyau) et soudez-la au premier pétal. Il faudra beaucoup d'essais pour trouver la bonne taille et distance de la barre par rapport à la base. Méthode essai-erreur. Soudez la barre, ajoutez la biellette entre l'axe de la tige et l'axe du pétale. Si la tige est en position haute et le pétale ouvert, l'espace entre les deux axes donne la longueur de la biellette.

Testez le mouvement haut/bas. Si ça marche sans frottement et que le pétale s'ouvre/ferme, premier pétale réussi ! Sinon, changez la longueur de la biellette ou la position de la barre. Répétez pour les 5 autres pétales. Les 3 pétales extérieurs doivent être un peu plus bas à l'ouverture pour bien chevaucher les intérieurs à la fermeture. Au final, vous devez pouvoir ouvrir/fermer le cœur. Pas de panique si ce n'est pas parfait du premier coup : cela signifie que les pétales ne sont pas parfaitement identiques. Il faudra beaucoup de réglages fins. Prenez votre temps ! La récompense est proche.

Pistil arc-en-ciel (1h)

Si vous en êtes là, vous êtes un roi et le plus dur est derrière vous. À l'intérieur du cœur, je place 7 LEDs NeoPixel pour briller de l'intérieur. Elles ne nécessitent qu'un fil DATA et peuvent être chainées. J'ai soudé 6 NeoPixels entre deux petits hexagones (encore un gabarit). L'hexagone inférieur est la masse, le supérieur le positif. Soudez les pattes appropriées des NeoPixels sur ces anneaux. Les LEDs sont placées à 45° pour éclairer les côtés. Placez la 7e LED au centre de l'hexagone supérieur. Connectez DATA IN et OUT pour créer la chaîne.

Cette structure aura besoin de deux fils descendant au piédestal : VCC et DATA. La masse est reprise par la structure en laiton. Soudez un fil de cuivre isolé 0,3 mm sur l'anneau supérieur pour VCC, et un second sur le premier LED de la chaîne pour DATA. Faites-les au moins 3 fois la longueur de la tige. Dénudez les extrémités (chaleur ou couteau). Testez les LEDs maintenant. Soyez doux : si vous dénudez ailleurs, court-circuit garanti !

Dernier travail de soudure laiton ! Placez la structure du pistil au centre du cœur. Décalez-la légèrement de la base hexagonale (1 cm pour moi) pour laisser de la place aux biellettes. Reliez tous les sommets avec des tiges de laiton pour rigidifier. La fleur est finie ! Testez que les pétales bougent encore librement.

Fabrication des racines (2h)

Pétales et NeoPixels ont besoin de fils d'alimentation. Toute la sculpture sera la masse, mais il y a 6 pétales et 2 fils pour les NeoPixels à connecter à l'Arduino dans le piédestal. Utilisez du fil de cuivre 0,3 mm isolé enroulé autour du tuyau de la tige. Les 2 fils NeoPixels sont déjà faits. Soudez 6 autres fils sur le fil de veine libre de chaque pétale près de la charnière et faites-les descendre par la structure dans la tige. Évitez les angles vifs (cassure).

Rassemblez tous les fils près du haut de la tige et fixez-les avec du ruban adhésif (pas trop serré). Organisez les fils à l'intérieur du cœur : pétales libres, tige de poussée sans collision. Serrez le ruban.

Enroulez patiemment les fils le long de la tige, serré et régulier (1h minimum). À la fin, mettez un autre ruban et de la superglue pour fixer. Ne collez pas le tuyau avec la tige de poussée !

Dernier fil manquant : la masse. Soudez un fil de cuivre à l'extrémité basse de la tige. Vous avez maintenant 9 fils sortant de la fleur. Branchez-les sur l'Arduino et testez : pas de court-circuit, toutes LEDs allumées.

Le pot de fleurs (2h)

Je voulais que la fleur pousse d'un pot artificiel cachant l'électronique. J'ai utilisé un morceau de bois usiné en cylindre (4 cm haut, 9 cm diamètre). Sans tour, j'ai utilisé une scie circulaire pour la forme brute, puis une perceuse à colonne comme tour improvisé. J'ai creusé une cavité de 2,5 cm profondeur, 7 cm diamètre pour loger servo, Arduino Nano et circuit tactile. En bas, une ouverture pour le port USB de l'Arduino.

Percez un trou du diamètre de la tige (avec fils) à l'endroit où la fleur poussera (centre). Essayez d'insérer la fleur. Attention aux fils : angle vif = casse. J'ai aussi ajouté un grand trou à l'intérieur pour laisser de la place au bras du servo et à la biellette.

Forme libre pour le pot, tant que l'électronique tient dedans.

Feuille tactile (1h)

La tulipe a besoin d'un élément interactif pour s'épanouir. J'ai choisi le capteur TTP223 de mon projet Arduinoflake. Où mettre le pavé tactile ? Une petite feuille sur le côté de la tige : naturelle et capacitive. Toucher la feuille déclenche le TTP223 et dit à l'Arduino d'ouvrir le cœur. C'est du gâteau pour vous maintenant ! Même technique que les pétales, sans LEDs. J'ai aussi fait un gabarit. Percez un petit trou dans le piédestal à côté de la tige pour fixer la feuille.

Si vous ne voulez/peuvez pas utiliser un capteur capacitif, un simple bouton poussoir sur le piédestal fait le même travail.

Assemblage final (2h)

Étape finale ! Êtes-vous nerveux ? Réinsérez la tige dans son trou. Mesurez deux fois avant de couper ! Ouvrez le cœur à fond. Coupez l'extrémité de la tige de poussée sortie de la tige, au ras. Refermez le cœur : la tige doit ressortir. Soudez un court tuyau perpendiculairement à l'extrémité de la tige : charnière pour la biellette du bras de servo. Quand vous lâchez, le tuyau fait butée en position ouverte.

Collez la tige dans le piédestal. Extrémité du tuyau au ras de l'intérieur pour maximiser l'espace du bras de servo. Superglue. Ne collez PAS la tige de poussée au tuyau ! Ça ruinerait tout.

Collez la feuille tactile. Soudez un fil de cuivre dessus pour la connecter au TTP223.

Mettez la fleur à l'envers. Attention à ne pas casser ! Placez le servo en position finale. Son bras doit être prêt depuis le banc d'essai. Trouvez l'endroit où le bras bouge librement et connectez la biellette à la tige. Fixez le servo avec une tôle et deux vis (flexible en cas de panne ou mauvais placement). Sinon, collez-le.

Si vous avez un module TTP223, soudez le fil de la feuille sur le pavé tactile original du module (côté opposé aux composants). Grattez le masque de protection pour exposer le cuivre. Collez le module.

Les 6 fils des pétales (LEDs) se connectent à l'Arduino via des résistances de limitation. J'ai utilisé six résistances de 200 Ω sur un petit bout de plaque d'essai. Collez-le.

Dernier composant : l'Arduino Nano, cerveau de la tulipe. Placez-le dans l'ouverture du piédestal (accessible pour USB) et câblez :

• Servo data → D9 (requis pour Adafruit_TiCoServo)
• TTP223 data → D2 (pour interruption)
• NeoPixel data → A0 (n'importe quelle sortie)
• Pétales → D3, D4, D5, D6, D10, D11 (sorties quelconques)
• Masse fleur → GND
• NeoPixel VCC → 5V
• TTP223 GND → GND
• TTP223 VCC → 5V
• Servo GND → GND
• Servo VCC → 5V

Programmation (1h)

La partie la plus facile. Vous avez déjà le code du servo. Il reste à contrôler NeoPixels, LEDs pétales et capteur tactile. Regardez mon code joint : il contient tout le nécessaire. Si vous avez suivi mon câblage, il fonctionne directement. N'oubliez pas de modifier les valeurs SERVO_OPEN et SERVO_CLOSED (elles seront différentes).

C'est fini !

N'oubliez pas de partager votre création ! Likez cet article. Pensez aussi à me soutenir en achetant mes produits sur ma boutique Tindie. Retrouvez-moi et mes derniers projets sur Twitter.

Code

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

// Animations pétales
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;
}

// Animations NeoPixel
void prepareCrossFadeBloom(unsigned int duration) {
  byte color = random(0, 5);
  switch (color) {
    case 0: prepareCrossFade(140, 140, 140, duration); break; // blanc
    case 1: prepareCrossFade(140, 5, 0, duration); break;      // rouge
    case 2: prepareCrossFade(30, 70, 170, duration); break;    // bleu
    case 3: prepareCrossFade(140, 0, 70, duration); break;     // rose
    case 4: prepareCrossFade(255, 70, 0, duration); break;     // orange
  }
}

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

// Servo
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;
}

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