Escudo multisensor ESP8266 con Nodo-RED

En el mundo de la tecnología y la automatización del hogar, el uso de escudos multisensor es cada vez más popular. En este artículo, exploraremos la creación de un escudo multisensor utilizando el ESP8266 y Nodo-RED. Descubre cómo esta combinación poderosa puede llevar tus proyectos de IoT al siguiente nivel. ¡Sigue leyendo para conocer todos los detalles!

En este proyecto aprenderá cómo integrar el Escudo Multisensor ESP8266 para la placa Wemos D1 Mini con Node-RED. El ESP8266 Multisensor Shield establece una conexión MQTT con una Raspberry Pi que ejecuta Node-RED y el broker Mosquitto MQTT.

Descripción del proyecto

El escudo multisensor consta de un sensor de temperatura, un sensor de movimiento, un LDR y un enchufe de 3 pines al que se puede conectar cualquier salida, por ejemplo un módulo de relé.

Usamos el broker Mosquitto instalado en la misma Raspberry Pi que ejecuta Node-RED. El corredor es responsable de recibir todos los mensajes, filtrarlos, decidir quién está interesado en ellos y publicarlos para todos los clientes suscritos. Para obtener más información sobre MQTT, consulte: ¿Qué es MQTT y cómo funciona?

La siguiente imagen muestra una descripción general de lo que haremos en este tutorial.

• La aplicación Node-RED publica noticias (“En» o «fuera de«) en tema esp8266/problema. El ESP8266 está suscrito a este tema. Entonces recibe el mensaje con «on» o «off» para activar o desactivar la salida.
• El ESP8266 da la temperatura en el esp8266/temperatura Tema y luminosidad en el esp8266/ldr Tema. La aplicación Node-RED está suscrita a estos temas. Así recibe los valores de temperatura y luminosidad, que se muestran en un gráfico y en una pantalla.
• Node-RED está suscrito al tema esp8266/movimiento. El ESP8266 publica sobre este tema cuando se detecta movimiento. Cuando se detecta movimiento, aparecerá el mensaje «¡MOVIMIENTO DETECTADO!» en el widget de texto del panel de Node-RED durante 10 segundos.

Recomendaciones de literatura: ESP32 MQTT: publicar y suscribirse con Arduino IDE

requisitos

• Diseñar y construir el escudo multisensor para ESP8266
• Deberías estar familiarizado con Raspberry Pi; lee Introducción a Raspberry Pi.
• Debe tener el sistema operativo Raspbian instalado en su Raspberry Pi; lea «Instalar, activar y conectar Raspbian Lite usando SSH».
• Aprenda qué es MQTT y cómo funciona.
• Debes tener los siguientes componentes instalados en tu Raspberry Pi: Node-RED, Node-RED Dashboard y Mosquitto MQTT Broker.

Si estás interesado en la domótica y quieres aprender más sobre Node-RED, Raspberry Pi, ESP8266 y Arduino, te recomendamos descargar nuestro curso: Construye un sistema domótico con Node-RED, ESP8266 y Arduino.

recursos

Todos los recursos que necesita para crear este proyecto se pueden encontrar en los enlaces a continuación (o visite el Proyecto GitHub):

• ESP8266 con MQTT para Node-RED (para Arduino IDE)
• Representación esquemática
• Archivos Gerber
• Proyecto KiCad para editar la placa de circuito.
• Caja de impresora 3D (archivos STL y proyecto SketchUp)
• Haga clic aquí para descargar todos los archivos

Esquema

Puede construir el blindaje multisensor en una placa de circuito impreso o el circuito de blindaje multisensor en una placa de pruebas.

Aquí hay una lista de las piezas que necesitará para construir el circuito:

• ESP8266 WemosD1Mini – leer La mejor placa de desarrollo Wi-Fi ESP8266
• 1 LED de 5 mm
• 1x resistencia de 330 ohmios
• 1x sensor de temperatura DS18B20
• 1x Mini sensor de movimiento PIR
• 1x resistencia dependiente de la luz
• 2x resistencia de 10k ohmios
• 1x módulo de relé
• tablero de circuitos
• Cables de puente

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

Una vez que tenga todas las piezas que necesita, monte el circuito de acuerdo con el siguiente diagrama de circuito:

Así es como se ve el circuito en una placa de pruebas:

Alternativamente, puede construir una PCB para WeMos D1 Mini (aprenda cómo construir un escudo multisensor para ESP8266):

Así es como se ve el circuito cuando se usa el escudo de PCB con una carcasa impresa en 3D:

Preparando el IDE de Arduino

