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

Wikipedia dice: un sensore, chiamato anche rilevatore, trasduttore o sonda, è un componente tecnico che può rilevare determinate proprietà fisiche o chimiche (fisicamente, ad esempio quantità di calore, temperatura, umidità, pressione, quantità di campo sonoro, luminosità, accelerazione, o chimicamente, ad esempio valore pH, forza ionica, potenziale elettrochimico) e/o la composizione materiale del suo ambiente qualitativamente o quantitativamente come una quantità misurata. Queste variabili sono registrate per mezzo di effetti fisici, chimici o biologici e convertite in un segnale elettrico che può essere ulteriormente elaborato.

A proposito, i prodotti per il blog sono disponibili in un bundle con il 55% di sconto sul secondo Avvento! Nessuno ha mai preso Babbo Natale a un prezzo così basso 😉

È importante per noi sapere quali sensori siano adatti al nostro scopo di rilevare Babbo Natale e in quale forma inviino un segnale elettrico. I sensori che inviano un segnale digitale sono di solito i più facili da rilevare. L'interrogazione nel programma è quindi fatta come il controllo se un pulsante è stato premuto. Se il sensore fornisce valori analogici, dobbiamo misurare all'ingresso analogico e - importante! - definire un valore di soglia al quale l'allarme viene attivato. E ci sono sensori complessi che inviano i loro dati al microcontrollore tramite un'interfaccia (per esempio I2C). È utile includere le librerie di programma all'inizio dello sketch.


Materiale necessario:

👉 al set di progetti risparmiando il 55%!

1- 2 

Microcontroller con cavo USB

1

Sensore di movimento HC-SR501

1

Modulo ad ultrasuoni HC-SR04

alternativamente

VL53L0X Time-of-Flight (ToF)

1

Sensore di temperatura, ad es. DHT11 AM2302

2

NRF24L01 con modulo wireless da 2,4 GHz e (optional) NRF24L01 modulo ricetrasmettitore adattatore

1

O lo stesso 35 in 1 kit sensore

1

Prototipo Shield Mini Breadboard per UNO R3

1

LCD1602 Display Keypad Shield


Basta con la prefazione. Mettiamoci al lavoro. Iniziamo con il rilevatore di movimento (PIR=Passive InfraRed) HC-SR501: In linea di principio, il collegamento è abbastanza semplice: alimentazione a 5V e GND, linea di segnale a un pin digitale (pin 2 nello schema del circuito). La cosa buona dell'HC-SR501 è che il segnale è solo 3,3V e può quindi essere utilizzato su tutti i microcontrollori e Raspberry Pis.

Sketch da scaricare:

