The COVID Counter

The COVID Counter is used to track the number of customers within a store at any given time due to the capacity limits of the pandemic.

IntermediateFull instructions provided467

Things used in this project

Hardware components

Particle Argon

PIR Motion Sensor (generic)

Adafruit RGB Backlight LCD - 16x2

Single Turn Potentiometer- 10k ohms

Solderless Breadboard Full Size

Solderless Breadboard Half Size

Jumper wires (generic)

Development Kit Accessory, Jumper Wire Kit

USB-A to Micro-USB Cable

Software apps and online services

Particle Build Web IDE

ThingSpeak API

Story

During the COVID-19 pandemic, life as we know it has changed in many ways. One of these instances being how people shop at grocery stores, department stores, and just about anywhere business is done. There is a limit to how many people can be inside all of these places at any given time. The stores have unique maximum capacities based on their square footage and how many people can safely social distance in the store. Stores must keep track of the number of customers to adhere to and not break the COVID guidelines. Before the COVID Counter, stores would have an employee at the entrance keeping track of the customers manually, whether with laminated numbers or a checklist or another tedious method. Then, if the store had two sets of doors, there would be an additional employee tracking and alerting the entrance employee of how many people were leaving. This isn’t always accurate and not the optimal use of an employee’s time.

Now, with the COVID counter, there is no need for employees monitoring the doors to make sure the maximum capacity isn't exceeded. The COVID counter does this all by itself through the use of motion sensors and an LCD module. There is one motion sensor placed at the entrance door and another placed at the exit door. When a customer enters, the LCD module increases the customer count and when a customer leaves through the exit door, a message is sent to the entrance mechanism, which decreases the total count of customers on the LCD module. This display is also programmed to tell potential customers whether they may enter or not depending on if the customer count has reached its store-specific maximum capacity. In addition to keeping track of the customers on the LCD module, there is live data sent directly to ThingSpeak. So, instead of having employees fully committed to standing by the door for their entire shift, there can be one employee doing their necessary tasks with the minor addition of occasionally checking in with the COVID Counter to be sure everything is running smoothly.

All in all, the COVID Counter is the ideal system to use in the midst of a pandemic and will continue to be a viable product for businesses that wish to remain below maximum capacity once the pandemic has passed. The COVID Counter leaves customers feeling more comfortable and safe in their shopping experience and allows companies to optimize their employees’ time and effort while also following protocol. Could you really ask for more?

YouTube Video:

Entrance ArgonWhenUnderMaximumCapacity:

Entrance ArgonWhenAtMaximumCapacity:

Exit Argon:

Real-Time Data (ThingSpeak):

This real-time graph displays the exact amount of customers in a store at any given time. Whenever a customer enters the store, the customer count is increased by 1 and whenever a customer leaves the store, the customer count is decreased by 1. This graph only displays the 60 most recent data points. Live data updates can be accessed at: COVID Counter: Real-Time Data

How to Set Up:

This project can be easily set up using the listed supplies above. The first thing to do is insert the argons, sensors, wiring, and components into your breadboards properly. The above pictures of the argons, along with the detailed schematics should be followed closely. It is crucial to pay close attention to the wiring for the LCD display because if only one of the many wires is out of place the display will not work. An image of the correct way to set up the argon on the wall next to the entrance doorway is provided below. The next step is to set up a ThingSpeak account to have live data and record the number of customers going in and out of the store. After this, a Webhook needs to be created in the integrations section of the particle console. Screenshots detailing what to insert into the ThingSpeak channel and Webhook set up are provided below. Next, reference and look through the code provided below. The code only needs minor changes in the ThingSpeak portion by inserting a unique channel ID and API codes. Detailed annotations are provided in the code itself to further provide assistance. Now, the last step is to flash the updated code to the two argons and enjoy the benefits of the COVID Counter.

Argon set up on wall next to doorway, with motion sensor pointed at doorway

ThingSpeak Channel Settings

Webhook Integration Info

Code

// The Covid Counter Exit Argon by Julian Doe and Jonathan Broome

// The following code is used to tally the amount of customers leaving a business
// This Argon should be paired to a PIR motion sensor
// This data obtained is relayed back to the Particle console, where the Entrance Argon can collect the data

