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

Según Wikipedia: Un sensor, también denominado como un detector, es un componente técnico que puede detectar determinadas propiedades físicas o químicas (físicamente, por ejemplo, la cantidad de calor, la temperatura, la humedad, la presión, las cantidades de campo sonoro, el brillo, la aceleración; o , químicamente, por ejemplo, el valor del pH, la fuerza iónica, el potencial electroquímico) y/o la composición material de su entorno cualitativa o cuantitativamente como una variable medida. Estas variables se registran mediante efectos físicos, químicos o biológicos y se convierten en una señal eléctrica que se puede procesar posteriormente.

Por cierto, los productos del blog del segundo Adviento están disponibles en un paquete con un 55% de descuento. Nadie ha atrapado nunca a Papá Noel a un precio tan bajo 😉

Para nosotros, es importante conocer qué sensores son adecuados para nuestro propósito de atrapar a Papá Noel y de qué forma envían una señal eléctrica. Normalmente, los sensores que envían una señal digital son los más fáciles de detectar. La consulta en el programa se hace entonces como si se comprobara si se ha pulsado un botón. Si el sensor proporciona valores analógicos, tenemos que medir en la entrada analógica e - importante - definir un valor umbral a partir del cual se activa la alarma. Y hay sensores complejos que envían sus datos al microcontrolador a través de una interfaz (por ejemplo, I2C). Es útil incluir las bibliotecas de programas al principio del boceto.


Material requerido:

👉 Al conjunto del proyecto y ahorrar 55%!

1- 2 

Microcontrolador

1

Módulo Sensor de Movimiento HC-SR501

1

Módulo Sensor de Rango HC-SR04

alternativa

Módulo Sensor de Distancia Láser de Tiempo de Vuelo (ToF) VL53L0X

1

Sensor de Temperatura, por ejemplo, Módulo de ruptura DHT11

2

NRF24L01 con Módulo Inalámbrico de 2,4 GHz y opcional Adaptador para NRF24L01

1

O el kit de sensores 35 en 1 ?

1

Shield Creación de Prototipos Mini Breadboard para UNO R3

1

Shield Pantalla con Teclado LCD1602


Suficiente del prefacio, vamos a trabajar. Comenzamos con el Módulo Sensor de Movimiento (PIR = Infrarrojo Pasivo) HC-SR501: Al principio, la conexión es bastante sencilla: Fuente de alimentación de 5V y GND, línea de señal a un pin digital (pin 2 en el diagrama del circuito). Lo óptimo del HC-SR501 es que la señal es sólo de 3,3 V y, por tanto, se puede utilizar en todos los microcontroladores y Raspberry Pis.

Sketch para Descargar:

 / * Probador sensor PIR
  * El circuito:
  * HC-SR501 Conectar a Vcc = 5V, GND, señal de pata a D2
  * USE LED_BUILTIN = D13 * /
 
 En t ledPin = 13;                // Selecciona el PIN para el LED
 En t InputPin = 2;               // elegir la entrada PIN (para el sensor PIR)
 En t pirstate = Bajo;         // empezamos, suponiendo que no hay movimiento detectado
 En t Val = 0;                       // variable para leer el estado del pin
 
 vacío configurar() {
   De serie.Empezar(9600);                 // utilizar Serial Monitor para mensajes
   pinMode(ledPin, PRODUCCIÓN);    // declara salida LED AS
   pinMode(InputPin, Aporte);     // declara SENSOR DE ENTRADA
 }
 
 vacío círculo(){
   Val = digitalRead(InputPin);    // Leer valor de entrada
   SI (Val == ELEVADO) {                    // Comprobar si la entrada es alto
     digitalWrite(ledPin, ELEVADO);   // TURN LED ON
     SI (pirstate == Bajo) {
       // Acabamos Girado
       De serie.println("Movimiento detectado!");
       pirstate = ELEVADO;
    }
  } demás {
     digitalWrite(ledPin, Bajo);  // TURN LED OFF
     SI (pirstate == ELEVADO){
       // acabamos de vuelta
       De serie.println("Movimiento terminó!");
       pirstate = Bajo;
    }
  }
 }

