3 Sensor People Counter

This project introduces a way to count the number of people entering a room using a motion sensor, IR sensor, and a button.

BeginnerFull instructions provided605

Things used in this project

Hardware components

SparkFun Button

Elegoo IR Emission

Elegoo IR Receiver

Elegoo HC-SR501 PIR Motion Sensor

Particle Argon

LED (generic)

Software apps and online services

Particle Build Web IDE

ThingSpeak API

Story

The People Counter was designed with safety and practicality in mind. This product is designed for situations such as indoor events, classes, sheer curiosity, or to comply with Covid-19 safety regulations. It has the ability to count the number of people entering a room using a motion sensor, IR sensor, and a button. The expectation is that a person entering the desired room will be detected by the motion sensor which will tell the Particle Argon to prepare for counting. Next, the person will proceed to push the button at the entrance thus adding a plus one to the people counter. If the person does not press the button, they will still trigger an IR tripwire which will continue counting the person anyway. If both the button and IR sensor are tripped within a short time span the Particle Argon will recognize this and still only count one person.

Video

About

The device with the button and the motion sensor, which will be referred to as Device 1, keeps track of the number of button presses and the total number of people counted. The device with the IR sensor will be referred to as Device 2, and it keeps track of the total number of IR triggers.

When the motion sensor on Device 1 is triggered, it publishes an event with the state of the motion sensor to Device 2. This particular motion sensor can be configured to stay activated for anywhere from 5 seconds to 5 minutes before turning off. While the motion sensor is on, if the button on Device 1 is pressed, it counts a person, and if the IR sensor is triggered on Device 2, it publishes an event so Device 1 knows to count another person. Whenever a person is counted on either device, an LED light turns on as a physical indicator that the program is working properly.

ThingspeakIntegration

The number of people counted, button presses, and IR sensor triggers are tracked since the program started and is published to Thingspeak every minute.

The channel is publicly available at the link HERE.

Examples of the data graphing are shown below.

The Thingspeak is triggered by one event, "Count, " with three different fields in order to send the data to the three different graphs. The device with the IR sensor tracks the total number of IR triggers and publishes it every minute, The device with the button tracks the total number of button presses and people counted and sends it every minute, offset by 30 seconds from the other device. This timing is due to Thingspeak only receiving data every 15 seconds.

The Thingspeak webhook integration settings and the Thingspeak settings are displayed below.

Thingspeak Webhook Integration Settings

Thingspeak Settings

/* Pin diagram of IR Sensor and IR Emitter
 *
 *
 *              /----------------------------------------------------\
 *              |              +-----+                               |
 *              |   +----------| USB |---------+                     |
 *              |   | O        +-----+      O  |                     |
 *              |   | [ ] RESET                |                     |
 *              \---| [*] 3V3                  |                     |
 *                  | [ ] MODE                 |                     |
 *                  | [*] GND                  |                     |
 *                  | [ ] A0          Lipo [ ] |                     | 
 *                  | [ ] A1  +-------+ EN [ ] |                     |
 *                  | [ ] A2  |   *   | VIN[ ] |                     |
 *                  | [ ] A3  | ARGON | D8 [ ] |                     |
 *                  | [ ] A4  |       | D7 [*] |----LED---GND        |
 *                  | [ ] A5  +-------+ D6 [ ] |                     |
 *                  | [ ] D13           D5 [*] |--------IR Sensor----/
 *                  | [ ] D12           D4 [ ] |  |
 *                  | [ ] D11           D3 [ ] | GND
 *                  | [ ] D10           D2 [ ] |
 *                  | [ ] D9            D1 [ ] |                
 *                  | [ ] NC            D0 [ ] |
 *                  |   WIFI0         0NFC     | 
 *                  |O                        O|  
 *                  +--------------------------+ 
 *                                                        
 *      
 */
/*
    This program houses all the processes involving the IR sensor.
    It has a running total of the IR triggers since the program was started, which it sends to Thingspeak every 30 seconds.
    It receives the value of the motion sensor from the other device, and if th IR sensor and the Motion sensor are triggered
    at the same time, it publishes an event that updates the people counter on the other device.
*/

int input;              // initialize input as an int
int ms_val = 0;         // initialize ms_val as an int and set to 0
int IR_count = 0;       // initialize IR_count as an int and set to 0

void setup() {

  pinMode(D5, INPUT);                                                   // set IR sensor pin as an input
  pinMode(D7, OUTPUT);
  Particle.subscribe("Motion Sensor Value", msfunc, MY_DEVICES);        // subscribe to "Motion Sensor Value" event from the other device
}

int msfunc (const char *event, const char *data) {
    if (strcmp(String(data), "HIGH") == 0) {            // check if the motion sensors is HIGH based on the event published from the other device
        ms_val = HIGH;                                  // set the motion sensor value as HIGH
    }
    else {
        ms_val = LOW;                                   // set the motion sensor value as LOW
    }
    
    return ms_val;                                      // return the motion sensor value
}

