20 Second Hand Washing Timer For Covid-19

About the project

How to ensure we have washed for 20s? I made this 20 Second Hand Washing Timer for COVID-19. You can easily know the time and when time countdown is started and ended, the buzzer will remind you with beeps.

Project info

Difficulty: Easy

Platforms: Python

Estimated time: 1 hour

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

MakePython ESP32

x 1

Story

As the global COVID-19 spread, we should protect ourself not only by gathering less and wearing face mask, but also washing hand more often.

It ’s not effective against viruses if you don’t wash your hands properly.

How to wash our hands correctly? We should use hand soap, and washing 20 seconds at least. But how to ensure we have washed for 20s? So I made this 20 Second Hand Washing Timer for COVID-19. You can easily know the time and when time countdown is started and ended, the buzzer will remind you with beeps.

We should protect ourselves in this special period.

Step 1: Materials

20-Second-Hand-Washing-Timer-Materials

Collect all the components you will use in this project.

I used the following components, for your reference:

Hardware:

MakePython ESP32
Buzzer
HC-SR04 Ultrasonic Range Measurement Module
Breadboard
Some jump wires

Software:

uPyCraft V1.1

Step 2: Wire the Electronics

Wire the Electronics

Next, wire up the electronics components according to my wiring diagram.

HC-SR04----MakePython ESP32

VCC → 3.3V
Trig → IO13
Echo → IO12

Buzzer----MakePython ESP32

VCC → 3.3V
O/I →IO15
GND → GND

Step 3: Program and Test

Programming

Testing

All the component and circuit is ready, then flash the codes. You can download here.

Step 4: Install the Timer to Your Sink

Install the Timer to Your Sink

Ok, it is time for washing! Install the timer to your washing sink.

Note:

1. You should adjust the appropriate measuring distance of HC-SR04, according to the condition of your sink.

2. Pls be aware to protect the electronics from humidity and direct contact with water💧.

Step 5: Complete and Wash Your Hands

Complete and Wash Your Hands

Let's wash our hands for 20s and protect ourselves from the coronavirus!

Step 6: Other Display Solutions

As Python is a simple and easy-to-learn programming language, you can program by yourself to realize more creative and beautiful displays for the countdown animation.

As we can see there's also the MakePython ESP32 Color LCD which is very interesting, with a colorful LCD display, so those boards are limited only by your imagination!

In addition, Makerfabs provide One stop PCB assemblies service for makers/ startups, to help you to turn your designs into prototypes and final product rapidly. If you need some custom PCBA boards and small batch PCB assemblies, pls contact service@makerfabs.com.

Code

ssd1306.py

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
from micropython import const
import time
import framebuf
import sys

currentBoard=""
if(sys.platform=="esp8266"):
  currentBoard="esp8266"
elif(sys.platform=="esp32"):
  currentBoard="esp32"
elif(sys.platform=="pyboard"):
  currentBoard="pyboard"
  import pyb
# register definitions
SET_CONTRAST        = const(0x81)
SET_ENTIRE_ON       = const(0xa4)
SET_NORM_INV        = const(0xa6)
SET_DISP            = const(0xae)
SET_MEM_ADDR        = const(0x20)
SET_COL_ADDR        = const(0x21)
SET_PAGE_ADDR       = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP       = const(0xa0)
SET_MUX_RATIO       = const(0xa8)
SET_COM_OUT_DIR     = const(0xc0)
SET_DISP_OFFSET     = const(0xd3)
SET_COM_PIN_CFG     = const(0xda)
SET_DISP_CLK_DIV    = const(0xd5)
SET_PRECHARGE       = const(0xd9)
SET_VCOM_DESEL      = const(0xdb)
SET_CHARGE_PUMP     = const(0x8d)
class SSD1306:
  def __init__(self, width, height, external_vcc):
    self.width = width
    self.height = height
    self.external_vcc = external_vcc
    self.pages = self.height // 8
    self.buffer = bytearray(self.pages * self.width)
    self.framebuf = framebuf.FrameBuffer(self.buffer, self.width, self.height, framebuf.MVLSB)
    self.poweron()
    self.init_display()
  def init_display(self):
    for cmd in (
      SET_DISP | 0x00, # off
      # address setting
      SET_MEM_ADDR, 0x00, # horizontal
      # resolution and layout
      SET_DISP_START_LINE | 0x00,
      SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
      SET_MUX_RATIO, self.height - 1,
      SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
      SET_DISP_OFFSET, 0x00,
      SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
      # timing and driving scheme
      SET_DISP_CLK_DIV, 0x80,
      SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
      SET_VCOM_DESEL, 0x30, # 0.83*Vcc
      # display
      SET_CONTRAST, 0xff, # maximum
      SET_ENTIRE_ON, # output follows RAM contents
      SET_NORM_INV, # not inverted
      # charge pump
      SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
      SET_DISP | 0x01): # on
      self.write_cmd(cmd)
    self.fill(0)
    self.show()
  def poweroff(self):
    self.write_cmd(SET_DISP | 0x00)
  def contrast(self, contrast):
    self.write_cmd(SET_CONTRAST)
    self.write_cmd(contrast)
  def invert(self, invert):
    self.write_cmd(SET_NORM_INV | (invert & 1))
  def show(self):
    x0 = 0
    x1 = self.width - 1
    if self.width == 64:
      # displays with width of 64 pixels are shifted by 32
      x0 += 32
      x1 += 32
    self.write_cmd(SET_COL_ADDR)
    self.write_cmd(x0)
    self.write_cmd(x1)
    self.write_cmd(SET_PAGE_ADDR)
    self.write_cmd(0)
    self.write_cmd(self.pages - 1)
    self.write_data(self.buffer)
  def fill(self, col):
    self.framebuf.fill(col)
  def pixel(self, x, y, col):
    self.framebuf.pixel(x, y, col)
  def scroll(self, dx, dy):
    self.framebuf.scroll(dx, dy)
  def text(self, string, x, y, col=1):
    self.framebuf.text(string, x, y, col)
  def hline(self, x, y, w, col):
    self.framebuf.hline(x, y, w, col)
  def vline(self, x, y, h, col):
    self.framebuf.vline(x, y, h, col)
  def line(self, x1, y1, x2, y2, col):
    self.framebuf.line(x1, y1, x2, y2, col)
  def rect(self, x, y, w, h, col):
    self.framebuf.rect(x, y, w, h, col)
  def fill_rect(self, x, y, w, h, col):
    self.framebuf.fill_rect(x, y, w, h, col)
  def blit(self, fbuf, x, y):
    self.framebuf.blit(fbuf, x, y)

