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

Wikipedia : Un capteur, également appelé détecteur, transducteur ou sonde, est un composant technique capable de détecter certaines propriétés physiques ou chimiques (physiquement, par exemple la quantité de chaleur, la température, l'humidité, la pression, la quantité de champ sonore, la luminosité, l'accélération, ou chimiquement, par exemple la valeur du pH, la force ionique, le potentiel électrochimique) et/ou la composition matérielle de son environnement qualitativement ou quantitativement sous forme de quantité mesurée. Ces variables sont enregistrées au moyen d'effets physiques, chimiques ou biologiques et converties en un signal électrique qui peut être traité ultérieurement.

D'ailleurs, les produits du blog sont disponibles dans une offre groupée avec 55% de réduction sur le deuxième Avent ! Personne n'a jamais pris le père Noël à un prix aussi bas 😉 .

Il est important pour nous de savoir quels capteurs conviennent à notre objectif de détection du Père Noël et sous quelle forme ils envoient un signal électrique. Les capteurs qui envoient un signal numérique sont généralement les plus faciles à détecter. L'interrogation dans le programme se fait donc de la même manière que de vérifier si un bouton a été pressé. Si le capteur fournit des valeurs analogiques, nous devons mesurer à l'entrée analogique et - important ! - définir une valeur seuil à partir de laquelle l'alarme est déclenchée. Et il existe des capteurs complexes qui envoient leurs données au microcontrôleur via une interface (par exemple I2C). Il est utile d'inclure les bibliothèques de programmes au début de l'esquisse.


Matériel nécessaire :

👉 à l'ensemble du projet économisez 55% !

1- 2 

Carte microcontrôleur avec câble USB

1

Détecteur de mouvement HC-SR501

1

HC-SR04 Ultrasonic Module

alternative

VL53L0X Capteur de distance laser de temps de vol (ToF)

1

Capteur de température, par exemple Module DHT11

2

NRF24L01 Module sans fil 2.4 GHz et (facultatif) NRF24L01 Adaptateur

1

Ou même Kit de capteur 35 en 1?

1

Prototype Shield Mini Breadboard pour UNO R3

1

LCD1602 Keypad Shield


Assez avec la préface. Passons aux choses sérieuses. Commençons par le détecteur de mouvement HC-SR501 (PIR=Passive InfraRed) : En principe, la connexion est assez simple : alimentation 5V et GND, ligne de signal vers une broche numérique (broche 2 dans le schéma de circuit). L'avantage du HC-SR501 est que le signal n'est que de 3,3 V et peut donc être utilisé sur tous les microcontrôleurs et Raspberry Pis.

