Der Valentinstag steht vor der Tür, ein Datum, an dem wir dem besonderen Menschen in unserem Leben unsere Zuneigung und Liebe zeigen. Ein Geschenk, das wir immer im Hinterkopf haben, sind rote Rosen, weil sie eine besondere Bedeutung haben. Aber nach ein paar Tagen verlieren sie ihre Frische und ihr Aussehen ist nicht mehr so schön wie in den ersten Tagen.

In diesem Projekt werden wir eine Rose herstellen, die wir in einer Schachtel präsentieren. Diese Schachtel wird sich bei Berührung oder bei Annäherung mit der Hand öffnen. Sie hat einen Bildschirm, auf dem wir eine Nachricht ausgeben können. Es ist ein sehr originelles Geschenk, und das Wichtigste ist, dass wir es mit nur wenigen Materialien und mit all der Liebe, die wir einem besonderen Menschen zeigen wollen, selbst herstellen können.

Für die Blütenblätter der Rose verwenden wir Seidenpapier, da es durchsichtig ist. Für die Kelchblätter, die Blätter und den Kelch nehmen wir ein DIN-A4-Blatt aus normalem, weißem Papier und für den Stiel die Tube einer Sprühflasche. Für die Beleuchtung der Rose werden wir eine dreifarbige LED-Diode verwenden.

Die Projektbox misst 10 x 10 cm und die Rose ist 7 cm hoch, die restlichen 3 cm sind das Gehäuse für alle Schaltkreise.

Obwohl die Rose im Projekt nur rot leuchtet, können wir sie in der Lieblingsfarbe der Person leuchten lassen, der wir die Schachtel schenken, oder auch eine Farbfolge erstellen. Wir nutzen zusätzlich einen Ring mit 12 dreifarbigen LEDs, um die grüne Farbe hervorzuheben und die Box auszuleuchten.

Zum Öffnen und Schließen der Box verwenden wir einen Servomotor und als Taster zwei kapazitive Sensoren, die wir mit nur zwei Drähten und Alufolie selbst herstellen werden.

Benötigte Materialien

1	LED Ring 5V RGB WS2812B 12-Bit 37mm
1	RGB LED
1	Nano V3.0 mit Atmega328 CH340!
1	MG90S Micro Servomotor oder SG90 Micro Servo Motor 9G
3	220 Ohm Widerstände
2	100 KOhm Widerstände
2	22 pF Kondensatoren
1	1,3 Zoll OLED I2C 128 x 64 Pixel Display
1	MB 102 Breadboard Kit mit Netzteil, Breadboard und Kabeln
1	Weißes Seidenpapier
1	Weißes Normalpapier
1	Plastiksprühflaschentülle
1	Aluminiumpapier
1	Transparenter Universalkleber

Die Box kann man aus unterschiedlichen Materialien herstellen. Ich habe mich für Balsaholz bzw. Pappelsperrholz entschieden. Mit einem 3D-Drucker können ebenfalls passende Gehäuse erstellt werden.

Erforderliche Software

• Arduino IDE
• Adafruit NeoPixel Library (über Bibliotheksverwaltung oder hier)
• Wire Library (integriert)
• Adafruit GFX_Library (über Bibliotheksverwaltung oder hier)
• Adafruit SSD1306 Library (über Bibliotheksverwaltung oder hier)
• CapacitiveSensor Library (über Bibliotheksverwaltung oder hier)
• Servo Library (integriert)
• Sketch ino
• Sketch ino

Entwurf und Montage der Rose

Ich zeige nun, wie ich die Blume herstelle. Die Schablone für die Teile der Blume muss an die Größe der Rose angepasst werden, die wir erstellen wollen.

Seidenpapier ist sehr dünn und schwer zu handhaben. Um die Blütenblätter anzufertigen, machen Sie zunächst eine Unterlage aus normalem Papier (1), zwei Blütenblätter sind ausreichend. Dann müssen wir drei Blütenblätter aus Seidenpapier erstellen und sie zusammenkleben, wobei wir darauf achten müssen, dass ihre Grundflächen den gleichen Umfang haben (2). Für den Kelch, die fünf Kelchblätter (3) und die zwei Blätter (4) nimmt man normales Papier, malt sie mit grünem Filzstift an und schneidet an den Rändern der Blätter kleine Dreiecke aus - fertig sind die Teile der Rose. Kleben Sie zunächst die fünf Kelchblätter zu einem Seestern zusammen (5) und lassen Sie in der Mitte ein 5 mm großes Loch für die dreifarbige LED frei. Biegen Sie die Blütenblätter vorsichtig nach innen und kleben Sie sie auf die Kelchblätter (6).

