ESP8266 publica lecturas DHT22 en Raspberry Pi usando MQTT

Si eres un entusiasta de la tecnología y te apasiona trabajar con dispositivos como el ESP8266 y la Raspberry Pi, este artículo es para ti. En esta ocasión, te enseñaremos cómo publicar lecturas de un sensor DHT22 en tu Raspberry Pi utilizando MQTT. ¡Sigue leyendo para descubrir cómo llevar a cabo esta emocionante integración de tecnologías!

En este proyecto, utilizará una Raspberry Pi para crear un servidor web independiente que muestre valores de temperatura y humedad mediante un sensor DHT22. También puedes controlar dos salidas de un ESP8266 usando el protocolo MQTT.

Para crear el servidor web, utiliza un microframework de Python llamado Flask. Aquí está la descripción general del sistema:

Primero, mire el vídeo de demostración.

Recursos recomendados:

• Usted necesita uno placa frambuesa pi – leer Los mejores kits de inicio de Raspberry Pi
• Raspberry Pi publica mensajes MQTT en ESP8266
• Servidor web Raspberry Pi con Flask para controlar GPIO
• Prueba de Mosquitto Broker y Client en Raspbbery Pi
• Cómo instalar Mosquitto Broker en Raspberry Pi
• ¿Qué es MQTT y cómo funciona?
• Comenzando con Node-RED en Raspberry Pi

Si estás interesado en la domótica y quieres montar un sistema domótico completo, te recomiendo descargar mi curso de domótica.

Configuración básica de la Raspberry Pi

Antes de continuar leyendo este proyecto, asegúrese de que el sistema operativo Raspbian esté instalado en su Raspberry Pi.

lee el mio Guía de introducción a Raspberry Pi para instalar Raspbian y completar la configuración básica.

Ejecutando e instalando el broker Mosquitto

La Raspberry Pi interactuará con el ESP8266 a través del protocolo MQTT. Si el broker Mosquitto está instalado, debe ejecutarse en segundo plano:

pi@raspberry:~ $ mosquitto -d

Instalar matraz

Usamos un microframework de Python llamado Botella para convertir la Raspberry Pi en un servidor web.

Para instalar Flask, se debe instalar Pip. Ejecute los siguientes comandos para actualizar su Pi e instalar Pip:

pi@raspberrypi ~ $ sudo apt-get update
pi@raspberrypi ~ $ sudo apt-get upgrade
pi@raspberrypi ~ $ sudo apt-get install python-pip python-flask git-core

Luego use pip para instalar Flask y Paho MQTT:

pi@raspberrypi ~ $ sudo pip install flask
pi@raspberrypi ~ $ sudo pip install paho-mqtt

Instalación de SocketIO

Este proyecto utiliza SocketIO, que le permite crear una página web de Python Flask que su aplicación Python Flask puede actualizar de forma asincrónica. Esto significa que no necesita actualizar la página web para ver las métricas más recientes, se actualizan instantáneamente. Instalas el Enchufe de botellaIO Paquete de Python.

pi@raspberrypi ~ $ sudo pip install flask-socketio

Creando el script Python

Este es el script principal de nuestra aplicación. Configura el servidor web y envía un mensaje MQTT al ESP8266 cuando se presionan estos botones. También está registrado en los temas MQTT de temperatura y humedad para obtener las lecturas.

Para realizar un seguimiento, primero cree una nueva carpeta:

pi@raspberrypi ~ $ mkdir web-server
pi@raspberrypi ~ $ cd web-server
pi@raspberrypi:~/web-server $

Crea un nuevo archivo llamado aplicación.py.

pi@raspberrypi:~/web-server $ nano app.py

Copie y pegue el siguiente script en su Raspberry Pi

#
# Created by Rui Santos
# Complete project details: https://randomnerdtutorials.com
#

import paho.mqtt.client as mqtt
from flask import Flask, render_template, request
from flask_socketio import SocketIO, emit

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)

# The callback for when the client receives a CONNACK response from the server.
def on_connect(client, userdata, flags, rc):
    print("Connected with result code "+str(rc))

    # Subscribing in on_connect() means that if we lose the connection and
    # reconnect then subscriptions will be renewed.
    client.subscribe("/esp8266/temperature")
    client.subscribe("/esp8266/humidity")

# The callback for when a PUBLISH message is received from the ESP8266.
def on_message(client, userdata, message):
    #socketio.emit('my variable')
    print("Received message '" + str(message.payload) + "' on topic '"
        + message.topic + "' with QoS " + str(message.qos))
    if message.topic == "/esp8266/temperature":
        print("temperature update")
	socketio.emit('dht_temperature', {'data': message.payload})
    if message.topic == "/esp8266/humidity":
        print("humidity update")
	socketio.emit('dht_humidity', {'data': message.payload})

