Calidad De Air Sensor Mq - 135

¡Bienvenidos a la presentación de nuestro proyecto de monitoreo de calidad del aire con Arduino! En un mundo donde la calidad del aire se ha vuelto cada vez más importante para la salud y el bienestar de las personas, hemos desarrollado una solución innovadora para monitorear y alertar sobre los niveles de dióxido de carbono en el ambiente.

Nuestro proyecto se centra en el uso del sensor MQ-135 junto con un Arduino para medir los niveles de CO2 en el aire de manera precisa y eficiente. Además, utilizamos un módulo RTC (Real Time Clock) para registrar la fecha y hora de cada lectura y una pantalla LCD para mostrar los resultados en tiempo real.

A lo largo de esta presentación, exploraremos cómo hemos diseñado y desarrollado este sistema de monitoreo, los componentes que utilizamos, y cómo puede ser implementado en diferentes entornos para mejorar la calidad del aire y la seguridad de las personas.

¡Comencemos explorando en detalle nuestro emocionante proyecto de monitoreo de calidad del aire con Arduino!

1. Arduino Uno o cualquier otra placa compatible
2. mini protoboart
3. Sensor de gas MQ-135
4. Pantalla LCD 20x4 con interfaz I2C
5. Resistencia de 180 ohmios
6. Resistencia de 220 ohmios
7. Zumbador o buzzer para las alarmas sonoras
8. Protoboard o placa de pruebas
9. Cables jumper macho-macho
10. Fuente de alimentación para el Arduino (puede ser a través del puerto USB o una batería)
11. Caja o carcasa para alojar el proyecto (opcional)
12. Elementos para montaje (tornillos, tuercas, etc.) (opcional)

El sensor MQ-135 es un sensor de gas semiconductor que se utiliza principalmente para detectar concentraciones de gases nocivos en el aire, como el amoníaco (NH3), el sulfuro de hidrógeno (H2S), el benceno (C6H6), el dióxido de carbono (CO2) y otros compuestos orgánicos volátiles (VOCs). Sin embargo, su principal aplicación y más común uso es la detección de dióxido de carbono (CO2) en el aire.

Usos:

• Control de la calidad del aire en interiores: El sensor MQ-135 se utiliza en sistemas de monitoreo de calidad del aire en interiores, como en edificios, oficinas, hogares, aulas, etc., para detectar niveles de CO2 que puedan afectar la salud y el confort de las personas.
• Control de la calidad del aire en exteriores: También se puede usar en sistemas de monitoreo ambiental para medir la calidad del aire en entornos exteriores.
• Seguridad: En aplicaciones industriales, se puede utilizar para detectar fugas de gases nocivos en entornos de trabajo.

Especificaciones técnicas:

• Rango de detección: 10 a 1000 ppm (partes por millón) de CO2
• Sensibilidad: El sensor es más sensible a gases como el CO2, el amoníaco y los compuestos orgánicos volátiles (VOCs).
• Voltaje de funcionamiento: 5V DC
• Corriente de calentamiento: < 150mA
• Tiempo de precalentamiento: Alrededor de 24 horas
• Tiempo de respuesta: < 10 segundos
• Vida útil: Depende del entorno de uso y la calidad del sensor, generalmente alrededor de 5 años.

Conexiones:

El sensor MQ-135 tiene varios pines que se conectan al Arduino de la siguiente manera:

• VCC: Conecta este pin a 5V del Arduino.
• GND: Conecta este pin a tierra (GND) del Arduino.
• AOUT (Analog Output): Este pin proporciona una salida analógica que varía según la concentración de gas detectada. Conéctalo a un pin analógico del Arduino para leer esta salida.
• DOUT (Digital Output): Algunos modelos de MQ-135 pueden tener un pin DOUT que proporciona una salida digital. Puedes usarlo para activar una alarma o LED cuando se supera cierto umbral de concentración de gas.
• RS (Sensor Resistor): Este pin se conecta a una resistencia de carga de 10k ohmios que, a su vez, se conecta a VCC.
• RL (Load Resistor): Este pin es opcional y se puede dejar sin conectar en la mayoría de las aplicaciones.

Recuerda que el sensor MQ-135 necesita un tiempo de precalentamiento antes de comenzar a realizar mediciones precisas, por lo que es importante dejarlo encendido durante al menos 24 horas antes de usarlo. Además, calibrarlo adecuadamente es fundamental para obtener lecturas precisas y confiables.

Con estas conexiones, el Arduino podrá leer los valores del sensor MQ-135 y mostrarlos en la pantalla LCD I2C de forma clara y legible. Asegúrate de ajustar el código para que se adapte a estas conexiones y puedas visualizar correctamente los datos del sensor en la pantalla LCD.

Conexiones:

1. Arduino Uno:

• Conecta el pin VCC del Arduino a la fuente de alimentación de 5V.
• Conecta el pin GND del Arduino a tierra (GND) de la fuente de alimentación.
• Conecta el pin A0 del Arduino al pin de salida analógica (AOUT) del sensor MQ-135.
• Opcionalmente, si el sensor MQ-135 tiene un pin DOUT, conéctalo a un pin digital del Arduino para la salida digital.
• No olvides conectar el sensor MQ-135 a una fuente de alimentación externa (5V) y a tierra (GND).

