Tunnel de Désinfection Intelligent : Sanitisation Automatisée pour Zones à Forte Fréquentation

Composants et fournitures

td>

Composant	Quantité
Arduino UNO	1
Fils de câblage (génériques)	1
Capteur de mouvement PIR (générique)	2
Relais de puissance 12V (4PDT)	1
Alimentation à découpage 12V (SMPS)	1
Seeed Grove - Relais 2 canaux SPDT	1
Alimentation à découpage 5V (SMPS)	1
Interrupteur à bascule (On)-Off-(On)	1
Raspberry Pi 3 Modèle B	1
Module Caméra Raspberry Pi V2	1
Carte Micro SD	1
Câble Micro-USB vers USB (générique)	1
Radiateur (heat sink)	1
Pompe à eau 1 HP	1
Tube boîte en acier (structure)	1
Réservoir d'eau (200 L)	1
Tube PVC	1
Buse brouillard 4 voies (4-Way Fogger)	1
Bannière Flex (revêtement)	1
Raccord en T	1
Micro-tuyaux	1
Applique murale	1
Coude	1
Collier de serrage double face	1

Outils et machines nécessaires

Poste à souder
Machine à découper (cut-off)
Fer à souder (électronique)
Fil à souder sans plomb
Découpeuse laser (générique)

Applications et services en ligne

Arduino IDE
Raspberry Pi OS (Raspbian)
OpenCV

À propos du projet

Introduction

Le Tunnel de Désinfection et Sanitisation Intelligent démontre comment fournir une protection maximale aux personnes le traversant en environ 15 secondes. Cela peut aider la communauté à lutter contre la COVID-19.

L'idée principale est de créer un tunnel qui tente de prévenir la propagation de la COVID-19 en sanitisant les personnes en 15 secondes contre toute bactérie possible.

La solution désinfectante utilisée combine de l'hypochlorite de sodium (NaOCl) et de l'eau (H₂O). Elle est non volatile, assurant une activité virucide et bactéricide prolongée et sanitisant les surfaces.

J'ai pris l'initiative de réaliser ce Tunnel Intelligent en 12 heures. Il désinfecte une personne entièrement de la tête aux pieds en 15 secondes avec une solution totalement inoffensive*. Le coût total est d'environ ₹30 000 ou 400 $ (coût révisé).

Tunnel de Désinfection Intelligent : Sanitisation Automatisée pour Zones à Forte Fréquentation

Où l'utiliser ?

Marchés alimentaires
Bureaux
Centres commerciaux
Aéroports
Arrêts de bus
Gares ferroviaires
Commissariats
Universités
Hôpitaux
Quartiers résidentiels

Comment ça fonctionne

Une pompe à eau 1 HP est placée sur le côté de chaque tunnel. Elle aspire la solution à 0,4% d'hypochlorite de sodium dans 100 litres d'eau depuis le réservoir. Le système étant automatique, il détecte si quelqu'un entre dans le tunnel. Dès qu'une personne y pénètre, la pompe démarre pendant 15 secondes, le temps que l'utilisateur traverse. S'il n'y a personne, la pompe s'arrête pour économiser eau et électricité. La brume désinfectante protège contre les bactéries pendant au moins 60 minutes (approx.*), désinfectant l'air, la peau exposée et les vêtements.

Un réservoir de 200 litres et une pompe pour le système de tuyaux haute pression sont situés sur le côté du tunnel, connectés à l'assemblage de buses brouillard 4 voies. D'après les calculs, la solution suffit pour 8-10 heures. Un capteur de mouvement à l'entrée économise le désinfectant (peut varier selon la fréquentation**)

Diagramme de flux

Configuration matérielle

J'ai construit la structure en profilés métalliques, démontable pour le transport et le stockage. Le revêtement est une bannière (utilisée pour la publicité extérieure), facile à fixer avec des colliers plastiques. C'est rapide et ne demande pas de compétences particulières.

Modèle 3D : skfb.ly/6RGvZ

Les micro-tuyaux alimentent les buses en solution à travers le tunnel.

À l'intérieur, une canalisation haute pression avec 4 buses brouillard 4 voies enveloppe complètement la personne entrante, détruisant le virus même dans les plis des vêtements, sans laisser de traces, avec une protection résiduelle après la sortie.

La solution utilisée est certifiée (certificat ci-dessous).

Spécifications de la buse 4 voies (4-Way Fogger)

Débit : 30 L/h / 0,5 L/min (par buse)
Pression recommandée : 45-60 psi
Taille moyenne des gouttelettes : 65 microns (à 55-60 psi)
Filtration requise : 130 microns (maille 120)
Pompe requise : 40 à 45 m de charge

Préparation de l'Arduino

