Túnel de Desinfección Inteligente: Sanitización Automatizada para Áreas de Alto Tráfico

Componentes y materiales

Componente	Cantidad
Arduino UNO	1
Cables de puente (genéricos)	1
Sensor de movimiento PIR (genérico)	2
Relé de potencia 12V (4PDT)	1
Fuente conmutada 12V (SMPS)	1
Relé SPDT de 2 canales Seeed Grove	1
Fuente conmutada 5V (SMPS)	1
Interruptor basculante (On)-Off-(On)	1
Raspberry Pi 3 Model B	1
Módulo de cámara Raspberry Pi V2	1
Tarjeta Micro SD	1
Cable Micro-USB a USB (genérico)	1
Disipador térmico	1
Bomba de agua 1 HP	1
Tubo de acero caja	1
Tanque de agua (200 L)	1
Tubo PVC	1
Nebulizador 4 vías (4-Way Fogger)	1
Lona publicitaria (Banner Flex)	1
Racor en T (Tee Joint)	1
Microtubo	1
Lámpara de pared	1
Codo	1
Bridas de cable doble cara	1

Herramientas y máquinas necesarias

• Máquina de soldar
• Máquina de corte
• Soldador (genérico)
• Hilo de soldar, sin plomo
• Cortadora láser (genérica)

Aplicaciones y servicios en línea

• Arduino IDE
• Raspberry Pi Raspbian
• OpenCV

Sobre el proyecto

Introducción

El Túnel Inteligente de Desinfección y Sanitización es una demostración de cómo se ha diseñado para proporcionar máxima protección a las personas que pasan por el túnel en unos 15 segundos. Lo que puede ayudar a la comunidad a luchar contra el COVID-19.

La idea principal de este proyecto es hacer un túnel que pueda intentar prevenir la propagación del COVID-19. Este túnel de desinfección y sanitización está preparado para sanitizar a las personas en 15 segundos de cualquier bacteria posible.

La solución desinfectante usada consiste en una combinación de hipoclorito de sodio (NaOCl) y agua (H2O). El desinfectante es no volátil, permitiendo una actividad viricida y bactericida prolongada y sanitizando las superficies.

Tomé la iniciativa de hacer este Túnel Inteligente de Desinfección y Sanitización. Este túnel se hizo en un plazo de 12 horas. Puede desinfectar a una persona completamente de la cabeza a los pies en solo 15 segundos y la solución usada es completamente inofensiva*. El coste total del túnel es aproximadamente ₹30,000 o $400. (Coste revisado)

¿Dónde usarlo?

• Mercados de alimentos
• Oficinas
• Centros comerciales
• Aeropuertos
• Paradas de autobús
• Estaciones de tren
• Comisarías
• Colegios/Universidades
• Hospitales
• Urbanizaciones/Colonias

Cómo funciona

Una bomba de agua de 1 HP se coloca a un lado del túnel que toma la solución de 0.4% de hipoclorito de sodio en 100 litros de agua del tanque. Al ser automática, detecta si alguien entra en el túnel. Cuando alguien entra, la bomba se activa durante 15 segundos para que el usuario pueda pasar. Si no hay nadie, la bomba se apaga para ahorrar agua y electricidad. La niebla desinfectante protege a los ciudadanos de contraer bacterias por un período de al menos 60 minutos (aprox*). Desinfecta el aire, la piel expuesta y la ropa.

Un tanque plástico de 200 litros de solución y una bomba para el sistema de tuberías de alta presión se ubica al lado del túnel. Según cálculos, la solución debería durar 8-10 horas. Tiene un sensor de movimiento sobre la entrada para ahorrar desinfectante. (Puede variar según personas que entren**)

Diagrama de flujo

Configuración del hardware

Monté la estructura con perfiles metálicos, plegable para transportar y almacenar. El revestimiento es con lona (usada para publicidad exterior). La lona se sujeta fácilmente al perfil metálico con bridas plásticas. Es rápido y no requiere habilidades especiales.

Modelo 3D: skfb.ly/6RGvZ

Tubo de microtubo usado en todo el túnel para suministrar solución al nebulizador.

En el interior, hay una tubería de alta presión con 4 nebulizadores 4-vías. La niebla no deja marcas en la ropa, mientras envuelve completamente a la persona entrante y destruye el virus incluso en pliegues difíciles de la ropa, protegiendo por un tiempo después de la salida.