1. Pantalla LCD I2C 16x2:

• Conecta el pin VCC de la pantalla LCD al pin VCC del Arduino (o a la fuente de alimentación de 5V).
• Conecta el pin GND de la pantalla LCD a tierra (GND) del Arduino (o a la fuente de alimentación).
• Conecta el pin SDA (Serial Data) de la pantalla LCD al pin A4 del Arduino (o al pin SDA en otros modelos de Arduino).
• Conecta el pin SCL (Serial Clock) de la pantalla LCD al pin A5 del Arduino (o al pin SCL en otros modelos de Arduino).

#include <LiquidCrystal_I2C.h> // para la pantalla LCD


#define PIN_MQ_ANALOGICO A0 // pin analógico para el sensor MQ-135 que utilizaremos para la medición


const int co2_pre_alarma = 600;
const int co2_alarma = 800;
const int co2_evacuar = 1200;


LiquidCrystal_I2C lcd(0x27, 16, 2); // Modulo LCD


void setup() {
  Serial.begin(9600); // inicializa comunicacion serie a 9600 bps


  lcd.init(); // Inicializamos el LCD
  lcd.clear(); // limpia pantalla
  lcd.backlight(); // Activamos el luz de fondo
}


void loop() {
 


  int medidaAnalogica = analogRead(PIN_MQ_ANALOGICO); // sensor MQ-135
  double CO2ppm = medidaAnalogica * 10.57;


  lcd.setCursor(0, 0);
  lcd.print("CO2: ");
  lcd.print(CO2ppm,0);
  lcd.print(" ppm");


  if (CO2ppm > co2_evacuar) {
 
    lcd.setCursor(0, 1);
    lcd.print("PELIGRO POR CO2");
  } else if (CO2ppm > co2_alarma) {


    lcd.setCursor(0, 1);
    lcd.print("ALARMA CO2");
  } else if (CO2ppm > co2_pre_alarma) {


    lcd.setCursor(0, 1);
    lcd.print("PRE ALARMA CO2");
  } else {
    lcd.setCursor(0, 1);
    lcd.print("             ");
  }


  delay(1000); // Espera 1 segundo antes de volver a leer el sensor
}

• Inclusión de la librería:
• Se incluye la librería LiquidCrystal_I2C.h para utilizar la pantalla LCD I2C.
• Definición de constantes:
• Se definen las constantes co2_pre_alarma, co2_alarma y co2_evacuar que representan los niveles de concentración de CO2 para prealarma, alarma y evacuación, respectivamente.
• Inicialización de la pantalla LCD:
• Se inicializa la pantalla LCD I2C con la dirección 0x27 y un tamaño de 16 columnas por 2 filas. Luego se limpia la pantalla y se activa la retroiluminación.
• Función loop():
• Se realiza la lectura del sensor MQ-135 conectado al pin analógico A0 del Arduino y se calcula la concentración de CO2 en partes por millón (ppm) utilizando la fórmula CO2ppm = medidaAnalogica * 10.57.
• Se muestra la lectura de la concentración de CO2 en la primera fila de la pantalla LCD.
• Se aplican las siguientes condiciones:Si la concentración de CO2 es mayor que el nivel de evacuación (co2_evacuar), se muestra el mensaje "PELIGRO POR CO2" en la segunda fila de la pantalla LCD.
• Si la concentración de CO2 está entre el nivel de alarma (co2_alarma) y el nivel de evacuación, se muestra el mensaje "ALARMA CO2".
• Si la concentración de CO2 está entre el nivel de prealarma (co2_pre_alarma) y el nivel de alarma, se muestra el mensaje "PRE ALARMA CO2".
• Si la concentración de CO2 es menor que el nivel de prealarma, se borra la segunda fila de la pantalla LCD.
• Espera antes de la próxima lectura:
• Se añade un retardo de 1 segundo (1000 milisegundos) antes de realizar la próxima lectura del sensor MQ-135.

Este código utiliza el sensor MQ-135 para medir la concentración de CO2 en el aire y muestra mensajes en una pantalla LCD I2C dependiendo de los niveles de concentración detectados.

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);  // Dirección I2C de la pantalla LCD


int buzzerPin = 3;
int ledPin = 4;
int sensorPin = A0;
 float ppm;
float sensorValue;
float voltage;
void setup() {
  Serial.begin(9600);
  lcd.init();                      // Inicializar la pantalla LCD
  lcd.backlight();
  pinMode(buzzerPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
   lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Calidad de aire:");
}


void loop(){
  sensorValue = analogRead(sensorPin);
   voltage = sensorValue * (5.0 / 1023.0);
  
   ppm = getPPM(voltage);  // Calcular los PPM de gas
   Serial.print("Voltaje:");
 Serial.print(voltage);
  Serial.print(",");
 Serial.print("Valor:");
  Serial.println(ppm);
  
  if(ppm > 10) {
    lcd.setCursor(0, 1);
    lcd.print("Gas: ");
    
    if(ppm < 200) {
      lcd.print("CO2       ");
    } else if(ppm >= 200 && ppm < 400) {
      lcd.print("Alcohol    ");
    } else if(ppm >= 400 && ppm < 1000) {
      lcd.print("Humo      ");
    } else {
      lcd.print("inflamable");
    }
    
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000);
  
  } else {
    lcd.setCursor(0, 1);
    lcd.print(" Sin problemas ");
    
    digitalWrite(ledPin, LOW);
    noTone(buzzerPin);
  }
  
  delay(1);
}