Programamos el ESP8266 con el IDE de Arduino. Para cargar código a su ESP8266 usando el IDE de Arduino, necesita instalar el complemento ESP8266 (Cómo instalar la placa ESP8266 en el IDE de Arduino). También necesita instalar tres bibliotecas adicionales para ejecutar el código en ESP8266.

Instalación de la biblioteca PubSubClient

El PubSubCliente La biblioteca proporciona un cliente para mensajes simples de publicación/suscripción con un servidor que admite MQTT (básicamente permite que su ESP8266 se comunique con Node-RED).

1. Haga clic aquí para descargar la biblioteca PubSubClientdeberías tener uno .Cremallera Carpeta en su carpeta de Descargas
2. Descomprime eso .Cremallera carpeta y deberías recibir maestro pubsubcliente Carpeta
3. Cambie el nombre de su carpeta de maestro pubsubcliente A pubsubcliente
4. mueve eso pubsubcliente Carpeta a su instalación Arduino IDE Bibliotecas Carpeta

Biblioteca OneWire

1. Haga clic aquí para descargar la biblioteca OneWire. Deberías tener una carpeta .zip en tus descargas.
2. Descomprime eso .Cremallera carpeta y deberías recibir Maestro OneWire Carpeta
3. Cambie el nombre de su carpeta de Maestro OneWire A Un cable
4. mueve eso Un cable Carpeta a su instalación Arduino IDE Bibliotecas Carpeta

Biblioteca de temperatura de Dallas

1. Haga clic aquí para descargar la biblioteca DallasTemperature. Deberías tener una carpeta .zip en tus descargas.
2. Descomprime eso .Cremallera carpeta y deberías recibir Maestro de la biblioteca de control de temperatura Arduino Carpeta
3. Cambie el nombre de su carpeta de Maestro de la biblioteca de control de temperatura Arduino A Dallastemperatura
4. mueve eso Dallastemperatura Carpeta a su instalación Arduino IDE Bibliotecas Carpeta
5. Finalmente, vuelva a abrir su IDE de Arduino

Subir código

Copie el siguiente código en el IDE de Arduino. El código está bien comentado y señala dónde es necesario realizar cambios. Debe editar el código con su propio SSID, contraseña y dirección IP del agente MQTT (dirección IP de Raspberry Pi).

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
*********/

// Load libraries
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Replace with your network credentials
const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Change the variable to your Raspberry Pi IP address, so it connects to your MQTT broker
const char* mqtt_server = "REPLACE_WITH_YOUR_MQTT_BROKER";
// MQTT Broker IP example
//const char* mqtt_server = "192.168.1.144";

// Initializes the espClient. You should change the espClient name if you have multiple ESPs running in your home automation system
WiFiClient espClient;
PubSubClient client(espClient);

// Variable to hold the temperature reading
String temperatureString = "";

// Set GPIOs for: output variable, status LED, PIR Motion Sensor, and LDR
const int output = 15;
const int statusLed = 12;
const int motionSensor = 5;
const int ldr = A0;
// Store the current output state
String outputState = "off";

// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;          
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

// Timers - Auxiliary variables
unsigned long now = millis();
unsigned long lastMeasure = 0;
boolean startTimer = false;
unsigned long currentTime = millis();
unsigned long previousTime = 0; 

// Don't change the function below. 
// This function connects your ESP8266 to your router
void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("WiFi connected - ESP IP address: ");
  Serial.println(WiFi.localIP());
}

// This functions is executed when some device publishes a message to a topic that your ESP8266 is subscribed to
// Change the function below to add logic to your program, so when a device publishes a message to a topic that 
// your ESP8266 is subscribed you can actually do something
void callback(String topic, byte* message, unsigned int length) {
  Serial.print("Message arrived on topic: ");
  Serial.print(topic);
  Serial.print(". Message: ");
  String messageTemp;
  
  for (int i = 0; i < length; i++) {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();

  // Feel free to add more if statements to control more GPIOs with MQTT
  // If a message is received on the topic esp8266/output, you check if the message is either on or off. 
  // Turns the output according to the message received
  if(topic=="esp8266/output"){
    Serial.print("Changing output to ");
    if(messageTemp == "on"){
      digitalWrite(output, LOW);
      Serial.print("on");
    }
    else if(messageTemp == "off"){
      digitalWrite(output, HIGH);
      Serial.print("off");
    }
  }
  Serial.println();
}

// This functions reconnects your ESP8266 to your MQTT broker
// Change the function below if you want to subscribe to more topics with your ESP8266 
void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);
    // Attempt to connect
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");  
      // Subscribe or resubscribe to a topic
      // You can subscribe to more topics (to control more outputs)
      client.subscribe("esp8266/output");  
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

