Halloween steht vor der Tür. Wir schmücken unsere Häuser. Verkleiden uns mit Masken, um nicht erkannt zu werden und böse Geister zu verscheuchen. Stellen Kerzen oder Kürbisse auf, um gute Geister anzulocken und vor allem müssen wir uns entscheiden, ob wir Süßes oder Saures geben.

Nachdem wir im ersten Halloween-Beitrag für dieses Jahr von Bernd Albrecht mit ähnlichen Komponenten gruselige Sounds abgespielt und eine Attrappe haben "fliegen" lassen, zeigen wir hier eine weitere Idee, um Ihren Halloween-Abend etwas gruseliger zu gestalten.

Mit diesem Projekt werden wir ein Gadget entwickeln, das böse Geister vertreibt und gleichzeitig eine kleine Überraschung für all die mutigen Menschen bereithält, die ein paar Süßigkeiten mitnehmen wollen. Sie müssen ihre Angst vor dem Wächter der Süßigkeiten überwinden, der versuchen wird, sie mit seinen Augen zu hypnotisieren.

Wenn wir uns den Süßigkeiten nähern, leuchtet das Innere des Sarges auf und Musik ertönt. Das soll uns zu warnen, nicht weiterzumachen. Wenn wir darauf nicht hören, öffnet sich der Deckel und der Wächter erwacht, seine Augen leuchten auf. Wenn wir die Hand ausstrecken, um einige Süßigkeiten zu nehmen, steht der Wächter auf und versucht, uns mit seinen Augen zu hypnotisieren.

Benötigte Komponenten und Materialien

1	Nano V3.0 Atmega328 CH340 fertig verlötet
	Jumper Wire Kabel 3 x 40 STK. je 20 cm M2M/ F2M / F2F
2	SG90 Micro Servo Motor 9G (alternativ hier) oder MG90S Micro Servomotor
1	Mini Breadboard 400 Pin
1	HC-SR04 Ultraschall Modul Entfernungsmesser (alternativ hier)
1	KY-006 Passiver Piezo Buzzer Alarm Modul
2	Rote LEDs
1	Weiße LED
3	220 Ohm Widerstände
	Externe Stromversorgung (5V)
	3mm Sperrholzplatten
	alternativ: 3D-Drucker

 

Benötigte Software

Arduino IDE

skeleton_guardian_candies.ino

Servomotor library (integriert Servo.h)

Schaltung und Beschreibung der verwendeten Module

Download des Schaltplans

Wie wir im Komponentenplan sehen können, verwenden wir zur Messung der Entfernung den Ultraschallsensor HC-SR04. Für die Tonwiedergabe wird das passive Buzzermodul verwendet, die beiden Servomotoren SG-90 (oder alternativ MG90S) werden zum Öffnen des Sargdeckels, sowie zum Anheben des Skeletts verwendet. Mit der weißen LED beleuchten wir das Innere des Sarges. Die beiden roten LEDs verwenden wir für die Augen des Skeletts. Die Vorwiderstände mit 220 Ohm nicht vergessen. Das alles steuern wir mit dem Nano V3. 0 CH340 Mikrocontroller. Als externe Stromversorgung wählte ich zwei 5-Volt-Batterien, die für den Mikrocontroller in Reihe geschaltet werden. Eine davon versorgt die übrigen Module. Der VIN-Eingang des Nanos sollte mit mehr als 5V gespeist werden, da dort ein Spannungsregler verbaut ist.

3D-Druck statt Holzplatten

Wenn Sie einen 3D-Drucker besitzen, können Sie das Gehäuse auch drucken. Der User Pontifex hat dazu ein Modell per Thingiverse zur Verfügung gestellt. Danke an dieser Stelle!

Bildquelle: https://www.thingiverse.com/thing:5584885

Youtube Video: https://www.youtube.com/shorts/7WrrfCwW81I

Quelle: Pontifex Maximus

Beschreibung des Programmablaufs und des Quellcodes