class SSD1306_I2C(SSD1306):
  def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
    self.i2c = i2c
    self.addr = addr
    self.temp = bytearray(2)
    super().__init__(width, height, external_vcc)
  def write_cmd(self, cmd):
    self.temp[0] = 0x80 # Co=1, D/C#=0
    self.temp[1] = cmd
    #IF SYS  :
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.i2c.writeto(self.addr, self.temp)
    elif currentBoard=="pyboard":
      self.i2c.send(self.temp,self.addr)
    #ELSE:
          
  def write_data(self, buf):
    self.temp[0] = self.addr << 1
    self.temp[1] = 0x40 # Co=0, D/C#=1
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.i2c.start()
      self.i2c.write(self.temp)
      self.i2c.write(buf)
      self.i2c.stop()
    elif currentBoard=="pyboard":
      #self.i2c.send(self.temp,self.addr)
      #self.i2c.send(buf,self.addr)
      self.i2c.mem_write(buf,self.addr,0x40)
  def poweron(self):
    pass

class SSD1306_SPI(SSD1306):
  def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
    self.rate = 10 * 1024 * 1024
    dc.init(dc.OUT, value=0)
    res.init(res.OUT, value=0)
    cs.init(cs.OUT, value=1)
    self.spi = spi
    self.dc = dc
    self.res = res
    self.cs = cs
    super().__init__(width, height, external_vcc)
  def write_cmd(self, cmd):
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.init(baudrate=self.rate, polarity=0, phase=0)
    elif currentBoard=="pyboard":
      self.spi.init(mode = pyb.SPI.MASTER,baudrate=self.rate, polarity=0, phase=0)
    self.cs.high()
    self.dc.low()
    self.cs.low()
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.write(bytearray([cmd]))
    elif currentBoard=="pyboard":
      self.spi.send(bytearray([cmd]))
    self.cs.high()
  def write_data(self, buf):
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.init(baudrate=self.rate, polarity=0, phase=0)
    elif currentBoard=="pyboard":
      self.spi.init(mode = pyb.SPI.MASTER,baudrate=self.rate, polarity=0, phase=0)
    self.cs.high()
    self.dc.high()
    self.cs.low()
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.write(buf)
    elif currentBoard=="pyboard":
      self.spi.send(buf)
    self.cs.high()
  def poweron(self):
    self.res.high()
    time.sleep_ms(1)
    self.res.low()
    time.sleep_ms(10)
    self.res.high()

main.py

from machine import Pin,I2C,PWM
from hcsr04 import HCSR04
import ssd1306
import time 

i2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000)     
olcd=ssd1306.SSD1306_I2C(128,64,i2c)

sensor = HCSR04(trigger_pin=13, echo_pin=12,echo_timeout_us=1000000)
sound = Pin(15,Pin.OUT)