La pompe fonctionne par détection infrarouge. Quand un corps humain approche du capteur PIR, il réfléchit les rayons IR, le capteur envoie un signal HIGH lu par l'Arduino. Si HIGH, l'Arduino active le relais qui active le relais de puissance, démarrant la pompe pour 15 secondes (modifiable). Si LOW, la pompe reste arrêtée.

J'ai utilisé 2 capteurs PIR pour plus de précision : si l'un détecte un mouvement, le relais s'active 15 secondes.

On ne peut pas utiliser un relais 5V directement avec la pompe (16A) car le relais 5V supporte max 10A. J'ai donc ajouté un relais de puissance 12V piloté par le module relais 5V.

Code 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;
    }
  }
}

Le câblage final est un peu désordonné mais fonctionne parfaitement.

Préparation du Raspberry Pi 3 (Optionnel)

Optionnel pour analyser les données et compter précisément le nombre de personnes. Bien qu'il existe des méthodes avec capteurs physiques (PIR, ultrasons), j'ai trouvé la vision par ordinateur plus précise.

Un modèle de détection de corps humain avec OpenCV en Python enregistre les logs dans un fichier, traitable pour affichage dans une application.

Connexion de la caméra Pi

Éteignez le Raspberry Pi
Localisez le connecteur caméra entre l'USB et le HDMI
Déverrouillez le clip noir en tirant vers le haut
Insérez le câble ruban (connecteurs métalliques loin des ports Ethernet/USB sur Pi 4)
Revirez le clip

Activation de la caméra Pi

Exécutez sudo raspi-config
Sélectionnez Interfacing Options (4ème option), Entrée
Sélectionnez Enable Camera (5ème option), Entrée
Sélectionnez ENABLE avec la flèche droite, Entrée

Test de la caméra Pi

Connectez-vous via VNC Viewer et lancez : raspistill -v -o test.jpg. Vous devriez voir l'aperçu de la caméra.

Installation d'OpenCV

Suivez ce guide : Installer OpenCV 4 sur Raspberry Pi

Code Python (main.py)

import cv2.cv as cv
from datetime import datetime
import time
import sys
import datetime
count=0
class MotionDetector():
  def onChange(self, val):
    self.ceil = val
  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)
            orig_stdout = sys.stdout
            f = open('out.txt', 'a+')
            sys.stdout = f
            print(count/2)
            sys.stdout = orig_stdout
            f.close()
            orig_stdout = sys.stdout
            f = open('log.txt', 'a+')
            sys.stdout = f
            timestampc = ('Timestamp: {:%Y-%b-%d %H:%M:%S}'.format(datetime.datetime.now()))
            print(timestampc+' Log Entry : 1')
            sys.stdout = orig_stdout
            f.close()
            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
    if avg > self.ceil:
      return True
    else:
      return False
if __name__=="__main__":
  detect = MotionDetector(doRecord=False)
  detect.run()

Téléchargement : main.py

Sauvegardez avec CTRL+X, Y, Entrée. Lancez avec python main.py.

J'ai créé un boîtier en MDF pour l'Arduino et le Raspberry Pi 3.

Création d'un tableau de bord pour application Desktop/App

Étape 1 : Installer Apache

sudo apt install apache2 -y

Étape 2 : Installer PHP

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

Rafraîchissez votre navigateur pour voir le tableau de bord.

Configuration du Raspberry Pi en Point d'Accès WiFi

Suivez : Documentation officielle

Note : Nommez le point d'accès SanitizingTunnel

interface=wlan0
driver=nl80211
ssid=SanitizingTunnel
hw_mode=g
channel=7
wmm_enabled=0
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=SecretPassword
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

Construction de l'application mobile

Application Android :

Prérequis : Android Studio. Téléchargez le code source et modifiez l'adresse IP du Raspberry Pi selon vos besoins.

Application iOS :

Prérequis : Xcode. Téléchargez le code source et modifiez l'adresse IP du Raspberry Pi.

Solution chimique utilisée

Le tunnel utilise 0,4% d'hypochlorite de sodium dans 100 litres d'eau.

Mise à jour : Beaucoup de commentaires s'inquiétaient de la toxicité. Le fournisseur (Raman & Weil Pvt. Ltd) possède une Déclaration de Bode Chemie Allemagne sur l'efficacité contre la COVID-19.

Lien officiel : Déclaration Bode Chemie

Assemblage final

Mise sous tension du tunnel et vérification de toutes les routines et applications.

Coût

Détail complet : Google Sheets

Code

Arduino Code Tunnel
main.py (Python/OpenCV)
Dashboard Files (PHP)
Sanitation-Tunnel Android Source Code
Sanitation-Tunnel Android App (APK)
Sanitation-Tunnel iOS Source Code

Arduino Code Tunnel C/C++

/* 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;
    }
  }
}