DEV Community: David Thomas

I Let a Raspberry Pi Find Empty Parking Spaces for Me

David Thomas — Thu, 30 Jul 2026 10:00:17 +0000

Finding a parking space shouldn't feel like solving a puzzle.

Whether you're visiting a shopping mall, college campus, or a busy office, the biggest challenge is often figuring out which parking spots are actually available. Even when someone is managing the parking lot, it's not always easy to keep track of every empty space.

That's exactly what inspired this project. Instead of relying on manual monitoring, a Raspberry Pi and a USB camera automatically detect occupied and vacant parking spaces using AI. The best part? You don't have to train a machine learning model or create your own dataset.

Why Build a Raspberry Pi Parking Space Detection System?

Computer vision projects usually begin with collecting thousands of images, labeling data, and training an AI model.

This Raspberry Pi Parking Space Detection System project skips that entire process. The Raspberry Pi simply captures an image and sends it to a cloud-based Parking Detection API. Within seconds, it receives the number of occupied and available parking spaces, making the entire setup beginner-friendly.

Hardware Required for the Smart Parking System

One thing I liked about this project is how simple the hardware is.

You'll only need a Raspberry Pi, a USB webcam, a microSD card with Raspberry Pi OS, and an internet connection. That's enough to build a working parking detection prototype without additional sensors or complicated electronics.

How the AI Parking Detection System Works

The workflow is surprisingly straightforward.

The USB camera continuously monitors the parking area. When an image is captured, OpenCV converts it into JPEG format before sending it securely to the cloud using an HTTPS request.

The cloud analyzes the image using a pre-trained AI model and returns the number of occupied and empty parking spaces. The Raspberry Pi simply displays the results in the terminal, making the entire process fast and easy to understand.

Multiple Capture Modes Make Testing Easy

Another feature I found useful is the flexibility during testing.

You can manually capture images by pressing the SPACE key, let the system capture images automatically after fixed intervals, or even run everything remotely through SSH without opening a graphical window. This makes the project suitable for both development and real-world deployment.

Why Cloud-Based Detection Instead of Local AI Models?

Running computer vision models locally on a Raspberry Pi is possible, but it usually requires more processing power and extra optimization.

By using a cloud API, the Raspberry Pi only focuses on capturing and sending images while the server performs all the AI processing. You don't need TensorFlow, Edge Impulse, or weeks of model training before getting useful results.

What You Can Learn from This Raspberry Pi Computer Vision Project

This project combines several useful technologies into one build.

You'll get hands-on experience with Raspberry Pi, Python, OpenCV, REST APIs, HTTPS communication, cloud computing, and basic computer vision. These are practical skills that show up in plenty of IoT and automation projects.

More importantly, you'll learn how modern AI applications are built by connecting embedded hardware with cloud services.

Real-World Applications

Although this project is designed as a prototype, the idea can easily scale.

It can be used in shopping malls, apartment complexes, universities, hospitals, office buildings, or any parking area where quickly identifying available spaces can save both time and effort. The same concept can also be expanded with LED indicators, automatic barriers, or mobile applications that guide drivers directly to vacant spots.

Sometimes the best engineering projects aren't the ones with the most hardware—they're the ones that solve a real problem with a simple approach.

This Raspberry Pi smart parking detection system shows how combining computer vision with cloud AI can create a practical solution without the complexity of building and training machine learning models. If you're looking for a beginner-friendly AI project that actually feels useful, this is definitely worth trying.

Raspberry Pi Projects, AI Projects, IoT Projects

Can a Raspberry Pi Tell the Difference Between Plastic and Food Waste?

David Thomas — Wed, 15 Jul 2026 15:15:25 +0000

We've all done it.

You're about to throw something away, stare at two different bins for a second, and then toss it into whichever one is closer. It doesn't seem like a big deal until you realize that mixed waste makes recycling much harder.

That simple problem inspired this project.

Instead of asking people to identify waste correctly every time, why not let a Raspberry Pi and a camera do it automatically? This project uses AI to classify waste as biodegradable or non-biodegradable without training a machine learning model yourself.

Why Build a Raspberry Pi Waste Segregation System?

Most AI-based waste sorting projects start with collecting thousands of images, labeling datasets, and training deep learning models.

This one skips all of that. The Raspberry Pi simply captures an image using a USB camera and sends it to a cloud-based API. Within seconds, it receives the classification result and displays whether the waste is biodegradable or non-biodegradable.

Hardware Required for Raspberry Pi Smart Waste Segregation

One of the best parts about this project is how little hardware it needs.

You'll only need a Raspberry Pi, a USB webcam, a microSD card, and an internet connection. There are no additional sensors or complex wiring, making it a perfect weekend project for students.

How the Raspberry Pi AI Waste Segregation System Works

The workflow is easy to understand.

The USB camera captures an image either when you press a key or automatically after a fixed interval. That image is compressed and uploaded securely to a cloud-based Waste Detection API.

