Due 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 Video: 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 Video: 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 Showing 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.pyfrom 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 / 10 gpio_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 / 10 lcd_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.If you like this project that I have done to be less affected by the covid-19 pandemic, I would be very grateful if you do not forget to vote and like.Thank you for reading my article and reviewing my project.Stay in touch with electronics.e-mail : agoktugaydin.ece@gmail.commedium blog : https://agoktugaydin.medium.com/youtube : https://www.youtube.com/channel/UCGHJt1cBOxA5xkZSUaCg2vA