ESP8266 publica métricas DHT22 en una base de datos SQLite

En este artículo te mostraremos cómo el ESP8266 puede ser utilizado para publicar métricas del sensor DHT22 en una base de datos SQLite. Esta combinación de tecnologías te permitirá almacenar y visualizar datos de temperatura y humedad de forma sencilla y eficiente. Sigue leyendo para aprender cómo implementar esta solución en tus proyectos de IoT.

En este proyecto, utilizará una Raspberry Pi para crear un servidor web independiente que utiliza un sensor DHT22 para mostrar los valores de temperatura y humedad almacenados en una base de datos SQLite.

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

Recursos recomendados:

• Usted necesita uno placa frambuesa pi – leer Los mejores kits de inicio de Raspberry Pi
• ESP8266 publica lecturas DHT22 en Raspberry Pi usando MQTT
• Raspberry Pi publica mensajes MQTT en ESP8266
• Prueba de Mosquitto Broker y Client en Raspbbery Pi
• Cómo instalar Mosquitto Broker en Raspberry Pi
• ¿Qué es MQTT y cómo funciona?

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:

pi@raspberrypi ~ $ sudo pip install flask

Creando el script Python

Este es el script principal de nuestra aplicación. Configura el servidor web, recibe los valores de temperatura/humedad y almacena estos valores de los sensores en una base de datos SQLite.

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
import json
import sqlite3

app = Flask(__name__)

def dict_factory(cursor, row):
    d = {}
    for idx, col in enumerate(cursor.description):
        d[col[0]] = row[idx]
    return d

# 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/dhtreadings")

# The callback for when a PUBLISH message is received from the ESP8266.
def on_message(client, userdata, message):
    if message.topic == "/esp8266/dhtreadings":
        print("DHT readings update")
        #print(message.payload.json())
        #print(dhtreadings_json['temperature'])
        #print(dhtreadings_json['humidity'])

        dhtreadings_json = json.loads(message.payload)

        # connects to SQLite database. File is named "sensordata.db" without the quotes
        # WARNING: your database file should be in the same directory of the app.py file or have the correct path
        conn=sqlite3.connect('sensordata.db')
        c=conn.cursor()

        c.execute("""INSERT INTO dhtreadings (temperature,
            humidity, currentdate, currentime, device) VALUES((?), (?), date('now'),
            time('now'), (?))""", (dhtreadings_json['temperature'],
            dhtreadings_json['humidity'], 'esp8266') )

        conn.commit()
        conn.close()

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

@app.route("/")
def main():
   # connects to SQLite database. File is named "sensordata.db" without the quotes
   # WARNING: your database file should be in the same directory of the app.py file or have the correct path
   conn=sqlite3.connect('sensordata.db')
   conn.row_factory = dict_factory
   c=conn.cursor()
   c.execute("SELECT * FROM dhtreadings ORDER BY id DESC LIMIT 20")
   readings = c.fetchall()
   #print(readings)
   return render_template('main.html', readings=readings)

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

Ver código sin formato

Preparando su archivo SQLite

Siga el siguiente tutorial para aprender cómo instalar una base de datos SQLite en una Raspberry Pi y preparar la base de datos. Necesita un archivo de base de datos SQLite con el siguiente esquema:

sqlite> .fullschema
CREATE TABLE dhtreadings(id INTEGER PRIMARY KEY AUTOINCREMENT, temperature NUMERIC, humidity NUMERIC, currentdate DATE, currentime TIME, device TEXT);

Su archivo de base de datos SQLite debe llamarse «sensordata.db» sin comillas.

ADVERTENCIA: Su archivo de base de datos debe estar en el mismo directorio que el archivo app.py o tener la ruta correcta en su archivo Python app.py creado en la sección anterior (sección conn=sqlite3.connect('sensordata.db')).

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">
</head>

<body>
   <h1>RPi Web Server - ESP8266 SQLite Data</h1>
   <table class="table table-hover">
     <tr><th>ID</th>
     <th>Temperature</th>
     <th>Humidity</th>
     <th>Date</th>
     <th>Time</th>
     <th>Device</th></tr>
     {% for entry in readings %}
        <tr><td>{{ entry.id }}</td>
        <td>{{ entry.temperature }}</td>
        <td>{{ entry.humidity }}</td>
        <td>{{ entry.currentdate }}</td>
        <td>{{ entry.currentime }}</td>
        <td>{{ entry.device }}</td></tr>
     {% endfor %}
   </table>