The cloud processes the image using AI and sends back the result, which the Raspberry Pi displays directly in the terminal.

Build an AI Waste Classifier Without Training Machine Learning Models

This is probably the biggest advantage.

You don't have to collect datasets, label images, build neural networks, or spend hours waiting for training to finish. The cloud already handles the difficult part, allowing you to focus on building the actual system instead of the AI pipeline.

Why This Raspberry Pi AI Project Is Perfect for Engineering Students

Projects like this combine multiple skills into one build.

You'll work with Python, Raspberry Pi, OpenCV, REST APIs, HTTPS communication, cloud services, and basic computer vision. These are practical technologies that appear in many modern IoT and automation projects.

Even if you've never built an AI application before, this project is a great place to start because the learning curve stays manageable.

Real-World Applications of AI-Based Waste Segregation

Although this is built as a prototype, the idea has plenty of real-world applications.

Smart dustbins, college campuses, offices, food courts, apartment complexes, and public spaces could all benefit from automatic waste classification. The same workflow can also be expanded later by adding servo motors or robotic mechanisms to physically separate the waste into different bins.

Learn Raspberry Pi, Computer Vision, and AI in One Project

What makes this project enjoyable is that everything feels achievable.

Instead of spending days understanding machine learning frameworks, you get a working AI-powered application with just a Raspberry Pi, a camera, and a few Python libraries. Once you understand this workflow, moving on to more advanced computer vision projects becomes much less intimidating.

AI Project, Raspberry Pi Project, IoT Project

Build a Raspberry Pi Object Detection System Without Training Any AI Models

David Thomas — Mon, 13 Jul 2026 18:48:18 +0000

Computer vision projects usually sound intimidating.

Most tutorials ask you to collect hundreds of images, label datasets, train a machine learning model, and finally deploy it to your hardware. By the time you reach the fun part, you've already spent hours preparing the model.

This Raspberry Pi Object Detection project skips all of that. Instead, a Raspberry Pi captures an image using a USB camera and sends it to a cloud-based Object Detection API. Within a few seconds, it receives the detected objects, confidence scores, and bounding box information—without running any AI model locally.

Why This Project Is Great for Beginners

If you've wanted to explore computer vision but didn't know where to start, this is a good first project.

You don't need TensorFlow, YOLO, or Edge Impulse. The Raspberry Pi simply captures an image, uploads it securely, and displays the detection results returned by the cloud. That means you spend more time understanding how the complete system works instead of struggling with model training.

What You'll Need

The hardware setup is refreshingly simple.

All you need is a Raspberry Pi, a USB webcam, a microSD card with Raspberry Pi OS, and an internet connection. Once the camera is connected, the Raspberry Pi handles image capture while the cloud takes care of object detection.

How the Detection Process Works

The workflow is surprisingly straightforward.

The USB camera captures an image whenever you trigger it manually or automatically. That image is compressed into JPEG format and uploaded to the cloud using an HTTPS request.

After processing, the API returns a list of detected objects along with their confidence values and bounding box coordinates. The Raspberry Pi simply displays the results in the terminal.

Multiple Ways to Capture Images

One feature I really liked is the flexibility.

You can capture images by pressing the spacebar while viewing the camera feed, let the system automatically capture images at fixed intervals, or even run everything through SSH without opening a graphical window. This makes the project useful for both testing and real deployments.

Why Use Cloud AI Instead of Local Inference?

Running object detection models directly on embedded hardware isn't always easy.

Large AI models consume significant memory and processing power, which increases development time. By moving the inference to the cloud, the Raspberry Pi stays lightweight while still delivering accurate detection results.

The biggest advantage is that there's no need to collect datasets, annotate images, train neural networks, or optimize models before building the project.

Real-World Applications

Although this project is simple, the same concept can be used in plenty of practical applications.

It can be adapted for smart surveillance systems, warehouse inventory monitoring, classroom demonstrations, robotics, people counting, or even automated inspection systems. Since the cloud performs all the heavy computation, upgrading the detection model becomes much easier.

What You'll Learn

This project teaches much more than object detection.

You'll work with Raspberry Pi, Python, OpenCV, REST APIs, HTTPS communication, image processing, and cloud integration—all in a single build. These are practical skills that appear in many real-world IoT and computer vision applications.

Instead of spending days training AI models, you can focus on building a complete working system and understanding how all the pieces fit together.

That's probably the best part of this project.
Raspberry Pi Projects, AI Projects, IoT Projects

I Connected a Webcam to a Raspberry Pi - Now It Detects Safety Helmets

David Thomas — Mon, 13 Jul 2026 18:30:14 +0000

Road safety is a major concern worldwide, and wearing a helmet is one of the most effective ways to reduce injuries during two-wheeler accidents. However, monitoring every rider manually is difficult, especially in areas with heavy traffic.

