Dem Weihnachtsmann auf der Spur - Sensoren für die Überwachung des Kaminzimmers

Bei Wikipedia liest man: Ein Sensor, auch als Detektor, (Messgrößen- oder Mess-) Aufnehmer oder (Mess-) Fühler bezeichnet, ist ein technisches Bauteil, das bestimmte physikalische oder chemische Eigenschaften (physikalisch z. B. Wärmemenge, Temperatur, Feuchtigkeit, Druck, Schallfeldgrößen, Helligkeit, Beschleunigung oder chemisch z. B. pH-Wert, Ionenstärke, elektrochemisches Potential) und/oder die stoffliche Beschaffenheit seiner Umgebung qualitativ oder als Messgröße quantitativ erfassen kann. Diese Größen werden mittels physikalischer, chemischer oder biologischer Effekte erfasst und in ein weiter verarbeitbares elektrisches Signal umgeformt.

Für uns ist wichtig, welche Sensoren für unseren Zweck, den Weihnachtsmann zu erfassen, in Frage kommen, und in welcher Form sie ein elektrisches Signal senden. Meist sind die Sensoren am einfachsten zu erfassen, die ein digitales Signal senden. Die Abfrage im Programm erfolgt dann wie das Prüfen, ob ein Taster gedrückt wurde. Liefert der Sensor analoge Werte, müssen wir am analogen Eingang messen und – wichtig! – einen Schwellwert festlegen, bei dem der Alarm ausgelöst wird. Und es gibt komplexe Sensoren, die ihre Daten über eine Schnittstelle (z.B. I2C) an den Micro Controller senden. Hilfreich sind dann Programm-Bibliotheken, die man zu Beginn des Sketches inkludiert.

 

Benötigtes Material:

1- 2 

Micro Controller

1

Bewegungsmelder HC-SR501

1

Entfernungsmesser HC-SR04

alternativ

VL53L0X Time-of-Flight (ToF) Laser Abstandssensor

1

Temperatursensor, z.B. DHT11 Breakout-Modul

2

NRF24L01 2,4 GHz Wireless Modul und optional NRF24L01 Breadboard Adapter

1

Oder gleich das 35 in 1 Sensors Kit?

1

Prototyping Shield mit Mini Breadboard für UNO R3

1

LCD1602 Display Keypad Shield


Genug der Vorrede. Ans Werk. Wir beginnen mit dem Bewegungsmelder (PIR=Passive InfraRed) HC-SR501: Der Anschluss erfolgt im Prinzip ganz einfach: Spannungsversorgung an 5V und GND, Signalleitung an einen digitalen Pin (im Schaltbild Pin 2). Das Gute am HC-SR501 ist, dass das Signal nur 3,3V hat und damit an allen Micro Controllern und Raspberry Pis verwendet werden kann.

Sketch zum Download:

 /* PIR sensor tester
  * The circuit:
  * HC-SR501 connect to VCC=5V, GND, Signal-Pin to D2
  * use LED_BUILTIN = D13     */
 
 int ledPin = 13;                // choose the pin for the LED
 int inputPin = 2;               // choose the input pin (for PIR sensor)
 int pirState = LOW;         // we start, assuming no motion detected
 int val = 0;                       // variable for reading the pin status
 
 void setup() {
   Serial.begin(9600);                 // use Serial Monitor for messages
   pinMode(ledPin, OUTPUT);    // declare LED as output
   pinMode(inputPin, INPUT);     // declare sensor as input
 }
 
 void loop(){
   val = digitalRead(inputPin);    // read input value
   if (val == HIGH) {                    // check if the input is HIGH
     digitalWrite(ledPin, HIGH);   // turn LED ON
     if (pirState == LOW) {
       // we have just turned on
       Serial.println("Motion detected!");
       pirState = HIGH;
    }
  } else {
     digitalWrite(ledPin, LOW);  // turn LED OFF
     if (pirState == HIGH){
       // we have just turned of
       Serial.println("Motion ended!");
       pirState = LOW;
    }
  }
 }

Vor einer kleinen Falle möchte ich noch warnen: Aufgrund verschiedener Hersteller kann es selbst bei drei Pins am PIR zu Verwechslungen der Anschlüsse kommen. Ggf. ist die Beschriftung auf der Oberseite unter der Kappe.

