What is the UVC dose for killing or disabling the COVID-19 virus
My Design

Published August 31, 2020 © GPL3+

Covid Warrior 1

A 4WD Robot which deactivates pathogens including COVID-19 utilizing UVC light from a surface.

AdvancedFull instructions providedOver 2 days2,303

First 25 Qualified Contest Entries

UV Robot Design Contest

Things used in this project

Hardware components

DFRobot Rover 5 Tank Chassis

Raspberry Pi 3 Model B

Raspberry Pi Camera Module

Arduino UNO

Adafruit Motor Shield for Arduino kit - v1.2

PIR Motion Sensor (generic)

HC-05 Bluetooth Module

Li-ion battery

Software apps and online services

MIT App Inventor 2

Arduino IDE

Raspberry Pi Raspbian

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Multitool, Screwdriver

Story

The absolute best way of dealing with the coronavirus pandemic is to just not get coronavirus in the first place. By now, you’ve (hopefully) had all of the strategies for doing this drilled into your skull—wash your hands, keep away from large groups of people, wash your hands, stay home when sick, wash your hands, avoid travel when possible, and please, please wash your hands.

As COVID-19 spreads across the world, hospitals have become ground zero for the coronavirus and this is top of the list of the places to avoid right now are hospitals, because that’s where all the really sick people go. But for healthcare workers, and the sick people themselves, there’s really no other option. To prevent the spread of coronavirus (and everything else) through hospitals, keeping surfaces disinfected is incredibly important, but it’s also dirty, dull, and (considering what you can get infected with) dangerous. And that’s why it’s an ideal task for autonomous robots.

Surfaces contaminated with SARS-CoV-2 pose a grave threat to the safety of staff and patients. To minimize the risks for their staff, hospitals are utilizing disinfection robots to sanitize surfaces. The robot can drives autonomously or remotely around hospitals emitting UVC light of 254-nanometer to eliminate bacteria and other harmful microorganisms. Using UVC robot, hospitals can guarantee a 99.99 percent disinfection rate – reducing the risk for patients, staff and relatives of contracting dangerous infections.

Can UVC lamps inactivate the SARS-CoV-2 coronavirus?

UVC radiation is a known disinfectant for air, water, and nonporous surfaces. UVC radiation has effectively been used for decades to reduce the spread of bacteria, such as tuberculosis. For this reason, UVC lamps are often called "germicidal" lamps.

UVC radiation has been shown to destroy the outer protein coating of the SARS-Coronavirus, which is a different virus from the current SARS-CoV-2 virus. The destruction ultimately leads to inactivation of the virus. (see Far-UVC light (222 nm) efficiently and safely inactivates airborne human coronavirusesExternal Link Disclaimer). UVC radiation may also be effective in inactivating the SARS-CoV-2 virus, which is the virus that causes the Coronavirus Disease 2019 (COVID-19). For more information see "Q: Where can I read more about UV radiation and disinfection?". However, currently there is limited published data about the wavelength, dose, and duration of UVC radiation required to inactivate the SARS-CoV-2 virus.

In addition to understanding whether UVC radiation is effective at inactivating a particular virus, there are also limitations to how effective UVC radiation can be at inactivating viruses, generally.

Direct exposure: UVC radiation can only inactivate a virus if the virus is directly exposed to the radiation. Therefore, the inactivation of viruses on surfaces may not be effective due to blocking of the UV radiation by soil, such as dust, or other contaminants such as bodily fluids.
Dose and duration: Many of the UVC lamps sold for home use are of low dose, so it may take longer exposure to a given surface area to potentially provide effective inactivation of a bacteria or virus.

Is it safe to use a UVC lamp for disinfection purposes at home?

A: Consider both the risks of UVC lamps to people and objects and the risk of incomplete inactivation of virus.

Risks: UVC lamps used for disinfection purposes may pose potential health and safety risks depending on the UVC wavelength, dose, and duration of radiation exposure. The risk may increase if the unit is not installed properly or used by untrained individuals.