In this project, we build a Raspberry Pi Helmet Detection System that automatically identifies whether riders are wearing helmets using a USB camera, Python, OpenCV, and the CircuitDigest Cloud Helmet Detection API.

Unlike traditional AI projects that require collecting datasets, training machine learning models, and deploying optimized neural networks, this project performs all AI processing in the cloud. This makes it easy for beginners, students, and developers to implement an intelligent traffic monitoring system without any prior machine learning experience.

How It Works

The Raspberry Pi continuously captures images through a connected USB camera. Using the OpenCV library, the captured frame is converted into JPEG format and securely uploaded to the CircuitDigest Cloud Helmet Detection API.

The cloud server analyzes the image using a pre-trained AI model and determines whether the detected riders are wearing helmets. The processed results, including detection status and confidence scores, are then returned to the Raspberry Pi and displayed in the terminal.

The project supports three operating modes:

Keyboard Mode for manually capturing images.
Auto Mode for automatic image capture at regular intervals.
SSH Mode for running the system remotely without a graphical interface.

Hardware Required

The hardware setup is intentionally simple and consists of:

Raspberry Pi
USB Camera
MicroSD Card with Raspberry Pi OS
Stable Internet Connection
Power Supply

Since the AI model is hosted in the cloud, the Raspberry Pi only handles image capture and API communication, reducing computational requirements.

Why Use CircuitDigest Cloud?

One of the biggest advantages of this project is that it removes the complexity of embedded AI development. Developers no longer need to:

Collect thousands of training images
Label datasets manually
Train machine learning models
Convert models into TensorFlow Lite or ONNX
Optimize models for embedded hardware

Instead, the Raspberry Pi simply sends an image to the cloud and receives accurate detection results through a single API call. This approach significantly reduces development time while allowing users to focus on building real-world applications.

Applications

This Raspberry Pi Helmet Detection System can be used in a wide range of real-world scenarios, including:

Smart traffic monitoring
Automated helmet violation detection
Highway surveillance
Toll booth monitoring
Parking management systems
Smart city infrastructure
Educational AI projects

The Raspberry Pi Helmet Detection System demonstrates how cloud-based AI can simplify computer vision applications. By combining Raspberry Pi, OpenCV, and the CircuitDigest Cloud API, developers can build a reliable real-time helmet detection solution without requiring machine learning expertise.
AI Project, Raspberry Pi Project, IoT Project

Raspberry Pi Helmet Detection System Using CircuitDigest Cloud API

David Thomas — Mon, 29 Jun 2026 10:53:55 +0000

In this project, we build a Raspberry Pi helmet detection system that automatically identifies whether riders are wearing helmets using a USB camera, Python, OpenCV, and the CircuitDigest Cloud Helmet Detection API.

How It Works

The project supports three operating modes:

Keyboard Mode for manually capturing images.
Auto Mode for automatic image capture at regular intervals.
SSH Mode for running the system remotely without a graphical interface.

Hardware Required

The hardware setup is intentionally simple and consists of:

Raspberry Pi
USB Camera
MicroSD Card with Raspberry Pi OS
Stable Internet Connection
Power Supply

Since the AI model is hosted in the cloud, the Raspberry Pi only handles image capture and API communication, reducing computational requirements.

Why Use CircuitDigest Cloud?

One of the biggest advantages of this project is that it removes the complexity of embedded AI development. Developers no longer need to:

Collect thousands of training images
Label datasets manually
Train machine learning models
Convert models into TensorFlow Lite or ONNX
Optimize models for embedded hardware

Applications

This Raspberry Pi Helmet Detection System can be used in a wide range of real-world scenarios, including:

Smart traffic monitoring
Automated helmet violation detection
Highway surveillance
Toll booth monitoring
Parking management systems
Smart city infrastructure
Educational AI projects

Build Parking Detection System with ESP32-CAM (No Model Training Required)

David Thomas — Fri, 26 Jun 2026 06:11:41 +0000

Smart parking systems are becoming more common, but building one often sounds like a machine learning project that requires collecting datasets, training models, and deploying them on edge devices.

The good news? You can skip all of that.

In this ESP32-CAM parking space detection system project, an ESP32-CAM captures an image of a parking lot and sends it to a cloud AI service. Within a few seconds, it receives the number of occupied and available parking spaces. No TensorFlow. No Edge Impulse. No custom AI model. Just a camera, Wi-Fi, and a few lines of code.

Why I Like This Approach

Most ESP32-CAM AI projects eventually hit the hardware limits.

The ESP32-CAM is an impressive little board, but it wasn't designed to run large computer vision models locally. Instead of forcing the microcontroller to perform heavy inference, this project lets the cloud handle all the image processing while the ESP32-CAM simply captures and uploads images.

For beginners, this makes the project much easier to understand and much quicker to build.

What You'll Need

The setup uses an ESP32-CAM, an ultrasonic sensor to detect incoming vehicles, an ESP32 for controlling the servo motor, and a small servo that acts as the parking gate. That's enough to build a working prototype without expensive hardware.