int ledPIN = D7;
int PIRsensor = D5;
int pirState = LOW;    //Initial State = No motion



void setup() {
    pinMode(PIRsensor, INPUT);  //This states the PIRsensor will be an input function
    pinMode(ledPIN, OUTPUT);    //This states the ledPIN will be an output function
}

void loop()  {
    delay(10);
    if (digitalRead(PIRsensor) == HIGH) {  //If there is motion
      digitalWrite(ledPIN, HIGH);  //LED turns on
      delay(1000);
      Particle.publish("Exit data", "-1", PUBLIC); //relays data to console to show motion sensor has been tripped for someone exiting the store
      delay(1000);
   }
    else {
        digitalWrite(ledPIN, LOW);   //LED turns off
   }
}

Entrance Argon

C/C++

This code is used to track how many customers enter the store and extracts data from the "Exit data" event in order to calculate the total number of customers at any given time. An LCD module is used display the calculated customer count as well as a "WELCOME!" message when the store is below capacity and a "DO NOT ENTER" message when the store reaches capacity. The entry and exit data is sent to a console event titled, "Customers". This data is then sent to a real-time graph through the ThingSpeak platform and is used to plot the exact number of customers at a given time. In order for the code to work properly, the ThingSpeak.h library and the LiquidCrystal.h library must be included in the app.

// The Covid Counter Entrance Argon by Julian Doe and Jonathan Broome

// The following code is used to keep track of how many customers are within a store at an exact time
// This Argon should be paired with a PIR Motion Sensor and an LCD 1602 Module
// As motion is detected, customer count is added up by the Entrance Argon
// The Entrance Argon pulls data from the Exit Argon to subract customers as they pass the exit and the exact number of customers is kept on display
// The produced data is relayed to ThingSpeak in order to create a real-time data trend
// A store capacity of 20 customers is assumed, but this is subject to change depending on the business


// This #include statement was automatically added by the Particle IDE.
#include <ThingSpeak.h>

// This #include statement was automatically added by the Particle IDE.
#include <LiquidCrystal.h>

LiquidCrystal lcd(6, 4, 3, 2, 1, 0); //Declare pins of the LCD module
int ledPIN = D7;   //Built in argon LED
int PIRsensor = D5;    //Pin of PIR motion sensor
int pirState = LOW;    //No motion assumed
int val = 0;      //Variable for reading the pin status
int counter = 0;     //Initial customer count is zero
int currentState = 0;
int previousState = 0;
void confirm(const char *event, const char *data);  //Forward Declaration
byte skull[] = {   //Custom 8 byte design for skull 
	0b01110,
	0b11111,
	0b10101,
	0b11011,
	0b01110,
	0b01110,
	0b00000,
	0b00000
};
byte smile[] = {   //Custom 8 byte design for smiley face
    0b00000,
	0b01010,
	0b01010,
	0b00000,
	0b10001,
	0b01110,
	0b00000,
	0b00000
};
int state = 0;  //Zero motion is assumed
int Customers = 0;  //There are initially zero customers
TCPClient client;
unsigned int myChannelNumber = 1250092;  //Replace with your ChannelID
const char * myWriteAPIKey = "5IPA2W9YVJM8W39N";  //Replace with your WriteAPIKey