Nach dem gleichen Prinzip arbeiten z.B. auch der Erschütterungs-/Schocksensor:

und der Vibration-/Schüttelsensor:

Um also Schritte oder andere Erschütterungen zu erkennen, können Sie den PIR durch diese Sensoren austauschen, oder sie im Sketch ergänzen.

Entfernungssensor

Die beiden möglichen Entfernungssensoren hatte ich im Halloween-Blog vorgestellt. Der Ultraschallsensor Entfernungsmesser HC-SR04 misst Entfernungen bis 3 m, der VL53L0X Time-of-Flight (ToF) Laser Abstandssensor misst bis 4 m. Ändert sich die gemessene Entfernung, so befindet sich jemand innerhalb der Messstrecke.

Für den HC-SR04 hier der angepasste Sketch ohne Einbinden einer Bibliothek zum Download:

 const int trigPin = 2;
 const int echoPin = 3;
 long duration;
 int distance1 = 100;
 int distance2;
 int led = LED_BUILTIN;
 
 void setup() {
   pinMode(trigPin, OUTPUT);
   pinMode(echoPin, INPUT);
   pinMode(led, OUTPUT);
   Serial.begin(9600);
 }
 void loop() {
   digitalWrite(trigPin, LOW);
   delayMicroseconds(2);
   digitalWrite(trigPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(trigPin, LOW);
   duration = pulseIn(echoPin, HIGH);
   distance2 = duration * 0.034 / 2;
   Serial.print("Distance: ");
   Serial.println(distance2);
   if (abs(distance2 - distance1) >10) {
     digitalWrite(led,HIGH);
     Serial.println("Alarm!");
     distance1 = distance2;
    }
   delay(1000);
   digitalWrite(led,LOW);
 }

Wenn sich die Distanz um mehr als 10 cm ändert, wird der Alarm ausgelöst. Nach dem Einschalten erfolgt ein Probealarm, bei dem zugleich der Vergleichswert ermittelt wird.

Der Anschluss erfolgt an VCC=5V und GND sowie an zwei digitale Pins (hier D2 und D3). Dabei benötigt der Trigger-Pin unbedingt 5V, 3,3V reichen leider nicht aus. Und der Echo-Pin liefert auch 5V, also zu viel für Raspberry Pi und einige Micro Controller. Deshalb schaffen wir Abhilfe mit einem NPN-Transistor bzw. mit einem Spannungsteiler für die Fälle, in denen die digitalen Pins nur 3,3V liefern bzw. vertragen.

Temperatursensor

Wenn der Weihnachtsmann direkt vom Nordpol kommt, bringt er bestimmt kalte Luft mit in unser Haus. Meist liegen die Temperaturen im Wohnzimmer zwischen 12 und 28°C. Wenn die gemessene Temperatur kälter ist, ist jemand von draußen hereingekommen. Und wenn es wärmer als 28°C wird, brennen nicht nur die Kerzen. In beiden Fällen also Achtung, hier stimmt etwas nicht.

Die Palette an Temperatursensoren ist groß. Ich entscheide mich exemplarisch für den DHT11, bei dem der erforderliche Pull-up-Widerstand bereits auf dem Break-out-Board vorhanden ist. Also VCC an 5V, GND an GND und die Signalleitung an einen digitalen Pin, im Beispiel Pin 7.

Hier der Beispiel-Sketch zum Download:

 // Modified Example sketch for DHT11 temperature sensor  by ladyada, public domain
 // REQUIRES the following Arduino libraries:
 // - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library
 // - Adafruit Unified Sensor Lib: https://github.com/adafruit/Adafruit_Sensor
 
 #include "DHT.h"
 #define DHTPIN 7     // Digital pin connected to the DHT sensor
 #define DHTTYPE DHT11   // DHT 11
 DHT dht(DHTPIN, DHTTYPE);
 
 void setup() {
   Serial.begin(9600);
   Serial.println(F("DHT11 test!"));
   dht.begin();
 }
 
 void loop() {
   // Wait a few seconds between measurements.
   delay(2000);
   // Read temperature as Celsius (the default)
   float t = dht.readTemperature();
   // Check if any reads failed and exit early (to try again).
   if (isnan(t)) {
     Serial.println(F("Failed to read from DHT sensor!"));
     return;
  }
   Serial.print(F(" Temperature: "));
   Serial.print(t);
   Serial.println(F("°C "));
   if (t<12 || t>28)   {
     Serial.println("Alarm");
  }
 }

Alternativ zum DHT11 können Sie auch den DHT22 verwenden:

Wie man ihn anschließt und den passenden Sketch programmiert, können Sie hier nachlesen.

Eine weitere Möglichkeit wäre ein GY-BME280 Barometrischer Sensor:

Auch dazu finden Sie eine ausführliche Beschreibung samt Sketch und Schaltplan in diesem Beitrag.

Lokale Anzeige der Sensordaten

Wer auf eine lokale Anzeige der Sensordaten und des Alarms nicht verzichten möchte, dem sei für die Micro Controller in der Bauform des Uno (also unser Mikrocontroller Board ATmega328 oder D1 NodeMCU mit ESP8266)  das sogenannte LCD-Keypad-Shield mit einer kleinen Modifikation empfohlen. Dieses Shield ist mit einem LCD1602 ohne die I2C-Schnittstelle ausgestattet. Stattdessen werden – neben der Spannungsversorgung – die digitalen Pins D4 bis D9 vom Display verwendet. Dafür wird die Bibliothek LiquidCrystal.h installiert und im Sketch inkludiert. Als Modifikation schlage ich das Einlöten von drei Federleisten vor (auf dem Bild rechts oben und unten), damit man die verbliebenen Pins gut erreichen kann. 

Die Belegung der ersten Federleiste unterhalb der Betriebsspannungs-Pins ist wie üblich. Bei den analogen Pins erhält man Zugang zu den analogen Eingängen A1 bis A5.

Zur Erinnerung: Man kann diese Pins auch als digitale Pins D15 bis D19 und als I2C-Schnittstelle (A4 = SDA und A5 = SCL) verwenden. Der analoge Eingang A0 steht nicht zur Verfügung, da hier die Taster über einen Spannungsteiler angeschlossen sind. Um herauszufinden, wie das funktioniert, empfehle ich Ihnen, einen kurzen Sketch zu schreiben, der mit analogRead(A0) den Pin in einer Schleife ausließt. Wenn Sie dann die Taster betätigen, werden Sie die gewandelten Werte des ADC sehen. Daraus lässt sich dann erschließen, wie man die Taster abfragt, um Projekte damit zu realisieren, oder Sie schauen in den Blogbeitrag Ein robustes Robot Car mit Fernsteuerung.

Wichtig:

Die ausgeführten digitalen Pins auf dem Shield (obere Federleiste) ist nicht intuitiv. Hier erhält man von rechts nach links betrachtet Zugang zu den digitalen Pins D0 = RX, D1 = TX, D2 und D3, sowie D11 = MOSI, D12 = MISO und D13 = SCK, also die fest vergebenen Pins der SPI-Schnittstelle. Die anderen digitalen Pins sind wie oben beschrieben vom Display belegt und nicht zugänglich.

Kleiner Tipp bei der ersten Inbetriebnahme: Im Bild oben links ist das blaue Potentiometer für den Kontrast zu sehen. Ich musste die kleine Schraube viele Male nach rechts drehen, bis die Schrift sichtbar wurde. Und kaum sichtbar: Über dem Display liegt eine kleine Schutzfolie.

Zum Download folgen die wesentlichen Zeilen für die Initialisierung des Displays. Diese Programmteile können in die Sketches für die Sensoren integriert werden.

 /*
 LCD-Keypad-Shield
 */
 
 // Das LCD hat keinen I2C-Adapter
 // Die Daten werden über die Pins D4 bis D7 übertragen
 #include <LiquidCrystal.h>
 //LCD pin to Arduino
 const int pin_EN = 9;
 const int pin_RS = 8;
 const int pin_D4 = 4;
 const int pin_D5 = 5;
 const int pin_D6 = 6;
 const int pin_D7 = 7;  
 LiquidCrystal lcd( pin_RS,  pin_EN,  pin_D4,  pin_D5,  pin_D6,  pin_D7);
 
 
 void setup() {
 // Initialisierung des eingebauten LCD
   lcd.begin(16, 2);       //LCD1602 mit 16 Zeichen und 2 Zeilen
   lcd.setCursor(0,0);     //Zählung beginnt bei Null, erst Zeichen, dann Zeile
   lcd.print("AZ-Delivery.com");
   lcd.setCursor(0,1);     // 0=Erstes Zeichen, 1=zweite Zeile
   lcd.print("Weihnachten 2021");
  }
 
 void loop() {
 
 }

Für die Verwendung mit dem D1-8266-Board verweise ich auf meinen Blog vom November 2020.

Wir fügen nun die Komponenten zu einem Aufbau zusammen:

Download des Sketches mit

  • HC-SR04 an D2 und D3
  • PIR an D15 = A1
  • DHT11 an D16 = A2

Entfernte Anzeige der Sensordaten

Mein Bloggerkollege Andreas Wolter hat das Projekt noch erweitert und daraus einen Santa Detector mit Funkübertragung gebaut:

Da wir Santa heimlich erwischen wollen, übertragen wir die Sensordaten nach außerhalb des Kaminzimmers, z.B. in das Kinderzimmer. Wir trennen daher den Aufbau und nehmen zwei ATmega328 Mikrocontroller. Auf den einen stecken wir das Display Shield, auf den anderen ein Prototyping Shield und schließen dort die Sensoren an. Beide bekommen ein NRF24L01 2,4 GHz Funkmodul. Auf diese Weise können wir zwischen beiden Geräten Daten übertragen. Wir nutzen für den ersten Test das beigelegte Mini-Steckbrett, um die Sensoren zu verbinden. Das sieht dann ungefähr so aus:

Aufbau mit zwei Mikrocontrollern

Für den PIR-Sensor habe ich Beine aus draht an eine dreipolige Federleister gelötet und ihn dort aufgesteckt.

Mikrocontroller mit Sensoren

Es folgen Schaltpläne und Pinout:

Schaltplan Mikrocontroller mit Display Shield

Display Shield am Mikrocontroller

NRF24L01 Funkmodul

GND

GND

3.3V

VCC

D2

CE

D3

CSN

D11

MOSI

D12

MISO

D13

SCK

 

Die Pinnummern für die Sensoren habe ich für diesen Aufbau verändert:

Schaltplan Mikrocontroller mit Sensoren

Mikrocontroller

NRF24L01 Funkmodul

GND

GND

3.3V

VCC

D9

CE

D10

CSN

D11

MOSI

D12

MISO

D13

SCK

 

DHT11 Temperatursensor

D8

S(ignal) / Dat

5V

VCC

GND

GND

 

HC-SR04 Ultraschallsensor

GND

GND

D6

Trigger

D7

Echo

5V

VCC

 

PIR Bewegungssensor

GND

GND

D5

OUT

5V

VCC

Eventuell verwenden Sie einen DHT11 Temperatursensor in einer anderen Ausführung. Wie im Schaltplan zu erkennen ist, liegt dann der S-Pin eventuell außen. Die Variante weiter oben im Beitrag, wie Sie sie im AZ-Shop erhalten, hat den Datenpin in der Mitte. Achten Sie daher genau auf die Beschriftung auf dem Breakout Board, oder schauen Sie in das Datenblatt.

Das NRF24L01 arbeitet mit einer Betriebsspannung von 3.3V. Wenn Sie zusätzlich das optionale NRF24L01 Breadboard Modul verwenden, müssen Sie es mit 5V versorgen!

Es folgen nun die beiden Sketches.

Sendermodul mit Sensoren (Download des Sketches)

 #include <SPI.h>
 #include "RF24.h"
 #include "DHT.h"
 
 // DHT 11
 #define DHTPIN 8
 #define DHTTYPE DHT11     // DHT 11
 
 // HC-SR04
 const int trigPin = 6;
 const int echoPin = 7;
 DHT dht(DHTPIN, DHTTYPE);
 
 // PIR
 const int pirPin = 5;
 
 // RF24 Funkmodul
 RF24 radio(9, 10);   // CE, CS
 const byte address[6] = "SANTA";
 char sendValues[15] = {'s', 't', 'a', 'r', 't', '\0'};        // Startcode
 int intervall = 200;                                          // Sendeintervall
 
 // Temperatur auslesen und zurueckgeben
 // DHT11 gibt keine Kommastellen aus,
 // daher kann die Ausgabe auf zwei Stellen verkuerzt werden
 int temperature() {
   float t = dht.readTemperature();
 
   if (isnan(t)) {
     Serial.println(F("Failed to read from DHT sensor!"));
     return -1;
  }
   return (int)t;
 }
 
 // Distanzmessung durch HC-SR04 Ultraschallmodul
 // ohne Bibliothek
 float distance() {
   unsigned long duration;
   float distance = 0;
 
   digitalWrite(trigPin, LOW);
   delayMicroseconds(2);
   digitalWrite(trigPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(trigPin, LOW);
   duration = pulseIn(echoPin, HIGH);
   distance = duration * 0.034 / 2.0;
   return distance;
 }
 
 void setup() {
   Serial.begin(115200);
   if (!radio.begin()) {
     Serial.println(F("Failed to read from RF24 sensor!"));
     while (1) {}
  }
   // DHT11 starten
   dht.begin();
 
   // Sensorpins initialisieren
   pinMode(trigPin, OUTPUT);
   pinMode(echoPin, INPUT);
   pinMode(pirPin, INPUT);
 
   // RF24 initialisieren
   radio.openWritingPipe(address);
   
   // PALevel kann fuer hoehere Reichweiter veraendert werden
   // Stromverbrauch steigt dadurch
   radio.setPALevel(RF24_PA_MIN);
   radio.stopListening();
 
   // Startcode senden
   radio.write(&sendValues, sizeof(sendValues));
 }
 
 void loop() {
   // Sensorwerte als String speichern
   sprintf(sendValues, "%d:%s:%i", temperature(), String(distance()).c_str(), digitalRead(pirPin));
   Serial.println(sendValues);
 
   // Sensorwerte an Empfaenger senden
   radio.write(&sendValues, sizeof(sendValues));
 
   // Sendeintervall
   delay(intervall);
 }

Empfängermodul mit Display (Download des Sketches)

 #include <SPI.h>
 #include "RF24.h"
 #include <LiquidCrystal.h>
 
 // LCD Shield Pins
 const int pin_EN = 9;
 const int pin_RS = 8;
 const int pin_D4 = 4;
 const int pin_D5 = 5;
 const int pin_D6 = 6;
 const int pin_D7 = 7;
 LiquidCrystal lcd( pin_RS, pin_EN, pin_D4, pin_D5, pin_D6, pin_D7);
 
 unsigned long interval = 500;
 unsigned long currentMillis = 0;
 unsigned long previousMillis = 0;
 unsigned long blinkTimeout = 4000;
 unsigned long blinkStart = 0;
 int minTemp = 12;
 int maxTemp = 28;
 float startDist = 0.0;
 float maxDist = 10.0;
 bool firstStart = true;
 bool blinkmode = false;
 bool displayToggle = LOW;
 
 // eigene Zeichen für das Bewegungs-Symbol des PIR
 
 byte movement1[] = {
   B00011,
   B00111,
   B01111,
   B01111,
   B01111,
   B01111,
   B00111,
   B00011
 };
 
 byte movement2[] = {
   B00000,
   B10000,
   B10100,
   B10101,
   B10101,
   B10100,
   B10000,
   B00000
 };
 
 byte movement3[] = {
   B00000,
   B00001,
   B00101,
   B10101,
   B10101,
   B00101,
   B00001,
   B00000
 };
 
 byte movement4[] = {
   B11000,
   B11100,
   B11110,
   B11110,
   B11110,
   B11110,
   B11100,
   B11000
 };
 
 // RF24 Funkmodul
 RF24 radio(2, 3); // CE, CSN
 const byte address[6] = "SANTA";
 bool transConnected = false;
 bool started = false;
 char startcode[6] = "start";          // Programm startet, wenn Sendermodul diesen Code sendet
 char recValues[15] = "";
 char *recValuesTemp = NULL;
 int temperatur = 0;
 float dist = 0.0;
 int moving = 0;
 
 // Startprozedur mit Ausgabe auf dem Display
 // und Verbindungsaufbau zum Sender
 void startConnect() {
   lcd.clear();
   lcd.home();
   lcd.print("AZ-Delivery.com");
   lcd.setCursor(0,1);
   lcd.print(" Santa Detector ");
   if (!radio.begin()) {
     lcd.print(" RF24 Sensor is ");
     lcd.print("not responding!!");
     while (1) {}
  }
   radio.openReadingPipe(1, address);
   radio.setPALevel(RF24_PA_LOW);  // RF24_PA_MAX is default.
   radio.startListening();
   delay(2000);
   lcd.clear();
   lcd.home();
   lcd.print(" waiting for");
   lcd.setCursor(0,1);
   lcd.print(" Transmitter... ");
   while(!transConnected) {
     if (radio.available()) {
       radio.read(&recValues, sizeof(recValues));
       if (strstr(recValues, startcode)) {
         transConnected = true;
      }
    }
  }
   lcd.clear();
   lcd.home();
   lcd.print(" Transmitter");
   lcd.setCursor(0,1);
   lcd.print("   connected");
   delay(2000);
   lcd.clear();
   lcd.home();
   lcd.print("Temp Dist Move");
   lcd.setCursor(0,1);
 }
 
 // Sendermodul sendet einen String,
 // der zerlegt und in passende Datentypen
 // gewandelt wird
 // Inhalt: int:float:int
 // ':' als Delimiter
 // Reihenfolge ist Temperatur:Distanz:Bewegung
 void parseValues() {
   int counter = 0;
   recValuesTemp = strtok(recValues, ":");
   while(recValuesTemp != NULL) {
       switch(counter) {
         case 0: {
           temperatur = atoi(recValuesTemp);
           counter++;
        } break;
         case 1: {
           dist = atof(recValuesTemp);
           counter++;
        } break;
         case 2: {
           moving = atoi(recValuesTemp);
           counter++;
        } break;
         default: break;
      }
       recValuesTemp = strtok(NULL, ":");
  }
 }
 
 // Ausgabe der Werte auf dem LCD
 void printValues() {
   lcd.setCursor(0,1);
   lcd.print("               ");
   lcd.setCursor(0,1);
   lcd.print(temperatur);
   lcd.setCursor(2,1);
   lcd.print((char)223);
   lcd.setCursor(3,1);
   lcd.print("C");  
   lcd.setCursor(5,1);
   lcd.print(dist);
   if (moving) {
     lcd.setCursor(12,1);
     lcd.print("   ");
     lcd.setCursor(12,1);
     lcd.write(1);
     lcd.setCursor(13,1);
     lcd.write(2);
     lcd.setCursor(14,1);
     lcd.write(3);
     lcd.setCursor(15,1);
     lcd.write(4);
  }
   else {
     lcd.setCursor(12,1);
     lcd.print("   ");
  }
 }
 
 void setup() {
   lcd.begin(16, 2); // Start LCD
 
   // eigene Symbole initialisieren
   lcd.createChar(1, movement1);
   lcd.createChar(2, movement2);
   lcd.createChar(3, movement3);
   lcd.createChar(4, movement4);
 
   // Startprozedur beginnen
   startConnect();
 }
 
 void loop() {
   
   // Bildschirm wird aktualisiert, wenn neue
   // Werte empfangen wurden
   // Intervall wird vom Sendermodul bestimmt
   if (radio.available()) {
     radio.read(&recValues, sizeof(recValues));
     parseValues();
 
     // Distanzmessung kalibrieren
     if (firstStart) {
       startDist = dist;
       firstStart = false;
    }
     printValues();
  }
   
   currentMillis = millis();
   
   // Alarm ausloesen
   if ((temperatur < minTemp || temperatur > maxTemp || abs(dist - startDist) > maxDist || moving) && !blinkmode) {
     blinkmode = true;
     blinkStart = millis();
  }
 
   // Blinken nach Ablauf des Intervalls abschalten
   if (currentMillis - blinkStart >= blinkTimeout && blinkmode) {
     blinkmode = false;
     lcd.display();
  }
 
   // nichtblockierendes Blinken des Displays
   if (currentMillis - previousMillis >= interval && blinkmode) {
     displayToggle = !displayToggle;
     if (displayToggle) {
       lcd.display();  
    }
     else {
       lcd.noDisplay();
    }
     previousMillis = currentMillis;
  }    
 }

Das Sendermodul sendet nach dem Start einen Startcode und anschließend die Sensorwerte als String mit einem Doppelpunkt als Trennzeichen zwischen den Sensorwerten. Die Intervallzeit, wie oft Daten gesendet werden, bestimmt der Sender. Die erste gemessene Entfernung des Ultraschallsensors wird als Referenz gespeichert. Es funktioniert quasi wie eine Kalibrierung.

Der Empfänger wartet nach dem Einschalten auf den Startcode vom Sender. Sie sollten also zuerst den Empfänger einschalten, dann den Sender platzieren und einschalten (oder neustarten).

Im Empfänger wird der String aus Sensordaten zerlegt und in passende Datentypen konvertiert. Die Funktionen aus den anderen Sketches wurde übernommen. Die tolerierte Temperatur liegt zwischen 12 und 28 Grad Celcius. Der gemessene Abstand darf nicht um mehr als 10 cm verändert werden und eine Bewegung in der Nähe wird umliegend detektiert, sichtbar durch ein Symbol im Display, dass ich als eigene Zeichen in den Quellcode eingefügt habe. Wird ein Alarm ausgelöst, blinkt der Inhalt des Displays für einige Sekunden.

Mikrocontroller mit Display

Sollte die Entfernung zwischen Sender und Empfänger zu groß sein und es wird keine Verbindung hergestellt, können Sie in beiden Quellcodes diese Zeile ändern:

 radio.setPALevel(RF24_PA_LOW);

Für die maximale Leistung ändern Sie den Übergabeparameter in RF24_PA_MAX. Dann wird allerdings mehr Strom verbraucht. Es empfiehlt sich dann, eine externe Spannungsquelle zu verwenden.

Um auf dem Sendermodul den Kabelsalat zu vermeiden, können Sie die Sensoren auf das Prototyping Shield löten. Ich habe Federleisten aufgelötet, damit ich die Sensoren tauschen kann, sollte einer defekt sein.

Sensorshield verloetet

Sensorshield verloetet von untenSensorshield verlötet mit Sensoren

Sender und Empfaenger

Das sieht schonmal sehr kompakt aus und es lassen sich dafür auch Gehäuse entwerfen. Wenn Sie nun den Sender mit den Sensoren platzieren und Ihren Kindern den Empfänger in die Hand drücken, könnten Sie an Heiligabend eventuell für noch mehr Spannung sorgen.

Als weitere Anregung könnten Sie die Funktion des Empfängers erweitern und zusätzlich noch die Tasten auf dem Display Shield ins Spiel bringen.

Viel Spaß beim Nachbasteln und an dieser Stelle wünsche ich ein schönes Weihnachtsfest.

Andreas Wolter

 

Weiterleitung des Alarms im heimischen WLAN

Für die Weiterleitung von Sensordaten und ggf. eine Alarmierung benötigt man zwei netzwerkfähige Micro Controller, z.B. die MCUs mit dem ESP 8266 oder ESP32. Wie das geht, habe ich in meinem Blog „Gartenhäuschen mit Micro Controller und Sensoren überwachen“ - Teil 1, Teil 2 und Teil 3 beschrieben.

Zu guter Letzt

Was passiert, wenn man den Weihnachtsmann leibhaftig erwischt, kann nicht vorhergesagt werden. Vielleicht nimmt er alle Geschenke wieder mit? Am besten, man verwöhnt ihn mit Leckereien. Wenn man der Reklame glaubt, kann man es mit roten Dosen eines Erfrischungsgetränks probieren. Wenn er jedoch so alt ist wie ich - angeblich ist er sogar noch älter - bevorzugt er sicherlich ein Gläschen Sherry oder Port und dazu ein Täfelchen mit Pfefferminzschokolade. Und Mohrrüben für Rudolf und die anderen Rentiere sollte man auch parat haben.

Wer nicht an den Weihnachtsmann glaubt, kann mit den Sensoren auch eine Alarmanlage gegen unerwünschte Besucher basteln.

Voor arduinoProjecten voor beginnersSensor

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Aanbevolen blog berichten

  1. Installeer ESP32 nu van de raad van bestuur
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP Programmeren via Wi-Fi