def Display():
  tim = 20
  t = 0
  b = 0
  olcd.fill(0) 
  olcd.rect(4, 20, 120, 6, 1)
  olcd.rect(3, 19, 122, 8, 1)
  olcd.rect(2, 20, 2, 6, 1)
  olcd.rect(1, 21, 2, 4, 1)
  olcd.rect(125, 20, 2, 6, 1)
  olcd.rect(126, 21, 2, 4, 1)
  olcd.text(str(tim), 75, 40)
  olcd.text('washing..', 35, 5)
  olcd.text('time:', 35, 40)
  for a in range(5,125):
    olcd.line(a, 21, a, 24, 1)
    olcd.show()
    time.sleep_ms(150)  
    t = t + 1  
    if t >= 6:
      tim = tim - 1
      b = b + 1
      #time.sleep_ms(60)
      olcd.fill_rect(75, 40, 20, 20, 0)     
      olcd.text(str(tim), 75, 40)
      olcd.text( '.', 107, 5)  
      t = 0
      if tim < 1:   
        #time.sleep(1)
        olcd.fill_rect(75, 40, 20, 20, 0)
        olcd.text('ok', 75, 40)  
      if b >= 2:
        olcd.fill_rect(107, 5, 12, 12, 0)
        olcd.show()
        b = 0
        
  olcd.show()
        
def Display_wait():
  olcd.fill(0) 
  olcd.rect(4, 20, 120, 6, 1)
  olcd.rect(3, 19, 122, 8, 1)
  olcd.rect(2, 20, 1, 6, 1)
  olcd.rect(1, 21, 1, 4, 1)
  olcd.rect(125, 20, 2, 6, 1)
  olcd.rect(126, 21, 2, 4, 1)

  olcd.text('waiting...', 35, 5)
  olcd.text('Please wash', 20, 35)
  olcd.text('your hands', 22, 48)
  olcd.show()
  
try:
  while True:
    Display_wait()
    sound.value(1)
    distance = sensor.distance_cm()
    if distance < 20:
      sound.value(0)
      time.sleep_ms(400)
      sound.value(1)
      Display()
      for i in range(3):
        sound.value(0)
        time.sleep_ms(600)
        sound.value(1)
        time.sleep_ms(400)
      olcd.fill(0)
    
except KeyboardInterrupt:
          pass

hcsr04.py

import machine, time
from machine import Pin

__version__ = '0.2.0'
__author__ = 'Roberto Schez'
__license__ = "Apache License 2.0. https://www.apache.org/licenses/LICENSE-2.0"

class HCSR04:
    """
    Driver to use the untrasonic sensor HC-SR04.
    The sensor range is between 2cm and 4m.

    The timeouts received listening to echo pin are converted to OSError('Out of range')

    """
    # echo_timeout_us is based in chip range limit (400cm)
    def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):
        """
        trigger_pin: Output pin to send pulses
        echo_pin: Readonly pin to measure the distance. The pin should be protected with 1k resistor
        echo_timeout_us: Timeout in microseconds to listen to echo pin. 
        By default is based in sensor limit range (4m)
        """
        self.echo_timeout_us = echo_timeout_us
        # Init trigger pin (out)
        self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)
        self.trigger.value(0)

        # Init echo pin (in)
        self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)

    def _send_pulse_and_wait(self):
        """
        Send the pulse to trigger and listen on echo pin.
        We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received.
        """
        self.trigger.value(0) # Stabilize the sensor
        time.sleep_us(5)
        self.trigger.value(1)
        # Send a 10us pulse.
        time.sleep_us(10)
        self.trigger.value(0)
        try:
            pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us)
            return pulse_time
        except OSError as ex:
            if ex.args[0] == 110: # 110 = ETIMEDOUT
                raise OSError('Out of range')
            raise ex

    def distance_mm(self):
        """
        Get the distance in milimeters without floating point operations.
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.34320 mm/us that is 1mm each 2.91us
        # pulse_time // 2 // 2.91 -> pulse_time // 5.82 -> pulse_time * 100 // 582 
        mm = pulse_time * 100 // 582
        return mm

    def distance_cm(self):
        """
        Get the distance in centimeters with floating point operations.
        It returns a float
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.034320 cm/us that is 1cm each 29.1us
        cms = (pulse_time / 2) / 29.1
        return cms

Credits

Makerfabs01

Makerfabs, Turnkey PCB Assemblies | Small Batch PCBA Prototyping | IoT Hardware Engineering.

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

20 Second Hand Washing Timer For Covid-19

About the project

Project info

Items used in this project

Hardware components

Story

Step 1: Materials

Step 2: Wire the Electronics

Step 3: Program and Test

Step 4: Install the Timer to Your Sink

Step 5: Complete and Wash Your Hands

Step 6: Other Display Solutions

Code

ssd1306.py

main.py

hcsr04.py

Credits

Makerfabs01

Leave your feedback...

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

20 Second Hand Washing Timer For Covid-19

About the project

Project info

Items used in this project

Hardware components

Story

Step 1: Materials

Step 2: Wire the Electronics

Step 3: Program and Test

Step 4: Install the Timer to Your Sink

Step 5: Complete and Wash Your Hands

Step 6: Other Display Solutions

Code

ssd1306.py

main.py

hcsr04.py

Credits

Makerfabs01

Leave your feedback...

Related products