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 |
|
|
1 |
|
|
1 |
|
|
alternativamente |
|
|
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 |
|
|
1 |
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(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;
}
}
}
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(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);
}
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
// Digital pin connected to the DHT sensor
// 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");
}
}
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
//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() {
}
Per l'uso con la scheda D1-8266, vi rimando al mio blog del novembre 2020.
Ora stiamo assemblando i componenti in una struttura:
- 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:
Per il sensore PIR, ho saldato le gambe del filo a un connettore femmina a tre poli e l'ho inserito lì.
Seguono schemi di cablaggio e pinout:
|
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:
|
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>
// DHT 11
// 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);
}
Modulo ricevitore con display (Download Sketch)
// 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;
}
}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.
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.
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.