</body>
</html>

/*****
 
 All the resources for this project:
 
(dup) Homepage

 
*****/

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

// DHT Sensor
const int DHTPin = 14;

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

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

char data[80];

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

// 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)
    } 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 DHT sensor, 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();
  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 30 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);
    
    String dhtReadings = "{ "temperature": "" + String(temperatureTemp) + "", "humidity" : "" + String(humidityTemp) + ""}";
    dhtReadings.toCharArray(data, (dhtReadings.length() + 1));
    
    // Publishes Temperature and Humidity values
    client.publish("/esp8266/dhtreadings", data);
    Serial.println(data);
    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
• Cables de puente
• tablero de circuitos

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

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

Aquí están los esquemas:

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

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

ESP8266 publica métricas DHT22 en una base de datos SQLite

En este proyecto, crearás un servidor web independiente con una Raspberry Pi que muestra lecturas de temperatura y humedad con un sensor DHT22 que se almacenan en una base de datos SQLite.

Resumen del sistema

Para crear el servidor web, utilizarás un microframework de Python llamado Flask. Aquí tienes una visión general del sistema:

1. Crea un servidor Mosquitto en tu Raspberry Pi para interactuar con el ESP8266 mediante el protocolo MQTT.
2. Instala Flask en tu Raspberry Pi para convertirla en un servidor web.
3. Configura un archivo Python que recibe las lecturas de temperatura/humedad y las guarda en una base de datos SQLite.

Recursos recomendados

Necesitarás una placa Raspberry Pi y otros componentes como el ESP8266 y el sensor DHT22. Aquí tienes algunos recursos recomendados:

• Kits de inicio de Raspberry Pi
• ESP8266 Publishing DHT22 Readings with MQTT to Raspberry Pi
• Raspberry Pi Publishing MQTT Messages to ESP8266
• Testing Mosquitto Broker and Client on Raspbbery Pi
• How to Install Mosquitto Broker on Raspberry Pi

Configuración básica de Raspberry Pi

Antes de continuar con el proyecto, asegúrate de tener el sistema operativo Raspbian instalado en tu Raspberry Pi. Puedes leer mi guía sobre Cómo Empezar con la Raspberry Pi para instalar Raspbian y completar la configuración básica.

Ejecutar e instalar el servidor Mosquitto

La Raspberry Pi interactuará con el ESP8266 mediante el protocolo MQTT. Para ello, es necesario tener el servidor Mosquitto instalado y en funcionamiento en segundo plano.

Instalar Flask

Utilizaremos Flask, un microframework de Python, para convertir la Raspberry Pi en un servidor web. Sigue las instrucciones para instalar Flask en tu Raspberry Pi.

Creación del script Python

El script Python es la parte central de la aplicación. Configura el servidor web, recibe las lecturas de temperatura/humedad y guarda esas lecturas en una base de datos SQLite.

Preparando tu archivo SQLite

Aprende cómo instalar SQLite en una Raspberry Pi y preparar la base de datos. Asegúrate de que tu archivo de la base de datos SQLite tenga el esquema correcto.

Creación del archivo HTML

Flask utiliza un motor de plantillas llamado Jinja2 para enviar datos dinámicos desde el script Python a tu archivo HTML. Crea un archivo HTML separado para mantener organizado tu proyecto.

Programando el ESP8266

Para que el ESP8266 interactúe con el servidor web de Raspberry Pi, necesitas instalar la biblioteca PubSubClient. Sigue las instrucciones para cargar el sketch en tu ESP8266.

Esquemático

Para completar este proyecto, necesitarás los componentes mencionados anteriormente. Aquí tienes el esquemático para ayudarte a conectarlos correctamente.

Lanzamiento del servidor web

Para poner en marcha tu servidor web en Raspberry Pi, muévete a la carpeta que contiene el archivo app.py y ejecuta el comando adecuado. Tu servidor web debería comenzar inmediatamente en el puerto :8181.

Demostración

Abre la dirección IP de tu Raspberry Pi en tu navegador para ver el servidor web en acción. Asegúrate de incluir el puerto :8181 al final de la dirección.

¡Espero que este proyecto te haya ayudado a entender cómo publicar métricas DHT22 en una base de datos SQLite! Si tienes alguna pregunta, ¡deja un comentario!