How the System Actually Works

The workflow is surprisingly straightforward.

When a vehicle approaches, the ultrasonic sensor detects it and signals the ESP32-CAM to capture an image of the parking area. The captured image is uploaded over HTTPS to a cloud-based Parking Detection API, which analyzes the parking slots and returns the number of occupied and empty spaces.

If at least one parking slot is available, the ESP32 opens the gate using the servo motor. Otherwise, the entrance remains closed.

Everything happens automatically within a few seconds.

Why Cloud AI Makes Sense Here

Running object detection directly on an ESP32-CAM isn't practical for most projects.

Modern detection models require far more memory than the ESP32-CAM can comfortably provide. By moving inference to the cloud, the firmware stays lightweight while still benefiting from accurate AI detection.

It also removes one of the biggest headaches in AI development—training your own model.

No dataset collection.

No image labeling.

No repeated training until the accuracy improves.

Just send the image and receive the result.

The Hardware Is Only Half the Story

The ESP32-CAM handles image capture, Wi-Fi communication, and secure API requests. The ESP32 manages the ultrasonic sensor and servo motor, while the cloud performs the computationally expensive detection work. Each device does exactly what it's good at.

That's good system design.

Where This Project Can Be Used

Although it's built as a learning project, the same idea can scale surprisingly well.

Apartment parking lots, college campuses, office buildings, shopping malls, and small commercial parking areas could all benefit from this type of system. Since detection happens in the cloud, updating the AI model doesn't require changing the firmware running on every device.

Things Worth Keeping in Mind

Like any cloud-based project, there are a few trade-offs.

The system needs an internet connection because every image is processed remotely. Image quality also matters quite a bit, so proper lighting and a clear camera angle will noticeably improve detection accuracy.

Fortunately, both of these are fairly easy to address during installation.

Why Engineering Students Should Build This

Projects like this teach much more than just object detection.

You'll work with embedded systems, Wi-Fi communication, REST APIs, HTTPS requests, cloud services, image capture, and automation—all in a single project. That's a combination of skills you'll see repeatedly in modern IoT development.

More importantly, you'll spend your time building the system instead of struggling through weeks of AI model training.

And sometimes, that's exactly the kind of engineering experience you want.

IoT Projects, ESP32 Projects, AI Projects

Raspberry Pi Face Detection System Without Training Any AI Models

David Thomas — Sat, 20 Jun 2026 10:41:20 +0000

Machine learning projects usually start with collecting datasets, labeling images, training models, and spending hours waiting for everything to work.

That's exactly why many engineering students avoid computer vision projects in the beginning.

This Raspberry Pi Face Detection project takes a completely different approach. Instead of running AI models locally on the Raspberry Pi, the heavy lifting is handled in the cloud. All the Raspberry Pi needs to do is capture an image and send it for processing. The result comes back in seconds with the number of detected faces and confidence scores.

Why This Project Is Different

Most face detection tutorials focus on model training or deploying pre-trained networks on the device itself.

While that's great for learning machine learning, it can become frustrating when you're simply trying to build something functional. Here, the Raspberry Pi acts as the bridge between the camera and a cloud-based Face Detection API.

The setup is surprisingly simple. A USB webcam captures frames, OpenCV handles image processing, and the cloud service performs face detection.

Hardware You'll Need

One reason I like this project is that the hardware requirements are minimal.

You'll need a Raspberry Pi, a USB camera, and a microSD card with Raspberry Pi OS installed. That's pretty much it.

No AI accelerator boards. No GPU. No complicated wiring.

How the Face Detection Workflow Works

The workflow is straightforward and easy to understand.

The USB camera continuously captures images while OpenCV displays the live feed. When an image is captured, it gets converted into JPEG format and sent securely to a cloud-based Face Detection API using HTTPS. The server analyzes the image and sends back the detection result, including the number of faces identified.

From the Raspberry Pi's perspective, it's simply sending an image and receiving a response.

Setting Up the Raspberry Pi

Before running the code, make sure Raspberry Pi OS is installed and your Pi is connected to the internet.

You can work directly with a monitor and keyboard, connect remotely using SSH, or access the full desktop using VNC Viewer. Personally, VNC is usually the most convenient option because it gives you access to both the desktop and terminal from your laptop.

The Role of OpenCV

OpenCV handles all camera operations in this project.

It initializes the webcam, captures images, converts frames into JPEG format, and provides a live preview window. Without OpenCV, you'd have to handle camera communication manually, which would make the project much more complicated.

The best part is that OpenCV runs smoothly even on a standard Raspberry Pi setup.

Multiple Capture Modes

One feature I found particularly useful is the availability of multiple operating modes.

Keyboard mode allows you to press the spacebar to capture an image manually. Auto mode captures images automatically at fixed intervals, making it suitable for monitoring applications. SSH mode works entirely from the terminal without displaying a video window, which is useful for headless deployments.

