ceroUno

cero_uno_E

Sensor de monóxido de carbono MQ-7 + Home Assistant

El monóxido de carbono es un gas altamente venenoso que se propaga rápidamente en el aire del ambiente. Se genera por combustiones deficientes y es imposible percibirlo porque no tiene color, no tiene olor ni sabor y no irrita las mucosas. Una vez inhalado, se combina con la hemoglobina de la sangre a través de los pulmones e impide que el oxígeno llegue a los órganos vitales.

Algunos indicios que nos pueden hacer sospechar la presencia de monóxido de carbono en el ambiente:

  • Coloración amarilla o anaranjada de la llama de hornallas o estufas
  • Aparición de manchas de hollín, tiznado o decoloración de los artefactos, de sus conductos de evacuación o alrededor de ellos.
En la patagonia, lamentablemente es frecuente anoticiarnos de decesos por intoxicación por monóxido de carbono, ya que, como se dijo anteriormente, es inolodoro, y a veces los detectores de este gas son caros o no están al alcance de los usuarios, cuando con un poco de trabajo, podemos crear un sensor preciso, económico y con herramientas libres, que es lo que vamos a ver a continuación.

En Home Assistant debemos instalar y configurar el complemento Mosquitto Broker

Entonces lo que vamos a hacer es lo siguiente:

  • crear un módulo que registre las partículas por millon de monóxido de carbono (CO)
  • comunicar a través del protocolo MQTT esa lectura
  • integrarlo a Home Assistant
  • generar una notificación en caso de que hayan niveles altos de CO.

Para esto necesitaremos:

Lo primero que debemos hacer es calibrar el sensor MQ-7, para ello, debe estar conectado de manera ininterrumpida al menos 48 horas antes de empezar a trabajar con él.

Este sensor posee una membrana que tiene un sensor electro-químico que al calentarse, varía su valor de resistencia al estar en contacto con el CO. Ese valor se puede obtener a través del pin analógico, o bien obtener un pulso a través del pin digital cuando el nivel de CO llega a cierto umbral, que podremos definir a través de un potenciómetro en el módulo del sensor.

Para este caso, trabajaremos con la lectura obtenida del pin analógico.

Este es el circuito

La fuente recibe 220 voltios y la transforma en 5 voltios que es el voltaje con el que trabaja el esp8266, el sensor MQ-7, el buzzer pasivo y el led (rojo: positivo, negro: negativo).

En este diagrama, el buzzer no está acompañado del módulo propio como en la imagen de los materiales necesarios, por eso se le agrega una resistencia.

Como dice la etiqueta, se conecta el cable de señal (amarillo) al pin analógico del sensor MQ-7.

  • A0 (ADC0) al pin analógico de sensor MQ-7
  • D6 (12) al pin de señal del buzzer pasivo
  • D7 (13) al positivo del led

Calibración del sensor

Una vez que ya tenemos listo el sensor MQ-7 para trabajar, debemos revisar cuál es la resistencia de la membrana en aire limpio, de manera de saber, mediante un cálculo, cuál es el valor de resistencia cuando entra en contacto con el gas.

Para ello abrimos el IDE Arduino y con el circuito armado introducimos el siguiente código:

float sensor_volt;
// resistencia del sensor en el monóxido
float RS_gas; 
// resistencia del sensor en el aire limpio
float R0;
int R2 = 2000;
  
void setup() {
 Serial.begin(9600);
}
 
void loop() {
  int sensorValue = analogRead(A0);
  sensor_volt=(float)sensorValue/1024*5.0;
  RS_gas = ((5.0 * R2)/sensor_volt) - R2;
  R0 = RS_gas / 1;
  Serial.print("R0: ");
  Serial.println(R0);
}

Abrimos el monitor serial y nos va a arrojar un valor que se va a actualizar constantemente, lo dejamos correr 30 segundos y tomamos el valor que nos arroja:

Ese valor es el de la resistencia de la membrana en aire limpio, lo vamos a llamar R0.

Programación del módulo e integración con MQTT.

Abrimos otra ventana y pegamos este código:

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// Credenciales de la red wifi.
const char* ssid = "MI-WIFI";
const char* password = "WIFI12345";

//ip del servidor mqtt en Home Assistant que es el mismo con el que te conectas vía web
const char* mqtt_server = "192.168.0.200";

WiFiClient espClient;
PubSubClient client(espClient);
unsigned long lastMsg = 0;
#define MSG_BUFFER_SIZE  (50)
char msg[MSG_BUFFER_SIZE];


int value = 0;

/* la lectura se realiza desde el pin analogico, de 1 a 1024, 
 *  para obtener los valores en unidades correspondientes a la medición del gas, 
 *  necesitamos escalar el valor leído, según lo mostrado en el datasheet 
*/

//variables necesarias para escalar el valor del pin analógico

// resistencia del módulo en el monóxido
float RS_gas = 0;
float ratio = 0;
float sensorValue = 0;
float sensor_volt = 0;

// resistencia del sensor en el aire limpio, aquí colocamos el valor obtenido antes
float R0 = 42521.74;
  
String estado = "Conectado";

