Raspberry Pi publica mensajes MQTT en ESP8266

¡Descubre cómo el Raspberry Pi puede publicar mensajes MQTT en ESP8266! En este artículo, exploraremos cómo puedes utilizar estas dos potentes herramientas para crear una red de comunicación eficiente y versátil. Sigue leyendo para aprender más sobre cómo hacerlo y las múltiples aplicaciones que esta combinación puede tener en tus proyectos de Internet de las Cosas. ¡No te lo pierdas!

En este proyecto, creará un servidor web independiente con una Raspberry Pi que puede alternar dos LED desde un ESP8266 usando el protocolo MQTT. Puede reemplazar estos LED con cualquier salida (como un relé que controla una lámpara).

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
• 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

Servidor web Python con Flask

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

Luego use pip para instalar Flask y sus dependencias:

pi@raspberrypi ~ $ sudo pip install flask

Instalación de Python Paho-MQTT

El OPS MQTT El paquete proporciona una clase de cliente que permite que las aplicaciones se conecten a un intermediario MQTT para publicar mensajes, suscribirse a temas y recibir mensajes publicados. En este ejemplo, el servidor web Python publicará mensajes en el ESP8266 para activar y desactivar los GPIO.

Para instalar paho-mqtt, ejecute el siguiente comando:

pi@raspberrypi ~ $ sudo pip install paho-mqtt

Creando el script Python

Este es el script principal de nuestra aplicación. Configura el servidor web y publica un mensaje MQTT en el ESP8266 cuando se presionan estos botones.

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
app = Flask(__name__)

mqttc=mqtt.Client()
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', **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 "on," 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)

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

Ver código sin formato

Creando el archivo HTML

Al separar las etiquetas HTML de su secuencia de comandos Python, mantiene su proyecto organizado.

Flask utiliza un motor de plantillas llamado Jinja2 que le permite enviar datos dinámicos desde su secuencia de comandos Python a su archivo HTML.

Cree una nueva carpeta llamada «Plantillas»:

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

Crea un nuevo archivo llamado archivo principal.html.

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

Copie y pegue la siguiente plantilla en su Pi:

<!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>
   <meta name="viewport" content="width=device-width, initial-scale=1">
</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 %}
</body>
</html>

Ver código sin formato

Programando el ESP8266

Para que el ESP8266 interactúe con el servidor web Raspberry Pi, debe instalar Biblioteca PubSubClient. Esta 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 un servidor web Python).

Se ha subido el boceto.

Finalmente, puede cargar el boceto completo en su ESP8266 (reemplácelo con su SSID, contraseña y dirección IP de RPi):

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

 
*****/

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

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

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

Ver código sin formato

Esquema

Los esquemas de este proyecto son muy simples. Solo conecta dos LED con dos Resistencias a su ESP8266 como se muestra en la siguiente figura.

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

Iniciando el servidor web

Para iniciar su servidor web Raspberry Pi, vaya a la carpeta que contiene el archivo aplicación.py:

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

Luego ejecute el siguiente comando:

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

¡Su servidor web debería iniciarse inmediatamente en el puerto: 8181!

demostración

Abra su dirección de Raspberry Pi en su navegador ingresando la dirección IP, en mi caso: http://192.168.1.98:8181

Nota: Debe ingresar su dirección IP seguida de :8181

Aquí hay una demostración en video del servidor web en acción:

Envolver

En la próxima publicación del blog publicaremos los valores de los sensores con ESP8266 en el servidor web Python.

¿Te gusta la domótica? Obtenga más información sobre Node-RED, Raspberry Pi, ESP8266 y Arduino con mi curso: Construya un sistema de automatización del hogar por 0.

¿Tiene usted alguna pregunta? ¡Deja un comentario a continuación!

Gracias por leer. Si te gusta esta publicación, probablemente también te gustarán las siguientes. Así que por favor apóyame suscribiéndote a mi blog.

<!DOCTYPE html>

Publicar mensajes MQTT con Raspberry Pi en ESP8266

Visión general del proyecto