Me gustaría advertir de un pequeño obstáculo: debido a los diversos fabricantes, incluso con tres pines en el PIR, es posible confundir las conexiones. Si es necesario, el etiquetado de la parte superior está debajo de la tapa.

El Sensor de Impacto/Vibración, por ejemplo, también funciona según el mismo principio:

y el Sensor de Vibración/Shake:

Así, para detectar pasos u otras vibraciones, puede sustituir el PIR por estos sensores, o añadirlos al Sketch.

Sensor de Distancia

Presenté los dos posibles sensores de distancia en el Blog de Halloween. El sensor de distancia ultrasónico HC-SR04 mide distancias de hasta 3 m, y el Módulo Sensor de Distancia Láser de Tiempo de Vuelo (ToF) VL53L0X mide hasta 4 m. Si la distancia que se mide cambia, alguien está dentro de la distancia de medición.

Para el HC-SR04, aquí se presenta el sketch para descargar sin incluir una biblioteca:

 const En t trigPin = 2;
 const En t echoPin = 3;
 largo duración;
 En t Distancia1 = 100;
 En t Distance2;
 En t dirigió = LED_BUILTIN;
 
 vacío configurar() {
   pinMode(trigPin, PRODUCCIÓN);
   pinMode(echoPin, Aporte);
   pinMode(dirigió, PRODUCCIÓN);
   De serie.Empezar(9600);
 }
 vacío círculo() {
   digitalWrite(trigPin, Bajo);
   microsegundos de retardo(2);
   digitalWrite(trigPin, ELEVADO);
   microsegundos de retardo(10);
   digitalWrite(trigPin, Bajo);
   duración = pulseIn(echoPin, ELEVADO);
   Distance2 = duración * 0.034 / 2;
   De serie.impresión("Distancia");
   De serie.println(Distance2);
   SI (Sección(Distance2 - Distancia1) >10) {
     digitalWrite(dirigió,ELEVADO);
     De serie.println("¡Alarma!");
     Distancia1 = Distance2;
    }
   demora(1000);
   digitalWrite(dirigió,Bajo);
 }

Si la distancia varía en más de 10 cm, se activa la alarma. Tras la conexión, se activa una alarma de prueba y se determina al mismo tiempo el valor de comparación.

La conexión se realiza a VCC=5V y GND, así como a dos digitales (aquí D2 y D3). El pin de disparo necesita absolutamente 5V, desafortunadamente 3.3V no es suficiente. Y el pin eco también proporciona 5V, que es demasiado para la Raspberry Pi y algunos microcontroladores. Por lo tanto, se remedia la situación con un transistor NPN o un divisor de tensión para los casos en que los pines digitales sólo suministran o toleran 3,3 V.

Sensor de temperatura

Cuando Papá Noel viene directamente desde el Polo Norte, seguro que trae aire frío a nuestra casa. Por lo general, las temperaturas en la sala de estar oscilan entre 12 a 28 °C. Si la temperatura medida es más fría, alguien ha llegado desde el exterior. Y si hace más de 28 °C, no sólo se queman las velas. Así que en ambos casos, cuidado, algo está mal aquí.

La gama de sensores de temperatura es amplia. He decidido utilizar el DHT11 como ejemplo, donde la resistencia de pull-up requerida ya está presente en la placa base. Así que VCC a 5V, GND a GND y la línea de señal a un pin digital, en el ejemplo el pin 7.

Aquí está el sketch de ejemplo para descargar:

 // Ejemplo modificado boceto para sensor de temperatura DHT11 por Ladyada, de dominio público
 // requiere que el Arduino bibliotecas Siguiendo:
 // - Biblioteca del sensor DHT: https://github.com/adafruit/DHT-sensor-library
 // - Adafruit sensor Unificado Lib: https://github.com/adafruit/Adafruit_Sensor
 
 # include "DHT.h"
 #define DHTPIN 7 // pin digital conectado al sensor de DHT
 #define DHTTYPE DHT11 // 11 DHT
 DHT DHT(DHTPIN, DHTTYPE);
 
 vacío configurar() {
   De serie.Empezar(9600);
   De serie.println(F("Prueba de DHT11!"));
   DHT.Empezar();
 }
 
 vacío círculo() {
   // Espera unos segundos entre las mediciones.
   demora(2000);
   // Leer la temperatura como Celsius (por defecto)
   flotador t = DHT.la temperatura de lectura();
   // Comprobar si los hay lecturas fallidas y salida temprana (para volver a intentarlo).
   SI (isnan(t)) {
     De serie.println(F("No se pudo leer desde el sensor DHT!"));
     regreso;
  }
   De serie.impresión(F("Temperatura:"));
   De serie.impresión(t);
   De serie.Imprimir(F("° C"));
   SI (t<12 || t>28)   {
     De serie.Imprimir("Alarma");
  }
 }