Für den Stiel der Blume (7) wird der Schlauch einer beliebigen Sprühflasche verwendet. Die dreifarbige LED der Blume löten wir an Drähte, die wir ins Innere der Röhre stecken. Wenn die LED auf dem Stiel sitzt, stecken wir sie durch das untere Loch der Rose und kleben den Kelch an die Kelchblätter. Um das obere Loch der Rose zu schließen, erstellen wir einen Kreis aus Seidenpapier, kleben einen dünnen Streifen darauf, kleben ihn auf die Rose und schon haben wir unsere Blume mit Liebe gemacht.

Auf dem Mini-Breadboard werden wir den Mikrocontroller, die Widerstände, Kondensatoren und in unserem Fall die 5-V-Gleichstromversorgung installieren. All das wird im unteren Teil unserer Box platziert. Im Inneren der Schachtel befinden sich der Servomotor, der LED-Ring, die beiden kapazitiven Sensoren und im Inneren der Rose die dreifarbige LED-Diode.

Herstellung und Beschreibung des kapazitiven Sensors

Zunächst werde ich nun erklären, wie der kapazitive Sensor, den wir zum Öffnen und Schließen der Box verwenden werden, funktioniert und wie man ihn herstellt.

Ein Kondensator besteht aus zwei Platten, die durch ein Dielektrikum getrennt sind. Für unseren Sensor benötigen wir nur einen 100-k-Ohm-Widerstand, einen 22-pF-Kondensator, ein Stück Aluminiumfolie und Kabel.

Wie wir in der Schaltung sehen können, haben wir einen Widerstand parallel zu einem Kondensator und am Empfänger das Stück Aluminiumfolie. Unter normalen Bedingungen wird der Kondensator durch den Sender-Pin bis zur Versorgungsspannung aufgeladen, der Empfänger-Pin liest die Spannung ab, die im 22 pF-Kondensator gespeichert ist und stabil bleibt. Unser Sensor ist das Stück Aluminium, das als eine der Platten eines Kondensators fungiert, und wir, bzw. unser Finger, als die andere Platte. Das Dielektrikum ist der Raum zwischen uns und dem Stück Aluminium. Je näher wir kommen, desto geringer wird der Wert des Dielektrikums, und wir erreichen einen Abstand, in dem wir beginnen, Strom zu leiten.

Zur Veranschaulichung der obigen Ausführungen soll die folgende Schaltung aufgebaut werden (Download des Schaltbildes):

Dafür muss nun die CapacitiveSensor-Bibliothek installiert und der Sketch capacitive_sensor_check.ino geladen werden. Wenn wir uns einem der Aluminiumfolienstücke nähern, sollte die entsprechende LED aufleuchten. In den Zeilen

long green_reading = green_sensor.capacitiveSensor(30);

steht die Zahl in Klammern für die Empfindlichkeit des Sensors, die sich aus der Anzahl der Abtastungen über einen bestimmten Zeitraum ergibt. Sie können den Wert ändern, um die Erkennung anzupassen.

Der Scketch-Code ist einfach und jede Zeile wird erklärt, so dass er sehr leicht zu verfolgen und zu analysieren ist.

Schaltung und Beschreibung der Funktionsweise des Gesamtprojektes

Das folgende Bild zeigt den elektronischen Aufbau aller verwendeten Komponenten (Download des Schaltbildes):

Die Bedienung ist sehr einfach: Sobald der Sketch gestartet wird, wird die Box geschlossen, es gibt kein Licht im Inneren und das OLED-Display zeigt die Meldung "14. Februar" an. Wenn man die Hand, den Finger oder (je nach Empfindlichkeitseinstellung) die Alufolie auf den Deckel legt, öffnet sich der Deckel mit dem Servomotor und die Rose im Inneren leuchtet rot auf (kann auch auf jede beliebige Farbe eingestellt werden), 6 der 12 LEDs auf dem Ring leuchten grün und verstärken das Grün der Blume und auf dem Display erscheint die Meldung "HAPPY VALENTINE'S DAY". Solange wir das Stück Alufolie im Inneren nicht berühren, beginnt sich die Schachtel nicht zu schließen, und wenn sie sich schließt, hört die LED an der Rose auf zu leuchten. Die LEDs des Rings wechseln von grün auf weiß, so dass die geschlossene Schachtel im Inneren beleuchtet bleibt. Das Display zeigt wieder die ursprüngliche Meldung "14. Februar".

