Immer blühende mechanische Tulpe – Berührungsaktivierte LED-Blume

Komponenten und Zubehör

• 1× Arduino Nano R3
• 1× SG90 Mikro-Servo
• 1× TTP223 Kapazitiver Touch-Sensor
• 1× Messingdraht 1 mm (für Blütenblätter & Gestänge)
• 1× Messingrohr 2 mm (Innendurchmesser ca. 1,2 mm, für Scharniere & Stiel)
• 1× Isolierter Kupferdraht 0,3 mm (für LED-Verkabelung)
• 7× WS2812B (NeoPixel 5050) RGB-LEDs
• 30× SMD 1206 weiße LEDs (für Blütenblätter)
• Holz für Sockel (ca. 4 cm hoch, 9 cm Ø)
• 6× 220 Ω Widerstände (für Blütenblatt-LEDs)
• Lötzinn, Lötkolben, Feinmechanik-Werkzeug, Superkleber, Klebeband

Funktionsweise

Die Tulpe besteht aus 6 Blütenblättern, jedes mit 5 weißen SMD-LEDs in Adern-Struktur. Im Inneren sitzen 7 NeoPixels (6 im Ring, 1 central) für Farbwechsel. Ein Servo im Sockel bewegt über ein Gestänge (Pushrod im Messingrohr) die Blütenblätter auf/zu. Ein kleines Messingblatt am Stiel dient als kapazitiver Touch-Sensor (TTP223). Berührt man es, öffnet sich die Blüte langsam mit Farbanimation; erneutes Berühren schließt sie.

Mechanischer Aufbau – Schritt für Schritt

1. Blütenblätter (ca. 4 h)

Jedes Blütenblatt wird auf einer Schablone (Gips oder 3D-Druck) aus 1 mm Messingdraht geformt: Außenrand, 5 SMD-LEDs + Adernstruktur, unten ein Stück 2 mm Messingrohr als Scharnier. Alle 6 Blütenblätter müssen identisch sein, damit sie sich beim Schließen perfekt überlappen.

2. Blütenkopf zusammenlöten (ca. 1 h)

Die 6 Scharniere werden an einen unregelmäßigen Sechskant (3 innere, 3 äußere Blütenblätter) gelötet. Eine Papier-Schablone hilft bei der exakten Positionierung. Beim Schließen bilden die Überlappungen die Tulpenform.

3. Stiel & Pushrod (ca. 1 h)

Der Stiel ist ein Messingrohr (Länge nach Wunsch). Unten wird ein V-förmiger Spreizdraht an zwei gegenüberliegenden Ecken des Sechskants angelötet – der Stiel muss exakt mittig und senkrecht stehen. Der Pushrod (1 mm Messingdraht) läuft im Stielrohr. Sein oberes Ende trägt einen winzigen Sechskantkopf (2 mm Scharniere), an dem die Verbindungsstangen der Blütenblätter angelenkt sind.

4. Blütenblatt-Mechanik (ca. 6 h – Geduld!)

Jedes Blütenblatt braucht einen Stift (Pin) an einem parallel zum Scharnier verlaufenden Bügel. Dessen Position und die Länge der Verbindungsstange zum Pushrod-Kopf bestimmen Öffnungswinkel und Synchronität. Versuch & Irrtum: Erst ein Blütenblatt perfekt einstellen, dann die anderen 5 exakt nachbauen. Äußere Blütenblätter etwas tiefer setzen für korrektes Überlappen.

5. Regenbogen-Stempel (ca. 1 h)

7 NeoPixels auf zwei kleinen Sechskant-Ringen (Masse & VCC), im 45°-Winkel nach außen gerichtet, 1 central. Datenleitung als Daisy-Chain. Zwei dünne Drähte (VCC, DATA) führen durch den Stiel nach unten.

6. Verkabelung („Wurzeln“, ca. 2 h)

Alle 8 Drähte (6× Blütenblatt-LED+, 2× NeoPixel) + Masse (Stielrohr) werden eng um den Stiel gewickelt, mit Klebeband fixiert und nach unten geführt. Unten am Stielende: Masse-Draht anlöten. Kurz testen: Kein Kurzschluss, alle LEDs leuchten.

7. Blumentopf / Sockel (ca. 2 h)