This flexibility makes the project useful for both learning and practical applications.

Real-World Applications

Face detection isn't just for fancy demos.

A project like this can be used for attendance systems, visitor logging, people counting, security monitoring, and educational demonstrations. Because the cloud handles the AI processing, students can focus more on building the overall system rather than spending time training models.

That's often where the most valuable learning happens.

What Makes It Great for Students

Many engineering students want to explore AI but get stuck at the model training stage.

This project removes that barrier completely. You still learn about computer vision, APIs, image processing, networking, and Raspberry Pi programming, but without the complexity of building and optimizing machine learning models from scratch.

For a weekend project, that's a pretty good trade-off.

What I like most about this setup is how quickly you can go from an idea to a working prototype.

Within a short time, you can have a Raspberry Pi capturing images, sending them to the cloud, and detecting faces in real time. It feels like one of those projects that introduces several important engineering concepts at once while still being simple enough for beginners to complete successfully.

Raspberry Pi Project, IoT Project, AI Project

I Opened Up an ESP32 Smart Display to See What's Inside: ESP32 2424S012C Teardown

David Thomas — Fri, 19 Jun 2026 10:38:53 +0000

Development boards usually hide all the interesting engineering under a neat enclosure.

Most of us connect a USB cable, upload some code, and start building projects without thinking much about what's happening underneath. But every now and then, it's worth taking a closer look at the hardware itself.

That's exactly what I did with the ESP32-2424S012C, a compact ESP32-C3 development board that comes with a built-in 1.28-inch IPS capacitive touch display. At first glance, it looks like a tiny smart display module. After opening it up, I realized there's a lot of clever engineering packed into this small board.

A Tiny Board Packed With Features: ESP32 2424S012C Teardown

The first thing that stands out is how much functionality is squeezed into such a compact design.

The board combines an ESP32-C3 microcontroller, a circular 240×240 IPS display, capacitive touch support, battery charging circuitry, voltage regulation, and USB programming hardware. Instead of connecting multiple modules with jumper wires, everything is integrated onto a single PCB.

For anyone who has spent hours wiring displays to ESP32 boards on a breadboard, this immediately feels like a cleaner solution.

Looking at the Main PCB

Once the display assembly is removed, the main components become easier to identify.

At the center sits the ESP32-C3, which handles all processing and wireless communication. Nearby are the boot, reset, and power buttons, along with a JST battery connector for connecting a 3.7V lithium battery.

The board also includes an IP5306 power management IC. This chip handles battery charging while simultaneously boosting the battery voltage when needed.

Another interesting component is the A6165P voltage regulator, which converts the available 5V rail into a stable 3.3V supply required by the ESP32 and display electronics.

The Display Is More Interesting Than It Looks

The display assembly itself contains some fascinating design choices.

Instead of using a traditional display controller mounted on a separate PCB, the display uses a GC9A01 driver implemented using Chip-On-Glass (COG) technology. The controller IC is bonded directly onto the display glass, reducing size and improving overall integration.

If you look closely, you'll notice a tiny black strip attached directly to the glass. That's actually the display controller.

The touch controller uses a different approach called Chip-On-Flex (COF), where the controller is mounted directly onto the flexible cable that connects the display to the main board.

It's one of those details that you rarely notice until you take the hardware apart.

Understanding the Display Connections

A single 16-pin FPC cable connects the display assembly to the main PCB.

These pins handle power delivery, LED backlight control, SPI communication for the display, and I²C communication for the touch controller.

The display uses SPI because graphical displays require fast data transfer speeds. The touch controller uses I²C because touch data requires far less bandwidth.

It's a simple design, but it's optimized well.

Battery Management Done Right

One thing I appreciate about this board is that it was clearly designed with portable projects in mind.

The IP5306 chip allows a lithium battery to be connected directly to the board. It manages charging while also providing a boosted output voltage when required.

This means you can build battery-powered projects such as smart watches, control panels, portable dashboards, or touch-based controllers without adding extra power management hardware.

For makers, that's a huge convenience.

USB Programming and Expansion Options

Programming the board is straightforward thanks to the USB Type-C connector.

The USB data lines connect directly to the ESP32-C3, allowing code uploads without additional adapters. There's also a dedicated UART connector available for alternative programming and debugging methods.

Having both options available makes development much easier, especially when troubleshooting firmware issues.

Why This Board Is Popular Among Makers

After looking through the hardware design, it becomes easy to understand why these smart display modules are becoming so popular.

They eliminate much of the wiring normally required when building graphical ESP32 projects. The display, touch controller, battery charging circuit, and microcontroller are already integrated and tested together.

That means less time troubleshooting hardware and more time building actual applications.

Teardowns are always a good reminder that even simple-looking development boards contain a surprising amount of engineering.

The ESP32-2424S012C combines display technology, power management, touch sensing, USB communication, and wireless processing into a remarkably compact package. For students learning embedded systems, exploring hardware like this is often just as educational as writing code.