Um die Schachtel wieder zu öffnen, muss man die Aluminiumfolie des Schachteldeckels berühren oder sich ihr nähern. Wenn die Schachtel geöffnet ist, wird sich der Deckel nicht bewegen, wenn man die Aluminiumfolie der Schachtel berührt, da ich eine Bedingung in den Sketch geschrieben habe, den ich später zeige.

Beginnen wir mit der Analyse des Codes des Sketches valentine_day_box.ino. Als erstes müssen die notwendigen Bibliotheken der Module oder Komponenten, die wir verwenden wollen, eingebunden werden. Sie enthalten die Methoden, die wir zum Beispiel bei der Initialisierung einer Komponente verwenden, oder um Aktionen mit diesen Modulen auszuführen. Die Bibliotheken, die wir imkludieren, sind die des OLED-Bildschirms, der I2C-Kommunikation (Wire), des kapazitiven Sensors, des Servomotors und des WS2812B RGB-LED-Rings.

// 1,3 inch OLED I2C 128x64 pixel display Libraries
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// Library required for operation of the Capacitive Foil Sensor
#include <CapacitiveSensor.h>

// Servo Motor Library
#include <Servo.h>

// LED ring WS2812B Library
#include <Adafruit_NeoPixel.h>

Nachdem wir die Bibliotheken eingebunden haben, müssen wir die Eigenschaften jedes Moduls oder jeder Komponente konfigurieren und ein Objekt für eine Komponente implementieren. Die erste Komponente, an der wir diese Maßnahmen durchführen, ist der LED-Ring. Wie Sie in der Schaltung sehen können, haben wir ihn an den digitalen Pin 10 angeschlossen, zu sehen in der ersten Zeile des folgenden Codes. In der zweiten Zeile geben wir die Anzahl der LEDs an, die im Ring enthalten sind, nämlich 12.

// Define pin and number of LEDs on WS2812B ring
#define ring_LED 10
#define ring_LED_count 12

In der folgenden Zeile implementieren wir ein Objekt für den Ring, das wir ring nennen. Im Konstruktor des Objekts müssen wir als Parameter die Anzahl der LEDs (12), den Pin des Mikrocontrollers (10) und die Eigenschaften des Rings angeben. Es handelt sich dabei um die dreifarbigen LEDs (RGB) mit einer Arbeitsfrequenz von 800 KHz.

// WS2812B ring object
Adafruit_NeoPixel ring(ring_LED_count, ring_LED, NEO_GRB + NEO_KHZ800);

In den folgenden Zeilen konfigurieren wir eine Reihe von Farben unter Verwendung von RGB-Werten für jede LED, z. B. für die Farbe Rot müssen wir die rote LED aktivieren und die grüne und blaue LED deaktiviert lassen. Für die gelbe Farbe schalten wir die rote und die grüne LED ein und lassen die blaue LED ausgeschaltet.

// WS2812B ring colors
uint32_t red = ring.Color(150,0,0);
uint32_t green = ring.Color(0,150,0);
uint32_t blue = ring.Color(0,0,150);
uint32_t yellow = ring.Color(150,150,0);
uint32_t purple = ring.Color(150,0,150);
uint32_t light_blue = ring.Color(0,150,150);
uint32_t white = ring.Color(150,150,150);

Die nächste Komponente, die wir konfigurieren, ist der OLED-Bildschirm. Seine Merkmale sind 128 Pixel breit und 64 Pixel hoch.

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Um ein Display-Objekt zu implementieren, sind die Konstruktorparameter, die wir berücksichtigen müssen, die Variablen für die Breite und Höhe des Displays, &Wire ist ein Aufruf an eine Adresse in der I2C-Kommunikationsbibliothek Wire und -1 wäre der Anschluss des Reset-Pins, falls vorhanden.

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

Die nächsten beiden Zeilen sind die Implementierungen von zwei Objekten der kapazitiven Sensorklasse für die Erkennung des Öffnens und Schließens der Box. Der erste Parameter ist der Senderpin, über den wir die Sensoren mit 5 Vdc versorgen, und der zweite Parameter ist der Empfänger, über den wir die Spannungsänderung erkennen.

CapacitiveSensor touch_open = CapacitiveSensor(4, 3);
CapacitiveSensor touch_close = CapacitiveSensor(6, 5);	

Für die Konfiguration des Servomotors implementieren wir zunächst das Objekt servo_box der Klasse Servo und definieren eine Variable namens grades, um den Positionswert des Servomotors in Grad zu speichern.

Servo servo_box;
int grades;