Der Ultraschallsensor HC-SR04 sendet Impulse mit einer Dauer von 10 Mikrosekunden und einer Wartezeit zwischen Puls und Puls von 5 Mikrosekunden. Wenn der Impuls an einer Person oder eines Objektes reflektiert und zurückgesendet wird, erkennt der Sensor das empfangene Signal. Der Mikrocontroller führt die Berechnungen auf Basis des Weg-Zeit-Gesetzes durch. Da wir die Schallgeschwindigkeit kennen, erhalten wir so die Entfernung. Solange der Abstand größer oder gleich 150 Zentimeter ist, nimmt der Sarg keine Änderungen vor. Wird ein Hindernis zwischen 149 und 101 Zentimetern erkannt, leuchtet die weiße LED im Inneren des Sarges auf und eine Melodie ertönt. Nähert man sich und positioniert sich in einem Abstand zwischen 100 und 31 Zentimetern, öffnet sich der Sarg mit Hilfe eines der Servomotoren, die Melodie hört auf zu spielen und das Skelett erwacht. Seine roten Augen leuchten mit Hilfe der beiden gleichfarbigen LEDs. Wenn wir versuchen, ein Bonbon in einer Entfernung von 30 Zentimetern oder weniger aufzuheben, wird das Skelett mit Hilfe des anderen Servomotors aufstehen, seine Arme ausstrecken und seine Augen beginnen zu pulsieren. Alle diese Schritte werden kontinuierlich durchgeführt, wenn wir in der entsprechenden Entfernung bleiben. Schauen wir uns nun den Sketch an.

Um den Servomotor zu verwenden, müssen wir seine Bibliothek am Anfang der Skizze hinzufügen. In diesem Projekt werden wir den Ultraschallsensor ohne die Bibliothek verwenden. Wir werden sehen, dass wir den Abstand zu den Objekten mit einer einfachen mathematischen Operation bestimmen können, so dass wir nur die Bibliothek für die Servomotoren hinzufügen. Diese ist in der Arduino IDE bereits enthalten.

#include <Servo.h>

Um die Servomotoren verwenden zu können, müssen wir für jeden Servomotor ein Servo-Objekt instanziieren.

Servo servo_cover;
Servo servo_skeleton;

In den nächsten beiden Zeilen des Sketches deklarieren wir zwei Variablen. Die erste Variable enthält Pin 5 des Mikrocontrollers. Die zweite Variable wird für den Augeneffekt verwendet. Dort wird der PWM-Wert des Pins, an den die roten LEDs angeschlossen sind, gespeichert.

int led_eyes = 5;
int led_intensity = 0;

In der folgenden Zeile des Codes deklarieren und definieren wir die Variable für Pin 7 des Mikrocontrollers, an den die weiße LED angeschlossen ist.

int white_led = 7;

Um das Buzzer-Modul zu verwenden, müssen wir eine Variable mit Pin 6 deklarieren und definieren.

int tonePin = 6;

Die letzten vier Zeilen vor der setup()-Methode sind dem Ultraschallmodul gewidmet. Die ersten beiden sind die Variablen mit den Namen der Pins, trigPin (Signalsender) und echoPin (Signalempfänger) des Sensors mit der Nummer der Pins 4 bzw. 2 des Mikrocontrollers. In den anderen beiden Variablen speichern wir jeweils den Wert der Zeit, in der der Sensor das Signal erkennt, das von einem Objekt abprallt, seit es ausgesendet wurde, sowie den Wert der Entfernung, den wir aus der erkannten Zeit berechnen.

int trigPin = 4;
int echoPin = 2;
long ultrasonic_time_measurement;
long distance;

Es folgt nun die setup()-Methode.  Mit den ersten beiden Zeilen initialisieren wir den seriellen Monitor und zeigen eine Textnachricht an.

Serial.begin (9600);
Serial.println ("Halloween 2022");

In den nächsten vier Zeilen konfigurieren wir die Servomotoren für den Sargdeckel und das Skelett. Zuerst den Pin 9 des Mikrocontrollers, an den wir das Signal des Servomotors des Deckels anschließen. In der zweiten Zeile konfigurieren wir die Ausgangsposition in Grad. Mit 80 ist die Box geschlossen. In den folgenden Zeilen konfigurieren wir den Servomotor des Skeletts. Wir schließen das Signal des Servomotors an Pin 10 des Mikrocontrollers an und als Ausgangsposition konfigurieren wir ihn in 90 Grad, so dass das Skelett unten liegt.

servo_cover.attach(9);
servo_cover.write(80);
servo_skeleton.attach(10);
servo_skeleton.write(90);

In den folgenden Zeilen konfigurieren wir die Pins für die roten und weißen LEDs als Ausgang und schalten sie aus.

pinMode (led_eyes, OUTPUT);
analogWrite(led_eyes, 0);
pinMode (white_led, OUTPUT);
digitalWrite (white_led, LOW);

In den letzten beiden Zeilen der setup()-Methode konfigurieren wir den Ultraschallsensor. Der trigPin ist ein Ausgangs-, der echoPin ist ein Eingangspin. Das Trigger-Signal wird ausgesendet, das Echo-Signal wird empfangen.