And honestly, once you've seen how much functionality fits inside a board this small, you'll never look at a smart display module the same way again.

PCB Projects, Product Reviews

Build an ESP32 GSM Voice Calling Device with Auto Answer Using SIM868

David Thomas — Thu, 18 Jun 2026 10:29:33 +0000

Most IoT projects focus on sending sensor data to the cloud. That's useful, but sometimes a simple phone call can be far more effective.

Imagine an emergency button that instantly calls a family member, a security device that automatically answers incoming calls, or a wireless intercom system that works without Wi-Fi. That's exactly what this project achieves using an ESP32 and a GSM network.

In this ESP32 GSM voice Calling Device build, we create a compact ESP32 GSM Voice Calling Device that can place a phone call with the press of a button and automatically answer incoming calls. The best part is that everything is built around a single board, making the setup surprisingly simple.

Why This Project Is Interesting

Instead of displaying information on a screen, the device lets people communicate directly through a speaker and microphone. It instantly feels more practical and closer to a real product.

The project uses the GeoLinker GL868 development board, which combines an ESP32-S3 and a SIM868 GSM module on the same PCB. This removes the need for complicated wiring between separate GSM and microcontroller modules.

How the System Works

The logic is straightforward.

A push button is connected to the ESP32. When the button is pressed, the ESP32 sends AT commands to the SIM868 modem, instructing it to dial a predefined phone number. The GSM network then handles the call just like a normal mobile phone.

For incoming calls, the process works in reverse.

Whenever the SIM868 detects an incoming call, it continuously sends a "RING" notification to the ESP32. The microcontroller immediately responds with the ATA command, automatically answering the call and enabling two-way communication through the connected speaker and microphone.

Hardware Requirements

The setup consists of the GeoLinker GL868 board, a small speaker, a condenser microphone, a push button, a 3.7V Li-ion battery, and a GSM SIM card with voice support.

That's enough to build a fully functional wireless communication device.

Understanding the SIM868 AT Commands

If you've never worked with GSM modules before, this project is a good introduction.

The ESP32 communicates with the SIM868 using standard AT commands. Commands such as ATD initiate a phone call, ATA answers incoming calls, and ATH disconnects an active call. Additional commands configure microphone gain, speaker volume, and audio routing.

Once you understand these commands, building more advanced GSM projects becomes much easier.

Challenges During Development

Like most GSM projects, power management is important.

The modem draws significant current while initiating calls. If the battery cannot supply enough current, calls may fail or disconnect unexpectedly. Using a fully charged lithium battery solves most of these issues.

Audio configuration can also be tricky. Repeatedly sending audio-related AT commands during a call may result in distorted or broken audio. Proper call-state management helps prevent this problem.

Real-World Applications

What makes this project exciting is how easily it can be adapted.

The same design can be used as an emergency calling device for elderly people, an industrial alert system, a wireless intercom, or a GSM-based security communication system.

With a few modifications, multiple buttons can even be added to call different phone numbers, making it suitable for larger communication networks.

What Engineering Students Can Learn

This project teaches much more than simply making phone calls.

You'll gain experience with GSM communication, AT commands, serial communication, battery-powered embedded systems, and real-time event handling. These are practical skills that appear frequently in IoT and industrial automation projects.

More importantly, you'll understand how cellular communication works beyond sending SMS messages.

Building an ESP32 GSM Voice Calling Device is a refreshing change from typical IoT projects. Instead of pushing data to a dashboard, you're creating a device that enables direct voice communication through the GSM network.

For students exploring embedded systems, IoT, and wireless communication, this project offers a hands-on way to learn how cellular technology can be integrated into real-world applications while keeping the hardware simple and approachable.

ESP32 Project, IoT Project

ESP32-CAM Face Detection Without AI Training

David Thomas — Thu, 18 Jun 2026 07:12:11 +0000

Face detection is one of those technologies that looks complicated from the outside. Many engineering students assume they need machine learning knowledge, large datasets, and powerful hardware before they can build something similar.

The good news is that isn't true anymore.

With an ESP32-CAM and a cloud-based face detection API, you can build a working ESP32-CAM Face Detection Project in just a few steps. No model training, no dataset collection, and no advanced AI setup required.

Why ESP32-CAM is a Great Choice for Face Detection Projects

The ESP32-CAM is one of the most popular boards among makers and engineering students because it combines Wi-Fi and a camera in a compact package.

Instead of spending money on expensive development kits, you can experiment with computer vision concepts using a low-cost board that fits comfortably on a breadboard.

For students working on mini-projects or final-year prototypes, that's a huge advantage.

How This ESP32-CAM Face Detection System Works

The concept behind this project is simple.

A push button is connected to the ESP32-CAM. Whenever the button is pressed, the camera captures an image and uploads it through Wi-Fi to a cloud-based face detection service.

The server processes the image and returns the detection results. The ESP32-CAM then displays the number of faces detected along with the confidence score through the Serial Monitor.