float getPPM(float voltage) {


  
    float RS_R0 = (5.0 - voltage) / voltage; // Relación entre la resistencia del sensor y la resistencia en condiciones limpias
  float ppmF = 116.6020682 * pow(RS_R0, -2.769034857); // Fórmula empírica para calcular los PPM
  
  return ppmF;
}

• Inclusión de librería y declaración de objetos:
• Se incluye la librería LiquidCrystal_I2C.h para utilizar la pantalla LCD I2C.
• Se declara un objeto lcd de tipo LiquidCrystal_I2C con la dirección I2C de la pantalla LCD y un tamaño de 16 columnas por 2 filas.
• Declaración de variables:
• Se declaran las variables buzzerPin, ledPin y sensorPin para los pines del zumbador, el LED y el sensor MQ respectivamente.
• Se declaran las variables ppm, sensorValue y voltage como tipo float para almacenar el valor de las partes por millón (ppm) del gas, el valor leído del sensor y el voltaje respectivamente.
• Función setup():
• Se inicializa la comunicación serial a una velocidad de 9600 baudios.
• Se inicializa la pantalla LCD y se activa la retroiluminación.
• Se configuran los pines buzzerPin y ledPin como salidas.
• Se limpia la pantalla LCD y se imprime el mensaje "Calidad de aire:" en la primera fila.
• Función loop():
• Se lee el valor analógico del sensor MQ y se calcula el voltaje correspondiente.
• Se calculan los ppm de gas utilizando la función getPPM() con el voltaje como argumento.
• Se imprime el voltaje y los ppm de gas en el monitor serial.
• Se realiza una serie de condicionales para determinar el tipo de gas detectado en base al valor de los ppm:Si los ppm son mayores que 10, se imprime el tipo de gas en la pantalla LCD y se activa el LED y el zumbador.
• Si los ppm son menores o iguales a 10, se imprime "Sin problemas" en la pantalla LCD y se apaga el LED y el zumbador.
• Función getPPM():
• Esta función calcula los ppm de gas utilizando la fórmula empírica proporcionada en el código.
• Se calcula la relación entre la resistencia del sensor y la resistencia en condiciones limpias (RS/R0).
• Se utiliza esta relación para calcular los ppm de gas según la fórmula empírica y se retorna el valor.

Este código realiza la lectura del sensor MQ y muestra el tipo de gas detectado en la pantalla LCD, activando el LED y el zumbador según sea necesario. Además, calcula los ppm de gas utilizando una fórmula empírica específica para el sensor MQ.

Ambos códigos realizan la lectura de un sensor MQ y muestran información sobre la calidad del aire en una pantalla LCD, pero difieren en varios aspectos:

1. Uso de librerías:

• El primer código utiliza la librería LiquidCrystal_I2C.h para manejar la pantalla LCD I2C, mientras que el segundo código también utiliza esta librería pero además incluye la función tone() y noTone() para generar sonidos con un zumbador.

1. Variables y pines:

• En el primer código, se declara y utiliza una variable ppm para almacenar los valores de concentración de gas, mientras que en el segundo código se utiliza directamente una variable float para el mismo propósito.
• Los pines utilizados para el zumbador y el LED son diferentes en cada código: buzzerPin y ledPin en el segundo código, mientras que en el primer código estos pines no están definidos.

1. Fórmula para calcular PPM:

• En el primer código, se utiliza una fórmula diferente para calcular los ppm de gas en la función getPPM(), mientras que en el segundo código se utiliza una fórmula empírica diferente dentro de la función loop().

1. Condiciones para determinar el tipo de gas:

• En el primer código, se determina el tipo de gas (CO2, alcohol, humo, inflamable) según el valor de ppm, mientras que en el segundo código no se realiza esta distinción y simplemente se activa una alarma si el valor de ppm es mayor que 10.

En resumen, la diferencia principal entre los dos códigos radica en la forma en que manejan la salida de la información del sensor y cómo reaccionan ante diferentes niveles de concentración de gas, así como en la inclusión de características adicionales como la generación de sonidos con un zumbador en el segundo código.

Si no tienes acceso a un Arduino físico, puedes utilizar simuladores como Proteus para probar y aprender sobre el funcionamiento de los circuitos electrónicos, incluyendo proyectos como este de calidad del aire.

Si estás interesado en obtener los archivos para simular este proyecto en Proteus, déjanos un comentario con tu correo electrónico y asegúrate de seguirnos en Facebook para que podamos ponernos en contacto contigo y enviarte los archivos. Estamos aquí para ayudarte a explorar el apasionante mundo de la electrónica y la programación. ¡No dudes en participar y aprender con nosotros!