En este proyecto, crearás un servidor web independiente con una Raspberry Pi que puede alternar dos LED desde un ESP8266 utilizando el protocolo MQTT. Puedes reemplazar esos LEDs con cualquier salida (como un relé que controle una lámpara).

Recursos recomendados

Para este proyecto, necesitarás una placa Raspberry Pi. Puedes leer acerca de los mejores kits de inicio de Raspberry Pi en el mercado.

Para más información sobre cómo configurar un servidor web en Raspberry Pi utilizando Flask, puedes consultar el tutorial de Raspberry Pi Web Server using Flask to Control GPIOs.

Proceso de 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 Cómo comenzar con Raspberry Pi para instalar Raspbian y completar la configuración básica.

Ejecutar e instalar el broker Mosquitto

La Raspberry Pi interactuará con el ESP8266 utilizando el protocolo MQTT. Es necesario tener instalado el broker Mosquitto y que se esté ejecutando en segundo plano:

        pi@raspberry:~ $ mosquitto -d
    

Configurar el servidor web Python con Flask

Utilizaremos un microframework de Python llamado Flask para convertir la Raspberry Pi en un servidor web.

Para instalar Flask, necesitarás tener pip instalado. Ejecuta los siguientes comandos para actualizar tu 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
    

Luego, usa pip para instalar Flask y sus dependencias:

        pi@raspberrypi ~ $ sudo pip install flask
    

Instalación de Python Paho-MQTT

El paquete Paho-MQTT proporciona una clase de cliente que permite a las aplicaciones conectarse a un broker MQTT para publicar mensajes y suscribirse a temas para recibir mensajes publicados.

Para instalar paho-mqtt, ejecuta el siguiente comando:

        pi@raspberrypi ~ $ sudo pip install paho-mqtt
    

Creación del script Python

Este es el script principal de nuestra aplicación. Configura el servidor web y cuando se presionan estos botones, publica un mensaje MQTT al ESP8266.

Para mantener todo organizado, comienza creando una nueva carpeta:

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

Crea un nuevo archivo llamado app.py.

        pi@raspberrypi ~ $ nano app.py
    

Copia y pega el siguiente script en tu Raspberry Pi:

Creación del archivo HTML

Para mantener separadas las etiquetas HTML de tu script Python, crea una nueva carpeta llamada templates:

        pi@raspberrypi ~ $ mkdir templates
        pi@raspberrypi ~ $ cd templates
    

Crea un nuevo archivo llamado main.html.

        pi@raspberrypi ~ $ nano main.html
    

Copia y pega la siguiente plantilla en tu Pi:

Programación del ESP8266

Para que el ESP8266 interactúe con el servidor web de Raspberry Pi, necesitas instalar la biblioteca PubSubClient.

Sube el nuevo sketch a tu ESP8266 reemplazando con tu SSID, contraseña y dirección IP de la Raspberry Pi:

        /* Add the code snippet for the ESP8266 sketch here */
    

Circuito

El esquemático para este proyecto es muy sencillo. Simplemente conecta dos LEDs con dos resistencias a tu ESP8266 como se muestra en la siguiente figura.

1. LED 1 al GPIO5
2. LED 2 al GPIO4

Inicio del servidor web

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

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

Luego, ejecuta el siguiente comando:

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

¡Tu servidor web debería iniciarse inmediatamente en el puerto :8181!

Demostración

Abre la dirección IP de tu Raspberry Pi en tu navegador ingresando su dirección IP, en mi caso: http://192.168.1.98:8181

Conclusión

En la próxima publicación del blog, publicaremos lecturas de sensores con el ESP8266 en el servidor web Python.

Si te gusta la domótica, aprende más sobre Node-RED, Raspberry Pi, ESP8266 y Arduino con mi curso: Construye un Sistema de Automatización del Hogar por $100.

¿Tienes alguna pregunta? ¡Déjanos un comentario!

Gracias por leer. Si te gustó esta publicación, probablemente también te gustarán las siguientes, así que por favor, apóyame suscribiéndote a mi blog.