Direct exposure of skin and eyes to UVC radiation from some UVC lamps may cause painful eye injury and burn-like skin reactions. Never look directly at a UVC lamp source, even briefly. If you have experienced an injury associated with using a UVC lamp, we encourage you to report it to the FDA.
Some UVC lamps generate ozone. Ozone inhalation can be irritating to the airway.
UVC can degrade certain materials, such as plastic, polymers, and dyed textile.
Some UVC lamps contain mercury. Because mercury is toxic even in small amounts, extreme caution is needed in cleaning a lamp that has broken and in disposing of the lamp.

[Source: https://www.fda.gov/medical-devices/coronavirus-covid-19-and-medical-devices/uv-lights-and-lamps-ultraviolet-c-radiation-disinfection-and-coronavirus]

Far-UVC light (207 to 222nm) has been shown to be as efficient as conventional germicidal UV light in killing microorganisms11, but studies to date suggest that these wavelengths do not cause the human health issues associated with direct exposure to conventional germicidal UV light. In short (see below) the reason is that far-UVC light has a range in biological materials of less than a few micrometers, and thus it cannot reach living human cells in the skin or eyes, being absorbed in the skin stratum corneum or the ocular tear layer. But because viruses (and bacteria) are extremely small, far-UVC light can still penetrate and kill them. Tus far-UVC light potentially has about the same highly effective germicidal properties of UV light, but without the associated human health risks. Several groups have thus proposed that far-UVC light (207 or 222 nm), which can be generated using inexpensive excimer lamps, is a potentially safe and efficient anti-microbial technology which can be deployed in occupied public locations.

What is the UVC dose for killing or disabling the COVID-19 virus?

Because the COVID-19 virus (SARS-CoV-2) is so new, the scientific community doesn’t yet have a specific deactivation dosage. However, we know the dosage values for comparable viruses in the same SARS virus family are 10-20 mJ/cm2 using direct UVC light at a wavelength of 254nm; this dosage will achieve 99.9% disinfection (i.e., inactivation) under controlled lab conditions. In real-life, the virus is often hidden or shaded from direct UVC light, reducing UVC’s effectiveness.

Using a simple UVGI chamber setup consisting of a 15 W UV-C bulb placed 0.15 meters (6 inches) away from the sanitizing surface will require at least 2 hours of exposure to achieve the target inactivation dosage.

My Design

I use a 4WD tank chassis for my robot. It is a chassis from DFRobot with 4 encoder gear motors. I connected 4 motors with Arduino using Adafruit motor driver shield 1. The robot will be controlled remotely using Bluetooth. For controlling an Android app was developed using MIT App Inventor. The source code of the app is attached.

1 / 2

I used a PVC pipe for supporting UVC lamps and as the same time housing the circuit components like Arduino, Motor driver and Raspberry Pi.

1 / 4

As the robot will be operated from outside of the room video streaming is required for viewing inside the room otherwise remote control will not be possible.I used Raspberry Pi with 5MP camera module for broadcasting the video of the room/place. The python code for raspberry pi for video streaming is attached.

I cut the PVC pipe with a hacksaw for bringing out the camera ribbon. Raspberry Pi is placed inside the pipe. The camera is fixed with the pipe using double-sided tape.

1 / 3

PIR motion sensors were placed to identify any live object in the room. Four PIR sensors ware used for covering all the surroundings of the robot. The robot will be operated from android app the disinfection lamp will be also operated from the app. If there is any living object inside the room the lamp will not be on and send a notification to the operator through the app. The video of the room will also be viewed from the app.

1 / 2

After connecting all the sensors and the Bluetooth module with the Arduino the whole electronics parts ware placed inside the pipe. I used some hot glue to fixed all the components with the pipe.

1 / 2

Then the pipe with all the components ware place in the middle place of the chassis and fixed with some glue. For powering the UVC lamps from battery we need an inverter. The ratting of the inverter should be 100W because I am using 4, 15W lamps. For the demonstration purpose, I am using direct AC supply using a long ac cable.

1 / 2

For powering all the other electronics including motor I used a 3 cell lipo battery. After powering the robot the completed robot looks like the following.

The code Arduino and Raspberri Pi, the schematic, and the android app source are attached in the code section.

Code

#include <AFMotor.h>
#include <SoftwareSerial.h>
SoftwareSerial bluetoothSerial(9, 10); // RX, TX

AF_DCMotor front_right(1);
AF_DCMotor front_left(2);
AF_DCMotor back_right(3);
AF_DCMotor back_left(4);

int pir1 = 14;
int pir2 = 15;
int pir3 = 16;
int pir4 = 17;

boolean pirStat1 = false;
boolean pirStat2 = false; 
boolean pirStat3 = false; 
boolean pirStat4 = false;  

int vuc_lamp = 13;

int manualSpeed = 160;

boolean living_object = false; 

char btCommand = 'S';
char prevCommand = 'A';
int velocity = 0;   
unsigned long timer0 = 2000;  //Stores the time (in millis since execution started) 
unsigned long timer1 = 0;  //Stores the time when the last command was received from the phone

String inputString = "";
String command = "";
String value = "";
boolean stringComplete = false; 

void setup() {
  
  bluetoothSerial.begin(9600); //set the baud rate for your bluetooth mode
  
  pinMode(pir1, INPUT);
  pinMode(pir2, INPUT);
  pinMode(pir3, INPUT);
  pinMode(pir4, INPUT);
  pinMode(uvc_lamp, OUTPUT);
  
  // turn on motor
  front_right.setSpeed(150);
  front_left.setSpeed(150);
  back_right.setSpeed(150);
  back_left.setSpeed(150);
 
  front_right.run(RELEASE);
  front_left.run(RELEASE);
  back_right.run(RELEASE);
  back_left.run(RELEASE);

  inputString.reserve(50);  // reserve 50 bytes in memory to save for string manipulation 
  command.reserve(50);
  value.reserve(50);
}

void loop() {

//  front_right.setSpeed(manualSpeed);
//  front_left.setSpeed(manualSpeed);
//  back_right.setSpeed(manualSpeed);
//  back_left.setSpeed(manualSpeed);

  pirStat1 = digitalRead(pir1);
  pirStat2 = digitalRead(pir2);
  pirStat3 = digitalRead(pir3);
  pirStat4 = digitalRead(pir4); //if any sensor detect motor state goes to high
   
  if (pirStat1 == HIGH || pirStat2 == HIGH || pirStat3 == HIGH || pirStat4 == HIGH) {            // if motion detected
   living_object = true; 
  }  
  bluetoothControl();
  
}

motor.run(FORWARD);
motor.run(BACKWARD);
motor.run(RELEASE);

void run_forward(){
   front_right.run(FORWARD);
   front_left.run(FORWARD);
   back_right.run(FORWARD);
   back_left.run(FORWARD);
 }

void run_backward(){
   front_right.run(BACKWARD);
   front_left.run(BACKWARD);
   back_right.run(BACKWARD);
   back_left.run(BACKWARD);
 }

void stop_position(){
   front_right.run(RELEASE);
   front_left.run(RELEASE);
   back_right.run(RELEASE);
   back_left.run(RELEASE);
 }

void rotate_write(){
   front_right.run(BACKWARD);
   front_left.run(FORWARD);
   back_right.run(BACKWARD);
   back_left.run(FORWARD);
 }

void rotate_left(){
   front_right.run(FORWARD);
   front_left.run(BACKWARD);
   back_right.run(FORWARD);
   back_left.run(BACKWARD);
 }


 void serialEvent() {
  while (bluetoothSerial.available()) {
    // get the new byte:
    char inChar = (char)bluetoothSerial.read(); 
    //Serial.write(inChar);
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline or a carriage return, set a flag
    // so the main loop can do something about it:
    if (inChar == '\n' || inChar == '\r') {
      stringComplete = true;
    } 
  }
}


void bluetoothControl(){
  if(bluetoothSerial.available() > 0){ 
    timer1 = millis();   
    prevCommand = btCommand;
    btCommand = bluetoothSerial.read(); 
    //Change pin mode only if new command is different from previous.   
    if(btCommand!=prevCommand){
      //Serial.println(command);
      switch(btCommand){
      case 'F':  
        run_forward();
        break;
      case 'B':  
        run_backward();
        break;
      case 'L':  
        rotate_left();
        break;
      case 'R':
        rotate_right();
        break;
      case 'S':  
        stop_position();
        break; 
      case 'U':  //uvc 
        if(!living_object)
          digitalWrite(uvc_lamp, HIGH);
        break;
      case 'V':  //uvc 
        digitalWrite(uvc_lamp, LOW);
        break;       
      default:  //Get velocity
        if(btCommand=='q'){
          velocity = 255;  //Full velocity
          manualSpeed = velocity;
        }
        else{ 
          //Chars '0' - '9' have an integer equivalence of 48 - 57, accordingly.
          if((btCommand >= 48) && (btCommand <= 57)){ 
            //Subtracting 48 changes the range from 48-57 to 0-9.
            //Multiplying by 25 changes the range from 0-9 to 0-225.
            velocity = (btCommand - 48)*25;       
            manualSpeed = velocity;
          }
        }
      }
    }
  } 
}

# Web streaming example
# Source code from the official PiCamera package
# http://picamera.readthedocs.io/en/latest/recipes2.html#web-streaming

import io
import picamera
import logging
import socketserver
from threading import Condition
from http import server

PAGE="""\
<html>
<head>
<title>COVID Warrior Robot</title>
</head>
<body>
<center><h3>COVID Warrior Robot</h3></center>
<center><img src="stream.mjpg" width="380" height="340"></center>
</body>
</html>
"""

class StreamingOutput(object):
    def __init__(self):
        self.frame = None
        self.buffer = io.BytesIO()
        self.condition = Condition()

    def write(self, buf):
        if buf.startswith(b'\xff\xd8'):
            # New frame, copy the existing buffer's content and notify all
            # clients it's available
            self.buffer.truncate()
            with self.condition:
                self.frame = self.buffer.getvalue()
                self.condition.notify_all()
            self.buffer.seek(0)
        return self.buffer.write(buf)

class StreamingHandler(server.BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/':
            self.send_response(301)
            self.send_header('Location', '/index.html')
            self.end_headers()
        elif self.path == '/index.html':
            content = PAGE.encode('utf-8')
            self.send_response(200)
            self.send_header('Content-Type', 'text/html')
            self.send_header('Content-Length', len(content))
            self.end_headers()
            self.wfile.write(content)
        elif self.path == '/stream.mjpg':
            self.send_response(200)
            self.send_header('Age', 0)
            self.send_header('Cache-Control', 'no-cache, private')
            self.send_header('Pragma', 'no-cache')
            self.send_header('Content-Type', 'multipart/x-mixed-replace; boundary=FRAME')
            self.end_headers()
            try:
                while True:
                    with output.condition:
                        output.condition.wait()
                        frame = output.frame
                    self.wfile.write(b'--FRAME\r\n')
                    self.send_header('Content-Type', 'image/jpeg')
                    self.send_header('Content-Length', len(frame))
                    self.end_headers()
                    self.wfile.write(frame)
                    self.wfile.write(b'\r\n')
            except Exception as e:
                logging.warning(
                    'Removed streaming client %s: %s',
                    self.client_address, str(e))
        else:
            self.send_error(404)
            self.end_headers()

class StreamingServer(socketserver.ThreadingMixIn, server.HTTPServer):
    allow_reuse_address = True
    daemon_threads = True

with picamera.PiCamera(resolution='640x480', framerate=24) as camera:
    output = StreamingOutput()
    #Uncomment the next line to change your Pi's Camera rotation (in degrees)
    #camera.rotation = 90
    camera.start_recording(output, format='mjpeg')
    try:
        address = ('', 8000)
        server = StreamingServer(address, StreamingHandler)
        server.serve_forever()
    finally:
        camera.stop_recording()

Credits

Md. Khairul Alam

68 projects • 584 followers

Developer, Maker & Hardware Hacker. Currently working as a faculty at the University of Asia Pacific, Dhaka, Bangladesh.

Comments

Awards

First 25 Qualified Contest Entries

UV Robot Design Contest

Covid Warrior 1