Como alternativa al DHT11 también puede utilizar el DHT22:

Puede revisar como conectarlo y programar el sketch correcto aquí.

Otra posibilidad sería utilizar un Sensor barométrico GY-BME280:

Además, encontrará una descripción detallada con el sketch y el diagrama de circuito en esta publicación.

Visualización local de los datos de los sensores

Para aquellos que no quieren prescindir de la visualización local de los datos del sensor y la alarma, recomendamos el denominado Shield con Teclado LCD con una pequeña modificación para los microcontroladores en el diseño del UNO (es decir, nuestra Placa de microcontrolador ATmega328 o D1 Placa NodeMCU ESP8266). Este Shield está equipado con un LCD1602 sin la interfaz I2C. En su lugar, además de la fuente de alimentación, se utilizan los pines digitales D4 a D9 de la pantalla. Para ello, se instala la biblioteca Liquidcrystal.h y se incluye en el boceto. Como modificación, propongo soldar tres conectores hambre (arriba y abajo a la derecha en la imagen) para que el resto de los pines sean fácilmente accesibles.

La asignación del primer conector hembra debajo de los pines de voltaje de funcionamiento es la habitual. Los pines analógicos dan acceso a las entradas analógicas A1 a A5.

Recuerda: También puede utilizar estos pines digitales D15 a D19 y como interfaz I2C (A4 = SDA y A5 = SCL). La entrada analógica A0 no está disponible porque los botones están conectados aquí a través de un divisor de voltaje. Para saber cómo funciona, le recomiendo que escriba un pequeño sketch que utilice analogRead(A0) para leer el pin en un bucle. Si a continuación pulsa los botones, verá los valores convertidos del ADC. A partir de ahí puede deducir cómo consultar los pulsadores para realizar proyectos con ellos o puede echar un vistazo a la publicación del blog Un coche robot con función de control remoto.

Importante:

Los pines digitales ejecutados en el Shield (conector hembra superior) no son intuitivos. Si se observa de derecha a izquierda, esto da acceso a los pines digitales: D0 = RX, D1 = TX, D2 y D3, y D11 = MOSI, D12 = MISO y D13 = SCK, es decir, los pines asignados permanentemente de la interfaz SPI. Los otros pines digitales están ocupados por la pantalla como se ha descrito anteriormente y no son accesibles.

Un pequeño consejo para la primera puesta en marcha: en la imagen de arriba a la izquierda, se puede ver el potenciómetro azul para el contraste. Tuve que girar el tornillo pequeño hacia la derecha muchas veces hasta que la fuente se hiciera visible. Y apenas visible: hay una pequeña película protectora sobre la pantalla.