Como solución se usa una solución certificada en este proyecto. (Certificado adjunto abajo)

Especificaciones del nebulizador 4 vías:

• Tasa de descarga: 30 LPH/0.5 LPM (por nebulizador)
• Presión recomendada: 45-60 psi
• Tamaño medio de gota: 65 micras (a 55-60 psi)
• Filtración requerida: 130 micras (malla 120)
• Bomba requerida: 40 a 45 metros de cabeza

Preparar el Arduino

La bomba de agua funciona detectando rayos infrarrojos. Cuando el cuerpo humano se acerca al sensor de movimiento, este detecta los infrarrojos reflejados y da una señal HIGH por el pin de salida. Esta señal HIGH es leída por el Arduino. Si Arduino lee HIGH, da HIGH al módulo relé, encendiendo el relé de potencia y la bomba de agua por 15 segundos (configurable). Si lee LOW, pone el pin del relé a LOW y la bomba permanece apagada.

Usé 2 sensores PIR para mayor precisión: si cualquiera detecta movimiento, el relé se enciende por 15 segundos.

No podemos usar relé 5V directamente con la bomba porque la bomba tiene 16A y el relé 5V soporta máx 10A. Por eso usé un relé de potencia 12V controlado por el módulo relé 5V.

Código Arduino:

/* Smart Disinfection and Sanitation Tunnel */
int relayPin = 12;
int inputPin = 2;
int inputPin2 = 3;
int pirState = LOW;
int val = 0;
int val2 = 0;

void setup() {
  pinMode(relayPin, OUTPUT);
  pinMode(inputPin, INPUT);
  pinMode(inputPin2, INPUT);
  Serial.begin(9600);
}

void loop() {
  val = digitalRead(inputPin);
  val2 = digitalRead(inputPin2);
  if (val == HIGH || val2 == HIGH) {
    digitalWrite(relayPin, HIGH);
    if (pirState == LOW) {
      Serial.println("Motion detected!");
      delay(15000);
      pirState = HIGH;
    }
  } else {
    digitalWrite(relayPin, 0);
    if (pirState == HIGH) {
      Serial.println("Motion ended!");
      pirState = LOW;
    }
  }
}

Preparar la Raspberry Pi 3 (Opcional)

Esta parte es opcional. Si necesitas analizar datos y contar precisamente el número de personas que usan el túnel. Hay muchas formas con sensores físicos, pero encontré esta más precisa.

Hay un modelo de machine learning que detecta el cuerpo humano usando OpenCV en Python y guarda el registro en un archivo procesable para mostrar datos en la app.

Conectar la cámara Pi

1. Apagar la Raspberry Pi
2. Localizar el módulo de cámara entre USB y HDMI
3. Desbloquear clip plástico negro tirando suavemente hacia arriba
4. Insertar cable plano del módulo (conectores metálicos alejados de puertos Ethernet/USB en Pi 4)
5. Bloquear clip plástico

Habilitar la cámara Pi

1. Ejecutar sudo raspi-config
2. Seleccionar Interfacing Options (4ta opción), Enter
3. Seleccionar Enable Camera (5ta opción), Enter
4. Usar flecha derecha para resaltar ENABLE, Enter

Probar cámara Pi

Conectar por VNC Viewer y ejecutar: raspistill -v -o test.jpg. Deberías ver imagen de la cámara.

Instalar OpenCV

Sigue: Instalar OpenCV 4 en Raspberry Pi

Código Python (main.py):

import cv2.cv as cv
from datetime import datetime
import time, sys, datetime
count = 0