// Checks if motion was detected and the sensors are armed. Then, starts a timer.
ICACHE_RAM_ATTR void detectsMovement() {
  Serial.println("MOTION DETECTED!");
  client.publish("esp8266/motion", "MOTION DETECTED!");
  previousTime = millis();
  startTimer = true;
}

void setup() {
  // Start the DS18B20 sensor
  sensors.begin();

  // Serial port for debugging purposes
  Serial.begin(115200);

  // PIR Motion Sensor mode, then set interrupt function and RISING mode
  pinMode(motionSensor, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(motionSensor), detectsMovement, RISING);
  
  // Initialize the output variable and the LED as OUTPUTs
  pinMode(output, OUTPUT);
  pinMode(statusLed, OUTPUT);
  digitalWrite(output, HIGH);
  digitalWrite(statusLed, LOW);
  
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  // Timer variable with current time
  now = millis();

  // Publishes new temperature and LDR readings every 30 seconds
  if (now - lastMeasure > 30000) {
    lastMeasure = now;
    sensors.requestTemperatures(); 
    // Temperature in Celsius degrees
    temperatureString = String(sensors.getTempCByIndex(0));
    // Uncomment the next line for temperature in Fahrenheit degrees
    //temperatureString = String(sensors.getTempFByIndex(0));
    // Publishes Temperature values
    client.publish("esp8266/temperature", temperatureString.c_str());
    Serial.println("Temperature published");
    
    // Publishes LDR values
    client.publish("esp8266/ldr", String(analogRead(ldr)).c_str());
    Serial.println("LDR values published");    
  }
  // After 10 seconds have passed since motion was detected, publishes a "No motion" message
  if ((now - previousTime > 10000) && startTimer) { 
    client.publish("esp8266/motion", "No motion");
    Serial.println("Motion stopped");
    startTimer = false;
  }
}

Ver código sin formato

La explicación de este código es bastante larga, por lo que simplemente puede reemplazar las siguientes tres variables con sus especificaciones y el código funcionará de inmediato.

const char* ssid = "";
const char* password = "";
const char* mqtt_server = "";

Si quieres saber cómo funciona este código, sigue leyendo.

Llamar de vuelta()

En el Llamar de vuelta() Función cuando llega un nuevo mensaje sobre el tema. esp8266/problemacomprobar si el mensaje En o fuera de para activar o desactivar la salida en consecuencia.

if(topic=="esp8266/output"){
  Serial.print("Changing output to ");
  if(messageTemp == "on"){
    digitalWrite(output, LOW);
    Serial.print("on");
  }
  else if(messageTemp == "off"){
    digitalWrite(output, HIGH);
    Serial.print("off");
  }
}

Publicación de lecturas de temperatura y LDR.

Esta sección de código publica nuevos valores de temperatura y LDR cada 30 segundos. Los valores de temperatura se muestran en la esp8266/temperatura Tema. Los valores de luminosidad se publican en el esp8266/ldr Tema.

if (now - lastMeasure > 30000) {
  lastMeasure = now;
  sensors.requestTemperatures(); 
  // Temperature in Celsius degrees
  temperatureString = String(sensors.getTempCByIndex(0));
  // Uncomment the next line for temperature in Fahrenheit degrees
  //temperatureString = String(sensors.getTempFByIndex(0));
  // Publishes Temperature values
  client.publish("esp8266/temperature", temperatureString.c_str());
  Serial.println("Temperature published");

  // Publishes LDR values
  client.publish("esp8266/ldr", String(analogRead(ldr)).c_str());
  Serial.println("LDR values published"); 
}

Nota: La temperatura se publica en grados Celsius, pero puedes comentar la siguiente línea para mostrar la temperatura en grados Fahrenheit:

temperatureString = String(sensors.getTempFByIndex(0));

Detección de movimiento

Cuando detecta movimiento llama detecta movimiento() función, publica el mensaje “¡MOVIMIENTO DETECTADO!” esp8266/movimiento Tema e inicia un cronómetro:

void detectsMovement() {
  Serial.println("MOTION DETECTED!");
  client.publish("esp8266/motion", "MOTION DETECTED!");
  previousTime = millis();
  startTimer = true;
}

Si no se detecta movimiento durante más de 10 segundos, se mostrará un nuevo mensaje esp8266/movimiento con el texto “Sin solicitud”:

 // After 10 seconds have passed since motion was detected, publishes a "No motion" message
if ((now - previousTime > 10000) && startTimer) { 
  client.publish("esp8266/motion", "No motion");
  Serial.println("Motion stopped");
  startTimer = false;
}

Estas son las secciones de código más importantes de las que debe preocuparse. Puedes cambiar los mensajes, suscribirte a más temas para controlar más gastos o publicar otras lecturas de sensores.

