CovAID An Electronic Door System Which We Prevent People Who are Suffering From Fever or not Wearing Mask From Public Places
1002 8
Vardan Kulshreshtha

CovAID An Electronic Door System Which We Prevent People Who are Suffering From Fever or not Wearing Mask From Public Places

CovAID-An electronic group system which will prevent people who are suffering from fever or not...


CovAID-An electronic group system which will prevent people who are suffering from fever or not wearing mask from public places. We noticed carelessness of staff which was responsible for keeping a check on their body temperature and mask. This resulted in increased rate of spread of Corona. So we made this project, it will keep a check on body temperature and mask people entering in public areas through infrared and object detection respectively. A project to fight corona.

Project Used Hardware

CovAID Hardware

Raspberry pi, PI-Camera, MLX90614, Linear motors

Project Used Software

Tensorflow, Python3, raspberry pi

Project Hardware software selection

Tensorflow- A good platform for object detection as I can Python-It is an open source language which supports a variety of packages and is a popular language for making automated projects. ____________HARDWARE_________ Raspberry Pi- The best computer in terms of size to performance ratio and it is cheap as well. It supports enough computing power to run object detection. MLX90614-It is an infrared temperature detection sensor to make the temperature detection contactless.

Circuit Diagram

CovAID Circuit Diagram


(Raspberry pi) SDA - (MLX90614) SDA (Raspberry pi)SCL - (MLX90614) SCL (Raspberry pi)VCC - (MLX90614) VCC (Raspberry pi)GND - (MLX90614) GND