void loop() {
    
    input = digitalRead(D5);                            // read the pin the IR sensor is plugged into
    if (input == HIGH)                                  // check if the IR sensor was triggered
    {
        IR_count = IR_count + 1;                        // update total IR sensor trigger count
        
        if (ms_val == HIGH && input == HIGH) {          // check if the IR sensor and the motion sensor are both triggered
            Particle.publish("Detect", "True");         // Publish that a person was detected. This will update the total people count on the other device
            digitalWrite(D7, HIGH);
        }
        
        delay(500);
    }
    
    else {
        digitalWrite(D7, LOW);
        
        delay(500);                                     // delay 500 milliseconds
    }
    
    if (Time.second() == 30) {                                                                                  // triggers every minute when the real world time is at 30 seconds
        Particle.publish( "Counter", "{ \"IR Triggers\": \"" + String(IR_count) + "\"}", 60, PRIVATE);          // Publish the number of IR Triggers to Thingspeak
    }
    
delay(1000);
}

/* Pin diagram of motion sensor and button
 *
 *
 *  /-------------------------------------------------------------------\
 *  |              +-----+                                              |
 *  |   +----------| USB |---------+                                    |
 *  |   | O        +-----+      O  |                                    |
 *  |   | [ ] RESET                |                                    |
 *  \---| [*] 3V3                  |                                    |
 *      | [ ] MODE                 |                                    |
 *      | [*] GND                  |                                    |
 *      | [ ] A0          Lipo [ ] |                                    | 
 *      | [ ] A1  +-------+ EN [ ] |                                    |
 *      | [ ] A2  |   *   | VIN[ ] |                                    |
 *      | [ ] A3  | ARGON | D8 [ ] |                                    |
 *      | [ ] A4  |       | D7 [ ] |            GND                     |
 *      | [ ] A5  +-------+ D6 [ ] |            |                       |
 *      | [ ] D13           D5 [ ] |            1k Resistor             |
 *      | [ ] D12           D4 [ ] |            |                       |
 *      | [ ] D11           D3 [*] |------------|-----Motion Sensor-----|
 *      | [ ] D10           D2 [*] |----------------|--Button-----------/
 *      | [ ] D9            D1 [ ] |                |
 *      | [ ] NC            D0 [*] |----|---LED     |
 *      |   WIFI0         0NFC     |    |           1k Resistor
 *      |O                        O|    |           |
 *      +--------------------------+    |           |
 *                                     GND         GND
 *      
 */


int led = 0;                // the pin that the LED is atteched to
int ms_sensor = 3;          // the pin that the motion sensor is atteched to
int button = 2;             // the pin that the button is a attached to
int state = LOW;            // by default, no motion detected
int ms_val = 0;             // variable to store the motion sensor status (value)
int ms_state = 0;
int button_val = 0;         // variable to store the button sensor status (value)
int IR_val = 0;             // variable to store the IR sensor status (value)
int IR_state = 0;
int count = 0;              // variable to store total people counted since device was turned on or reset
int button_presses = 0;
int IR_triggers = 0;

void setup() {
  pinMode(led, OUTPUT);         // initalize LED as an output
  pinMode(ms_sensor, INPUT);    // initialize motion sensor as an input
  pinMode(button, INPUT);       // initialize button as an input
  digitalWrite(led, LOW);       // set the LED as off
  Particle.subscribe("Detect", IR_func, MY_DEVICES);
}

int IR_func(const char *event, const char *data) {
    if (data) {                 // check if any data was sent
        count = count + 1;          // set IR_val to HIGH
    }
    
    return count;              // return IR_val so it carries over to the rest of the code
}


void loop(){
  ms_val = digitalRead(ms_sensor);      // read motion sensor value
  button_val = digitalRead(button);     // read button value
  
  if (ms_val == HIGH) {
      if (ms_state == LOW) {
          Particle.publish("Motion Sensor Value", "HIGH");
          ms_state = HIGH;
      }
  }
  else {
      if (ms_state == HIGH) {
          Particle.publish("Motion Sensor Value", "LOW");
          ms_state = LOW;
      }
  }

  if (button_val == HIGH) {
        button_presses = button_presses + 1;                            // running total of total button presses

        if (button_val == HIGH && ms_val == HIGH) {                     // check if button is pressed and motion sensor is activated
            count = count + 1;
            digitalWrite(led, HIGH);                                    // turn LED on
        
            if (state == LOW) {                                         // check if state is LOW
                state = HIGH;                                           // check if state is HIGH
            }
        }
        
        delay(500);                                                     // delay 500 milliseconds
    }
  /*
  if (IR_val == HIGH) {
        IR_triggers = IR_triggers + 1;                              // running total of total IR sensor
  
        if (IR_val == HIGH && ms_val == HIGH) {                     // check if IR and motion sensors are activated
            count = count + 1;
            digitalWrite(led, HIGH);                                // turn LED on

            delay(500);                                             // delay 500 milliseconds
        
            if (state == LOW) {                                     // check if state is LOW
                state == HIGH;                                      // update variable state to HIGH
            }
        }
        
        IR_val = LOW;                                               // set IR val to low
    }
  */
  
  else {
      digitalWrite(led, LOW);                       // turn LED OFF
      delay(500);                                   // delay 500 milliseconds 
      
      if (state == HIGH){                           // check if state is high
        state = LOW;                                // update variable state to LOW
    }
  }
  
  
  
  
  if (Time.second() == 0) {
       Particle.publish( "Counter", "{ \"People Counted\": \"" + String(count) + "\","+              //Publishes people counted, button presses, and IR sensor triggers to Thingspeak
       "\"Button Presses\": \"" + String(button_presses) + "\"}", 60, PRIVATE);
  }
  
}

Credits

Chase Rudin

1 project • 1 follower

Contact

3 Sensor People Counter