pinMode (trigPin, OUTPUT);
pinMode (echoPin, INPUT);

So viel zur setup()-Methode, jetzt beginnen wir mit der nächsten Methode, die kontinuierlich ausgeführt wird, loop(). Die erste Zeile ist ein Aufruf der Methode measure_distance(). Diese berechnet die Enfernung und speichert sie in der dazugehörigen Variablen.

measure_distance();

Es folgen vier if-Blöcke als Bedingung. Sie führen die verschiedenen Aktionen aus, abhängig von der Entfernung, in der sich ein vom Sensor erkanntes Hindernis befindet. Der erste Block wird ausgeführt, wenn die Entfernungsvariable einen Wert größer oder gleich 150 Zentimeter hat. Die Befehle, die ausgeführt werden, sind:

• den Mikrocontroller-Pin mit der weißes LED auf einen LOW-Zustand setzen
• das PWM-Signal des Mikrocontroller-Pins der roten LEDs auf 0 setzen, so dass sie ebenfalls aus sind
• den Servomotor des Skeletts in der 90-Grad (liegend) positionieren
• den Servomotor des Deckels in 80 Grad (geschlossen) positionieren

Ich habe eine Verzögerung von 200 Millisekunden zwischen den beiden Servomotoren eingebaut, damit die Bewegung des Skeletts nicht mit der des Sargdeckels kollidiert.

if (distance >= 150) { digitalWrite (white_led, LOW);
                       analogWrite(led_eyes, 0);
                       servo_skeleton.write(90);
                       delay(200);
                       servo_cover.write(80);
                     }

Der folgende bedingte Block wird ausgeführt, wenn der in der Entfernungsvariablen gespeicherte Abstand zwischen 149 und 101 Zentimetern liegt. In diesem Fall werden folgende Funktionen ausgeführt:

• Das PWM-Signal des roten LED-Pins wird auf 0 belassen (völlig ausgeschaltet)
• die Servomotoren werden wie im vorherigen Zustand belassen
• das Skelett liegt (Servomotor auf 90 Grad)
• der Deckel ist geschlossen (Servomotor auf 80 Grad)

Der Unterschied zum vorherigen Block ist die weiß leuchtende LED. Deren Pin setzen wir auf HIGH. Außerdem führen wir die play_music()-Methode aus, um eine Melodie zu spielen. Diese Methode wird später beschrieben.

if (distance < 150 && distance > 100) { analogWrite(led_eyes, 0);
                                 servo_skeleton.write(90);             
                                 servo_cover.write(80);                                                                   
                                 digitalWrite (white_led, HIGH);
                                 play_music();
                                      }

Wenn die Entfernungsvariable einen Wert zwischen 100 und 31 Zentimetern hat, wird der unten beschriebene dritte Block ausgeführt. In diesem Block leuchtet die weiße LED weiter, der Servomotor des Skeletts bleibt bei 90 Grad, so dass es liegen bleibt. Der Servomotor des Sargdeckels wird bei 180 Grad positioniert und damit geöffnet. Mit der letzten Zeile schalten wir die roten Leds ein, indem wir den PWM-Wert auf 150 übergeben.

if (distance <= 100 && distance > 30) { digitalWrite (white_led, HIGH);
                                        servo_skeleton.write(90);            
                                        servo_cover.write(180);
                                        analogWrite (led_eyes, 150);          
                                      }

Der letzte Block wird ausgeführt, wenn die Variable distance einen Wert von 30 oder weniger hat. In diesem Fall werden folgende Aktionen ausgeführt:

• die weiße LED leuchtet weiter
• das Skelett wird auf 20-Grad-Position gestellt und damit hingelegt
• der Sargdeckel bleibt mit 180 Grad offen
• die Methode hypnotizing_led_eyes() wird ausgeführt, die die Leuchtkraft der roten Leds langsam verringert und erhöht. Diese Methode wird unten beschrieben.

if (distance <= 30) { digitalWrite (white_led, HIGH);
                      servo_skeleton.write(20);
                      servo_cover.write(180);
                      hypnotizing_led_eyes();
                    }

So viel zur Methode loop(), jetzt wollen wir die drei Methoden erklären, die wir von dort aus aufrufen.

