Sistema de Control de CO2 en Ambientes Cerrados

Titulo

Sistema de Control de CO2 en Ambientes Cerrados

Participantes

Juan Guillermo Parra Gärtner
Aura Vanesa Sanchez
Juliette Andrea Pereira Gutierrez

Abstract

In working conditions, the aspect related to air quality in offices and general services is of vital importance. the continued expositions to CO2 produce physical and mental health effects in workers, causing greater stress and thus a decrease in laboral performance. For this rason we made this control system of CO2 optimized with help of cloud processing, in this case Ubidots server. Basically Ubidots will receive the amount of CO2 concentration , which will send back an order to turn on the leds according level of concentration, and in its maximum point it will request to turn on a fan.

Problema

El sistema de control de co2 en ambientes cerrados tiene como objetivo mantener la concentración de este gas en los limites recomendados por entidades de salud, para el bienestar del ser humano

Diseño (Arquitectura HW)

Untitled%20Diagram.png

Desarrollo

Funcionamiento

De acuerdo con lo planteado este sistema tiene como prioridad mantener hasta cierto nivel de concentración CO2 y esto se logra por medio del sensor Mq135, se tuvo en cuenta la cantidad de PPM de CO2 máximas recomendadas en lugares cerrados, lo cual es de 800 PPM, se establecieron otros niveles menores a este para determinar con mayor precisión la cantidad de PPM en este caso de 100 PPM, 200 PPM y 400 PPM los cuales son también casos para encendido de leds. Se caracterizó el sensor para que la Beaglebone tomara el voltaje recibido e interpretara cuantas PPM de Co2 hay en el aire, estos datos se envían a Ubidots y allí según los rangos que se establecieron de PPM manda una orden de encendido de leds correspondientes o si iguala/supera los 800 PPM encenderá además de todos los leds un ventilador.

Este sistema es resiliente a fallas de potencia (soporta perturbaciones de potencia) ya que al utilizar el divisor de voltaje para conectar el sensor se asegura estar en los limites de que soporta el sensor, por otro lado también es resiliente a fallas de red (soporta caídas de conexión a red) debido a que cada vez que se restablezca la conexión con Ubidots envía desde el último dato que recibió el servidor

Caracterización del sensor

El Mq135 se utiliza en equipos de control de calidad del aire para edificios y oficinas, son adecuados para la detección de NH3, NOx, alcohol, benceno, humo, CO2, etc.
Este sensor es sensible en similar proporción a los gases mencionados, con lo que podemos determinar si el aire está limpio.

sensor-calidad-aire-mq135.jpg

Fuente: http://www.naylampmechatronics.com/blog/42_Tutorial-sensores-de-gas-MQ2-MQ3-MQ7-y-MQ13.html

En la aplicación implementada se necesita los valores en unidades correspondientes a la medición del gas, se necesita escalar el valor leído, la relación entre la lectura
Analógica y el valor real no es lineal. Por lo que necesitamos estimar la curva que nos da la hoja de especificaciones el cual se indica abajo.

senci.jpg

Fuente: https://www.olimex.com/Products/Components/Sensors/SNS-MQ135/resources/SNS-MQ135.pdf

Debido a que da la curva y no la ecuación es necesario estimar y por regresión hallar la ecuación, se usa Excel, para eso se debe ingresar datos de la curva de CO2 y graficamos en Excel.
Agregar línea de tendencia y escoger la ecuación potencial

Imagen12.jpg

La ecuación que obtiene es:

CO2=115,26 (Rs/Ro)^(-2.887)

CO2 es el valor de concentración de CO2, Ro es una constante que equivale al valor de la resistencia del sensor cuando se lo expone a una concentración de 115,26 PPM y Rs es la
Resistencia del sensor, el cual leemos desde la Beaglebone.

Se calcula el voltaje leído del sensor, para calcular el valor de Rs se despeja la ecuación del divisor de voltaje que forma el sensor con la resistencia de carga RL que es de 20K.

V_leido=1.67(20000/(Rs+20000))

Rs=((1.67*20000)/V)+20000

Y de curva anterior solo se toma la forma que tiene, e incluso Ro se consideramos como constante. La ecuación seria de la siguiente forma.
PPM=a*(Rs/Ro)^b

Para calcular las constantes a y b solo se necesitan tomar dos muestras, con el sensor se medirá el Rs de dichas muestras

Esquemático del montaje

ESQUEM.png

Posibles aplicaciones

Como se menciono anteriormente su principal funcion es controlar cuanto CO2 permite dentro de cualquier establecimiento por lo que este puede variar según se requiera
este sistema, puede ser para :

  • Evitar altas exposiciones del ser humano a co2 en lugares no industriales como oficinas
  • Ritmo productivo de cultivos en ambiente cerrado manteniendo una constante adecuada de evaporación (mediante un aire limpio según tipo de cultivo)
  • Mantener mínima concentración co2 para el crecimiento correcto de animales en cautiverios