Die letzten drei Zeilen des Definitionsblocks sind die Pins des Mikrocontrollers, an die wir die Pins der dreifarbigen Diode für die Rose anschließen (7, 8 und 9) für die Farben Rot, Grün bzw. Blau.

#define red_LED 7
#define green_LED 8
#define blue_LED 9

Der nächste Block ist das setup(), der nur einmal ausgeführt wird und die anfängliche Konfiguration der Komponenten bei der Spannungsversorgung des Mikrocontrollers und beim Starten darstellt. Wir beginnen mit der Initialisierung der seriellen IDE-Konsole, wir initialisieren auch den OLED-Bildschirm und überprüfen, ob er über die Adresse 0x3C per I2C-Kommunikationsprotokoll angeschlossen ist. Wenn er nicht angeschlossen ist oder die Adresse anders ist, erscheint eine Meldung auf der seriellen IDE-Konsole, die uns darüber informiert. Öffnen Sie für die Ausgabe den Seriellen Monitor (STRG+UMSCH+M).

    Serial.begin(9600);
    if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {            // Display connection check
          Serial.println(F("SSD1306 allocation failed"));
          for(;;);
    }

Nach der Initialisierung des Bildschirms wollen wir eine Nachricht darauf anzeigen. Dazu müssen wir den Parametern der Methoden des Bildschirmobjekts Werte zuweisen. Wir stellen die Farbe des Textes und die Schriftgröße ein (2 entspricht einer Höhe von 16 Pixeln), positionieren den Cursor in Spalte 20 und Zeile 0, wo wir "Februar" schreiben wollen und setzen den Cursor in Spalte 40 und Zeile 30, um das Wort "14" zu schreiben. Nachdem wir alle Werte der Texteigenschaften und den Text selbst zugewiesen haben, geben wir mit display.display() den Befehl, den in den vorherigen Zeilen beschriebenen Text mit den Werten für Positionierung, Schriftgröße und Farbe auf dem Bildschirm anzuzeigen.

    delay(10);
    display.clearDisplay();                                     // Delete screen content
    display.setTextColor(WHITE);                                // Set color text 
    display.setTextSize(2);                                     // Set font size
    display.setCursor(20,0);                                    // Position the cursor in column 20 and row 0
    display.print("February");                                  // Word to be displayed
    display.setCursor(40,30);                                   // Position the cursor in column 40 and row 30
    display.print("14th");                                      // Word to be displayed
    display.display();                                          // Show all the above words with the settings

In der nächsten Zeile des setup()-Blocks geben wir an, dass wir den Servomotor an Pin 12 des Mikrocontrollers angeschlossen haben.

    servo_box.attach(12);  

Wir müssen auch die Ausgangs-Pins des Mikrocontrollers konfigurieren, an denen wir die dreifarbige LED der Rose angeschlossen haben. Erinnern Sie sich, dass wir im vorherigen Block drei Variablen mit den Pin-Nummern definiert haben.

    pinMode(red_LED, OUTPUT);
    pinMode(green_LED, OUTPUT);
    pinMode(blue_LED, OUTPUT);

Die letzte Zeile dieses Blocks ist die Initialisierung des LED-Rings.

    ring.begin();

Nun gehen wir zum loop()-Block über, der als Dauerschleife ständig läuft. Er wurde durch Methoden vereinfacht, um einen saubereren und schematischeren Code zu erhalten. In diesem Block haben wir nur die Definitionen von zwei Variablen für die Werte der kapazitiven Sensoren zum Öffnen und Schließen der Box. Außerdem die einfachen bedingten Blöcke, um die Werte zu überprüfen und die entsprechenden Methoden auszuführen. Erinnern wir uns dara, dass die Zahl in Klammern ( (30) ) in den Definitionszeilen der Variablen die Empfindlichkeit ist. Es ist die Anzahl von Proben in einem bestimmten Zeitraum, die wir anpassen können, um die Berührung zu erkennen und die entsprechende Aktion durchzuführen.

Die Erkennung erfolgt, weil wir, wenn wir uns der Aluminiumfolie nähern, einen "Kondensator" zwischen uns und der Box schaffen. Unsere Annäherung führt dazu, dass sich der Spannungswert im Senderpin ändert. Der Wert wird in den Variablen open_box oder close_box gespeichert. Diese Variablen werden an die if-Bedingungen als Argumente zur Überprüfung übergeben. Wenn eine Bedingung erfüllt ist, wird die entsprechende Methode ausgeführt.

    long open_box = touch_open.capacitiveSensor(30);        // Variable to store the value of open box, sensitivity in parentheses

    long close_box = touch_close.capacitiveSensor(30);      // Variable to store the value of close box, sensitivity in parentheses

    // Compare readings
    if(open_box > 1) {
        opening_box();              // Call to the method of opening the box
    }

    if(close_box > 1) {
        closing_box();             // Call to the method of closing the box 
    }

