Object Counter with IR Sensor & OLED Display using ESP32
Learn How to Make a Smart Object Counter with ESP32, IR Sensor & OLED Display – Full Tutorial
Last Updated on August 13, 2025 by Engr. Shahzada Fahad
Table of Contents
Object Counter with ESP32:
Object Counter with IR Sensor & OLED Display using ESP32- Have you ever wanted to count how many times something passes a certain point? like
- People entering a room
- Boxes on a conveyor belt or even just
- How many times you waved your hand?
Well today, we are building a smart Object Counter using an IR proximity sensor, an ESP32, and an OLED display.
And here is the coolest part; just wave your hand in front of the IR Sensor and the number goes up instantly on the screen.
No delay. No contact. Just smooth real-time counting.
And that’s not all; even if the system turns off, or there’s a power failure; or you intentionally reset the controller, your count does not disappear!
You know Why?
Because we have got it saved safely in the EEPROM; kind of like a memory card for your numbers.
It will stay right there, ready for you when the system powers back on.
The only way to reset it back to zero; is by pressing this pushbutton.
Total control; in your hands.
Now some of you might be wondering
“Why didn’t I just use an Arduino?”
Well, here’s the deal;
I picked the ESP32 for a couple of really good reasons.
First, the ESP32 comes with built-in Bluetooth, so later on, I can send this counter value wirelessly to my phone; no need to connect any extra Bluetooth modules. This way I can monitor the counter value in my custom designed Android application.
The ESP32 gives you everything in one package, making your project simple, compact, and powerful.
Second, you already know; the ESP32 also has WiFi built right in; and that opens up a world of possibilities!
I can send this data to the cloud; whether it’s Blynk, Ubidots, Thingspeak, Google Sheets; you name it.
Basically, what I am trying to say is; you can send this number anywhere in the world in real-time.
So if you are planning to expand this project later; maybe build a people counter for your shop, or track items remotely; ESP32 is definitely the way to go. I highly recommend it.
Amazon Links:
ESP32 WiFi + Bluetooth Module (Recommended)
Other Tools and Components:
Arduino Nano USB C type (Recommended)
*Please Note: These are affiliate links. I may make a commission if you buy the components through these links. I would appreciate your support in this way!
Components Used in This Project:
In this project, we are using the ESP32 Dev Module, a Digital Adjustable Infrared Sensor from DFRobot, a pushbutton, and the SSD1306 OLED Display. I am sure you know about most of these sensors expect the IR Sensor.
This Digital IR Proximity Sensor has an adjustable detection range of 0 to 200 centimeters.
- This sensor uses infrared light to detect objects
- it sends out a beam, and when an object comes in front of it, the beam reflects back to the sensor.
Right here at the back of the sensor, you will see this tiny screw; this is used to adjust the detection distance.
You can rotate it to increase or decrease how far the sensor can detect objects.
And right next to it, there is a small red LED; this is just an indicator light.
Whenever the sensor detects an object, this LED turns on instantly, letting you know that the sensor has been triggered. You can clearly see in the above image; my hand is in front of the sensor so that’s why the RED LED is ON.
It’s compact; just 75 by 18 millimeters; and can be used in many applications like counting objects, or even as a smart door trigger.
It gives a digital output:
- 0 means no object detected
- 1 means an object is in range
IR Sensor Specification
- Output Form: PNP normally open
- Signal Type: Digital signal
- Operating Voltage: 3~5V
- Interface: XH2.54-3Pin
- Detection range: 0~200 cm
- Switch Level: 0, No obstacles in the area; 1, There are obstacles in the area.
- Operating Temperature: -15~60 ℃
- Temperature Effect: Within -15 ℃ to + 60 ℃, the detection distance is below 10% at + 25 ℃
- Storage Temperature: -25~75 ℃
- Humidity: 35% ~ 95% RH
- Size: 75 * Φ18 mm
Object Counter Circuit and Interfacing:
We have connected the signal wire of the IR Proximity Sensor to GPIO 25 on the ESP32. Connect the other two wires to the 3.3V and GND.
The pushbutton is connected to GPIO 15, and is used to reset the counter value.
For the display, we are using the SSD1306 OLED. Connect its SDA and SCL pins to the GPIOs 21 and 22 on the ESP32 Dev Module. Connect its voltage and ground pins to the ESP32’s 3.3V and GND pins.
Now, here is what is happening behind the scenes:
ESP32 Object Counter Arduino Code
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
#include <Wire.h> #include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #include <Preferences.h> #define SCREEN_WIDTH 128 #define SCREEN_HEIGHT 64 #define OLED_RESET -1 Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); #define IR_SENSOR_PIN 25 #define RESET_BUTTON_PIN 15 volatile unsigned long counter = 0; volatile bool updateDisplay = false; volatile bool saveToEEPROM = false; Preferences prefs; void IRAM_ATTR handleIR() { static unsigned long lastInterruptTime = 0; unsigned long interruptTime = millis(); if (interruptTime - lastInterruptTime > 300) { // debounce counter++; updateDisplay = true; saveToEEPROM = true; lastInterruptTime = interruptTime; } } void displayCounter() { // OLED display.clearDisplay(); display.setTextSize(2); display.setCursor(0, 0); display.print("Count:"); display.setCursor(0, 30); display.setTextSize(3); display.print(counter); display.display(); // Serial Serial.print("Current Count: "); Serial.println(counter); } void setup() { Serial.begin(115200); delay(500); // Load value from EEPROM prefs.begin("ircounter", true); // read-only counter = prefs.getULong("count", 0); prefs.end(); // OLED Init if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { Serial.println(F("SSD1306 init failed")); while (true); } display.setTextColor(SSD1306_WHITE); displayCounter(); // IR sensor and reset button pinMode(IR_SENSOR_PIN, INPUT); pinMode(RESET_BUTTON_PIN, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(IR_SENSOR_PIN), handleIR, RISING); } void loop() { // Handle count updates if (updateDisplay) { displayCounter(); updateDisplay = false; } if (saveToEEPROM) { prefs.begin("ircounter", false); // write mode prefs.putULong("count", counter); prefs.end(); // Serial.print("Saved Count: "); // Serial.println(counter); saveToEEPROM = false; } // Check reset button (active LOW) if (digitalRead(RESET_BUTTON_PIN) == LOW) { delay(200); // basic debounce if (digitalRead(RESET_BUTTON_PIN) == LOW) { counter = 0; displayCounter(); prefs.begin("ircounter", false); prefs.putULong("count", counter); prefs.end(); Serial.println("Counter reset to 0"); delay(1000); // prevent multiple resets } } } |
How the Code Works: Saving to EEPROM
First, we include the necessary libraries to talk to the OLED display and to save data in the ESP32’s internal memory using the Preferences library. We define the screen size, and then create a display object using the Adafruit SSD1306 library. Next, we set up two GPIO pins — one for the IR sensor, which is connected to pin 25, and one for the reset pushbutton on pin 15..
We use an interrupt for the IR sensor, so whenever an object passes by and triggers the sensor, the handleIR function runs instantly. We have added a small debounce delay of 300 milliseconds so it doesn’t count the same object multiple times. Each time an object is detected, the counter increases, and we mark the display for update and the value to be saved.
In the setup function, we initialize Serial, read the last saved counter value from EEPROM, and prepare the OLED display. If the OLED doesn’t initialize, we stop everything and show an error in the serial monitor. Once everything is good, we show the current count on the screen.
In the main loop, we check if there’s a new count to show; if yes, we update the display. If the value needs to be saved, we write it back to EEPROM so that even if the ESP32 resets or loses power, the counter won’t be lost. Finally, we check if the reset button is pressed; and if it is, we clear the counter, update the display, and also reset the saved value in memory. All this happens smoothly in real time; making the system fast, reliable, and super responsive.
Object Counter Practical Demonstration:
Watch this; I wave my hand in front of the sensor;
And boom! The number increases!
Let me try again.
Another wave; and there it goes again; the count goes up.
Now I will press the pushbutton on GPIO 15.
And just like that; the counter resets to zero.
But here is the real magic; on the display you can see the value is 8.
Now I will turn off the ESP32.
Turn it back on.
And look at that; the count is still there, saved perfectly, just like before.
That’s the power of using EEPROM.
So, that’s all for now.
Watch Video Tutorial:
Discover more from Electronic Clinic
Subscribe to get the latest posts sent to your email.