Sketch à Télécharger:

 /* 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;
    }
  }
 }

Je tiens à vous mettre en garde contre un petit piège : en raison des différents fabricants, même avec trois broches sur le PIR, il est possible de confondre les connexions. Si nécessaire, les indications sur le dessus se trouvent sous le bouchon.

Le capteur de vibrations, par exemple, marche également sur le même principe :

et le capteur de vibrations/chocs :

Ainsi, pour détecter des bruits de pas ou d'autres vibrations, vous pouvez remplacer le capteur infrarouge passif par ces capteurs, ou les ajouter au sketch.

Capteur de distance

J'ai présenté les deux capteurs de distance possibles dans le blog d'Halloween. Le capteur de distance à ultrasons HC-SR04 mesure des distances allant jusqu'à 3m, le capteur de distance laser à temps de vol (ToF) VL53L0X mesure jusqu'à 4m. Si la distance mesurée change, cela signifie que quelqu'un se trouve dans la plage de mesure.

Pour le HC-SR04, voici le sketch adapté sans incorporer une bibliothèque téléchargeable

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);
 }

Si la distance varie de plus de 10 cm, l'alarme se déclenche. Après le déclenchement de l'alarme, une alarme de test est activée et la valeur de comparaison est déterminée en même temps.

La connexion est faite à VCC=5V et GND ainsi qu'à deux broches numériques (ici D2 et D3). La broche de déclenchement a absolument besoin de 5V, malheureusement 3.3V n'est pas suffisant. Et la broche écho fournit également 5V, ce qui est trop pour le Raspberry Pi et certains micro-contrôleurs. Par conséquent, nous remédions à la situation avec un transistor NPN ou un diviseur de tension pour les cas où les broches numériques ne fournissent ou ne tolèrent que 3,3V.

Capteur de température

Lorsque le Père Noël arrive tout droit du pôle Nord, il est certain qu'il apporte de l'air froid dans notre maison. Habituellement, la température dans le salon se situe entre 12 et 28°C. Si la température mesurée est plus froide, quelqu'un est entré depuis l'extérieur. Et s'il fait plus de 28°C, ce ne sont pas seulement les bougies qui brûlent. Donc dans les deux cas, attention, quelque chose ne va pas ici.

La gamme des capteurs de température est large. Je décide d'utiliser le DHT11 comme exemple, où la résistance pull-up requise est déjà présente sur la carte de sortie. Donc VCC à 5V, GND à GND et la ligne de signal à une broche numérique, dans l'exemple la broche 7.

Voici l'exemple de sketch à télécharger:

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

Comme alternative au DHT11, le DHT22 peut également être utilisé :

Vous pouvez lire comment le connecter et programmer le sketch approprié ici.

Une autre possibilité serait un capteur barométrique GY-BME280 :

Vous trouverez également une description détaillée comprenant un sketch et un schéma de circuit dans cet article.

Affichage local des données du capteur

Pour ceux qui ne veulent pas se priver d'un affichage local des données des capteurs et des alarmes, nous recommandons le bouclier dit "clavier LCD" avec une petite modification pour les microcontrôleurs de la conception Uno (c'est-à-dire notre ATmega328 ou la carte microcontrôleur D1 NodeMCU avec ESP8266). Ce blindage comporte un LCD1602 sans l'interface I2C. Au lieu de cela, les broches numériques D4 à D9 de l'écran sont utilisées - ainsi que l'alimentation électrique. Pour cela, la bibliothèque LiquidCrystal.h est installée et incluse dans le sketch. Comme modification, je suggère de souder trois connecteurs femelles (en haut et en bas à droite sur la photo) afin que les broches restantes soient facilement accessibles. 

L'affectation du premier connecteur femelle sous les broches de tension de fonctionnement est habituelle. Les broches analogiques donnent accès aux entrées analogiques A1 à A5.

Rappel : Vous pouvez également utiliser ces broches comme broches numériques D15 à D19 et comme interface I2C (A4 = SDA et A5 = SCL). L'entrée analogique A0 n'est pas disponible car les boutons sont connectés ici via un diviseur de tension. Pour savoir comment cela fonctionne, je vous suggère d'écrire un court sketch qui utilise analogRead(A0) pour lire la broche en un cycle. Si vous appuyez ensuite sur les boutons, vous verrez les valeurs converties de l'ADC. À partir de là, vous pouvez ensuite voir comment interroger les boutons pour réaliser des projets avec eux, ou vous pouvez consulter l'article du blog intitulé Une machine robotique robuste avec télécommande.

Important:

L'exécution des broches numériques sur l'écran (connecteur femelle supérieur) n'est pas intuitive. De droite à gauche, elle donne accès aux broches numériques D0 = RX, D1 = TX, D2 et D3, ainsi qu'à D11 = MOSI, D12 = MISO et D13 = SCK, c'est-à-dire les broches de l'interface SPI qui sont affectées de manière permanente. Les autres broches numériques sont occupées par l'écran comme décrit ci-dessus et ne sont pas accessibles.

Un petit conseil pour le premier démarrage : sur l'image en haut à gauche, vous pouvez voir le potentiomètre bleu pour le contraste. J'ai dû tourner la petite vis à droite plusieurs fois jusqu'à ce que l'écriture devienne visible. Et à peine visible : il y a un petit film de protection sur l'écran.

Ce sont les lignes essentielles pour initialiser l'affichage à télécharger. Ces parties du programme peuvent être intégrées dans les croquis des capteurs.

 /*
 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() {
 
 }

Pour une utilisation avec la carte D1-8266, je vous renvoie à mon blog de novembre 2020.

Nous sommes maintenant en train d'assembler les composants en une structure :

Téléchargez le Sketch avec

  • HC-SR04 à D2 et D3
  • PIR à D15 = A1
  • DHT11 à D16 = A2


Affichage à distance des données du capteur

Mon collègue blogueur Andreas Wolter a étendu le projet et construit un détecteur de Père Noël avec transmission radio :

Étant donné que nous voulons attraper le Père Noël en cachette, nous transférons les données du capteur hors de la pièce où se trouve la cheminée, par exemple dans la chambre des enfants. Nous séparons ensuite le montage et prenons deux microcontrôleurs ATmega328. Sur l'un, nous mettons l'écran d'affichage, sur l'autre un écran de prototypage et nous y connectons les capteurs. Tous deux possèdent un module radio NRF24L01 de 2,4 GHz. De cette façon, nous pouvons transférer des données entre les deux appareils. Pour le premier test, nous utilisons la mini carte enfichable fournie pour connecter les capteurs. Cela ressemble à quelque chose comme ça :

Construction avec deux microcontrôleurs

Pour le capteur PIR, j'ai soudé les branches du fil à un connecteur femelle à trois broches et je l'ai branché là.

Microcontrôleur avec capteurs

Les schémas de câblage et les brochages suivent :

Schéma de commutation Microcontroller avec écran d'affichage

Bouclier d'affichage sur microcontrôleur

NRF24L01 Module radio

GND

GND

3.3V

VCC

D2

CE

D3

CSN

D11

MOSI

D12

MISO

D13

SCK


J'ai changé les numéros de broches des capteurs pour cette configuration :

Microcontrôleur de diagramme de commutation avec capteurs

Microcontrôleur

NRF24L01 Module radio

GND

GND

3.3V

VCC

D9

CE

D10

CSN

D11

MOSI

D12

MISO

D13

SCK


Capteur de température DHT11

D8

S(ignal) / Dat

5V

VCC

GND

GND


Capteur ultrasonique HC-SR04

GND

GND

D6

Trigger 

D7

Echo

5V

VCC


Capteur de mouvement pir

GND

GND

D5

OUT

5V

VCC

Peut-être utilisez-vous un capteur de température DHT11 dans une version différente. Comme vous pouvez le voir sur le schéma du circuit, la broche S peut alors être à l'extérieur. La version qui figure plus haut dans l'article, telle qu'elle a été obtenue dans le magasin AZ, a la broche de données au milieu. Faites donc bien attention à l'étiquetage de la carte d'extension, ou jetez un coup d'œil à la fiche technique.

Le NRF24L01 opère avec une tension de fonctionnement de 3.3V. Si vous utilisez également le module optionnel NRF24L01 breadboard, vous devez l'alimenter en 5V !

Voici les deux sketches

Module émetteur avec capteurs (Téléchargez le 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);
}

Module récepteur avec écran (Télécharger 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;
  }    
 }

Le module transmetteur envoie un code de démarrage après la mise en route, puis les valeurs du capteur sous forme de chaîne avec un deux-points comme séparateur entre les valeurs du capteur. Le temps d'intervalle, c'est-à-dire la fréquence d'envoi des données, est déterminé par l'émetteur. La première distance mesurée par le capteur à ultrasons est stockée comme référence. Il fonctionne plus ou moins comme un étalonnage.

Le récepteur attend le code de démarrage de l'émetteur après la mise sous tension. Vous devez donc d'abord allumer le récepteur, puis positionner l'émetteur et l'allumer (ou le redémarrer).

Dans le récepteur, la chaîne de données du capteur est décomposée et convertie en types de données appropriés. Les fonctions des autres sketches sont adoptées. La température tolérée est comprise entre 12 et 28 degrés Celsius. La distance mesurée ne doit pas être modifiée de plus de 10 cm, et un mouvement à proximité est détecté, visible par un symbole dans l'affichage que j'ai inséré comme un caractère séparé dans le code source. Si une alarme est déclenchée, le contenu de l'écran clignote pendant quelques secondes.

Microcontrôleur avec écran

Si la distance entre l'émetteur et le récepteur est trop importante et qu'une connexion ne peut être établie, vous pouvez modifier cette ligne dans les deux codes source :

 radio.setPALevel(RF24_PA_LOW);

Pour une puissance maximale, changez le paramètre de transfert en RF24_PA_MAX. Cependant, la consommation de courant est plus importante. Il est donc recommandé d'utiliser une source de tension externe.

Pour éviter d'emmêler les câbles sur le module émetteur, vous pouvez souder les capteurs sur l'écran de prototypage. J'ai soudé des connecteurs femelles afin de pouvoir changer les capteurs si l'un d'eux est défectueux.

Sensorshield versé

Sensorshield perdu de dessousCaporshield soudé avec des capteurs

Expéditeur et récepteur

Il semble déjà très compact et vous pouvez même concevoir des boîtiers pour lui. Si vous mettez maintenant l'émetteur avec les capteurs et que vous donnez le récepteur à vos enfants, vous pourrez créer encore plus d'excitation la veille de Noël.

Une autre suggestion est d'étendre la fonction du récepteur et de mettre en jeu les boutons de l'écran.

Amusez-vous bien avec le bricolage et à ce stade, je vous souhaite un joyeux Noël.

Andreas Wolter


Transfert d'alarme dans le WLAN domestique

Pour transmettre les données des capteurs et, si nécessaire, une alarme, vous avez besoin de deux microcontrôleurs compatibles avec le réseau, par exemple des MCU avec ESP 8266 ou ESP32. J'ai décrit comment faire cela dans mon blog "Surveiller l'abri de jardin avec des microcontrôleurs et des capteurs" - Partie 1, Partie 2 et Partie 3.

Dernier point mais non le moindre

On ne peut pas prédire ce qui se passe quand on reçoit le Père Noël en chair et en os. Peut-être qu'il va encore emporter tous les cadeaux ? La meilleure chose à faire est de le gâter avec des friandises. Si vous croyez au battage médiatique, vous pouvez essayer les canettes rouges d'une boisson gazeuse. Mais s'il est aussi vieux que moi - il est censé l'être encore plus - il préférera certainement un verre de sherry ou de porto et une barre de chocolat à la menthe poivrée pour l'accompagner. Il faut aussi prévoir des carottes pour Rudolf et les autres rennes.

Si vous ne croyez pas au Père Noël, vous pouvez également utiliser les capteurs pour créer un système d'alarme contre les visiteurs indésirables.

Pour arduinoProjets pour débutantsCapteurs

Laisser un commentaire

Tous les commentaires sont modérés avant d'être publiés

Messages de blogs recommandés

  1. Installez maintenant ESP32 via l'administrateur de la carte
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA-Over the Air-ESP Programmation par WiFi