mqttc=mqtt.Client()
mqttc.on_connect = on_connect
mqttc.on_message = on_message
mqttc.connect("localhost",1883,60)
mqttc.loop_start()

# Create a dictionary called pins to store the pin number, name, and pin state:
pins = {
   4 : {'name' : 'GPIO 4', 'board' : 'esp8266', 'topic' : 'esp8266/4', 'state' : 'False'},
   5 : {'name' : 'GPIO 5', 'board' : 'esp8266', 'topic' : 'esp8266/5', 'state' : 'False'}
   }

# Put the pin dictionary into the template data dictionary:
templateData = {
   'pins' : pins
   }

@app.route("/")
def main():
   # Pass the template data into the template main.html and return it to the user
   return render_template('main.html', async_mode=socketio.async_mode, **templateData)

# The function below is executed when someone requests a URL with the pin number and action in it:
@app.route("/<board>/<changePin>/<action>")
def action(board, changePin, action):
   # Convert the pin from the URL into an integer:
   changePin = int(changePin)
   # Get the device name for the pin being changed:
   devicePin = pins[changePin]['name']
   # If the action part of the URL is "1" execute the code indented below:
   if action == "1" and board == 'esp8266':
      mqttc.publish(pins[changePin]['topic'],"1")
      pins[changePin]['state'] = 'True'
   if action == "0" and board == 'esp8266':
      mqttc.publish(pins[changePin]['topic'],"0")
      pins[changePin]['state'] = 'False'
   # Along with the pin dictionary, put the message into the template data dictionary:
   templateData = {
      'pins' : pins
   }
   return render_template('main.html', **templateData)

@socketio.on('my event')
def handle_my_custom_event(json):
    print('received json data here: ' + str(json))

if __name__ == "__main__":
   socketio.run(app, host="0.0.0.0", port=8181, debug=True)

Ver código sin formato

Creando el archivo HTML

pi@raspberrypi:~/web-server $ mkdir templates
pi@raspberrypi:~/web-server $ cd templates
pi@raspberrypi:~/web-server/templates $

pi@raspberrypi:~/web-server/templates $ nano main.html