void setup_wifi() {


  //pin D7 para el led
  pinMode(13, OUTPUT);
  //pin D6 para el buzzer pasivo
  pinMode(12, OUTPUT);
  
    
  delay(10);
  // Nos conectamos a la red wifi
  Serial.println();
  Serial.print("Conectando a la red ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  randomSeed(micros());

  Serial.println("");
  Serial.println("Conexión exitosa");
  Serial.print("dirección IP: ");
  Serial.println(WiFi.localIP());
}

//respuesta del servidor mqtt
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

void reconnect() {
  // ... en caso de que necesite reconectarse
  while (!client.connected()) {
    Serial.print("Intentando conexión MQTT...");
    // Se crea un cliente ID con las credenciales del servidor de Home Assistant
    String clientId = "ESP8266Client";

    // se toman los parámetros de la configuración del complemento de MQTT en Home assistant
    String serverId = "homeassistant";
    String passId = "3f29e1b2b05f8371595dc761fed8e8b37544b38d56dfce81a551b46c82f2f56b";

    
    clientId += String(random(0xffff), HEX);
    // intenta la conexión
    if (client.connect(clientId.c_str(), serverId.c_str(), passId.c_str())) {
      Serial.println("conectado");
      // Una vez conectado, se publica un mensaje
      client.publish("/sensor/monoxido_carbono/estado", estado.c_str());
      // ... y se resuscribe
      client.subscribe("/sensor/monoxido_carbono");
    } else {
      Serial.print("falló la conexión, reconectando=");      
      Serial.print(client.state());
      Serial.println(" intente en 5 segundos");
      // espera de 5 segundo para reintentar
      delay(5000);
    }
  }
}
    
void setup() {

  // se inicializa el pin BUILTIN_LED del arduino como salida
  pinMode(BUILTIN_LED, OUTPUT);
  
  Serial.begin(9600);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  
}

void loop() {

   sensorValue = analogRead(A0);
   sensor_volt = sensorValue/1024*5.0;
   RS_gas = (5.0-sensor_volt)/sensor_volt;
   ratio = RS_gas/R0; 
   float x = 1538.46 * ratio;
   float ppm = pow(x,-1.709);


  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  // si la lectura el sensor es mayor a 50 ppm se dispara una alarma 
 if(ppm >= 50){
  
  // se publica el mensaje de alerta en este tópico
  client.publish("/sensor/monoxido_carbono", "PELIGRO");  
  // se apaga el led
  digitalWrite(13, LOW);

  // se enciende el buzzer
  //digitalWrite(12, HIGH); (en caso de usar un buzzer activo)
  tone(12, 440);
  delay(500);

  //se publica la medición
  client.publish("/sensor/monoxido_carbono", String(ppm).c_str());

  // se apaga el buzzer  
  //digitalWrite(13, HIGH); (en caso de usar un buzzer activo)
  noTone(12);
  //digitalWrite(12, LOW);
  delay(500);
 }else{
  //caso contrario, se muestra la lectura del sensor
  digitalWrite(13, LOW);
  client.publish("/sensor/monoxido_carbono", String(ppm).c_str());  
 }
 delay(1000);
}

De vuelta abrimos el monitor serial y nos va a arrojar la lectura que está publicando

La medición la está publicando en el tópico “/sensor/monoxido_carbono”

Integración con Home Assistant

Ahora podemos entrar a Home Assistant y en el menú lateral Configuración -> Integraciones hacemos click en CONFIGURAR para asegurarnos que el broker instalado escucha las publicaciones que hace el esp8266 de las lecturas del sensor MQ-7:

Dentro de esa ventana podemos escuchar el tópico que le indiquemos al sistema

En MQTT settings podemos ver el puerto, el nombre, y la contraseña del broker que va a trabajar en Home Assistant. Esa información es la que tenemos que volcar en el código con el que programamos el esp8266 para el envío de las lecturas vía mqtt.

En Publicar un paquete, podemos establecer un tema o tópico para que enviemos o “publiquemos” información para que otro broker lo escuche. Para eso escribimos el mensaje en la caja Payload y damos click en PUBLICAR, así cualquiera que se subscriba este tópico podrá escucharnos.

En la opción Escuchar un tema escribimos el tópico que queremos indicarle al broker que escuche, de manera de estar seguros que la información está llegando.

Damos click en EMPEZAR A ESCUCHAR y podemos empezar a ver cómo (en este caso) se van recibiendo los mensajes del esp8266 con las lecturas del sensor MQ-7.

Una parte ya está hecha, ahora le tenemos que decir a Home Assistant que reciba esa información y la muestre en el panel principal. Para eso, tenemos que crear la entidad correspondiente.

Para eso tenemos que editar el archivo configuration.yaml.

Para eso buscamos el archivo y escribimos el siguiente código en él:

sensor:
  - platform: mqtt
    name: "Monóxido de carbono"
    state_topic: "/sensor/monoxido_carbono"
    unit_of_measurement: "PPM"

De esta manera creamos una entidad del tipo sensor con las siguientes características:

  • platform: se nombra al tipo de integración desde donde se va a recibir la información
  • name: es el nombre que va a tener esta entidad
  • state_topic: es el tópico desde donde se va a recibir la información
  • unit_of_measurement: es la unidad de medida, que depende del tipo de sensor que se utilice, en este caso, al ser un sensor que mide partículas de gas por millón de partículas, su unidad es “partículas por millón” o PPM.

Reiniciamos Home Assistant y añadimos la tarjeta Entidad, en la lista de entidades elegimos la creada en el archivo configuration.yaml:

Y así tenemos la lectura en el panel de control de nuestro Home Assistant.

Deja un comentario