This approach removes the need to run complex image-processing algorithms directly on the microcontroller.

Hardware Required for the Face Detection System

One of the best things about this project is the minimal hardware requirement.

You only need:

ESP32-CAM Module
Push Button
Breadboard
Jumper Wires

If you're using a standard ESP32-CAM without onboard USB support, you'll also need an FTDI programmer for uploading the code.

That's enough to get the entire system working.

Why Cloud-Based Face Detection Makes Sense

Running face detection locally requires significant memory and processing power.

While the ESP32-CAM is powerful for its size, it isn't designed to handle advanced computer vision algorithms efficiently. Offloading the heavy processing to the cloud allows the microcontroller to focus on capturing and transmitting images.

The result is a faster and more reliable system without increasing hardware costs.

For students, it also means spending more time building projects and less time training AI models.

Improving Face Detection Accuracy

During testing, one thing became obvious.

Image quality matters.

A well-lit image with a clear view of the face produces much better results than a dark or blurry image. Poor lighting can reduce confidence scores and sometimes prevent faces from being detected altogether.

If you're planning to deploy this system, proper camera placement and lighting should be your first priority.

Real-World Applications of ESP32-CAM Face Detection

Once the basic project is working, there are plenty of ways to expand it.

You can integrate it into a smart doorbell that detects visitors before sending notifications. It can also be used in attendance monitoring systems where the system counts the number of people entering a classroom.

Retail visitor counters, security monitoring systems, and smart alert applications are also possible extensions.

The project serves as a strong foundation for more advanced computer vision applications.

Challenges You May Encounter

Like most IoT projects, this one has a few limitations.

The system depends on an internet connection because image processing happens in the cloud. If Wi-Fi connectivity is unstable, image uploads may fail.

Detection accuracy can also be affected by poor image quality, low lighting conditions, or partially visible faces.

Despite these limitations, the setup remains much simpler than building and training a custom AI model from scratch.

This project goes beyond face detection.

While building it, you'll learn about ESP32-CAM programming, image capture, cloud APIs, HTTPS communication, JSON responses, and IoT integration.

These are practical skills that appear frequently in modern embedded and IoT projects.

More importantly, you'll get hands-on experience with a real-world computer vision application without needing advanced machine learning knowledge.

The ESP32-CAM Face Detection Project is a great example of how modern cloud services can simplify complex tasks. Instead of worrying about datasets, model training, and optimization, you can focus on understanding how the system works and building useful applications around it.

For engineering students looking to explore computer vision, IoT, and embedded systems, this project is an excellent place to start. It delivers quick results, teaches valuable concepts, and opens the door to many more advanced projects in the future.

ESP32 Projects, IoT Projects, AI Projects

Smart Waste Detection System with ESP32-CAM

David Thomas — Sat, 13 Jun 2026 10:53:24 +0000

Walk past any public dustbin and you'll probably notice the same thing - food waste, plastic bottles, paper cups, and wrappers all mixed together.

The problem isn't collecting waste anymore. The real challenge is sorting it correctly. When biodegradable and non-biodegradable waste get mixed, recycling becomes harder and a large portion of the waste ends up in landfills instead.

As engineering students, we've all seen projects that try to solve this problem using sensors. But I wanted to explore something more practical: what if a camera could simply look at a piece of waste and identify its category automatically?

That's exactly what this ESP32-CAM waste detection project does.

Why I Chose ESP32-CAM for This Project

Computer vision projects often sound expensive.

Most people immediately think about Raspberry Pi boards, GPUs, or dedicated AI hardware. But the ESP32-CAM changes that perception completely.

For a few dollars, you get a microcontroller, Wi-Fi connectivity, and a camera module in a single board. That makes it one of the easiest ways to start experimenting with image-based AI projects.

For student projects, that's a huge advantage.

Hardware Required

One of the best parts of this build is its simplicity.

The hardware consists of:

ESP32-CAM
Push button
Red LED
Green LED
Breadboard and resistors

That's it. No external processors, no dedicated AI hardware, and no complex sensor networks. :contentReference[oaicite:2]{index=2}

Smart Waste Detection System

The workflow is surprisingly simple.

When the push button is pressed, the ESP32-CAM captures an image of the waste item placed in front of it. The image is then sent through Wi-Fi to a cloud AI service for analysis.

Within a few seconds, the system receives a response indicating whether the object belongs to the biodegradable or non-biodegradable category.

To make the output easy to understand, LEDs provide instant visual feedback. One LED indicates biodegradable waste, while the other indicates non-biodegradable waste.

The Smart Part Happens in the Cloud

One thing I really liked about this project is that there was no need to train a machine learning model.

Anyone who has worked with TensorFlow or Edge Impulse knows that collecting datasets, labeling images, training models, and optimizing them can take days or even weeks.