Dificultad encontrada

No se pudo delimitar correctamente los rangos de PPM captadas por el sensor en Ubidots, lo que no nos daba el resultado que queríamos según script de la beaglebone para el encendido del ventilador y/o leds, pero esto solo es debido a las limitaciones de este sitio web el cual no tiene una forma óptima de limitación en su versión gratuita.

Configuración - paso a paso

Primero se debe realizar la siguiente configuración en la beaglebone

Configuración en Beaglebone

1. Descargar la imagen .iso de ubuntu (http://elinux.org/BeagleBoardUbuntu#BeagleBone_White.2FBlack.2FGreen)
2. Descargar e instalar 7-zip
3. Descomprimir la imagen con el programa instalado anteriormente.
4. Descargar writer for windows
5. Conectar la microsd al computador y pasar la imagen a esta.
6. Colocar la microsd en al beaglebone.

Configuración en PC

Estas configuraciones se realizaran en el terminal de ubuntu:
1. Se debe descargar e instalar (http://beagleboard.org/static/Drivers/Linux/FTDI/mkudevrule.sh).
2. Verificar que la beaglebone este conectada a nuestro ordenador con el siguiente comando (ls /dev/ttyUSB0).
3. Instalar la siguiente aplicacion para que se pueda manejar la beaglebone en una terminal distinta (sudo apt-get install screen )
4. Conectar la beaglebone con el siguiente comando

sudo screen /dev/ttyUSB0 115200

el ingreso a ella sera : Login: ubuntu | Password: temppwd

Conectarse por SSH a la beaglebone
1. Configurar la siguiente ip en nuestro pc

sudo ifconfig eth2 192.168.7.1/30 broadcast 192.168.7.3

2. Colocar una ruta estatica en la beaglebone (sudo route add default gw 192.168.7.1)
3. Realizamos un ping entre el computador y la beaglebone para mirar si se tiene conectividad (ping 192.168.7.1)
4. Conectar con la beagle (ssh 192.168.7.2 -l ubuntu) su contraseña es temppwd

Para tener internet en la beaglebone:
1. mirar en que interfaz está conectada a la beaglebone dependiendo de esto se le colocara su eth.
2. Agregar la siguiente dirección ip

sudo ip addr add 192.168.7.1/24 dev eth

3. ejecutar los siguientes comandos:

 sudo iptables -A FORWARD -o eth0 -i eth -s 192.168.0.0/24 -m conntrack --ctstate NEW -j ACCEPT
 sudo iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
 sudo iptables -t nat -F POSTROUTING
 sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

Se debe colocar el gateway correspondiente en nuestro computador, ejecutando los siguientes comandos:
1.

 sudo iptables-save | sudo tee /etc/iptables.sav

2. Se debe editar la siguiente libreria

/etc/rc.local

despues de la linea de exit 0, colcando la siguiente linea de comando

(sudo iptables-restore < /etc/iptables.sav)

3. Activar el enrutamiento, para configurar el gateway que permita hacer enrutamiento entre dos interfaces activando el ip forwarding, entrando a la siguiente libreria (/etc/sysctl.conf) y descomentarear la siguiene linea de codigo ( #net.ipv4.ip_forward=1)

Volvemos a la beaglebone para mirar la conexión a internet:
1. deshabilitamos nuestra tarjeta de internet

sudo /etc/init.d/networking stop

2. Activamos la ruta
 (sudo ip route add default via 192.168.7.1)

3. Instalando el servidor dns en la siguiente libreria

(/etc/resolv.conf )

y colocamos las siguiente linea

 (nameserver 8.8.8.8)

4. Volvemos a habilitar tarjeta de internet

 (sudo /etc/init.d/networking restart)

Mirar si hay conexion a internet en la beaglebone

1. ping 192.168.7.1
2. ping 8.8.8.8
3. ping www.google.com
4. sudo apt-get update

Configuración en Ubidots

Partes por millon que nos arroja el sensor:

La plataforma de wikidots recibe los datos y las guarda en una variable llamada ppm
15231680_10154787672071983_1084612482_o.png

Grafica de partes por millon recibidas por ubidots

15271312_10154787672571983_736779603_o.png

Casos para encendido de leds dependiendo rangos de partes por millon

Utilizamos varios casos para mostrar si esta el ambiente limpio o ya muy lleno de dioxido de carbono, el cual esta guardado en una variable ppm la cual se compara con un valor en especifico que despues la plataforma de wikidots nos devolvera un valor de 1 a 4 el cual lo recibira la beaglebone la cual dependiendo el valor se encendera en los leds.
15303999_10154787672066983_22295709_o.png

Código fuente - Scripts en la Beaglebone

1. Debemos instalar python para poder desarrollar nuestro primero script

sudo apt-get install python3.1

2. Ejecutamos el siguiente script que es para calcular las partes por millon de los valores que se reciben de nuestro sensor de dioxido de carbono que lo convierte de ppm a voltaje
import Adafruit_BBIO.ADC as ADC
ADC.setup()
from time import sleep
analogPin = 'P9_36'
while(1):

potVal=ADC.read(analogPin)       
 potVolt=potVal*1.67       
 #print "The Potentiometer Voltage is: ",potVolt 
        sleep(.9)

  #codigo para calcular partes por millon      
  RS=1.67*20000/potVal + 20000

#PPM =115.255874618*(RS/1)**(-2.8867696989)       
 #print "Las portes por millon calculada es  ",PPM

Rs=(20000*((5-1)/1))#Rs con rl=20k y el sensor saturado        
Ro=Rs/0.8# Valor encontrado cuando hay 200 PPM segun datasheet       
 PPM=115.255874618*(RS/750000)**(-2.8867696989)

#print "Las partes por millon calculada es ",PPM

 #Creando archivo para enviar dato

fo = open("/home/ubuntu/voltaje", "wb")        
fo.write(str(PPM))       
 fo.close()

#      
 GPIO.output("P8_3", GPIO.LOW)

2. Configuramos la subida a ubidots con el siguiente URL
curl -X POST -H "Content-Type: application/json" -d '{"value":100}' https://things.ubidots.com/api/v1.6/variables/58135948762542795875cfd1/values/?token=a0I9q7n0eRjxsK1Ld0FlEXLIObSTVQ

3. Configuración de pines
#!/bin/bash
echo 38 
 /sys/class/gpio/export
echo 39 
 /sys/class/gpio/export
echo 66 
 /sys/class/gpio/export
echo 67 
 /sys/class/gpio/export
echo 45 
 /sys/class/gpio/export
echo out 
 /sys/class/gpio/gpio38/direction
echo out 
 /sys/class/gpio/gpio39/direction
echo out 
 /sys/class/gpio/gpio66/direction
echo out 
 /sys/class/gpio/gpio67/direction
echo out 
 /sys/class/gpio/gpio45/direction

4. Vamos a la parte del get de ubidots y mirar si tenemos conectada la beagle a internet

#!/bin/bash
   while :
    do
      var=$(ip link show usb0|ip link show usb0 | awk {'print $9'}) #mirando si tenemos conectada nuestra beaglebone
       Vol=`more /home/ubuntu/voltaje` #donde se guardan os voltajes que vota nuestro sensor

 if [ "$var" = "UP" ]; then

  cadena1="'{"
                cadena2='"value":'
                cadena3="$Vol}'"

    valor=$cadena1""$cadena2""$cadena3

       comandofinal='curl -X POST -H "Content-Type: application/json" -d'" "$valor"  "'https://things.ubidots.com/api/v1.6/variables/58135948762542795875cfd1/values/?token=a0I9q7n0eRjxsK1Ld0FlEXLIObSTVQ'

  rm /home/ubuntu/comandocompleto              
  echo $comandofinal >> comandocompleto              
  sh /home/ubuntu/comandocompleto

 #esta ultima linea hace un get a ubidot para leer el dato procesado. 

  alarma=$(curl -X GET http://things.ubidots.com/api/v1.6/devices/iot/alarma/?token=a0I9q7n0eRjxsK1Ld0FlEXLIObSTVQ | awk {'print $34'} | grep -oE '*. *.0')

  #Haciendo la comparación en ubidots dependendiendo el tipo de alarma que bote.   
        if [ "$alarma" = "1.0" ]; then

                    echo 1 > /sys/class/gpio/gpio38/value  
                    echo 0 > /sys/class/gpio/gpio39/value   
                    echo 0 > /sys/class/gpio/gpio66/value  
                    echo 0 > /sys/class/gpio/gpio67/value  
                    echo 0 > /sys/class/gpio/gpio45/value  

                fi

          if [ "$alarma" = "2.0" ]; then

                   echo 1 > /sys/class/gpio/gpio38/value        
                   echo 1 > /sys/class/gpio/gpio39/value         
                   echo 0 > /sys/class/gpio/gpio66/value                 
               echo 0 > /sys/class/gpio/gpio67/value                       
           echo 0 > /sys/class/gpio/gpio45/value                  
         fi

          if [ "$alarma" = "3.0" ]; then

              echo 1 > /sys/class/gpio/gpio38/value                       
          echo 1 > /sys/class/gpio/gpio39/value            
              echo 1 > /sys/class/gpio/gpio66/value
                  echo 0 > /sys/class/gpio/gpio67/value            
              echo 0 > /sys/class/gpio/gpio45/value            
            fi

         if [ "$alarma" = "4.0" ]; then

          echo 1 > /sys/class/gpio/gpio38/value                     
          echo 1 > /sys/class/gpio/gpio39/value
                  echo 1 > /sys/class/gpio/gpio66/value                     
          echo 1 > /sys/class/gpio/gpio67/value                    
          echo 1 > /sys/class/gpio/gpio45/value              
             fi

          else

          echo $Vol >> historialdePPM

               fi
done
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License