#----------------------Object detection INSTRUCTIONS ----------------------
'''download the necessary files and packages for object detection from'''
#type this command to install openCV  --  pip install opencv-contrib-python
#----------------------------Infrared thermometer(MLX90614)INSTRUCTIONS -----------------------
# Enable I2C and PI Camera in raspberry settings, the procedure for the same is given in the presentation.
# Download the package of MLX90614 form the given link  --
''' These are commands for raspberry pi terminal window
tar -xf PyMLX90614-0.0.3.tar.gz        (to extract the folder with the extension of tar -xf file)
sudo apt-get install python-setuptools
sudo apt-get install -y i2c-tools
sudo apt-get install RPi.GPIO
sudo apt-get install Adafruit Blinka
sudo apt-get install adafruit-circuitpython-mlx90614/
apt-get install python3-rpi.gpio                                (to install the packages)
Go in the PyMLX90614-0.0.3 by typing ** cd PyMLX90614-0.0.3/
Now type this command - sudo python install
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.models import     load_model
from import VideoStream
from gpiozero import Servo
import numpy as np
import argparse
import imutils
import time
import cv2
import os
import RPi.GPIO as gpio
import board
import busio as io
import adafruit_mlx90614
***********************Face Mask Detection********************
def detect_and_predict_mask(frame, faceNet, maskNet):
    # grab the dimensions of the frame and then construct a blob
    # from it
    (h, w) = frame.shape[:2]
    blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300),
        (104.0, 177.0, 123.0))
    # pass the blob through the network and obtain the face detections
    detections = faceNet.forward()
    # initialize our list of faces, their corresponding locations,
    # and the list of predictions from our face mask network
    faces = []
    locs = []
    preds = []
    # loop over the detections
    for i in range(0, detections.shape[2]):
        # extract the confidence (i.e., probability) associated with
        # the detection
        confidence = detections[0, 0, i, 2]
        # filter out weak detections by ensuring the confidence is
        # greater than the minimum confidence
        if confidence > args["confidence"]:
            # compute the (x, y)-coordinates of the bounding box for
            # the object
            box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
            (startX, startY, endX, endY) = box.astype("int")
            # ensure the bounding boxes fall within the dimensions of
            # the frame
            (startX, startY) = (max(0, startX), max(0, startY))
            (endX, endY) = (min(w - 1, endX), min(h - 1, endY))
            # extract the face ROI, convert it from BGR to RGB channel
            # ordering, resize it to 224x224, and preprocess it
            face = frame[startY:endY, startX:endX]
            face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
            face = cv2.resize(face, (224, 224))
            face = img_to_array(face)
            face = preprocess_input(face)
            # add the face and bounding boxes to their respective
            # lists
            locs.append((startX, startY, endX, endY))
    # only make a predictions if at least one face was detected
    if len(faces) > 0:
        # for faster inference we'll make batch predictions on *all*
        # faces at the same time rather than one-by-one predictions
        # in the above `for` loop
        faces = np.array(faces, dtype="float32")
        preds = maskNet.predict(faces, batch_size=32)
    # return a 2-tuple of the face locations and their corresponding
    # locations
    return (locs, preds)
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-f", "--face", type=str,
    help="path to face detector model directory")
ap.add_argument("-m", "--model", type=str,
    help="path to trained face mask detector model")
ap.add_argument("-c", "--confidence", type=float, default=0.5,
    help="minimum probability to filter weak detections")
args = vars(ap.parse_args())
# load our serialized face detector model from disk
print("[INFO] loading face detector model...")
prototxtPath = os.path.sep.join([args["face"], "deploy.prototxt"])
weightsPath = os.path.sep.join([args["face"],
faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)
# load the face mask detector model from disk
print("[INFO] loading face mask detector model...")
maskNet = load_model(args["model"])
# initialize the video stream and allow the camera sensor to warm up
print("[INFO] starting video stream...")
#vs = VideoStream(src=0).start()
vs = VideoStream(usePiCamera=True).start()
# loop over the frames from the video stream
while True:
    # grab the frame from the threaded video stream and resize it
    # to have a maximum width of 400 pixels
    frame =
    frame = imutils.resize(frame, width=500)
    # detect faces in the frame and determine if they are wearing a
    # face mask or not
    (locs, preds) = detect_and_predict_mask(frame, faceNet, maskNet)
    # loop over the detected face locations and their corresponding
    # locations
    for (box, pred) in zip(locs, preds):
        # unpack the bounding box and predictions
        (startX, startY, endX, endY) = box
        (mask, withoutMask) = pred
        # determine the class label and color we'll use to draw
        # the bounding box and text
        if mask > withoutMask:
            label = "Thank You. Mask On."
            color = (0, 255, 0)
            label = "No Face Mask Detected"
            color = (0, 0, 255)
        #label = "Thank you" if mask > withoutMask else "Please wear your face mask"
        #color = (0, 255, 0) if label == "Thank you" else (0, 0, 255)
        # include the probability in the label
        #label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)
        # display the label and bounding box rectangle on the output
        # frame
        cv2.putText(frame, label, (startX-50, startY - 10),
            cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
        cv2.rectangle(frame, (startX, startY), (endX, endY), color, 2)
    # show the output frame
    cv2.imshow("Face Mask Detector", frame)
    key = cv2.waitKey(1) & 0xFF
    # if the `q` key was pressed, break from the loop
    if key == ord("q"):
# do a bit of cleanup
#**********************Infrared detection**************************
i2c = io.I2C(board.SCL, board.SDA, frequency=100000)
mlx = adafruit_mlx90614.MLX90614(i2c)
ambientTemp = "{:.2f}".format(mlx.ambient_temperature)
targetTemp = "{:.2f}".format(mlx.object_temperature)
fahrenheit = (targetTemp * 1.8) + 32
if fahrenheit > 99:
    b = 0
elif fahrenheit <= 99:
    b = 1
#***************************** CONDITION LOOP***************************
servo = Servo(25) # it defines the pin 25 for servo motor to control the gate
''' we are using a 360 degree motor for the slide gate
servo.max means gate open and servo.min means gate closed.'''
if a==1 and b==1:
    servo.max()                # both variables showing 1 means the person has worn the mask and doesn't suffer from fever
elif a==1 and b==0:
    servo.min()                #if a=1 and b=0 means the person has worn the mask but suffer from fever
elif a==0 and b==1:
    servo.min()                #if a=0 and b=1 means the person hasn't worn the mask but doesn't suffer from fever
elif a==0 and b==0:
    servo.min()                # both variables showing 1 means the person hasn't worn the mask and suffer from fever
#**************************************    END     ************************************