<!DOCTYPE html>
<head>
   <title>RPi Web Server</title>
   <!-- Latest compiled and minified CSS -->
   <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
   <!-- Optional theme -->
   <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap-theme.min.css" integrity="sha384-fLW2N01lMqjakBkx3l/M9EahuwpSfeNvV63J5ezn3uZzapT0u7EYsXMjQV+0En5r" crossorigin="anonymous">
   <!-- Latest compiled and minified JavaScript -->
   <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>
   <script src="https://code.jquery.com/jquery-3.1.1.min.js" integrity="sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8=" crossorigin="anonymous"></script>
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/1.3.6/socket.io.min.js"></script>
   <script type="text/javascript" charset="utf-8">
      $(document).ready(function() {
      	var socket = io.connect('http://' + document.domain + ':' + location.port);
      	socket.on('connect', function() {
          socket.emit('my event', {data: 'I'm connected!'});
      	});
      	socket.on('dht_temperature', function(msg) {
	  var nDate = new Date();
          $('#readingsUpdated').text(nDate.getHours() + 'h:' + nDate.getMinutes() +
             'm:' + nDate.getSeconds() + 's').html();
          $('#temperature').text(msg.data).html();
      	});
      	socket.on('dht_humidity', function(msg) {
          $('#humidity').text(msg.data).html();
      	});
      });
   </script>
</head>

<body>
   <h1>RPi Web Server - ESP8266 MQTT</h1>
   {% for pin in pins %}
   <h2>{{ pins[pin].name }}
   {% if pins[pin].state == 'True' %}
      is currently <strong>on</strong></h2><div class="row"><div class="col-md-2">
      <a href="/esp8266/{{pin}}/0" class="btn btn-block btn-lg btn-default" role="button">Turn off</a></div></div>
   {% else %}
      is currently <strong>off</strong></h2><div class="row"><div class="col-md-2">
      <a href="/esp8266/{{pin}}/1" class="btn btn-block btn-lg btn-primary" role="button">Turn on</a></div></div>
   {% endif %}
   {% endfor %}
   <h3>DHT Readings (updated <span id="readingsUpdated"></span>)</h3>
   <h3>Temperature: <span id="temperature"></span>ºC</h3>
   <h3>Humidity: <span id="humidity"></span>%</h3>
</body>
</html>

/*****
 
 All the resources for this project:
 
Home

 
*****/

// Loading the ESP8266WiFi library and the PubSubClient library
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include "DHT.h"

// Uncomment one of the lines bellow for whatever DHT sensor type you're using!
//#define DHTTYPE DHT11   // DHT 11
//#define DHTTYPE DHT21   // DHT 21 (AM2301)
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321

// Change the credentials below, so your ESP8266 connects to your router
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

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

// Initializes the espClient
WiFiClient espClient;
PubSubClient client(espClient);

// Connect an LED to each GPIO of your ESP8266
const int ledGPIO5 = 5;
const int ledGPIO4 = 4;

// DHT Sensor
const int DHTPin = 14;

// Initialize DHT sensor.
DHT dht(DHTPin, DHTTYPE);

// Timers auxiliar variables
long now = millis();
long lastMeasure = 0;

// Don't change the function below. This functions 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 home/office/esp1/gpio2, you check if the message is either 1 or 0. Turns the ESP GPIO according to the message
  if(topic=="esp8266/4"){
      Serial.print("Changing GPIO 4 to ");
      if(messageTemp == "1"){
        digitalWrite(ledGPIO4, HIGH);
        Serial.print("On");
      }
      else if(messageTemp == "0"){
        digitalWrite(ledGPIO4, LOW);
        Serial.print("Off");
      }
  }
  if(topic=="esp8266/5"){
      Serial.print("Changing GPIO 5 to ");
      if(messageTemp == "1"){
        digitalWrite(ledGPIO5, HIGH);
        Serial.print("On");
      }
      else if(messageTemp == "0"){
        digitalWrite(ledGPIO5, LOW);
        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...");
    // Attempt to connect
     /*
     YOU  NEED TO CHANGE THIS NEXT LINE, IF YOU'RE HAVING PROBLEMS WITH MQTT MULTIPLE CONNECTIONS
     To change the ESP device ID, you will have to give a unique name to the ESP8266.
     Here's how it looks like now:
       if (client.connect("ESP8266Client")) {
     If you want more devices connected to the MQTT broker, you can do it like this:
       if (client.connect("ESPOffice")) {
     Then, for the other ESP:
       if (client.connect("ESPGarage")) {
      That should solve your MQTT multiple connections problem

     THE SECTION IN loop() function should match your device name
    */
    if (client.connect("ESP8266Client")) {
      Serial.println("connected");  
      // Subscribe or resubscribe to a topic
      // You can subscribe to more topics (to control more LEDs in this example)
      client.subscribe("esp8266/4");
      client.subscribe("esp8266/5");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

// The setup function sets your ESP GPIOs to Outputs, starts the serial communication at a baud rate of 115200
// Sets your mqtt broker and sets the callback function
// The callback function is what receives messages and actually controls the LEDs
void setup() {
  dht.begin();
  pinMode(ledGPIO4, OUTPUT);
  pinMode(ledGPIO5, OUTPUT);
  
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

// For this project, you don't need to change anything in the loop function. 
// Basically it ensures that you ESP is connected to your broker
void loop() {
  if (!client.connected()) {
    reconnect();
  }
  if(!client.loop())
     /*
     YOU  NEED TO CHANGE THIS NEXT LINE, IF YOU'RE HAVING PROBLEMS WITH MQTT MULTIPLE CONNECTIONS
     To change the ESP device ID, you will have to give a unique name to the ESP8266.
     Here's how it looks like now:
       client.connect("ESP8266Client");
     If you want more devices connected to the MQTT broker, you can do it like this:
       client.connect("ESPOffice");
     Then, for the other ESP:
       client.connect("ESPGarage");
      That should solve your MQTT multiple connections problem

     THE SECTION IN recionnect() function should match your device name
    */
    client.connect("ESP8266Client");
    
  now = millis();
  // Publishes new temperature and humidity every 10 seconds
  if (now - lastMeasure > 10000) {
    lastMeasure = now;
    // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
    float h = dht.readHumidity();
    // Read temperature as Celsius (the default)
    float t = dht.readTemperature();
    // Read temperature as Fahrenheit (isFahrenheit = true)
    float f = dht.readTemperature(true);

    // Check if any reads failed and exit early (to try again).
    if (isnan(h) || isnan
      Serial.println("Failed to read from DHT sensor!");
      return;
    }

    // Computes temperature values in Celsius
    float hic = dht.computeHeatIndex(t, h, false);
    static char temperatureTemp[7];
    dtostrf(hic, 6, 2, temperatureTemp);
    
    // Uncomment to compute temperature values in Fahrenheit 
    // float hif = dht.computeHeatIndex(f, h);
    // static char temperatureTemp[7];
    // dtostrf(hic, 6, 2, temperatureTemp);
    
    static char humidityTemp[7];
    dtostrf(h, 6, 2, humidityTemp);

    // Publishes Temperature and Humidity values
    client.publish("/esp8266/temperature", temperatureTemp);
    client.publish("/esp8266/humidity", humidityTemp);
    
    Serial.print("Humidity: ");
    Serial.print(h);
    Serial.print(" %t Temperature: ");
    Serial.print
    Serial.print(" *C ");
    Serial.print(f);
    Serial.print(" *Ft Heat index: ");
    Serial.print(hic);
    Serial.println(" *C ");
    // Serial.print(hif);
    // Serial.println(" *F");
  }
}

Esquema

Para completar este proyecto necesitará los siguientes componentes:

• 1 ESP8266 12E. – leer Las mejores placas de desarrollo Wi-Fi ESP8266
• 1x sensor DHT22
• 1x resistencia de 4700 ohmios
• 2x resistencias de 470 ohmios
• 2x LED

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

Nota: Otros tipos de sensores DHT también funcionan con un pequeño cambio en el código.

Aquí están los esquemas:

pi@raspberrypi:~/web-server/templates $ cd ..

pi@raspberrypi:~/web-server $ sudo python app.py

ESP8266 publica lecturas DHT22 en Raspberry Pi usando MQTT

Introducción

En este proyecto crearás un servidor web autónomo con una Raspberry Pi que muestra lecturas de temperatura y humedad con un sensor DHT22. También podrás controlar dos salidas desde un ESP8266 utilizando el protocolo MQTT.

¿Qué necesitas?

• Raspberry Pi – consulta los mejores Kits de Inicio de Raspberry Pi
• Raspberry Pi publicando mensajes MQTT al ESP8266
• Servidor web de Raspberry Pi usando Flask para controlar GPIOs
• Pruebas de Mosquitto Broker y Cliente en Raspberry Pi
• Cómo instalar Mosquitto Broker en Raspberry Pi
• ¿Qué es MQTT y cómo funciona?
• Primeros pasos con Node-RED en Raspberry Pi

Configuración básica de Raspberry Pi

Antes de continuar con este proyecto, asegúrate de tener instalado el sistema operativo Raspbian en tu Raspberry Pi. Puedes seguir la Guía de Inicio con Raspberry Pi para instalar Raspbian y completar la configuración básica.

Instalación de Mosquitto Broker

El broker Mosquitto permitirá que la Raspberry Pi interactúe con el ESP8266 mediante el protocolo MQTT. Asegúrate de tener Mosquitto broker ejecutándose en segundo plano con el siguiente comando:

pi@raspberry:~ $ mosquitto -d

Instalación de Flask

Vamos a utilizar Flask, un microframework de Python, para convertir la Raspberry Pi en un servidor web. Sigue los siguientes pasos para instalar Flask y Paho MQTT:

pi@raspberrypi ~ $ sudo apt-get update

pi@raspberrypi ~ $ sudo apt-get upgrade

pi@raspberrypi ~ $ sudo apt-get install python-pip python-flask git-core

pi@raspberrypi ~ $ sudo pip install flask

pi@raspberrypi ~ $ sudo pip install paho-mqtt

Instalación de SocketIO

Para crear una página web dinámica en Python Flask que puede actualizarse de forma asincrónica, utilizaremos Flask SocketIO. Instala el paquete Flask SocketIO con el siguiente comando:

pi@raspberrypi ~ $ sudo pip install flask-socketio

Creación del Script Python

Este es el script principal de nuestra aplicación. Establece el servidor web y, al presionar los botones, publica un mensaje MQTT al ESP8266. Además, está suscrito a los temas de temperatura y humedad MQTT para recibir las lecturas.

A continuación, se muestra el script Python:

        
            // Aquí va el código Python
        
    

Creación del Archivo HTML

Para mantener los tags HTML separados de tu script Python, utiliza una plantilla HTML. Crea un nuevo archivo HTML llamado main.html con el siguiente contenido:

        
            // Aquí va el código HTML
        
    

Programación del ESP8266

Para que el ESP8266 interactúe con el servidor web de Raspberry Pi, debes instalar la librería PubSubClient. Esta librería proporciona un cliente para enviar y recibir mensajes MQTT con un servidor que soporta MQTT.

Esquemáticos

Para completar este proyecto necesitas los componentes mencionados como el ESP8266, el sensor DHT22, resistencias, LEDs, entre otros. Aquí tienes un esquemático con la configuración necesaria:

Puesta en marcha del Servidor Web

Para iniciar tu servidor web en Raspberry Pi, muévete a la carpeta que contiene el archivo app.py y ejecuta el siguiente comando:

pi@raspberrypi:~/web-server $ sudo python app.py

Conclusión

En el siguiente artículo, publicaremos lecturas de sensores con el ESP8266 en el servidor web de Python y las almacenaremos en una base de datos SQLite. ¡Si te gusta la domótica, te invito a que aprendas más con mi curso de Automatización del Hogar por $100!

¿Tienes alguna pregunta? ¡Deja un comentario abajo! ¡Gracias por leer!