A continuación, las líneas esenciales para la inicialización de la pantalla para descargar. Estas partes del programa se pueden integrar en los sketches de los sensores.

 /*
 Lcd-keypad-shield
 */
 
 // la pantalla LCD no tiene adaptador I2C
 // Los datos se transmiten a través de los pines D4 a D7
 #include
 // Pin LCD a Arduino
 constante En t pin_en = 9;
 constante En t pin_rs = 8;
 constante En t pin_d4 = 4;
 constante En t pin_d5 = 5;
 constante En t pin_d6 = 6;
 constante En t pin_d7 = 7;  
 Cristal liquido LCD( pin_rs,  pin_en,  pin_d4,  pin_d5,  pin_d6,  pin_d7);
 
 
 vacío configurar() {
 // Inicialización de la pantalla LCD incorporada
   LCD.Empezar(16, 2);       // LCD1602 con 16 caracteres y 2 líneas
   LCD.setcursor(0,0);     // El conteo comienza en cero, primer signo, luego línea
   LCD.impresión("Az-Delivery.com" ");
   LCD.setcursor(0,1);     // 0 = primer signo, 1 = segunda línea
   LCD.impresión("Navidad 2021");
  }
 
 vacío círculo() {
 
 }

Para el uso me remito a mi blog de noviembre de 2020, el D1-8266-Tablero .

Ahora juntamos los componentes para formar una estructura:

Descargar el sketch con:

  • HC-SR04 en D2 y D3
  • PIR en D15 = A1
  • DHT11 en D16 = A2


Visualización remota de los datos de los sensores

Mi colega bloguero Andreas Wolter ha ampliado el proyecto y ha construido un detector de Papa Noél con transmisión de radio:

Como queremos atrapar a Papá Noel en secreto, transferimos los datos del sensor fuera de la sala de chimenea, por ejemplo, a la habitación de los niños. Por lo tanto, separamos la configuración y tomamos dos microcontroladores ATmega328. En uno de ellos colocamos el Shield de la pantalla, en el otro Shield de prototipado y conectamos allí los sensores. Ambos reciben un módulo de radio NRF24L01 de 2,4 GHz. De esta manera, podemos transferir datos entre ambos dispositivos. Para la primera prueba, utilizamos la miniplaca enchufable adjunta para conectar los sensores. Se parece a esto:

Construcción con dos microcontroladores

Para el sensor PIR, soldé patas de cable a un conector hembra de tres polos y lo enchufé allí.

Microcontrolador con sensores

A continuación, los esquemas y la distribución de los pines:

Diagrama de conmutación de microcontrolador con el protector de pantalla

Pantalla Shield en el microcontrolador

Módulo de radio NRF24L01

GND

GND

3.3V

VCC

D2

CE

D3

CSN

D11

MOSI

D12

MISO

D13

SCK


He cambiado los números de pin de los sensores para esta configuración:

Diagrama de conmutación de microcontrolador con sensores

Microcontrolador

Módulo de radio NRF24L01

GND

GND

3.3V

VCC

D9

CE

D10

CSN

D11

MOSI

D12

MISO

D13

SCK


Sensor de temperatura DHT11

D8

S (ignal) / dat

5V

VCC

GND

GND


Sensor ultrasónico HC-SR04

GND

GND

D6

Trigger

D7

Echo

5v

VCC


Sensor de movimiento PIR

GND

GND

D5

OUT

5V

VCC

Es posible que esté utilizando un sensor de temperatura DHT11 en una versión diferente. Como se puede ver en el diagrama del circuito, el pin S puede estar entonces en el exterior. La versión mostrada en el artículo anterior, tal y como está disponible en la tienda de AZ, tiene el pin de datos en el centro. Por lo tanto, preste mucha atención al etiquetado de la placa base, o eche un vistazo a la hoja de datos.

El NRF24L01 funciona con un voltaje de funcionamiento de 3,3V. Si además utiliza el módulo opcional NRF24L01 de la breadboard, debe suministrarlo con 5V!

A continuación, los dos sketches.

Módulo transmisor con sensores (Descargar el sketch)

 #include 
 #inClude "rf24.h"
 #include "dht.h"
 
 // dht 11
 #define dhtpin 8
 #define dhttype dht11 // dht 11
 
 // hc-sr04
 constante En t trigpin = 6;
 constante En t eco = 7;
 Dht dht(Dhtpin, Dhttype);
 
 // pir
 constante En t pirata = 5;
 
 // RF24 Módulo de radio
 Rf24 radio(9, 10);   // cs, cs
 constante byte Dirección[6] = "Papa Noel";
 Carbonizarse Envalues[15] = {'s', "T ', "a ', "R ', "T ', '\0'};        // startupcode
 En t intervalo = 200;                                          // enviar intervalo
 
 // Temperatura de lectura y devolución
 // DHT11 no emite ninguna comilla,
 // Por lo tanto, la salida se puede acortar a dos dígitos
 En t temperatura() {
   flotador t = dht.Temperatura de lectura();
 
   SI (Isnan(t)) {
     De serie.Imprimir(F("¡Falló en leer del sensor DHT!"));
     regreso -1;
  }
   regreso (En t)t;
 }
 
 // Medición de distancia por HC-SR04 Módulo ultrasónico
 // sin biblioteca
 flotador distancia() {
   no firmado largo duración;
   flotador distancia = 0;
 
   escritura digital(trigpin, Bajo);
   Retrasta de retrasos(2);
   escritura digital(trigpin, ELEVADO);
   Retrasta de retrasos(10);
   escritura digital(trigpin, Bajo);
   duración = legumbres(eco, ELEVADO);
   distancia = duración * 0.034 / 2.0;
   regreso distancia;
 }
 
 vacío configurar() {
   De serie.Empezar(115200);
   SI (!radio.Empezar()) {
     De serie.Imprimir(F("¡Error al leer del sensor RF24!"));
     muecero (1) {}
  }
   // Iniciar DHT11
   dht.Empezar();
 
   // Inicializar los pasadores del sensor
   mono(trigpin, PRODUCCIÓN);
   mono(eco, Aporte);
   mono(pirata, Aporte);
 
   // Inicializar RF24
   radio.OpenWritingPipe(Dirección);
   
   // PALEVEL se puede cambiar para más alto reicher
   // aumenta el consumo de electricidad
   radio.setpalevel(RF24_PA_min);
   radio.deja de escuchar();
 
   // enviar código de inicio
   radio.escribiendo(&Envalues, tamaño de(Envalues));
 }
 
 vacío círculo() {
   // guardar los valores del sensor como una cadena
   pique(Envalues, "%d:%s:%i", temperatura(), Cuerda(distancia()).C_str(), lectura digital(pirata));
   De serie.imprimir(envalues);
 
   // sensorwerte un empanador senderen
   radio.escribir(&envalues, tamaño de(envalues));
 
   // sendaintervall
   demora(intervalo);
 }

Módulo receptor con pantalla (Descargar el sketch)

 #include 
 #inClude "rf24.h"
 #include
 
 // LCD SHIELD PINS
 const En t pin_en = 9;
 const En t pin_rs = 8;
 const En t pin_d4 = 4;
 const En t pin_d5 = 5;
 const En t pin_d6 = 6;
 const En t pin_d7 = 7;
 Cristal liquido LCD( pin_rs, pin_en, pin_d4, pin_d5, pin_d6, pin_d7);
 
 no firmado largo intervalo = 500;
 no firmado largo Currentmillis = 0;
 no firmado largo AnteriorMILLIS = 0;
 no firmado largo tiempo de parpadeo = 4000;
 no firmado largo parpadeo = 0;
 En t Mintemp = 12;
 En t maxtemp = 28;
 flotador iniciador = 0.0;
 flotador maxdista = 10.0;
 boquilla primer minúsculo = cierto;
 boquilla blinkmode = falso;
 boquilla displaytoggle = BAJO;
 
 // eigene zeichen für das bewegungs-símbolo des piror
 
 byte movimiento1[] = {
   B00011,
   B00111,
   B01111,
   B01111,
   B01111,
   B01111,
   B00111,
   B00011
 };
 
 byte movimiento2[] = {
   B00000,
   B10000,
   B10100,
   B10101,
   B10101,
   B10100,
   B10000,
   B00000
 };
 
 byte movimiento3[] = {
   B00000,
   B00001,
   B00101,
   B10101,
   B10101,
   B00101,
   B00001,
   B00000
 };
 
 byte movimiento4[] = {
   B11000,
   B11100,
   B11110,
   B11110,
   B11110,
   B11110,
   B11100,
   B11000
 };
 
 // rf24 funkmodul
 RF24 radio(2, 3); // csn
 const byte Dirección[6] = "PAPA NOEL";
 boquilla transconjunto = falso;
 boquilla empezado = falso;
 carbonizarse código de inicio[6] = "comienzo";          // Programma Startet, Wenn SenderModul Diesen Código Sendet
 carbonizarse recvalas[15] = "";
 carbonizarse *recvaleste = NULO;
 En t temperatura = 0;
 flotador distante = 0.0;
 En t Moviente = 0;
 
 // STARTPROZEDUR MIT AUSGABE AUF DEM Pantalla
 // und verbindungsaufbau zum remitente
 vacío startconnect() {
   LCD.claro();
   LCD.hogar();
   LCD.impresión("Az-Delivery.com" ");
   LCD.setcursor(0,1);
   LCD.impresión("Detector de Santa");
   si (!radio.empezar()) {
     LCD.impresión("El sensor RF24 es");
     LCD.impresión("¡¡no responde!!");
     tiempo (1) {}
  }
   radio.OpenReadingPipe(1, Dirección);
   radio.setpalevel(RF24_PA_LOW);  // RF24_PA_MAX es predeterminado.
   radio.empieza a escuchar();
   demora(2000);
   LCD.claro();
   LCD.hogar();
   LCD.impresión(" esperando");
   LCD.setcursor(0,1);
   LCD.impresión("Transmisor ...");
   tiempo(!transconjunto) {
     si (radio.disponible()) {
       radio.leer(&recvalas, tamaño de(recvalas));
       si (estrampo(recvalas, código de inicio)) {
         transconjunto = cierto;
      }
    }
  }
   LCD.claro();
   LCD.hogar();
   LCD.impresión("Transmisor");
   LCD.setcursor(0,1);
   LCD.impresión("Conectado");
   demora(2000);
   LCD.claro();
   LCD.hogar();
   LCD.impresión("Temp Dist Mover");
   LCD.setcursor(0,1);
 }
 
 // SenderderModul Sendet Einen String,
 // der Zerlegt und en Passende DatentyPen
 // Gewandelt Wird
 // Inhalt: int: flotan: int
 // ':' als delimitador
 // reihenfolge ist Temperatur: DISTANZ: BEWEGUNG
 vacío estimulantes() {
   En t encimera = 0;
   recvaleste = strtok(recvalas, ":");
   tiempo(recvaleste != NULO) {
       cambiar(encimera) {
         caso 0: {
           temperatura = atoi(recvaleste);
           encimera++;
        } rotura;
         caso 1: {
           distante = atacar(recvaleste);
           encimera++;
        } rotura;
         caso 2: {
           Moviente = atoi(recvaleste);
           encimera++;
        } rotura;
         defecto: rotura;
      }
       recvaleste = strtok(NULO, ":");
  }
 }
 
 // AUSGABE DER WERTE AUF DEM LCD
 vacío PrintValues() {
   LCD.setcursor(0,1);
   LCD.impresión("               ");
   LCD.setcursor(0,1);
   LCD.impresión(temperatura);
   LCD.setcursor(2,1);
   LCD.impresión((carbonizarse)223);
   LCD.setcursor(3,1);
   LCD.impresión("C");  
   LCD.setcursor(5,1);
   LCD.impresión(distante);
   si (Moviente) {
     LCD.setcursor(12,1);
     LCD.impresión("   ");
     LCD.setcursor(12,1);
     LCD.escribir(1);
     LCD.setcursor(13,1);
     LCD.escribir(2);
     LCD.setcursor(14,1);
     LCD.escribir(3);
     LCD.setcursor(15,1);
     LCD.escribir(4);
  }
   demás {
     LCD.setcursor(12,1);
     LCD.impresión("   ");
  }
 }
 
 vacío configuración() {
   LCD.empezar(16, 2); // Iniciar LCD
 
   // EIGENE SYMBOLE INILICIONESIEREN
   LCD.createchar(1, movimiento1);
   LCD.createChar(2, movement2);
   lcd.createChar(3, movement3);
   LCD.createChar(4, movement4);
 
   begin // iniciar el procedimiento
   indicada();
 }
 
 vacío círculo() {
   
   // pantalla se actualiza al nuevo
   // se recibieron valores
   // intervalo se determina por el módulo transmisor
   SI (radio.disponible()) {
     radio.leer(&recValues, tamaño de(recValues));
     parseValues();
 
     // medición de la distancia de calibración
     SI (primera apertura) {
       startDist = dist;
       primera apertura = falso;
    }
     los valores de impresión();
  }
   
   Millis actuales = Millis();
   
   // Activación de alarma
   SI ((temperatura < MinTemp || temperatura > MaxTemp || Sección(dist - startDist) > maxdist || Moviente) && !modo intermitente) {
     modo intermitente = cierto;
     parpadear inicio = Millis();
  }
 
   // apagar el parpadeo después del intervalo
   SI (Millis actuales - parpadear inicio >= tiempo de espera intermitente && modo intermitente) {
     modo intermitente = falso;
     LCD.monitor();
  }
 
   // no bloqueo intermitente de la pantalla
   SI (Millis actuales - previousMillis >= intervalo && modo intermitente) {
     displayToggle = !displayToggle;
     SI (displayToggle) {
       LCD.monitor();  
    }
     demás {
       LCD.sin pantalla();
    }
     previousMillis = Millis actuales;
  }    
 }

Tras el encendido, el módulo transmisor envía un código de inicio y luego los valores de los sensores como una cadena con dos puntos como separador entre los valores de los sensores. El intervalo de tiempo, la frecuencia con la que se envían los datos, lo determina el transmisor. La primera distancia medida del sensor ultrasónico se almacena como referencia. Funciona más o menos como una calibración.

Tras el encendido, el receptor espera el código de inicio del transmisor. Por lo tanto, primero debe encender el receptor, a continuación, colocar el transmisor y encenderlo (o reiniciarlo).

En el receptor, la cadena de datos del sensor se descompone y se convierte en tipos de datos apropiados. Las funciones de los otros sketches se han retomado. La temperatura tolerada se sitúa entre los 12 y 28 grados Celsius. La distancia medida no se debe modificar en más de 10 cm y se detecta un movimiento en las proximidades, visible por un símbolo en la pantalla que inserté como carácter independiente en el código fuente. Si se activa una alarma, el contenido de la pantalla parpadea durante unos segundos.

Microcontrolador con pantalla

Si la distancia entre el emisor y el receptor es demasiado grano y no se establece ninguna conexión, puede cambiar esta línea en ambos códigos fuentes:

 radio.setpalevel(RF24_PA_LOW);

Para obtener el máximo rendimiento, cambie los parámetros de transferencia a RF24_PA_MAX. Sin embargo, entonces se consumirá más energía. Se recomienda entonces utilizar una fuente de tensión externa.

Con el fin de evitar que los cables se enreden en el módulo transmisor, puede soldar los sensores en la pantalla de prototipos. He soldado conectores hembra para poder intercambiar los sensores en caso de que uno esté defectuoso.

Sensorshield versado

Sensorshield perdido desde abajoSensorshield suelda con sensores

Emisor y el receptor

Esto ya parece muy compacto y también se pueden diseñar carcasas para ello. Si ahora coloca el transmisor con los sensores y regala el receptor a sus hijos, es posible que genere aun más emoción en Nochebuena.

Como sugerencia adicional, se podría ampliar la función del receptor y poner en juego también los botones del Display Shield.

Diviértase con sus propios proyectos y le deseo una Feliz Navidad.

Andreas Wolter


La transmisión de la alarma en la WLAN del hogar

Para la transmisión de los datos de los sensores y, eventualmente, de una alarma, se necesitan dos microcontroladores compatibles con la red, por ejemplo, los MCU con el ESP 8266 o ESP32. He descrito cómo hacerlo en mi blog "Monitorizar la caseta de jardín con microcontroladores y sensores"- Parte 1, Parte 2 y Parte 3.

Por último, pero no menos importante

¿Qué ocurre cuando atrapa a Papá Noel en persona? Es algo que no se puede predecir. ¿Tal vez se lleve todos los regalos de nuevo? Lo mejor es mimarlo con golosinas. Si cree en la publicdad, puede probar con las latas rojas de un refresco. Sin embargo, si es tan viejo como yo, supuestamente es incluso mayor, seguro que prefiere un vaso de jerez o de oporto y una barra de chocolate con menta para acompañar. Y también hay que tener a mano zanahorias para Rodolfo y los demás renos.

Si no cree en Papá Noel, también puede utilizar los senores para crear un sistema de alarma contra visitas no deseadas.

Für arduinoProjekte für anfängerSensoren

Deja un comentario

Todos los comentarios son moderados antes de ser publicados

Publicaciones de blog recomendadas

  1. Wir bauen eine Smart Home Zentrale mit ArduiTouch
  2. Schrittmotor Steuerung für Antennen Rotor
  3. Arbeiten mit dem Cayenne Dashboard - einfacher Sensor (Teil 1)
  4. Mit dem ESP8266 8 Lampen steuern