Wir werden nun die Methode opening_box analysieren. Wenn diese Methode ausgeführt wird, ist der erste Befehl das Auslesen der Position des Servomotors. Wenn die Box offen ist, müssen wir keine Aktion durchführen. Wenn die Position des Servomotors höher als 175 Grad ist, bedeutet dies, dass sie offen ist. Dann verlassen wir die Methode und kehren zum loop()-Block zurück.

    grades = servo_box.read();
    if (grades>175) {                             // We check that if the servo motor position is higher than 170 degrees we exit and the lid does not move.
      return;   
    } 

Andernfalls, wenn das Kästchen geschlossen ist, führen wir die for-Schleife aus und die Position des Servomotors bewegt sich von der 90-Grad-Position auf 180 Grad. Dann leuchtet unsere Rose sofort rot auf.

    else {
      for (int pos=90; pos<180; pos++) {          // If it is lower, the box opens at slow speed up to 180 degrees.
        servo_box.write(pos);
        delay(10);
      }
    }

    color_LED(255, 0, 0); 

Der WS2812B-RGB-LED-Ring wird 6 der 12 LEDs grün leuchten lassen. Die Befehle, die wir dafür programmieren, laufen in der folgenden Reihenfolge:

Zuerst schalten wir alle LEDs aus, wenn sie leuchten. Wir stellen die Helligkeit auf einen Wert von 50 von insgesamt 255 ein. Dann deklarieren wir die LEDs, die wir verwenden wollen, und die Farbe jeder einzelnen von ihnen. Hier müssen wir uns merken, dass sie von LED0 bis LED11 aufgelistet sind. Schließlich führen wir alles, was zuvor deklariert wurde, mit dem Befehl ring.show() aus.

    ring.clear();                                 // Power off the LEDs
    ring.setBrightness(50);                       // Set Luminosity set to 50 out of 255
    ring.setPixelColor(0, green);                 // We set the LED 1 of 12 of the ring lights green
    ring.setPixelColor(2, green);                 // LED 3
    ring.setPixelColor(4, green);                 // LED 5
    ring.setPixelColor(6, green);                 // LED 7
    ring.setPixelColor(8, green);                 // LED 9
    ring.setPixelColor(10, green);                // LED 11
    ring.show();                                  // Turn on the LEDs with the configured color and brightness.

Wenn die Box geöffnet ist, ändern wir die Nachricht auf dem Bildschirm in "HAPPY VALENTINE'S DAY" mit den folgenden Codezeilen:

    display.clearDisplay();                       // Delete screen content
    display.setTextSize(1);                       // Set font size
    display.setCursor(50,0);                      // Position the cursor in column 50 and row 0.
    display.print("HAPPY");                       // Word to be displayed
    display.setCursor(30,20);                     // Position the cursor in column 30 and row 20.
    display.print("VALENTINE'S");                 // Word to be displayed
    display.setCursor(55,40);                     // Position the cursor in column 55 and row 40.
    display.print("DAY");                         // Word to be displayed
    display.display();                            // Show all the above words with the settings 

Diese Zeilen ähneln denen, die zuvor im setup()-Block beschrieben wurden, wo wir ebenfalls den Text "14. Februar" auf dem Bildschirm angezeigt haben. Mit der Analyse der opening_box()-Methode wird es Ihnen leicht fallen, die Analyse des closing_box()-Blocks selbst durchzuführen, da sie sehr ähnlich ist.

Die letzte Methode, die wir im Sketch haben, wird verwendet, um die dreifarbige LED der Rose leuchten zu lassen. Diese LED besteht aus drei unabhängigen Dioden, die durch die visuelle Mischung die gewünschte Farbe anzeigt. Es handelt sich um 8-Bit-Werte von 0 bis 255.

void color_LED (int value_red_LED, int value_green_LED, int value_blue_LED) {

      // Analog output method for the tricolor LED (output pin, RGB value)
      analogWrite(red_LED, value_red_LED);
      analogWrite(green_LED, value_green_LED);
      analogWrite(blue_LED, value_blue_LED);
}

Sketch Downloads:

valentine_day_box.ino

capacitive_sensor_check.ino

Berührung mit geringer und hoher Empfindlichkeit:

 Wir hoffen, dass Ihnen dieses neue Projekt gefällt.