Probando la conexión

Sube el código a tu tablero. Después de la carga, y mientras su aplicación Node-RED y su corredor Mosquitto se están ejecutando en la Raspberry Pi, abra el monitor serial Arduino IDE con una velocidad de baudios de 115200 y vea qué sucede en tiempo real.

Esto es útil para comprobar si el ESP8266 se ha conectado correctamente a su enrutador y al corredor Mosquitto.

Creando el flujo Node-RED

Antes de crear el flujo, debes tener instalado lo siguiente en tu Raspberry Pi:

• Nudo-ROJO
• Panel de control del nodo RED
• corredor de mosquitos

Importando el flujo Node-RED

Para importar el flujo Node-RED implementado, vaya a repositorio de GitHub o haga clic en la imagen a continuación para ver el archivo sin formato y copiar el código proporcionado.

A continuación, en la ventana Node-RED, seleccione el menú en la parte superior derecha y vaya a Importar > Portapapeles.

Luego pegue el código proporcionado y haga clic Importar.

Aquí está el flujo importado que controla el ESP8266 y muestra los valores del sensor publicados.

Interfaz de usuario Nodo-RED

Después de realizar todos los cambios necesarios, haga clic en el Insertar Botón para guardar todos los cambios.

Ahora su aplicación Node-RED está lista. Para acceder a la interfaz de Node-RED y ver cómo se ve su aplicación, abra cualquier navegador en su red local y escriba:

http://Your_RPi_IP_address:1880/ui

Su aplicación debería verse como la siguiente imagen.

Cuando se detecta movimiento, se imprime el mensaje «¡MOVIMIENTO DETECTADO!» en el campo «Estado PIR»:

Envolver

Eso es todo por este proyecto. Esperamos que este proyecto te haya resultado útil y que puedas integrar Multisensor Shield con Node-RED en tu propio sistema domótico.

Si te gusta este proyecto, es posible que también te gusten nuestros otros proyectos:

• Curso de domótica con ESP8266
• Construya un escudo multisensor para ESP8266
• Construya un escudo de estación meteorológica ESP32 todo en uno
• Servidor web ESP32 con BME280 – mini estación meteorológica

Gracias por leer.

Proyecto de Integración de Escudo Multisensor ESP8266 con Node-RED

En este proyecto se detalla cómo integrar el Escudo Multisensor ESP8266 con la placa Wemos D1 Mini en Node-RED. El Escudo Multisensor ESP8266 establecerá una conexión MQTT con una Raspberry Pi que ejecuta Node-RED y el broker MQTT Mosquitto.

Visión General del Proyecto

El escudo multisensor consta de un sensor de temperatura, un sensor de movimiento, un LDR y un zócalo de 3 pines donde se puede conectar cualquier salida, como un módulo de relé, por ejemplo.

Se usará el broker Mosquitto instalado en la misma Raspberry Pi que ejecuta Node-RED. El broker es responsable de recibir todos los mensajes, filtrar los mensajes, decidir quién está interesado en ellos y publicar los mensajes a todos los clientes suscritos. Para aprender más sobre MQTT, puedes leer: ¿Qué es MQTT y cómo funciona?.

Preguntas Frecuentes

1. ¿Qué componentes necesito para construir el proyecto?

   Para construir el circuito, necesitas un ESP8266 Wemos D1 Mini, un sensor de temperatura DS18B20, un sensor de movimiento PIR, un LDR, resistencias, un módulo de relé, una placa de pruebas, cables puente, entre otros componentes. Puedes encontrar la lista completa en el diagrama esquemático proporcionado.

2. ¿Cómo programo el ESP8266?

   Para cargar el código en tu placa, necesitas el IDE de Arduino. El código proporcionado en el tutorial está bien comentado para que puedas realizar los cambios necesarios, como configurar tu SSID, contraseña y la dirección IP del broker MQTT.

3. ¿Cómo puedo probar la conexión?

   Después de cargar el código en tu placa, abre el monitor serial del IDE de Arduino a una velocidad de 115200 baudios para verificar una conexión exitosa con tu enrutador y el broker Mosquitto.

4. ¿Cómo creo el flujo en Node-RED?

   Para importar el flujo proporcionado, asegúrate de tener instalado Node-RED, Node-RED Dashboard y el broker Mosquitto en tu Raspberry Pi. Exporta el flujo desde el repositorio GitHub y siga los pasos para importarlo en Node-RED

Esperamos que este proyecto te sea útil y que puedas integrar el Escudo Multisensor en tu propio sistema de domótica utilizando Node-RED. Recuerda consultar nuestros otros proyectos relacionados si te interesa seguir aprendiendo sobre el tema.