Instead of doing all that, the ESP32-CAM simply uploads an image and receives the classification result through an API. This keeps the hardware lightweight while still delivering AI-powered functionality.

What I Learned During Testing

Getting the first successful detection felt great.

But I quickly realized that image quality plays a major role in accuracy. Poor lighting, shadows, and blurry images can affect the classification result significantly.

After a few tests, proper lighting and a stable camera position made the system much more reliable. It's one of those small details that makes a big difference in computer vision projects.

Real-World Applications Beyond a Classroom Project

What started as a simple experiment can actually be expanded into something much larger.

Smart dustbins, automated recycling systems, public waste collection centers, and educational demonstrations can all benefit from image-based waste classification.

With additional hardware, the system could even be integrated with automated sorting mechanisms that physically separate waste into different containers.

Many AI projects seem intimidating because they involve machine learning, datasets, and complex deployment pipelines.

This project shows that you can still build something genuinely useful without getting buried in model training. It combines embedded systems, Wi-Fi communication, cloud computing, and computer vision in a way that's easy to understand and surprisingly fun to build.

And honestly, seeing a tiny ESP32-CAM identify waste categories in real time feels pretty satisfying.

ESP32 Project, AI Project

Building an ESP32-CAM Indian Currency Recognition System for the Visually Impaired

David Thomas — Thu, 11 Jun 2026 12:10:07 +0000

Handling cash is something most of us do without thinking. But for visually impaired people, identifying currency notes can be a daily challenge.

Many people learn to recognize notes by touch, but that becomes harder with age. An elderly shopkeeper or street vendor with weak eyesight may struggle to verify the denomination handed over by customers. A simple mistake can lead to financial loss.

To address this problem, I built an ESP32-CAM Indian Currency Recognition. The idea is simple: point a camera at a currency note, press a button, and hear the denomination announced through a speaker.

The Idea Behind the Project

The system uses an ESP32-CAM to capture an image of an Indian currency note.

Instead of running a machine learning model directly on the microcontroller, the captured image is sent to a cloud-based AI service. The cloud processes the image, identifies the denomination, and sends the result back to the ESP32-CAM. The system then converts the result into speech and announces it through a speaker.

The entire process takes only a few seconds.

Why Use ESP32-CAM?

The ESP32-CAM is one of the most affordable boards available for computer vision projects.

It combines Wi-Fi connectivity, a camera interface, onboard processing, and compact size into a single board. This makes it perfect for projects that need image capture without requiring expensive hardware.

For student projects, it is often the easiest way to get started with AI-powered vision applications.

Hardware Required

The hardware setup is surprisingly simple.

You only need:

ESP32-CAM
PAM8403 audio amplifier
Speaker
Push button

The push button triggers image capture, the ESP32-CAM handles image transmission, and the speaker announces the detected denomination.

How the System Works

The workflow is straightforward.

First, the user places a currency note in front of the camera and presses the button. The ESP32-CAM captures a high-quality image and uploads it to the cloud recognition API. The cloud analyzes the note and returns the detected denomination.

Once the result arrives, the system generates audio using text-to-speech and plays it through the speaker. Instead of reading a display, the user simply listens to the spoken output.

This makes the system far more accessible for visually impaired users.

Why CircuitDigest Cloud Instead of Running ML on the ESP32?

This was one of the most interesting parts of the project.

Traditional machine learning workflows usually require collecting hundreds of images, labeling datasets, training models, optimizing them, and then deploying them to embedded hardware.

That process can take days.

In this project, the heavy lifting happens in the cloud. The ESP32-CAM only captures and uploads images. The recognition model is already trained and maintained on the server side, making development much faster.

For beginners, this removes one of the biggest barriers to building AI-powered projects.

Audio Feedback Makes a Huge Difference

The recognition itself is useful, but the audio output is what makes the system practical.

After identifying the note, the ESP32-CAM uses a text-to-speech service to generate spoken audio. The amplifier boosts the sound, and the speaker announces the denomination clearly.

This means users don't need a display or smartphone screen to understand the result.

Challenges I Faced

Like most vision-based projects, image quality matters.

Poor lighting, folded notes, camera shake, or blurry images can affect recognition accuracy. During testing, keeping the note around 10–15 cm from the camera and using proper lighting produced the most reliable results.

A stable Wi-Fi connection is also important since the image must be uploaded before processing can begin.

Where This Can Be Used

While this project was designed for visually impaired users, there are several other use cases.

It can be used in small shops, educational demonstrations, assistive devices, banking kiosks, or even as part of a larger financial accessibility system.

The same concept can also be expanded to recognize foreign currencies, documents, or everyday objects.

What I like most about this project is that it combines embedded systems, cloud AI, computer vision, and accessibility into a single build.

The hardware is simple, the setup is beginner-friendly, and the result solves a real-world problem. More importantly, it shows how affordable hardware like the ESP32-CAM can be used to create practical assistive technology that genuinely helps people become more independent.

IoT Projects, ESP32 Projects, AI Project