Der kleine Computer namens Wemos D1 Mini braucht Strom, damit er funktioniert. Dafür gibt es zwei Möglichkeiten:
Wichtig:
Stell dir vor, du hast einen kleinen Computer (das ist das Arduino-Board), der wie ein kleines Gehirn funktioniert. Er kann mit seinen „Sinnen“ Dinge messen und dann Dinge tun – so wie wir Menschen mit Augen sehen und mit unserem Mund sprechen können. In diesem Programm gibt es:
Der Lichtsensor ist wie ein Auge, das erkennt, wie hell oder dunkel es ist.
Der Buzzer ist wie ein kleiner Lautsprecher oder eine Hupe, der Töne machen kann – laut oder leise, hoch oder tief.
Das ist eine winzige Lampe auf dem Board selbst. Wenn sie an ist, leuchtet sie, und wenn sie aus ist, dann sieht man nichts. (Oft ist sie an, wenn man „LOW“ schreibt, und aus, wenn man „HIGH“ schreibt – bei manchen Arduinos ist das umgekehrt.)
Am Anfang schalten wir das WLAN aus, weil wir es nicht brauchen. Das spart Strom und macht das Board ruhiger.
Gleich zu Beginn misst der kleine Computer, wie hell es ungefähr ist, wo er gerade liegt (das ist der Wert lichtstart). Damit weiß er: „So hell ist es, wenn alles normal ist“.
Das Programm lässt die kleine LED (Lampe) am Anfang fünfmal an- und ausgehen (blinken). So kann man sehen, dass das Programm gestartet wurde und „bereit“ ist.
Dann sagt das Programm: „Okay, ich passe jetzt auf! (systemArmed = true)“ – das heißt, es macht sich bereit, einen Alarm auszulösen, wenn sich etwas ändert (wenn es plötzlich dunkler wird).
In der Dauerschleife (loop()) macht der Computer immer wieder Folgendes:
analogRead(sensorPin) liest den Lichtsensor aus).- Prüft er, ob schon 30 Sekunden vergangen sind.
- Sind noch nicht 30 Sekunden um, macht er weiter „Alarmtöne“.
- Sind 30 Sekunden vorbei, hört er auf und sagt: „Jetzt mache ich keinen Alarm mehr und bin erstmal unscharf.“ (Dann kann man sich beruhigen, weil der Alarm zu Ende ist.)
- Schaut der Computer, ob es plötzlich viel dunkler geworden ist (dunkler als dieser „Schwellenwert“).
- Wenn ja, startet er den Alarm! Die LED geht an und die Sirene (der Buzzer) macht Töne.
- Schaut der Computer, ob es wieder hell genug ist.
- Wenn ja, wird das System wieder scharf gestellt, damit der Alarm beim nächsten Mal wieder losgehen kann, wenn es dunkel wird.
Es gibt verschiedene Töne, die der Buzzer machen kann:
Das kannst du dir so vorstellen, als würde der Computer ganz verschiedene Melodien auf einem Mini-Lautsprecher abspielen. Welche Melodie genommen wird, hängt von der Zahl tonauswahl ab.
So ist das Programm wie ein kleiner Wachhund, der scharf wird, wenn sich das Licht ändert (z.B. wenn jemand das Licht verdeckt). Dann fängt er laut an zu bellen (der Buzzer macht Töne). Wenn alles wieder okay ist, beruhigt er sich und wartet auf das nächste Mal.
Das ist alles! So ungefähr kann man es sich vorstellen, wenn man erst 9 Jahre alt ist und wissen will, was dieser Code tut. Viel Spaß beim Tüfteln und Ausprobieren!
#include "Arduino.h"
#include "ESP8266WiFi.h" // nur um WLAN zu deaktivieren
// --- Pin-Belegung ---
const int sensorPin = A0; // Lichtsensor an A0
const int buzzerPin = D1; // Buzzer an D1
const int ledPin = LED_BUILTIN; // interne LED (Wemos D1 mini = D4)
// --- Einstellungen ---
int lichtSchwelle = 100; // Schwellwert für Dunkel/Hell
int lichtstart = -1;
unsigned long alarmDauer = 30000; // 30 Sekunden Alarm (in ms)
// --- Zustandsvariablen ---
bool systemArmed = true; // Ist die Schaltung scharf?
bool alarmActive = false; // Läuft gerade ein Alarm?
unsigned long alarmStartTime = 0; // Wann der Alarm gestartet wurde?
int tonauswahl = 2; // Werte: 1..6, je nach gewünschtem Tonmuster
void setup() {
Serial.begin(115200);
delay(100);
// WLAN deaktivieren
WiFi.mode(WIFI_OFF);
WiFi.forceSleepBegin();
delay(1);
// Pinmodi
pinMode(buzzerPin, OUTPUT);
pinMode(ledPin, OUTPUT);
noTone(buzzerPin); // Buzzer aus
// Initialzustand
systemArmed = true; // Beim Start direkt scharf
alarmActive = false;
lichtstart = analogRead(sensorPin);
Serial.print("lichtstart ");
Serial.println(lichtstart);
// LED 5 Sekunden lang blinken lassen
for (int i = 0; i < 5; i++) {
digitalWrite(ledPin, LOW); // LED an (bei vielen Boards ist LOW an)
delay(500);
digitalWrite(ledPin, HIGH); // LED aus
delay(500);
}
Serial.println("Setuplichtstart fertig, Schaltung ist scharf (systemArmed = true).");
}
void loop() {
// Lichtwert messen Serial.print("lichtstart ");
digitalWrite(ledPin, HIGH); // LED aus
int lichtWert = analogRead(sensorPin);
Serial.print("lichtstart ");
Serial.print(lichtstart);
Serial.print(" lichtWert ");
Serial.println(lichtWert);
// --- 1) Falls Alarm aktiv, prüfen, ob die 30 Sekunden um sind ---
if (alarmActive) {
unsigned long laufzeit = millis() - alarmStartTime;
if (laufzeit < alarmDauer) {
// Alarm läuft noch -> Sirenenton erzeugen
heulenderAlarm();
} else {
// Alarmdauer abgelaufen -> Alarm beenden
noTone(buzzerPin);
alarmActive = false;
systemArmed = false; // Schaltung unscharf machen
Serial.println("ALARM beendet. Schaltung ist jetzt unscharf.");
}
}
else {
// Kein Alarm aktiv -> keinen Ton
noTone(buzzerPin);
// --- 2) Schaltung ist scharf? Falls ja, auf Dunkelheit prüfen ---
if (systemArmed) {
// Wenn der Wert unter dem Schwellwert liegt, Alarm starten
if (lichtWert < lichtstart-lichtSchwelle) {
alarmActive = true;
alarmStartTime = millis();
digitalWrite(ledPin, LOW);
delay(100);
Serial.println("ALARM gestartet!");
}
}
else {
// Schaltung ist unscharf -> Checken, ob wir sie wieder scharf schalten sollen
// Wir schalten erst wieder scharf, wenn es "hell" genug ist:
if (lichtWert >= lichtstart-lichtSchwelle) {
systemArmed = true;
lichtstart = analogRead(sensorPin);
Serial.println("Schaltung wieder scharf (weil es hell genug wurde).");
}
}
}
// Kurzes Delay, damit loop nicht zu schnell rotiert (optional)
delay(30);
}
// heulenderAlarm()
void heulenderAlarm(){
// Beispiel: so lange wir in der Loop sind, spielen wir das ausgewählte Muster
// In einem echten Alarm-Szenario würdest du diese Funktion nur
// aufrufen, wenn "Alarm" aktiv ist.
alarmTon(tonauswahl);
// Kleiner Delay, damit der Loop nicht zu schnell rotiert
delay(50);
}
// ------------------------------------------
// Funktion: Spielt das ausgewählte Tonmuster
// ------------------------------------------
void alarmTon(int auswahl) {
switch (auswahl) {
case 1:
// 1) Heulton (einmal auf- und abschwellend)
heulton(1);
break;
case 2:
// 2) Sirenen-Sweep (mehrfach auf- und abschwellend)
heulton(3); // z.B. 3 Wiederholungen
break;
case 3:
// 3) Melodie: "Alle meine Entchen" (kurze Version)
alleMeineEntchen();
break;
case 4:
// 4) Kurze Pieptöne (Beispiel)
kurzePieptoene();
break;
case 5:
// 5) Aufsteigende Tonfolge
ascendingBeep();
break;
case 6:
// 6) Absteigende Tonfolge
descendingBeep();
break;
default:
// Unbekannte Auswahl -> kein Ton
noTone(buzzerPin);
break;
}
}
// ------------------------------------------
// 1) & 2) "Heulton" / "Sirenen-Sweep"
// ------------------------------------------
// Parameter repeat: wie oft auf- und ab (z.B. 1 oder 3 Mal)
void heulton(int repeat) {
for (int r = 0; r < repeat; r++) {
// Frequenz von 500 bis 1000 Hz hoch
for (int freq = 500; freq <= 1000; freq += 5) {
tone(buzzerPin, freq);
delay(2);
}
// und wieder runter
for (int freq = 1000; freq >= 500; freq -= 5) {
tone(buzzerPin, freq);
delay(2);
}
}
}
// ------------------------------------------
// 3) Kurze Version von "Alle meine Entchen"
// Frequenzen für Töne (C-D-E-F-G-A-H usw.)
// Hier nur ein kleiner Ausschnitt
// ------------------------------------------
void alleMeineEntchen() {
// Noten-Frequenzen (ca. Werte in Hz):
const int C4 = 262;
const int D4 = 294;
const int E4 = 330;
const int F4 = 349;
const int G4 = 392;
const int A4 = 440;
// Das Original ist etwas länger, hier nur ein Teil:
playNote(G4, 300); // G
playNote(G4, 300); // G
playNote(A4, 300); // A
playNote(A4, 300); // A
playNote(G4, 300); // G
playNote(G4, 300); // G
playNote(E4, 600); // E (etwas länger)
delay(100); // kurze Pause
playNote(G4, 300); // G
playNote(G4, 300); // G
playNote(E4, 300); // E
playNote(E4, 300); // E
playNote(D4, 300); // D
playNote(D4, 300); // D
playNote(C4, 600); // C (etwas länger)
delay(200); // kleine Pause
}
// Hilfsfunktion zum Abspielen einer Note
void playNote(int freq, int duration) {
tone(buzzerPin, freq, duration);
delay(duration);
noTone(buzzerPin);
delay(20); // kleine Pause zwischen den Noten
}
// ------------------------------------------
// 4) Kurze Pieptöne (z.B. 3 piep-piep-piep)
// ------------------------------------------
void kurzePieptoene() {
for (int i = 0; i < 3; i++) {
tone(buzzerPin, 1000); // Ton 1000 Hz
delay(200); // 200ms Ton
noTone(buzzerPin);
delay(200); // 200ms Pause
}
}
// ------------------------------------------
// 5) Aufsteigende Tonfolge
// ------------------------------------------
void ascendingBeep() {
// Beispiel: 5 Frequenzen aufsteigend
for (int freq = 200; freq <= 800; freq += 150) {
tone(buzzerPin, freq);
delay(200);
noTone(buzzerPin);
delay(100);
}
}
// ------------------------------------------
// 6) Absteigende Tonfolge
// ------------------------------------------
void descendingBeep() {
// Beispiel: 5 Frequenzen absteigend
for (int freq = 800; freq >= 200; freq -= 150) {
tone(buzzerPin, freq);
delay(200);
noTone(buzzerPin);
delay(100);
}
}
Programm und Erklärung wurden durch Künstliche Intelligenz erstellt.