Hardware components | ||||||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 2 | |||
| × | 2 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 4 | ||||
 |
| × | 1 | |||
| × | 4 | ||||
| × | 1 | ||||
piCounter v1.0 for Indoor Social Distancing Control
Read moreDue to the Covid-19 pandemic, the importance of social distance, which should be at least 1.5-2 meters, has increased. While this increase caused many new rules, it also brought some obligations.
It is obvious that one of the most important of these obligations is the limit of the maximum number of people that can exist indoors.
In an interior; for example, a cafe, a bakery, a grocery store, or a public toilet, etc. It is necessary to monitor the number of people inside and the distance of this number to the limit.
piCounter is a device that will provide exactly this tracking and carry out the necessary pre-planned instructions.
The piCounter will process the signals it receives from the ultrasonic sensors on it, count the people entering and leaving, and will give a warning when the limit is approached by showing the current number inside. When the limit is reached or no one is inside, it will do its part by carrying out the necessary pre-planned instructions (such as sounding an alarm when the limit is reached, activating the security system when no one is inside, and turning off the lights, etc.).
piCounter can be easily transported and installed with the advantage of having an internal battery. The internal 18650 battery can be charged via the power panel, output can be obtained if desired. This battery is rechargeable, can be used as a power source. It can give linear 5V 1A output.
piCounter is a customizable device. You can change the limit according to the place where you will install, and the direction of the entrance according to the door you will install from the set mode.
When we set the distance to the door of the sensors with the potentiometer on the front panel can make a more accurate count.
Range Adjustment:
There are three push buttons used to adjust the person limit that can be indoor and also to adjust the entrance direction. When the left button is pressed once it will enable the set mode for the limit, each press on the middle button will decrease the limit and each press on the right button will increase the limit. The second press for the left button will enable the set mode for the direction of the entrance. The middle button will set the direction from the left to right and the right button will set the direction from the right to left. The third press on the left button will disable the setting mode.
Limit and Entrance Direction Adjustment:
With the potentiometer on the other side of the box, the brightness of the screen can be adjusted, the piCounter can be reset, or it can be turned off and on completely.
Left Panel:
It starts to flash when 2 people are left to the limit assigned by the led on it. When the limit is reached and the limit is exceeded, the LED lights continuously.
Video Shows the Limit Working Principle:
Code:
I preferred object-oriented programming to work somewhat modularly and wrote the range finder and lcd classes to be reusable.
import time
from machine import Pin, ADC, PWM
from range_finder import RangeFinder
from gpio_lcd import GpioLcd
class VisitorCounter():
def __init__(self):
self.potValue = 0
self.counter = 0
self.first = 0
self.second = 0
self.prior = 0
self.limit = 2
self.time1 = 0
self.distance1 = 0
self.time2 = 0
self.distance2 = 0
self.limitRange = 0
self.doorRange = 0
self.pot = ADC(26) # the middle pin on the Potentiometer
self.lcd = GpioLcd(rs_pin=Pin(7),
enable_pin=Pin(9),
d4_pin=Pin(10),
d5_pin=Pin(11),
d6_pin=Pin(12),
d7_pin=Pin(13),
num_lines=2, num_columns=16)
self.led = Pin(25, Pin.OUT)
self.warningLed = Pin(0, Pin.OUT)
self.rangeFinderObject = RangeFinder(echo_pin=15, trigger_pin=14)
self.rangeFinderObject2 = RangeFinder(echo_pin=21, trigger_pin=20)
def setup(self):
self.lcd.clear()
self.lcd.move_to(0,0)
self.lcd.putstr("Limit : " + str(self.limit))
time.sleep(2)
self.lcd.clear()
#time.sleep(0.01)
self.lcd.move_to(0,0) # default cursor position is (0,0)
self.lcd.putstr("Existing: " + str(self.counter))
self.setButton = Pin(16, Pin.IN, Pin.PULL_DOWN)
self.decButton = Pin(17, Pin.IN, Pin.PULL_DOWN)
self.incButton = Pin(18, Pin.IN, Pin.PULL_DOWN)
""" Maps two ranges together """
def range_mapper(self,x, in_min, in_max, out_min, out_max):
return int((x-in_min) * (out_max-out_min) / (in_max - in_min) + out_min)
def run(self):
while True:
print("tt")
if self.limit - self.counter <= 2 and self.limit - self.counter >0 and self.limit - self.counter != 0:
self.warningLed.on()
time.sleep(0.1)
self.warningLed.off()
time.sleep(0.1)
elif self.limit - self.counter <= 0:
self.warningLed.on()
else:
self.warningLed.off()
if self.setButton.value():
time.sleep(0.2)
print("111")
self.lcd.clear()
self.lcd.putstr("Current Limit : " + str(self.limit))
while True:
if self.incButton.value():
time.sleep(0.2)
print("222")
self.limit += 1
self.lcd.clear()
self.lcd.putstr("Current Limit : " + str(self.limit))
elif self.decButton.value():
time.sleep(0.2)
print("333")
self.limit -= 1
self.lcd.clear()
self.lcd.putstr("Current Limit : " + str(self.limit))
elif self.setButton.value():
time.sleep(0.2)
self.lcd.clear()
self.lcd.putstr("Set direction mode. (Right/Left)")
while True:
if self.incButton.value():
time.sleep(0.2)
self.rangeFinderObject2 = RangeFinder(echo_pin=15, trigger_pin=14)
self.rangeFinderObject = RangeFinder(echo_pin=21, trigger_pin=20)
self.lcd.clear()
self.lcd.putstr("Right to left.")
elif self.decButton.value():
time.sleep(0.2)
self.rangeFinderObject = RangeFinder(echo_pin=15, trigger_pin=14)
self.rangeFinderObject2 = RangeFinder(echo_pin=21, trigger_pin=20)
self.lcd.clear()
self.lcd.putstr("Left to right.")
if self.setButton.value():
time.sleep(0.2)
break
#self.lcd.clear()
print("set")
break
time.sleep(0.2)
potValue = self.pot.read_u16()
distanceLimit = self.range_mapper(potValue,600, 65535,0,330)
self.doorRange = distanceLimit
self.lcd.clear()
self.lcd.move_to(0,0) # default cursor position is (0,0)
self.lcd.putstr("Existing: " + str(self.counter))
self.lcd.move_to(0,1)
self.lcd.putstr("Range: " + str(distanceLimit) + " cm")
if(self.counter < 0): #reset
self.counter = 0
self.first = 0
self.second = 0
self.prior = 0
# next 3 lines are equal to setup() method
self.lcd.clear()
#time.sleep(0.01)
self.lcd.move_to(0,0)
self.lcd.putstr("Existing: " + str(self.counter))
if(self.counter >= 3):
self.led.on()
else:
self.led.off()
print(self.counter)
print(self.first," ",self.second," ",self.prior)
self.distance1 = round(self.rangeFinderObject.find(),1) # distance calculated in cm
print(self.distance1)
if (self.distance1 < self.doorRange and self.distance1 != 0 and self.first == 0): # first sensor detected
self.first = 1
if(self.prior == 0):
self.prior = 1
print("first active")
elif (self.distance1 > self.doorRange):
self.first = 0
if(self.prior == 2 and self.first == 1 and self.second == 0):
print("exit")
self.counter -= 1
self.prior = 0
if self.counter < 0:
self.counter = 0
# next 3 lines are equal to setup() method
self.lcd.clear()
#time.sleep(0.01)
self.lcd.move_to(0,0)
self.lcd.putstr("Existing: " + str(self.counter))
time.sleep(0.1)
self.distance2 = round(self.rangeFinderObject2.find(),1)
print(self.distance2)
if(self.distance2 < self.doorRange and self.distance2 != 0 and self.second == 0):
self.second = 1
print("second active")
if(self.prior == 0 and self.first == 0):
self.prior = 2
elif (self.distance2 > self.doorRange):
self.second = 0
if(self.prior == 1 and self.first == 0 and self.second == 1):
self.counter += 1
self.prior = 0
# next 3 lines are equal to setup() method
self.lcd.clear()
#time.sleep(0.01)
self.lcd.move_to(0,0)
self.lcd.putstr("Existing: " + str(self.counter))
print("entry")
visitorCounter = VisitorCounter()
visitorCounter.setup()
visitorCounter.run()Libraries and classes required for this code to work:
You can also download these codes from the bottom of the page.
range_finder.py
from time import sleep_us, ticks_us
from machine import Pin, ADC, PWM
import time
class RangeFinder():
duration = 0
distance = 0
def __init__(self, echo_pin, trigger_pin):
self.__echo_pin = Pin(echo_pin, Pin.IN)
self.__trigger_pin = Pin(trigger_pin, Pin.OUT)
def find(self):
self.__trigger_pin.low()
sleep_us(2)
self.__trigger_pin.high()
sleep_us(5)
self.__trigger_pin.low()
signal_on = 0
signal_off = 0
while self.__echo_pin.value() == 0:
signal_off = ticks_us()
while self.__echo_pin.value() == 1:
signal_on = ticks_us()
elapsed_time = signal_on - signal_off
self.duration = elapsed_time
self.distance = (elapsed_time * 0.343) / 2
return self.distance / 10gpio_lcd.py
"""Implements a HD44780 character LCD connected via ESP32 GPIO pins."""
from lcd_api import LcdApi
from machine import Pin
from utime import sleep_ms, sleep_us
class GpioLcd(LcdApi):
"""Implements a HD44780 character LCD connected via ESP32 GPIO pins."""
def __init__(self, rs_pin, enable_pin, d0_pin=None, d1_pin=None,
d2_pin=None, d3_pin=None, d4_pin=None, d5_pin=None,
d6_pin=None, d7_pin=None, rw_pin=None, backlight_pin=None,
num_lines=2, num_columns=16):
"""Constructs the GpioLcd object. All of the arguments must be machine.Pin
objects which describe which pin the given line from the LCD is
connected to.
When used in 4-bit mode, only D4, D5, D6, and D7 are physically
connected to the LCD panel. This function allows you call it like
GpioLcd(rs, enable, D4, D5, D6, D7) and it will interpret that as
if you had actually called:
GpioLcd(rs, enable, d4=D4, d5=D5, d6=D6, d7=D7)
The enable 8-bit mode, you need pass d0 through d7.
The rw pin isn't used by this library, but if you specify it, then
it will be set low.
"""
self.rs_pin = rs_pin
self.enable_pin = enable_pin
self.rw_pin = rw_pin
self.backlight_pin = backlight_pin
self._4bit = True
if d4_pin and d5_pin and d6_pin and d7_pin:
self.d0_pin = d0_pin
self.d1_pin = d1_pin
self.d2_pin = d2_pin
self.d3_pin = d3_pin
self.d4_pin = d4_pin
self.d5_pin = d5_pin
self.d6_pin = d6_pin
self.d7_pin = d7_pin
if self.d0_pin and self.d1_pin and self.d2_pin and self.d3_pin:
self._4bit = False
else:
# This is really 4-bit mode, and the 4 data pins were just
# passed as the first 4 arguments, so we switch things around.
self.d0_pin = None
self.d1_pin = None
self.d2_pin = None
self.d3_pin = None
self.d4_pin = d0_pin
self.d5_pin = d1_pin
self.d6_pin = d2_pin
self.d7_pin = d3_pin
self.rs_pin.init(Pin.OUT)
self.rs_pin.value(0)
if self.rw_pin:
self.rw_pin.init(Pin.OUT)
self.rw_pin.value(0)
self.enable_pin.init(Pin.OUT)
self.enable_pin.value(0)
self.d4_pin.init(Pin.OUT)
self.d5_pin.init(Pin.OUT)
self.d6_pin.init(Pin.OUT)
self.d7_pin.init(Pin.OUT)
self.d4_pin.value(0)
self.d5_pin.value(0)
self.d6_pin.value(0)
self.d7_pin.value(0)
if not self._4bit:
self.d0_pin.init(Pin.OUT)
self.d1_pin.init(Pin.OUT)
self.d2_pin.init(Pin.OUT)
self.d3_pin.init(Pin.OUT)
self.d0_pin.value(0)
self.d1_pin.value(0)
self.d2_pin.value(0)
self.d3_pin.value(0)
if self.backlight_pin is not None:
self.backlight_pin.init(Pin.OUT)
self.backlight_pin.value(0)
# See about splitting this into begin
sleep_ms(20) # Allow LCD time to powerup
# Send reset 3 times
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(5) # need to delay at least 4.1 msec
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(1)
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(1)
cmd = self.LCD_FUNCTION
if not self._4bit:
cmd |= self.LCD_FUNCTION_8BIT
self.hal_write_init_nibble(cmd)
sleep_ms(1)
LcdApi.__init__(self, num_lines, num_columns)
if num_lines > 1:
cmd |= self.LCD_FUNCTION_2LINES
self.hal_write_command(cmd)
def hal_pulse_enable(self):
"""Pulse the enable line high, and then low again."""
self.enable_pin.value(0)
sleep_us(1)
self.enable_pin.value(1)
sleep_us(1) # Enable pulse needs to be > 450 nsec
self.enable_pin.value(0)
sleep_us(100) # Commands need > 37us to settle
def hal_write_init_nibble(self, nibble):
"""Writes an initialization nibble to the LCD.
This particular function is only used during initialization.
"""
self.hal_write_4bits(nibble >> 4)
def hal_backlight_on(self):
"""Allows the hal layer to turn the backlight on."""
if self.backlight_pin:
self.backlight_pin.value(1)
def hal_backlight_off(self):
"""Allows the hal layer to turn the backlight off."""
if self.backlight_pin:
self.backlight_pin.value(0)
def hal_write_command(self, cmd):
"""Writes a command to the LCD.
Data is latched on the falling edge of E.
"""
self.rs_pin.value(0)
self.hal_write_8bits(cmd)
if cmd <= 3:
# The home and clear commands require a worst
# case delay of 4.1 msec
sleep_ms(5)
def hal_write_data(self, data):
"""Write data to the LCD."""
self.rs_pin.value(1)
self.hal_write_8bits(data)
def hal_write_8bits(self, value):
"""Writes 8 bits of data to the LCD."""
if self.rw_pin:
self.rw_pin.value(0)
if self._4bit:
self.hal_write_4bits(value >> 4)
self.hal_write_4bits(value)
else:
self.d3_pin.value(value & 0x08)
self.d2_pin.value(value & 0x04)
self.d1_pin.value(value & 0x02)
self.d0_pin.value(value & 0x01)
self.hal_write_4bits(value >> 4)
def hal_write_4bits(self, nibble):
"""Writes 4 bits of data to the LCD."""
self.d7_pin.value(nibble & 0x08)
self.d6_pin.value(nibble & 0x04)
self.d5_pin.value(nibble & 0x02)
self.d4_pin.value(nibble & 0x01)
self.hal_pulse_enable()
return self.distance / 10lcd_api.py
"""Provides an API for talking to HD44780 compatible character LCDs."""
import time
class LcdApi:
"""Implements the API for talking with HD44780 compatible character LCDs.
This class only knows what commands to send to the LCD, and not how to get
them to the LCD.
It is expected that a derived class will implement the hal_xxx functions.
"""
# The following constant names were lifted from the avrlib lcd.h
# header file, however, I changed the definitions from bit numbers
# to bit masks.
#
# HD44780 LCD controller command set
LCD_CLR = 0x01 # DB0: clear display
LCD_HOME = 0x02 # DB1: return to home position
LCD_ENTRY_MODE = 0x04 # DB2: set entry mode
LCD_ENTRY_INC = 0x02 # --DB1: increment
LCD_ENTRY_SHIFT = 0x01 # --DB0: shift
LCD_ON_CTRL = 0x08 # DB3: turn lcd/cursor on
LCD_ON_DISPLAY = 0x04 # --DB2: turn display on
LCD_ON_CURSOR = 0x02 # --DB1: turn cursor on
LCD_ON_BLINK = 0x01 # --DB0: blinking cursor
LCD_MOVE = 0x10 # DB4: move cursor/display
LCD_MOVE_DISP = 0x08 # --DB3: move display (0-> move cursor)
LCD_MOVE_RIGHT = 0x04 # --DB2: move right (0-> left)
LCD_FUNCTION = 0x20 # DB5: function set
LCD_FUNCTION_8BIT = 0x10 # --DB4: set 8BIT mode (0->4BIT mode)
LCD_FUNCTION_2LINES = 0x08 # --DB3: two lines (0->one line)
LCD_FUNCTION_10DOTS = 0x04 # --DB2: 5x10 font (0->5x7 font)
LCD_FUNCTION_RESET = 0x30 # See "Initializing by Instruction" section
LCD_CGRAM = 0x40 # DB6: set CG RAM address
LCD_DDRAM = 0x80 # DB7: set DD RAM address
LCD_RS_CMD = 0
LCD_RS_DATA = 1
LCD_RW_WRITE = 0
LCD_RW_READ = 1
def __init__(self, num_lines, num_columns):
self.num_lines = num_lines
if self.num_lines > 4:
self.num_lines = 4
self.num_columns = num_columns
if self.num_columns > 40:
self.num_columns = 40
self.cursor_x = 0
self.cursor_y = 0
self.implied_newline = False
self.backlight = True
self.display_off()
self.backlight_on()
self.clear()
self.hal_write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC)
self.hide_cursor()
self.display_on()
def clear(self):
"""Clears the LCD display and moves the cursor to the top left
corner.
"""
self.hal_write_command(self.LCD_CLR)
self.hal_write_command(self.LCD_HOME)
self.cursor_x = 0
self.cursor_y = 0
def show_cursor(self):
"""Causes the cursor to be made visible."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def hide_cursor(self):
"""Causes the cursor to be hidden."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def blink_cursor_on(self):
"""Turns on the cursor, and makes it blink."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR | self.LCD_ON_BLINK)
def blink_cursor_off(self):
"""Turns on the cursor, and makes it no blink (i.e. be solid)."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def display_on(self):
"""Turns on (i.e. unblanks) the LCD."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def display_off(self):
"""Turns off (i.e. blanks) the LCD."""
self.hal_write_command(self.LCD_ON_CTRL)
def backlight_on(self):
"""Turns the backlight on.
This isn't really an LCD command, but some modules have backlight
controls, so this allows the hal to pass through the command.
"""
self.backlight = True
self.hal_backlight_on()
def backlight_off(self):
"""Turns the backlight off.
This isn't really an LCD command, but some modules have backlight
controls, so this allows the hal to pass through the command.
"""
self.backlight = False
self.hal_backlight_off()
def move_to(self, cursor_x, cursor_y):
"""Moves the cursor position to the indicated position. The cursor
position is zero based (i.e. cursor_x == 0 indicates first column).
"""
self.cursor_x = cursor_x
self.cursor_y = cursor_y
addr = cursor_x & 0x3f
if cursor_y & 1:
addr += 0x40 # Lines 1 & 3 add 0x40
if cursor_y & 2: # Lines 2 & 3 add number of columns
addr += self.num_columns
self.hal_write_command(self.LCD_DDRAM | addr)
def putchar(self, char):
"""Writes the indicated character to the LCD at the current cursor
position, and advances the cursor by one position.
"""
if char == '\n':
if self.implied_newline:
# self.implied_newline means we advanced due to a wraparound,
# so if we get a newline right after that we ignore it.
pass
else:
self.cursor_x = self.num_columns
else:
self.hal_write_data(ord(char))
self.cursor_x += 1
if self.cursor_x >= self.num_columns:
self.cursor_x = 0
self.cursor_y += 1
self.implied_newline = (char != '\n')
if self.cursor_y >= self.num_lines:
self.cursor_y = 0
self.move_to(self.cursor_x, self.cursor_y)
def putstr(self, string):
"""Write the indicated string to the LCD at the current cursor
position and advances the cursor position appropriately.
"""
for char in string:
self.putchar(char)
def custom_char(self, location, charmap):
"""Write a character to one of the 8 CGRAM locations, available
as chr(0) through chr(7).
"""
location &= 0x7
self.hal_write_command(self.LCD_CGRAM | (location << 3))
self.hal_sleep_us(40)
for i in range(8):
self.hal_write_data(charmap[i])
self.hal_sleep_us(40)
self.move_to(self.cursor_x, self.cursor_y)
def hal_backlight_on(self):
"""Allows the hal layer to turn the backlight on.
If desired, a derived HAL class will implement this function.
"""
pass
def hal_backlight_off(self):
"""Allows the hal layer to turn the backlight off.
If desired, a derived HAL class will implement this function.
"""
pass
def hal_write_command(self, cmd):
"""Write a command to the LCD.
It is expected that a derived HAL class will implement this
function.
"""
raise NotImplementedError
def hal_write_data(self, data):
"""Write data to the LCD.
It is expected that a derived HAL class will implement this
function.
"""
raise NotImplementedError
def hal_sleep_us(self, usecs):
"""Sleep for some time (given in microseconds)."""
time.sleep_us(usecs)A piece of code where you can make sample applications for the LCD screen.
from machine import Pin
from gpio_lcd import GpioLcd
# Create the LCD object
lcd = GpioLcd(rs_pin=Pin(8),
enable_pin=Pin(9),
d4_pin=Pin(10),
d5_pin=Pin(11),
d6_pin=Pin(12),
d7_pin=Pin(13),
num_lines=2, num_columns=16)
# #The following line of codes should be tested using the REPL
#
# #1. To print a string to the lcd, you can use
lcd.putstr('Hello world!')
# #2. Now, to clear the display.
# lcd.clear()
# #3. and to exactly position the cursor location
# lcd.move_to(1,1)
# # If you do not set the cursor position,
# # the character will be displayed in the
# # default cursor position starting from
# # 0, x and 0, y location which is the top left-hand side.
# # There are other useful functions we can use in using the lcd.
# #4. Show the cursor
# lcd.show_cursor()
# #5. Hide the cursor
# lcd.hide_cursor()
# #6. Turn ON blinking cursor
# lcd.blink_cursor_on()
# #7. Turn OFF blinking cursor
# lcd.blink_cursor_off()
# #8. Disable display
# lcd.display_off()
# this will only hide the characters
# #9. Enable display
# lcd.display_on()
# #10. Turn backlight OFF
# lcd.backlight_off()
# #11. Turn backlight ON
# lcd.backlight_on()
# # 12. Print a single character
# lcd.putchar('x')
# but this will only print 1 character
# #13. Display a custom characters
# happy_face = bytearray([0x00,0x0A,0x00,0x04,0x00,0x11,0x0E,0x00])
# lcd.custom_char(0, happy_face)
# lcd.putchar(chr(0))Future Works:
- The data can be transferred to a smartphone or any other device through a wireless protocol. That will allow people to monitor from another place and will maintain the portability of the device.
- The set mode code can be added to adjust the distance from the limit variable which is 2 now.
Thank you for reading my article and reviewing my project.
Stay in touch with electronics.
e-mail : agoktugaydin.ece@gmail.com
medium blog : https://agoktugaydin.medium.com/
youtube : https://www.youtube.com/channel/UCGHJt1cBOxA5xkZSUaCg2vA
Comments