class MotionDetector():
    def __init__(self, ceil=8, doRecord=True, showWindows=True):
        self.writer = None
        self.font = None
        self.doRecord = doRecord
        self.show = showWindows
        self.frame = None
        self.capture = cv.CaptureFromCAM(0)
        self.frame = cv.QueryFrame(self.capture)
        if doRecord: self.initRecorder()
        self.frame1gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
        cv.CvtColor(self.frame, self.frame1gray, cv.CV_RGB2GRAY)
        self.res = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
        self.frame2gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
        self.width = self.frame.width
        self.height = self.frame.height
        self.nb_pixels = self.width * self.height
        self.ceil = ceil
        self.isRecording = False
        self.trigger_time = 0
        if showWindows: cv.NamedWindow("Image")

    def initRecorder(self):
        codec = cv.CV_FOURCC('D','I','V','X')
        self.writer = cv.CreateVideoWriter(datetime.now().strftime("%b-%d_%H:%M:%S")+".avi", codec, 15, cv.GetSize(self.frame), 1)
        self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8)

    def run(self):
        global count
        started = time.time()
        while True:
            curframe = cv.QueryFrame(self.capture)
            instant = time.time()
            self.processImage(curframe)
            if not self.isRecording:
                if self.somethingHasMoved():
                    self.trigger_time = instant
                    if instant > started + 5:
                        print "Human Detected"
                        count += 1
                        print(count/2)
                        # Guardar en archivos out.txt y log.txt
                        if self.doRecord: self.isRecording = True
            else:
                if instant >= self.trigger_time + 10:
                    print "Stop recording"
                    self.isRecording = False
                else:
                    cv.PutText(curframe, datetime.now().strftime("%b %d, %H:%M:%S"), (25,30), self.font, 0)
                    cv.WriteFrame(self.writer, curframe)
            if self.show: cv.ShowImage("Image", curframe)
            cv.Copy(self.frame2gray, self.frame1gray)
            c = cv.WaitKey(1)
            if c == 27 or c == 1048603: break

    def processImage(self, frame):
        cv.CvtColor(frame, self.frame2gray, cv.CV_RGB2GRAY)
        cv.AbsDiff(self.frame1gray, self.frame2gray, self.res)
        cv.Smooth(self.res, self.res, cv.CV_BLUR, 5,5)
        element = cv.CreateStructuringElementEx(5*2+1, 5*2+1, 5, 5, cv.CV_SHAPE_RECT)
        cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_OPEN)
        cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_CLOSE)
        cv.Threshold(self.res, self.res, 10, 255, cv.CV_THRESH_BINARY_INV)

    def somethingHasMoved(self):
        nb = 0
        for y in range(self.height):
            for x in range(self.width):
                if self.res[y,x] == 0.0: nb += 1
        avg = (nb * 100.0) / self.nb_pixels
        return avg > self.ceil

if __name__ == "__main__":
    detect = MotionDetector(doRecord=False)
    detect.run()

Descargar: main.py

Ejecutar: python main.py

Crear panel de control para app/escritorio

Paso 1: Instalar Apache

sudo apt install apache2 -y

Paso 2: Instalar PHP

sudo apt install php libapache2-mod-php -y

Descargar Dashboard.zip:

cd /var/www/html && wget "https://hacksterio.s3.amazonaws.com/uploads/attachments/1097966/Dashboard.zip" && sudo apt-get install unzip && unzip Dashboard.zip

Configurar Raspberry Pi como Punto de Acceso Inalámbrico

Sigue: Documentación oficial

Nombre del AP: SanitizingTunnel

Construir la App

App Android:

Requisito: Android Studio. Descarga el código y cambia credenciales (IP de tu Raspberry Pi).

App iOS:

Requisito: XCode. Descarga el código y cambia credenciales (IP de tu Raspberry Pi).

Solución química usada

El túnel usa 0.4% de hipoclorito de sodio en 100 litros de agua.

Actualización: El químico es de Raman & Weil Pvt. Ltd con "Declaración" de Bode Chemie Alemania sobre eficacia contra COVID-19.

Enlace oficial: Declaración de eficacia

Uniendo todo

Finalmente, encender el túnel y verificar que todas las rutinas y apps funcionan según lo planeado.

Coste

Hoja de cálculo detallada: Google Sheets

Código

• Arduino Code Tunnel (C/C++)
• main.py (Python)
• Dashboard Files (PHP)
• Sanitation-Tunnel Android Source Code (Java)
• Sanitation-Tunnel Android App (Java)
• Sanitation-Tunnel iOS Source Code (Swift)

Repositorio: GitHub - Smart Disinfection and Sanitation Tunnel

Piezas personalizadas y envolventes

Archivo 3MF: smart_disinfection_and_sanitation_tunnel_prlFu8ZRXO.3mf

Esquemáticos

Diagrama de circuito - archivo fritzing: smart_disinfection_and_sanitation_tunnel_Zkb20Q5S2B.fzz