/* 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(ledPinOUTPUT);    // declare LED as output
   pinMode(inputPinINPUT);     // declare sensor as input
 }
 
 void loop(){
   val = digitalRead(inputPin);    // read input value
   if (val == HIGH) {                    // check if the input is HIGH
     digitalWrite(ledPinHIGH);   // turn LED ON
     if (pirState == LOW) {
       // we have just turned on
       Serial.println("Motion detected!");
       pirState = HIGH;
    }
  } else {
     digitalWrite(ledPinLOW);  // turn LED OFF
     if (pirState == HIGH){
       // we have just turned of
       Serial.println("Motion ended!");
       pirState = LOW;
    }
  }
 }

Vorrei avvertire di una piccola insidia: a causa dei diversi produttori, anche con tre pin sul PIR, è possibile confondere le connessioni. Se necessario, le indicazioni sul lato superiore sono sotto il tappo.

Anche il sensore di vibrazioni/urti, per esempio, funziona secondo lo stesso principio:

e il sensore di vibrazioni/scosse:

Quindi, per rilevare i passi o altre vibrazioni, si può sostituire il PIR con questi sensori, o aggiungerli allo sketch.

Sensore di distanza

Ho introdotto i due possibili sensori di distanza nel blog di Halloween. Il sensore di distanza a ultrasuoni HC-SR04 misura distanze fino a 3 m, il sensore di distanza laser VL53L0X Time-of-Flight (ToF) misura fino a 4 m. Se la distanza misurata cambia, significa che qualcuno si trova nel raggio di misurazione.

Per l'HC-SR04, ecco lo sketch adattato senza incorporare una libreria da scaricare:

  const int trigPin = 2;
 const int echoPin = 3;
 long duration;
 int distance1 = 100;
 int distance2;
 int led = LED_BUILTIN;
 
 void setup() {
   pinMode(trigPinOUTPUT);
   pinMode(echoPinINPUT);
   pinMode(ledOUTPUT);
   Serial.begin(9600);
 }
 void loop() {
   digitalWrite(trigPinLOW);
   delayMicroseconds(2);
   digitalWrite(trigPinHIGH);
   delayMicroseconds(10);
   digitalWrite(trigPinLOW);
   duration = pulseIn(echoPinHIGH);
   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);
 }

Se la distanza varia di più di 10 cm, scatta l'allarme. Dopo l'attivazione dell'allarme, viene attivato un allarme di prova e allo stesso tempo viene determinato il valore di confronto.

La connessione è fatta a VCC=5V e GND così come a due pin digitali (qui D2 e D3). Il pin di trigger ha assolutamente bisogno di 5V, purtroppo 3.3V non è sufficiente. E il pin echo fornisce anche 5V, che è troppo per il Raspberry Pi e alcuni micro controller. Pertanto, rimediamo alla situazione con un transistor NPN o con un divisore di tensione per i casi in cui i pin digitali forniscono o tollerano solo 3,3V.

Sensore di temperatura

Quando Babbo Natale arriva direttamente dal Polo Nord, è sicuro di portare aria fredda in casa nostra. Di solito le temperature nel soggiorno sono tra i 12 e i 28°C. Se la temperatura misurata è più fredda, qualcuno è entrato dall'esterno. E se fa più caldo di 28°C, non sono solo le candele a bruciare. Quindi in entrambi i casi, attenzione, qui c'è qualcosa che non va.

La gamma di sensori di temperatura è ampia. Decido di usare il DHT11 come esempio, dove la resistenza di pull-up richiesta è già presente sulla scheda di break-out. Quindi VCC a 5V, GND a GND e la linea di segnale a un pin digitale, nell'esempio il pin 7.

Ecco lo sketch d'esempio da scaricare:

 // 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(DHTPINDHTTYPE);
 
 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");
  }
 }

In alternativa al DHT11, è possibile utilizzare anche il DHT22:

Potete leggere come collegarlo e programmare lo sketch appropriato qui.

Un'altra possibilità sarebbe un sensore barometrico GY-BME280:

Troverete anche una descrizione dettagliata che include uno sketch e un diagramma di circuito in questo articolo.

Visualizzazione locale dei dati del sensore

Per coloro che non vogliono fare a meno di una visualizzazione locale dei dati del sensore e dell'allarme, consigliamo il cosiddetto LCD keypad shield con una piccola modifica per i micro controller nel design della Uno (cioè la nostra scheda microcontroller ATmega328 o D1 NodeMCU con ESP8266). Questo shield è dotato di un LCD1602 senza l'interfaccia I2C. Invece, vengono usati i pin digitali da D4 a D9 del display - oltre all'alimentazione. Per questo, la libreria LiquidCrystal.h è installata e inclusa nello sketch. Come modifica, suggerisco di saldare tre connettori femmina (in alto e in basso a destra nella foto) in modo che i pin rimanenti siano facilmente raggiungibili. 

L'assegnazione del primo connettore femmina sotto i pin della tensione di funzionamento è come al solito. I pin analogici danno accesso agli ingressi analogici da A1 a A5.

Promemoria: potete anche usare questi pin come pin digitali da D15 a D19 e come interfaccia I2C (A4 = SDA e A5 = SCL). L'ingresso analogico A0 non è disponibile perché i pulsanti sono collegati qui tramite un divisore di tensione. Per scoprire come funziona, vi consiglio di scrivere un breve sketch che usa analogRead(A0) per leggere il pin in un ciclo. Se poi premete i pulsanti, vedrete i valori convertiti dell'ADC. Da questo si può poi vedere come interrogare i pulsanti per realizzare progetti con loro, o si può guardare il post del blog Una robusta macchina robotica con telecomando.

Importante:

L'esecuzione dei pin digitali sullo schermo (connettore femmina superiore) non è intuitiva. Visto da destra a sinistra, questo dà accesso ai perni digitali D0 = RX, D1 = TX, D2 e D3, così come D11 = MOSI, D12 = MISO e D13 = SCK, cioè i pin permanentemente assegnati dell'interfaccia SPI. Gli altri pin digitali sono occupati dal display come descritto sopra e non sono accessibili.

Un piccolo suggerimento per il primo avvio: nella foto in alto a sinistra, si può vedere il potenziometro blu per il contrasto. Ho dovuto girare la piccola vite a destra molte volte finché la scritta non è diventata visibile. E poco visibile: c'è una piccola pellicola protettiva sopra il display.

Seguono le linee essenziali per l'inizializzazione del display da scaricare. Queste parti del programma possono essere integrate negli sketch dei sensori.

 /*
 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 lcdpin_RS,  pin_EN,  pin_D4,  pin_D5,  pin_D6,  pin_D7);
 
 
 void setup() {
 // Initialisierung des eingebauten LCD
   lcd.begin(162);       //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() {
 
 }

Per l'uso con la scheda D1-8266, vi rimando al mio blog del novembre 2020.

Ora stiamo assemblando i componenti in una struttura:

Scarica lo sketch con

  • HC-SR04 a D2 e D3
  • PIR a D15 = A1
  • Da DHT11 a D16 = A2


Visualizzazione remota dei dati del sensore

Il mio collega blogger Andreas Wolter ha esteso il progetto e costruito un Santa Detector con trasmissione radio:

Dato che vogliamo catturare Babbo Natale di nascosto, trasferiamo i dati del sensore fuori dalla stanza del camino, per esempio nella stanza dei bambini. Separiamo quindi il setup e prendiamo due microcontrollori ATmega328. Su uno mettiamo lo schermo di visualizzazione, sull'altro uno schermo di prototipazione e vi colleghiamo i sensori. Entrambi hanno un modulo radio NRF24L01 a 2,4 GHz. In questo modo possiamo trasferire dati tra entrambi i dispositivi. Per il primo test, usiamo la mini scheda plug-in allegata per collegare i sensori. Sembra qualcosa del genere:

Costruzione con due microcontrollori

Per il sensore PIR, ho saldato le gambe del filo a un connettore femmina a tre poli e l'ho inserito lì.

Microcontrollore con sensori

Seguono schemi di cablaggio e pinout:

Diagramma di commutazione Microcontrollore con schermo display

Display Shield sul microcontrollore

Modulo radio NRF24L01

GND

GND

3.3V

VCC

D2

CE

D3

CSN

D11

MOSI

D12

MISO

D13

SCK


Ho cambiato i numeri dei pin dei sensori per questa configurazione:

Diagramma di commutazione Microcontrollore con sensori

Microcontrollore

Modulo radio NRF24L01

GND

GND

3.3V

VCC

D9

CE

D10

CSN

D11

MOSI

D12

MISO

D13

SCK


DHT11 Sensore di temperatura

D8

S(ignal) / Dat

5V

VCC

GND

GND


Sensore ad ultrasuoni HC-SR04

GND

GND

D6

Trigger

D7

Echo

5 V

VCC


Sensore di movimento PIR

GND

GND

D5

OUT

5V

VCC

Forse stai usando un sensore di temperatura DHT11 in una versione diversa. Come si può vedere nello schema del circuito, il perno S può quindi essere all'esterno. La versione più in alto nell'articolo, come si ottiene nel negozio AZ, ha il pin dati al centro. Perciò, fate molta attenzione all'etichettatura sulla scheda di breakout, o date un'occhiata alla scheda tecnica.

Il NRF24L01 funziona con una tensione di funzionamento di 3,3V. Se utilizzate anche il modulo breadboard NRF24L01 opzionale, dovete alimentarlo con 5V!

Ecco i due sketch.

Modulo trasmettitore con sensori (Download Sketch)

 #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(DHTPINDHTTYPE);
 
 // PIR
 const int pirPin = 5;
 
 // RF24 Funkmodul
 RF24 radio(910);   // 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(trigPinLOW);
   delayMicroseconds(2);
   digitalWrite(trigPinHIGH);
   delayMicroseconds(10);
   digitalWrite(trigPinLOW);
   duration = pulseIn(echoPinHIGH);
   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(trigPinOUTPUT);
   pinMode(echoPinINPUT);
   pinMode(pirPinINPUT);
 
   // 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(&sendValuessizeof(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(&sendValuessizeof(sendValues));
 
   // Sendeintervall
   delay(intervall);
}

Modulo ricevitore con display  (Download Sketch)

#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 lcdpin_RSpin_ENpin_D4pin_D5pin_D6pin_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(23); // 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(1address);
   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(&recValuessizeof(recValues));
       if (strstr(recValuesstartcode)) {
         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;
         defaultbreak;
      }
       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(162); // Start LCD
 
   // eigene Symbole initialisieren
   lcd.createChar(1movement1);
   lcd.createChar(2movement2);
   lcd.createChar(3movement3);
   lcd.createChar(4movement4);
 
   // Startprozedur beginnen
   startConnect();
 }
 
 void loop() {
   
   // Bildschirm wird aktualisiert, wenn neue
   // Werte empfangen wurden
   // Intervall wird vom Sendermodul bestimmt
   if (radio.available()) {
     radio.read(&recValuessizeof(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;
  }    
 }

Il modulo trasmettitore invia un codice di start dopo l'avvio e poi i valori del sensore come una stringa con un due punti come separatore tra i valori del sensore. Il tempo di intervallo, la frequenza di invio dei dati, è determinato dal trasmettitore. La prima distanza misurata dal sensore a ultrasuoni viene memorizzata come riferimento. Funziona più o meno come una calibrazione.

Il ricevitore attende il codice di avvio dal trasmettitore dopo l'accensione. Quindi dovresti prima accendere il ricevitore, poi posizionare il trasmettitore e accenderlo (o riavviarlo).

Nel ricevitore, la stringa di dati del sensore viene scomposta e convertita in tipi di dati adatti. Le funzioni degli altri sketch sono state adottate. La temperatura tollerata è tra i 12 e i 28 gradi Celsius. La distanza misurata non deve essere cambiata di più di 10 cm e viene rilevato un movimento nelle vicinanze, visibile da un simbolo nel display che ho inserito come carattere separato nel codice sorgente. Se scatta un allarme, il contenuto del display lampeggia per alcuni secondi.

Microcontrollore con display

Se la distanza tra il trasmettitore e il ricevitore è troppo grande e non si stabilisce una connessione, potete cambiare questa linea in entrambi i codici sorgente:

  radio.setPALevel(RF24_PA_LOW);

Per la massima potenza, cambiate il parametro di trasferimento a RF24_PA_MAX. Tuttavia, viene consumata più corrente. Si raccomanda quindi di utilizzare una fonte di tensione esterna.

Per evitare cavi aggrovigliati sul modulo trasmettitore, potete saldare i sensori sullo schermo di prototipazione. Ho saldato dei connettori femmina in modo da poter cambiare i sensori se uno fosse difettoso.

SensorShield versato

Sensorshield perso dal bassoSensorShield saldato con sensori

Mittente e ricevitore

Questo sembra già molto compatto e si possono anche progettare degli alloggiamenti per esso. Se ora mettete il trasmettitore con i sensori e date il ricevitore ai vostri bambini, potreste creare ancora più eccitazione alla vigilia di Natale.

Come ulteriore suggerimento, si potrebbe estendere la funzione del ricevitore e mettere in gioco anche i pulsanti dello schermo.

Divertitevi con il fai da te e a questo punto vi auguro un buon Natale.

Andreas Wolter


Inoltro dell'allarme nella WLAN di casa

Per l'inoltro dei dati dei sensori e, se necessario, di un allarme, sono necessari due microcontrollori compatibili con la rete, ad esempio gli MCU con ESP 8266 o ESP32. Ho descritto come farlo nel mio blog "Monitoraggio della casetta da giardino con microcontrollori e sensori" - Parte 1, Parte 2 e Parte 3.

Ultimo ma non meno importante

Quello che succede quando si prende Babbo Natale in carne ed ossa non si può prevedere. Forse porterà via di nuovo tutti i regali? La cosa migliore è viziarlo con dei dolcetti. Se credi alla pubblicità, puoi provare le lattine rosse di una bibita. Ma se è vecchio come me - si suppone che sia anche più vecchio - preferirebbe certamente un bicchierino di sherry o di porto e una tavoletta di cioccolato alla menta piperita per accompagnarlo. E anche le carote per Rudolf e le altre renne dovrebbero essere a portata di mano.

Se non credete in Babbo Natale, potete anche usare i sensori per creare un sistema di allarme contro i visitatori indesiderati.

Per arduino.Progetti per principiantiSensori

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Post di blog consigliati

  1. Installa ESP32 ora dal gestore del consiglio di amministrazione
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - Programmazione ESP tramite WLAN