Die erste Methode, ist diejenige, die die Zeit misst, die das zurückgeworfene Signal braucht, um den Sensor zu erreichen. Damit wird die Berechnungen durchgeführt, um die Entfernung zu erhalten. Um die Entfernung zwischen einem Objekt und dem Sensor zu messen, müssen wir einfach die Zeit messen, die zwischen dem Senden und dem Empfangen eines Signals vergeht. Um diesen Prozess auszuführen, müssen wir zuerst den trigPin des Sensors für 5 Millisekunden in den Low-Zustand versetzen, danach denselben Pin (trigPin) für 10 Millisekunden in den High-Zustand versetzen, um das Signal zu senden und danach wieder in den Low-Zustand versetzen, um kein Signal mehr zu senden.

Wenn dies geschehen ist, können wir mit der Funktion pulseIn(echoPin, HIGH) die Zeit ermitteln, die verstrichen ist, seit der Pin trigPin das Signal ausgesendet und der Pin echoPin des Sensors das abgeprallte Signal empfangen hat. Jetzt kennen wir die Zeit, die das Signal in Mikrosekunden benötigt. Letzteres ist sehr wichtig und wir speichern es in der Variablen ultrasonic_time_measurement. Um die Entfernung zu bestimmen, müssen wir nur eine mathematische Operation durchführen. Wir wissen, dass die Schallgeschwindigkeit in der Luft bei 20 Grad Celsius 343 m/s beträgt. Wir müssen diese Geschwindigkeit in cm/µs umrechnen, also:

Die vom Sensor gemessene Zeit ist die Zeit, in der das Signal zum Objekt und zurückläuft. Die Zeit bis zum Hindernis ist also nur die Hälfte der gemessenen Zeit, die in Mikrosekunden angegeben wird:

Wir erhalten den Abstand zum Objekt in Zentimetern und wird in der Variablen distance gespeichert, die wir in den bedingten if-Blöcken verwenden, um in Abhängigkeit von ihrem Wert den entsprechenden Block auszuführen. Diese Entfernung wird auch vom seriellen Monitor angezeigt, wenn der Mikrocontroller mit der Arduino IDE verbunden ist.

void measure_distance() {
      digitalWrite(trigPin, LOW);
      delayMicroseconds(5);
      digitalWrite(trigPin, HIGH);
      delayMicroseconds(10);
      digitalWrite(trigPin, LOW);

      ultrasonic_time_measurement = pulseIn(echoPin, HIGH);

      distance = (ultrasonic_time_measurement/2)*0.0343;

      Serial.print(distance);
      Serial.print(" cm");
      Serial.println(); 
} 

Die nächste Methode, hypnotizing_led_eyes(), ist für den Effekt der Augen des Skeletts zuständig. Damit wird die Leuchtkraft der LEDs erhöht und verringert. Dadurch wird ein Pulsieren der LEDs erreicht. Wir verwenden verschachtelte Schleifen. Die erste Schleife ist ein Zähler, der alles vier Mal wiederholt. Die erste Schleife innerhalb des Zählers beginnt mit einem PWM-Wert von 150 und geht schrittweise auf einen Wert von 10 zurück, wodurch die Helligkeit der LEDs verringert wird. Die nächste Schleife führt genau das Gegenteil durch, indem sie mit einem pwm-Wert von 10 beginnt und diesen langsam bis zu einem Wert von 150 erhöht. Das pulsieren der LEDs blockiert den restlichen Programmablauf. Um eine nicht-blockierende Variante zu programmieren, müssten wir den Code verändern.

void hypnotizing_led_eyes() {
       for (int n=0; n<4; n++){                                                    
              for (led_intensity = 150; led_intensity >=10; led_intensity --) {         
                     analogWrite(led_eyes, led_intensity);
                     delay(15);
               }
              for (led_intensity = 10; led_intensity <=150; led_intensity ++) {         
                     analogWrite(led_eyes, led_intensity);
                     delay(10);    
              }
       }
}

Jetzt bleibt nur noch die letzte Methode übrig, die für das Spielen der Melodie zuständig ist. In dieser Methode rufen wir nur die Befehle tone (pin, frequency, duration) und delay() auf. Die Tonfunktion hat als Parameter den Pin, an den wir den Summer angeschlossen haben, die Frequenz des gespielten Tons und die Zeit, die der Ton gespielt wird.

void play_music() {
    tone(tonePin, 261, 117.1875);
    delay(130.208333333);
    delay(376.041666667);
    tone(tonePin, 311, 116.25);
    delay(129.166666667);
    delay(362.5);
    
    ...
    
    tone(tonePin, 293, 87.1875);
    delay(96.875);
    delay(167.708333333);
    
}

Hier können Sie noch die Vorlagen für die Schablonen herunterladen:

Bauplan des Sarges

Skelett

Wir wünschen Ihnen einen gruselig schönen Halloween-Abend.