Holzzylinder (4 cm hoch, 9 cm Ø), innen ausgehöhlt (2,5 cm tief, 7 cm Ø) für Servo, Arduino Nano, TTP223-Modul. Seitliche Öffnung für USB-Port. Loch in der Mitte für Stiel mit Drähten. Großes Innenloch für Servo-Arm.

8. Touch-Blatt (ca. 1 h)

Kleines Messingblatt am Stiel, per Draht mit TTP223-Touchpad verbunden (Schutzlack abkratzen). Alternative: Taster im Sockel.

9. Endmontage & Verdrahtung (ca. 2 h)

• Blüte vollständig öffnen → Pushrod bündig mit Stielende abschneiden → kurzes Rohrstück als Anschlag anlöten.
• Stiel in Sockel kleben (Pushrod darf nicht festkleben!).
• Servo positionieren, Gestänge verbinden, Servo mit Blech & Schrauben fixieren.
• TTP223-Modul einkleben, Blatt-Draht anlöten.
• 6× 220 Ω Widerstände auf Lochraster für Blütenblatt-LEDs.
• Arduino Nano einbauen & verdrahten:
  • Servo Signal → D9 (Adafruit_TiCoServo)
  • TTP223 Signal → D2 (Interrupt)
  • NeoPixel DATA → A0
  • Blütenblätter → D3, D4, D5, D6, D10, D11 (SoftPWM)
  • Masse (Stiel) → GND
  • NeoPixel VCC → 5V
  • TTP223 VCC/GND → 5V/GND
  • Servo VCC/GND → 5V/GND

Arduino-Code (flower.ino)

Der Code nutzt Adafruit_NeoPixel, Adafruit_TiCoServo und SoftPWM. Er verwaltet Zustände (Schlafen, Aufblühen, Geblüht, Verblühen, Regenbogen) und reagiert per Interrupt auf den Touch-Sensor. Die Servo-Endpositionen (SERVO_OPEN, SERVO_CLOSED) müssen kalibriert werden.

#include 
#include 
#include "SoftPWM.h"

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

#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;

float currentRGB[3] = {0,0,0}, changeRGB[3] = {0,0,0};
byte newRGB[3] = {0,0,0};
int servoPosition = SERVO_SAFE_MIDDLE;
int counter = 0;
byte speed = 15;

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); // Startfarbe Orange
  servo.write(servoPosition);
}

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 m) { if(mode!=m){ mode=m; counter=0; } }
void _touchISR() { if(mode==MODE_SLEEPING) changeMode(MODE_BLOOM); else if(mode==MODE_BLOOMED) changeMode(MODE_FADE); }

// Blütenblatt-LEDs (SoftPWM)
boolean petalsBloom(int j) { if(j<250) return false; if(j>750) return true; int v=(j-250)/2; for(int i=0;i<6;i++) SoftPWMSet(petalPins[i],v); 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; }

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

// NeoPixel Farbüberblendung
void prepareCrossFade(byte r,byte g,byte b,unsigned int dur) {
  changeRGB[0]=(r-currentRGB[0])/(float)dur;
  changeRGB[1]=(g-currentRGB[1])/(float)dur;
  changeRGB[2]=(b-currentRGB[2])/(float)dur;
  newRGB[0]=r; newRGB[1]=g; newRGB[2]=b;
}
void prepareCrossFadeBloom(unsigned int dur) {
  switch(random(0,5)){
    case 0: prepareCrossFade(140,140,140,dur); break; // Weiß
    case 1: prepareCrossFade(140,5,0,dur); break;     // Rot
    case 2: prepareCrossFade(30,70,170,dur); break;   // Blau
    case 3: prepareCrossFade(140,0,70,dur); break;    // Rosa
    case 4: prepareCrossFade(255,70,0,dur); break;    // Orange
  }
}
boolean crossFade() {
  if(currentRGB[0]==newRGB[0] && currentRGB[1]==newRGB[1] && currentRGB[2]==newRGB[2]) return true;
  for(byte i=0;i<3;i++){
    if(changeRGB[i]>0 && currentRGB[i]newRGB[i]) currentRGB[i]+=changeRGB[i];
    else currentRGB[i]=newRGB[i];
  }
  pixelsUnifiedColor(pixels.Color(currentRGB[0],currentRGB[1],currentRGB[2]));
  return false;
}
void pixelsUnifiedColor(uint32_t c){ for(uint16_t i=0;i