void setup() {
     Particle.subscribe("Exit data", confirm);   //Pull data from the exit argon's console
     pinMode(ledPIN, OUTPUT);   //Declare LED as output
     pinMode(PIRsensor, INPUT); //Declare sensor as input
     lcd.begin(16, 2);    //specify column and row count of lcd module
     lcd.setCursor(0,1);  
     lcd.print("Customers:");
     lcd.setCursor(4,0);
     lcd.print("WELCOME!");
     lcd.createChar(0, skull);   //create skull design
     lcd.createChar(1, smile);   //create smile design
     lcd.setCursor(2,0);
     lcd.write((byte)1);    //print smile design
     lcd.setCursor(13,0);
     lcd.write((byte)1);    //print smile design
     ThingSpeak.begin(client);
}
void loop(){
    val = digitalRead(PIRsensor);   // read PIR sensor input value
    if (val == HIGH) {       // check if the input is HIGH
            digitalWrite(ledPIN, HIGH);    // turn LED ON
            if (pirState == LOW) {  
                currentState = 1;
                pirState = HIGH;
                delay(1000);
           }
   } 
    else {
        digitalWrite(ledPIN, LOW);  // turn LED OFF
        if (pirState == HIGH){
            currentState = 0;
            pirState = LOW;
       }
   }
    if(currentState != previousState){
        if(currentState == 1){
           counter = counter + 1;  // Adds a customer to previous customer count
           lcd.setCursor(11,1);  
           lcd.print(counter);   //Displays new number of customers in the store
           Particle.publish("Customers","+1");  //Relays change to console
           state = !state;
           Customers= Customers+1;  //Customer tallied for ThingSpeak data
           unsigned long now = millis();
           ThingSpeak.setField(1,Customers);
           ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);  
           delay(1000);
       }
            if(counter >= 20){  //set maximum amount of customers allowed in the store at any given time
               lcd.clear(); //clears display
               lcd.setCursor(2,0);
               lcd.print("DO NOT ENTER");
               lcd.setCursor(0,0);
               lcd.write((byte)0);  //prints skull design
               lcd.setCursor(15,0);
               lcd.write((byte)0);  //prints skull design
               lcd.setCursor(0,1);
               lcd.print("Customers:");
               lcd.setCursor(11,1);  
               lcd.print(counter);   //Displays new number of customers in the store
           }
            if(counter == 0){     //this statement is to drop the extra digit left behind by the -1 
               lcd.clear();   //clears display
               lcd.setCursor(4,0);
               lcd.print("WELCOME!");
               lcd.setCursor(2,0);
               lcd.write((byte)1);    //print smile design
               lcd.setCursor(13,0);
               lcd.write((byte)1);    //print smile design
               lcd.setCursor(0,1);
               lcd.print("Customers:");
               lcd.setCursor(11,1);  
               lcd.print(counter);   //Displays new number of customers in the store
           }
   }
     
}

void confirm(const char *event, const char *data){  //called when "-1" data is published to the console from the exit argon
    if(strcmp(data,"-1")==0) {
       counter = counter - 1;  //subtracts customer from customer total
       lcd.setCursor(11,1);
       lcd.print(counter);
       Particle.publish("Customers","-1");  //relays change to console
       state = !state;
       Customers= Customers-1;  //Customer count is calculated for ThingSpeak 
       //       delay(1000);
       unsigned long now = millis();
       ThingSpeak.setField(1,Customers);
       ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);  
        if(counter == 19) {   //this statement is to revive the welcome sign once store is below capacity
            lcd.clear();   //clears display
            lcd.setCursor(4,0);
            lcd.print("WELCOME!");
            lcd.setCursor(2,0);
            lcd.write((byte)1);    //print smile design
            lcd.setCursor(13,0);
            lcd.write((byte)1);    //print smile design
            lcd.setCursor(0,1);
            lcd.print("Customers:");
            lcd.setCursor(11,1);  
            lcd.print(counter);   //Displays new number of customers in the store
       }
        if(counter == 9) {  //this statement is to drop the extra digit left behind from the 10
            lcd.clear();   //clears display
            lcd.setCursor(4,0);
            lcd.print("WELCOME!");
            lcd.setCursor(2,0);
            lcd.write((byte)1);    //print smile design
            lcd.setCursor(13,0);
            lcd.write((byte)1);    //print smile design
            lcd.setCursor(0,1);
            lcd.print("Customers:");
            lcd.setCursor(11,1);  
            lcd.print(counter);   //Displays new number of customers in the store
       }
        if(counter == 99) {   //this statement is to drop the extra digit left behind from the 100
            lcd.clear(); //clears display
            lcd.setCursor(2,0);
            lcd.print("DO NOT ENTER");
            lcd.setCursor(0,0);
            lcd.write((byte)0);  //prints skull design
            lcd.setCursor(15,0);
            lcd.write((byte)0);  //prints skull design
            lcd.setCursor(0,1);
            lcd.print("Customers:");
            lcd.setCursor(11,1);  
            lcd.print(counter);   //Displays new number of customers in the store
       }
   }
}