Forem: David Thomas

Build a Smart ESP32 Speaking Alarm Clock with AI Voice

David Thomas — Wed, 08 Apr 2026 11:21:33 +0000

Traditional alarm clocks wake you up with a harsh beep - but what if your alarm could talk to you instead? In this project, we transform a basic alarm into a smart, voice-enabled IoT device that announces the time and delivers personalized reminders using natural speech.

This ESP32-based speaking alarm clock combines embedded systems with cloud AI to create a more intuitive and human-friendly experience.

What Makes This Alarm Clock Different?

Instead of relying on a buzzer, this system uses a cloud-based Text-to-Speech (TTS) engine to generate clear voice announcements. At the scheduled time, the device speaks out the current time along with a custom message you set - like “Good morning” or “Meeting in 10 minutes.”

It’s not just an alarm - it’s a smart assistant built on simple hardware.

How It Works

At the heart of this project is the XIAO ESP32-S3 microcontroller, which handles everything from Wi-Fi connectivity to alarm scheduling. Once powered on, the ESP32 connects to your Wi-Fi network and syncs the current time using an NTP server.

You can configure alarms through a browser - based interface hosted directly on the ESP32. Each alarm includes a specific time and a custom message.

When the alarm triggers:

The ESP32 sends the message to a cloud TTS service
The service converts it into audio
The audio is played through a speaker using an I2S amplifier

This creates a seamless flow from text to natural voice output.

Key Features

Voice-based alarm instead of a buzzer
Wi-Fi time synchronization (no RTC needed)
Browser-based alarm configuration
Multiple alarms with custom messages
OLED display for real-time clock and next alarm
Push button to stop alarm instantly
Clean digital audio using I2S output

Hardware Components

The setup is simple and beginner - friendly. You’ll need:

XIAO ESP32-S3
MAX98357A I2S Amplifier
0.96” OLED Display (SSD1306)
Speaker (4Ω or 8Ω)
Push Button
Connecting wires

All components are affordable and easily available.

Smart Control via Web Interface

One of the most powerful features is the built-in web server. Once connected to Wi-Fi, the ESP32 hosts a control page that you can access from your phone or laptop.

From there, you can:

Add new alarms
Edit existing ones
Delete schedules

No app required - just a browser.

Real-World Applications

This project goes beyond a bedside alarm. It can be adapted for:

Medication reminders for elderly users
Study and exam alerts
Office task notifications
Voice alerts for visually impaired users
General IoT-based announcement systems

Limitations to Consider

While powerful, the system has a few constraints:

Requires internet for voice output
Alarms reset after power loss
No authentication on the web interface
Limited number of alarms

These can be improved with features like flash storage, offline audio fallback, and security layers.

This ESP32 Speaking Alarm Clock is a perfect example of how IoT and AI can enhance everyday devices. By combining Wi-Fi, cloud services, and embedded hardware, you create a system that feels modern, interactive, and practical.

Whether you're exploring ESP32 development or building smarter home devices, this project is a solid step into the future of connected electronics.
ESP32 project

Arduino Email Alert System Using DHT11 & Circuitdigest Cloud API

David Thomas — Fri, 27 Mar 2026 09:49:59 +0000

Ever left your room and wondered what happened to the temperature while you were away?

Maybe it got too hot.

Maybe humidity spiked.

And unless you were constantly watching a screen, you’d never know.

That’s exactly the problem this project solves.

Most beginner projects stop at printing values on a serial monitor.

But in real applications, data alone isn’t enough. You need action.

This Send Email Notifications using Arduino project adds that missing piece. Instead of just measuring temperature, it reacts when something goes wrong.

Hardware Setup (Clean & Minimal)

The setup is intentionally simple.

You use an Arduino UNO R4 with built-in WiFi, and a DHT11 sensor for readings. The sensor connects to 5V, GND, and a single digital pin for data.

No external modules. No complicated wiring.

Just plug, connect, and you’re good to go.

How It Works Behind the Scenes

Once powered on, the Arduino connects to your WiFi.

After that, it continuously reads temperature and humidity from the DHT11 sensor. These values are compared with a threshold you define in the code.

If everything is normal, the system stays quiet.

But the moment temperature crosses the limit, the Arduino sends a secure HTTPS request to a cloud email API, which triggers an alert email.

And just like that, you get notified instantly.

Smart Alert Logic (This Matters)

Here’s where things get interesting.

The system doesn’t keep spamming emails.

Once an alert is sent, it pauses further notifications until the temperature drops back to normal. Only then does it reset and get ready for the next alert.

This small logic makes the project practical, not annoying.

What’s Happening in the Code

The code handles three main things.

First, it connects to WiFi using built-in libraries.

Then it reads sensor values at fixed intervals.

Finally, it checks if the threshold is exceeded and sends an email.

The email content is created as a JSON payload, which includes temperature and humidity values in real time.

Common Issues You Might Face

WiFi issues are usually the first thing to check.

Make sure your SSID and password are correct, and watch the serial monitor for connection status.

If the sensor shows NaN values, it’s mostly wiring or incorrect pin configuration.

And if emails don’t show up, check your API settings or spam folder.

Where You Can Use This

This Send Email Notifications using Arduino project is surprisingly versatile.

You can use it in server rooms to monitor overheating, in greenhouses to track environmental conditions, or even at home for basic safety alerts.

It’s also a great starting point for building more advanced IoT systems.

Why This Project Stands Out

Because it doesn’t just measure.

It responds.

And once you build something like this, you naturally start thinking bigger. SMS alerts, mobile notifications, automation triggers... it all builds from here.

This is where Arduino projects start feeling real.

I Built a Pocket-Sized Arduino Game Console (And It’s Actually Playable)

David Thomas — Thu, 26 Mar 2026 18:27:30 +0000

Tired of blinking LEDs and basic sensor projects?

Same here.

So I tried something different. I built a handheld Arduino game console that actually runs real games, fits in your pocket, and feels surprisingly fun to use.

What This Project Is About

This isn’t just another Arduino demo.

It’s a fully working mini game console powered by an Arduino UNO R4 WiFi, paired with a small OLED display and a few buttons. The goal was simple, build something interactive, not just functional.

And honestly, it turned out better than expected.

The Idea Behind It

Instead of building separate small projects, I wanted one device that could do multiple things.

Games felt like the perfect choice.

So I packed 10 classic-style games into a single system. Think Snake, Pong, Tetris, and a few more, all recreated to run smoothly on limited hardware.

Not exact arcade versions, but close enough to feel nostalgic.

The Hardware Setup

The hardware is simple but cleverly arranged.

Everything sits on a custom HAT-style board mounted directly on the Arduino. That means no messy breadboards or loose wires hanging around.

You’ve got:

A 0.96” OLED display
Four tactile buttons for control
A buzzer for sound
A LiPo battery for portability

And that’s all it takes to turn a dev board into a mini gaming device.

What Makes It Feel Like a Real Console

The compact design makes a huge difference.

It’s not just something sitting on your desk. You can actually hold it, carry it around, and play anywhere. The battery-powered setup makes it feel like a proper handheld device rather than a prototype.

That’s where the fun really kicks in.

How the Software Is Structured

This is where things get interesting.

Each game is written separately and stored in its own file. The main program just acts like a launcher, showing a menu and loading whichever game you select.

This makes the system super easy to expand.

Want to add a new game? Just drop in a new file and update the menu.

Handling Buttons Like a Pro

If you’ve worked with buttons before, you know they can be messy.

One press often registers multiple times due to bouncing.

To fix that, the code includes a debounce function that filters out unwanted signals and ensures each press is clean and accurate.

This small detail makes gameplay feel smooth instead of frustrating.

Challenges That Actually Taught Something

Not everything worked on the first try.

One major issue was with display libraries. Some popular ones didn’t behave well with this board, so switching to a better-supported library fixed stability issues.

Another classic problem was button noise, which was solved through software timing logic.

These are the kind of problems that actually teach you how embedded systems behave in real life.

What You Can Do Next

This project is just the beginning.

You can easily take it further by adding more games, improving sound effects, or even introducing wireless multiplayer using the board’s WiFi capability.

You could also upgrade the display or move to a more powerful controller for better graphics.

Why This Project Feels Different

Most Arduino projects stop at “it works.”

This one goes a step further.

It’s interactive. It’s fun. And it feels like something you’d actually use, not just build and forget.

Once you power it on and start playing, it hits differently.

And that’s what makes it worth building.
For more info check out: DIY Handheld Arduino Game Console With 10 Retro Games

ESP32 Email Alerts Made Simple (IoT Notification System with Ultrasonic Sensor)

David Thomas — Thu, 26 Mar 2026 10:38:43 +0000

Ever built something cool and then realized… you still have to keep checking it manually?

Yeah, that gets annoying fast.

So instead of constantly watching your system, why not make it notify you automatically? That’s exactly what this Send Email Notifications using ESP32 project does using an ESP32 and a simple ultrasonic sensor.

What You’re Building

This is a smart alert system.

The ESP32 continuously measures distance using an ultrasonic sensor. When something comes too close, it instantly sends an email notification to your inbox.

No GSM. No complicated email servers. Just WiFi and a clean API-based approach.

Why This Approach Is Better

A lot of people try sending emails directly from microcontrollers.

That usually turns into a headache.

Here, the ESP32 doesn’t deal with email protocols at all. It just sends a small JSON request to a cloud API, and the platform handles formatting and delivery.
Less complexity, more reliability.

Hardware Setup (Super Simple)

This is one of those builds where you don’t need much.

Just an ESP32 and an ultrasonic sensor.

The trigger pin sends a pulse, the echo pin reads the return signal, and that’s how distance is calculated. A couple of jumper wires and you’re good to go.

How the System Works

The logic is clean and easy to follow.

The sensor keeps checking distance in a loop. As long as everything is normal, nothing happens.

But the moment an object crosses the threshold, the ESP32 sends data to the cloud API, which then delivers an email alert.

Simple flow, real-world impact.

What’s Happening in the Code

There are three main parts in the code.

First, the ESP32 connects to WiFi. Then it reads distance using pulse timing. Finally, when the condition is met, it creates a JSON payload and sends it securely using HTTPS.

That payload includes your email, template ID, and sensor value.

Everything else is handled on the cloud side.

One Smart Feature You Shouldn’t Skip

There’s a small but important trick in this project.

A cooldown mechanism.

Without it, the ESP32 would keep sending emails again and again while the object stays close. So the code ensures only one alert is sent per event.

Once the object moves away, the system resets.

Where You Can Actually Use This

This isn’t just a learning project.

You can turn it into something useful pretty quickly.

Think intrusion alerts, parking sensors, safety monitoring, or even simple automation triggers. Anywhere you need instant updates without checking manually, this fits in.

Common Issues (Quick Reality Check)

If emails aren’t coming through, don’t panic.

It’s usually an API key issue or an unverified email. Sometimes the message lands in spam, so check there too.

If the sensor isn’t working, it’s almost always wiring. Loose connections love to ruin otherwise perfect builds.

Why This Project Is Worth Trying

This is more than just sending an email.

You’re actually learning how real IoT systems work. Devices collect data, send it to the cloud, and trigger actions based on conditions.

Once you understand this flow, you can build way more advanced systems.

Swap the ultrasonic sensor with anything else, and you’ve got a completely new project.

Send Email Notifications using ESP32

DIY Optocoupler Tester Circuit for Quick Fault Detection

David Thomas — Tue, 24 Mar 2026 10:09:47 +0000

If you’ve worked with optocouplers, you’ve probably faced this.

Everything looks fine. No burns, no cracks.

But the circuit just doesn’t work.

That’s the frustrating part.

Optocouplers can fail silently, and a multimeter doesn’t always give a clear answer. So instead of guessing, this project builds Optocoupler Tester Circuit, a simple tester that tells you instantly whether an optocoupler is working or not.

What This Project Solves

In labs and repair work, testing components quickly matters.

An optocoupler might look perfectly normal, but internally, the LED or phototransistor could be dead. This tester checks both sides in seconds and removes that uncertainty.

No complex measurements. Just a clear visual result.

What an Optocoupler Tester Actually Checks

The idea is simple.

An optocoupler has two sides:

Input → an internal IR LED
Output → a light-sensitive transistor

This tester verifies both at the same time.

When you press a button, the input LED is powered. If it works, light is produced internally. That light should activate the output transistor.

If both sides respond correctly, the device is good.

Components You’ll Need

This build is intentionally simple.

You only need basic components:

Optocoupler (for testing)
Red LED (input indicator)
Green LED (output indicator)
Push button
Two resistors (470Ω)
3.7V Li-ion battery
IC base (4-pin / 6-pin)
Dot board

Nothing fancy here.

And that’s the beauty of it.

How the Circuit Works

Let’s break it down in a practical way.

When you press the push button, current flows through the optocoupler’s input LED. If that LED is working, the red LED lights up, confirming input activity.

Now comes the important part.

The light generated inside the optocoupler should trigger the output transistor. If that happens, current flows through the green LED, and it turns on.

So in one quick press, you get a full check.

Input + Output.

Understanding the LED Results

This is where the tester becomes really useful.

Red ON + Green ON → Good optocoupler
Red ON + Green OFF → Output failure
Both OFF → Input failure or wrong insertion
Green ON alone → Wiring issue or short

No need to interpret numbers.

Just look and decide.

Why Not Just Use a Multimeter?

You can.

But it’s limited.

A multimeter mainly checks the input LED using diode mode. It doesn’t properly verify the output behavior unless you set up additional circuits.

That means you might think the optocoupler is fine when it’s actually faulty.

This tester avoids that completely by checking real operation, not just electrical continuity.

Real-World Usage

This becomes super handy in situations like:

Repairing SMPS circuits
Testing salvaged components
Verifying batches of optocouplers
Lab experiments and demos

Instead of spending minutes per component, you can test one in under 2 seconds.

Practical Tip While Building

Use IC sockets.

Don’t solder the optocoupler directly.

This allows you to test multiple components easily and avoids damaging them with heat. It also makes the tester reusable, which is a big plus.

Common Issues You Might Face

If the red LED doesn’t light, check polarity or pin placement.

If only red lights up, the output transistor is likely dead.

If nothing works at all, check battery voltage or loose connections.

These are small issues, but they’re common during first builds.

Why This Project Is Worth It

It’s one of those tools you don’t think about until you need it.

But once you have it, you’ll use it again and again.

You’re not just building a circuit here. You’re building a diagnostic tool that saves time, prevents wrong assumptions, and makes debugging much easier.

And honestly, that’s something every electronics setup should have.
Optocoupler Tester Circuit

ESP32 WhatsApp Alerts Made Simple (No GSM, No Hassle)

David Thomas — Mon, 23 Mar 2026 19:23:24 +0000

If you’ve ever wanted your project to send alerts directly to your phone, this one hits the sweet spot. No GSM module, no SIM card, and no complicated setup.

Just WiFi and a few lines of code.

This project Send WhatsApp Messages using ESP32 shows how to send real-time WhatsApp alerts using an ESP32 and a simple sensor. And honestly, once you get this working, you’ll start thinking of a lot of use cases.

What This Project Actually Does

At its core, the idea is simple.

The ESP32 reads data from a sensor. If something crosses a limit, like temperature going too high, it instantly sends a WhatsApp message.

That’s it.

No direct connection to WhatsApp servers though. Instead, the ESP32 sends a secure API request, and the cloud platform handles formatting and delivery.

This makes the whole system clean and beginner-friendly.

Why This Approach Works So Well

Traditionally, sending alerts from microcontrollers meant using GSM modules. That adds cost, complexity, and sometimes unreliable networks.

Here, WiFi does everything.

The ESP32 connects to the internet and sends a structured JSON request. The cloud handles the rest, including message templates and delivery.

So your firmware stays simple.

And honestly, that’s a big win.

Hardware Setup (Super Minimal)

You only need a few components:

ESP32 board
DHT11 sensor
Breadboard and jumper wires

That’s it.

The DHT11 reads temperature, and the ESP32 handles everything else. You can swap the sensor with anything later, motion sensor, gas sensor, or even voltage monitoring.

How the Flow Works

Let’s break it down in a real-world way.

The ESP32 connects to WiFi and keeps reading sensor data. When the value crosses a threshold, it prepares a small JSON payload.

That payload includes your phone number, a template ID, and the sensor value.

Then it sends an HTTPS request.

The cloud verifies your API key, inserts your data into a pre-defined WhatsApp template, and delivers the message instantly.

Clean. Efficient. No extra overhead.

Code Logic (What’s Happening Behind the Scenes)

The code follows a very straightforward pattern.

First, it connects to WiFi and initializes the sensor. Then it continuously reads temperature values inside the loop.

Once the value crosses a limit, say 30°C, it triggers the alert function.

There’s also a cooldown timer.

This is important because without it, your phone would get flooded with messages if the condition stays true. So the system waits a few seconds before sending the next alert.

That’s a small detail, but it makes the system usable.

The JSON Payload Idea

This is where things get interesting.

Instead of writing full message text inside your code, you send structured data.

Something like:

Device name
Parameter
Measured value
Location

The platform maps these values into a template and generates the final message.

This keeps your code reusable.

You can switch from temperature alerts to motion alerts without rewriting everything.

Real Use Cases

Once you build this, you’ll see how flexible it is.

You can use it for:

Temperature monitoring in rooms or servers
Intrusion detection with PIR sensors
Water level alerts
Industrial parameter monitoring

Basically anything that needs instant notification.

What Makes This Project Worth Trying

It’s not just about sending messages.

You’re learning how to:

Work with APIs from microcontrollers
Handle HTTPS requests
Structure JSON data
Design event-driven systems

These are real-world skills.

And the best part, the setup stays simple enough that you won’t get stuck debugging hardware for hours.

Once you get this running, try replacing the sensor.

That’s where the fun starts.

The logic remains the same, only the data changes.
Send WhatsApp Messages using ESP32

Raspberry Pi Pico RTC Digital Clock

David Thomas — Sun, 22 Mar 2026 05:30:00 +0000

If you’ve ever tried building a digital clock using a microcontroller, you probably noticed one issue. The time drifts.

That’s where an RTC comes in.

In this project Raspberry Pi Pico RTC Module, we build a clean and reliable digital clock using a Raspberry Pi Pico, a DS3231 RTC module, and a 16x2 I2C LCD. It not only shows time and date, but also rotates the display to show temperature.

Simple build.

Very practical outcome.

Why This Project Is Actually Useful

This isn’t just another clock project.

Once you understand this setup, you can reuse it in data loggers, automation systems, or scheduling-based projects. Anything that needs accurate timekeeping depends on this kind of setup.

And accuracy is where the DS3231 really shines.

Why DS3231 Over Other RTCs

Most basic RTC modules depend on external crystals.

That’s the problem.

Temperature changes affect those crystals, and over time your clock starts drifting. Sometimes by minutes every month.

The DS3231 solves this with a built-in temperature-compensated oscillator.

It adjusts itself based on temperature, so your time stays accurate even in changing environments.

For long-running projects, this matters a lot.

How the System Works

The setup is built around I2C communication.

The Pico talks to both the DS3231 and the LCD using just two lines, SDA and SCL. That’s the beauty of I2C, multiple devices sharing the same bus without extra wiring.

The RTC keeps track of time independently.

Even if power goes off, the coin cell battery keeps it running. The Pico simply reads the current time and displays it.

Smart Display Handling

Here’s a small but interesting part.

A 16x2 LCD is limited in space, so instead of cramming everything at once, the display rotates.

For a few seconds, it shows time and date. Then it switches to temperature.

This keeps the display clean and readable.

And it’s a good example of writing efficient UI logic even on small hardware.

Setting the Time (Important Part)

When using DS3231, you only need to set the time once.

There are two ways to do it.

The easiest is compile-time sync. When you upload the code, it takes your computer’s current time and writes it to the RTC.

But there’s a catch.

If you don’t comment out that line after uploading, the time resets every time the Pico restarts. That’s a very common beginner mistake.

The second method is manual time setting.

This is useful if you want to test specific timestamps or sync multiple devices.

Code Flow Overview

The code is pretty clean.

It initializes I2C, checks if the RTC is connected, and then starts reading values. If the RTC has lost power, it sets the time again.

Inside the loop, it reads:

Current date and time
Temperature from the DS3231

Then formats everything into clean strings before sending it to the LCD.

This formatting step is important.

It avoids leftover characters and keeps the display stable.

Hardware Setup

The wiring is minimal.

You connect:

Pico to DS3231 using SDA and SCL
LCD to the same I2C bus
Power and ground shared across components

That’s it.

No complex wiring. No extra modules.

Just make sure you’re using 3.3V for the Pico.

Common Issues You’ll Run Into

If the clock resets after power off, the battery is usually the issue.

Check if the CR2032 is properly inserted or dead.

If the LCD shows weird characters, it’s often the I2C address or contrast setting. Try 0x27 or 0x3F.

If the RTC isn’t detected, double-check SDA and SCL connections.

These small issues are very common but easy to fix.

Where You Can Take This Next

Once this is working, you’ve got a solid base.

You can add alarms using the DS3231 interrupt pin. You can build scheduling systems or automate devices based on time.

You can even log timestamped data using an SD card.

This project Raspberry Pi Pico RTC Module might look simple.

But it quietly teaches some core embedded concepts that show up everywhere later.

Smart Energy Meter Using IoT with MQTT & SMS Alerts (ESP32 + PZEM-004T)

David Thomas — Fri, 20 Mar 2026 07:39:58 +0000

Ever wondered how much power your home actually consumes in real time?

Not just the monthly bill, but live voltage, current, and power usage while things are running. That’s where this project comes in. It’s a Smart Energy Meter Using IoT that gives you real-time data and even sends alerts when something goes wrong.

No bulky setup.

No complicated hardware.

Just an ESP32, a PZEM module, and a clean IoT workflow.

What This Project Does

At its core, this system tracks electrical parameters like voltage, current, power, and power factor.

It sends this data to an MQTT dashboard so you can monitor everything remotely. And when something abnormal happens, like high voltage or unusual current, it sends an SMS alert straight to your phone.

That extra layer of safety makes this more than just a monitoring tool.

It feels like a smart watchdog for your home.

Why PZEM-004T Makes Things Easy

If you’ve worked with voltage or current sensors before, you know calibration can get messy.

The PZEM-004T solves that.

It’s factory-calibrated and handles all the heavy calculations internally. You just connect it and start reading accurate values without spending hours tuning things.

It measures voltage, current, power, energy, frequency, and power factor all in one module.

For most DIY builds, that’s more than enough.

How the System Works

The setup is actually pretty clean once you break it down.

The PZEM module reads electrical data from your mains line using a current transformer. The ESP32 communicates with it over UART and collects all the values.

From there, two things happen at the same time.

The ESP32 publishes data to an MQTT broker for remote monitoring. At the same time, it displays readings locally on an LCD.

And if a condition like high voltage is detected, it triggers an SMS alert.

Simple flow, but very effective.

MQTT Makes It Feel Real-Time

Instead of using traditional HTTP requests, this project uses MQTT.

That’s a big deal.

MQTT works on a publish-subscribe model, so data gets pushed instantly instead of being requested repeatedly. This means lower latency and smoother updates.

In practice, it feels like live streaming your electrical data.

No delays.

No refresh needed.

Hardware Setup

The hardware side is pretty straightforward.

You connect the PZEM module to the ESP32 using TX and RX pins. The LCD uses I2C, so only two wires are needed for data.

The CT clamp goes around the live wire to measure current.

That’s it.

The rest is just powering everything properly and making sure connections are clean.

Code Logic (What’s Happening Inside)

The ESP32 continuously reads values like voltage, current, and power from the PZEM module.

These values are then sent to the MQTT broker and displayed on the LCD.

At the same time, the code checks for abnormal conditions. For example, if voltage crosses a certain limit, it triggers an SMS alert.

There’s also a cooldown system in place.

This prevents multiple alerts from being sent repeatedly for the same issue.

Real-Time Monitoring Experience

Once everything is running, you can see your data in multiple places.

On the LCD for quick local viewing.

On the serial monitor for debugging.

And on the MQTT dashboard for remote access.

All three show the same data in sync.

It’s actually satisfying to watch your system behave like a proper IoT device.

Where This Can Be Used

This kind of setup fits into a lot of real-world scenarios.

You can use it at home to monitor power consumption and detect faults early. You can use it in small industrial setups where basic monitoring is needed without expensive systems.

Or even in remote locations where you just want alerts when something goes wrong.

That’s where the Smart Energy Meter Using IoT idea really shines.

It doesn’t just show data.

It tells you when something needs attention.

Troubleshooting Tips

If current always shows zero, the CT clamp is usually the issue.

Make sure it’s properly closed and placed only on the live wire. Clamping both live and neutral will cancel the measurement.

If the LCD doesn’t show anything, check the I2C address and wiring.

And if values look weird, double-check the UART connections between ESP32 and the PZEM module.

Small mistakes here can throw off everything.

Why This Project Feels Practical

A lot of IoT projects look good on paper but don’t feel useful in real life.

This one is different.

You’re actually monitoring something important, and the system reacts when something goes wrong. It’s simple enough to build, but powerful enough to be useful.

That balance is what makes this a solid engineering project.

Send WhatsApp Alerts Using Arduino UNO R4 WiFi (No GSM, No API Headache)

David Thomas — Thu, 19 Mar 2026 13:15:47 +0000

If you’ve ever tried sending notifications from an Arduino project, you’ve probably run into the usual problems. GSM modules, SIM cards, or complex APIs that feel like overkill for a simple alert system. It works, but it’s not exactly fun.

This project we Send WhatsApp Messages using Arduino with the help of circuitdigest cloud API takes a much simpler route.

Instead of dealing with telecom hardware or complicated setups, you can send WhatsApp messages directly from an Arduino UNO R4 WiFi using a simple HTTPS request. That means your Arduino connects to WiFi, sends data to a cloud service, and the message lands on your phone instantly.

What This Project Does

The idea is straightforward.

An ultrasonic sensor measures distance continuously. When an object comes closer than a defined limit, the Arduino sends that data to the cloud, which then delivers a WhatsApp message.

It turns your Arduino into a real-time alert system.

This can be used for proximity detection, parking alerts, or even basic intrusion detection setups.

Why Arduino UNO R4 WiFi?

Unlike older boards like the UNO R3, the UNO R4 WiFi comes with built-in WiFi support. That removes the need for external modules and keeps the setup clean.

Because of this, the Arduino can directly send HTTPS requests.

No extra hardware.

No extra complexity.

How the System Works

The workflow is simple but effective.

The ultrasonic sensor measures distance using trigger and echo signals. The Arduino processes this data and checks if it crosses a threshold, like 20 cm.

When that condition is met, the Arduino prepares a JSON payload.

This payload includes your phone number, a template ID, and the sensor value. It then sends this data securely over HTTPS to a cloud endpoint.

From there, the cloud service handles everything else.

It formats the message, inserts the values into a template, and delivers it to WhatsApp.

The Role of Templates

Instead of writing full message text in your code, the system uses pre-approved templates.

Each template has placeholders like {#var#} that get replaced with your data. This keeps your Arduino code simple and avoids dealing with formatting logic.

You just send structured data.

The cloud handles the message.

Hardware Setup

The hardware side is refreshingly simple.

You connect the HC-SR04 ultrasonic sensor to the Arduino using four wires. Power, ground, trigger, and echo.

Once connected, the sensor can measure distances from around 2 cm up to a few meters.

Mounting the sensor properly also matters.

Place it in a direction where it can clearly detect objects without obstructions.

Code Logic Overview

The Arduino continuously measures distance using ultrasonic pulses.

Each reading is converted into centimeters using the speed of sound. The code then checks if the distance is below a defined limit.

If the condition is true and enough time has passed since the last alert, it sends a WhatsApp message.

A cooldown timer is important here.

Without it, the Arduino would send messages continuously while the object remains in range.

Why This Approach Works Well

The biggest advantage of this setup is simplicity.

You don’t need to integrate with WhatsApp directly. You don’t need to manage authentication or message formatting.

Your Arduino just sends data.

Everything else is handled in the cloud.

This makes it perfect for quick IoT builds where you want real-time notifications without getting stuck in setup complexity.

Where You Can Use This

Once you build this, you’ll start seeing use cases everywhere.

You can use it as a parking assistant that alerts when a car gets too close. You can turn it into a door or entry monitor that sends alerts when someone approaches.

Or just keep it as a learning project to understand how hardware and cloud services work together.

It’s one of those builds that feels simple at first but opens up a lot of ideas once you get it working.

Send WhatsApp Messages using Arduino

Add a WiFi Camera to a LiteWing ESP32 Drone for Live Video Streaming

David Thomas — Tue, 17 Mar 2026 02:08:08 +0000

If you enjoy experimenting with small drones, adding a camera is one of the most satisfying upgrades you can try. Watching a live aerial view from something you built yourself feels rewarding. That’s exactly why we added Wi-Fi Camera to LiteWing ESP32 Drone.

The result is a compact drone that can stream live video while flying. No complicated firmware integration and no heavy payload that affects flight stability. Just a simple modification that adds a completely new dimension to the drone.

Why Add a Camera to a DIY Drone?

Most commercial drones already include cameras, but they often come with a higher price and limited customization options. For hobbyists and engineering students, building a camera-enabled drone from scratch is far more exciting.

Adding a WiFi camera module allows the drone to stream live video directly to a smartphone. This means you can view the drone’s perspective in real time while controlling it.

It also opens up new possibilities. Aerial monitoring, hobby video capture, or even prototype surveillance projects suddenly become possible with a simple setup.

Hardware Used in the Build

The main platform in this project is the LiteWing ESP32 drone. Since it is based on the ESP32 microcontroller, it is easy to modify and experiment with.

For video streaming, a compact dual WiFi camera module taken from a toy drone is used. These modules are lightweight and designed specifically for small aerial platforms.

Power comes from a single 1S LiPo battery. Using a battery with a higher C-rating is recommended because it can provide stable current when the motors demand more power.

Two Independent Wireless Systems

One interesting aspect of this setup is that the flight system and the camera system operate independently.

The LiteWing drone creates its own WiFi access point for flight control. Your phone connects to this network using the drone control app, which allows you to manage throttle, pitch, roll, and yaw.

The camera module also creates its own WiFi network.

This means two wireless channels are active at the same time. One network handles flight control while the other streams the live video feed.

Because the systems are separated, the video transmission does not interfere with the drone’s flight responsiveness.

How the Camera Streams Video

When the drone powers on, the camera module automatically creates its own WiFi access point. Your phone can connect to this network just like connecting to any regular hotspot.

Once connected, you simply open a compatible viewing app. Many of these modules work with generic apps such as IP Camera or WebCam available on Android and iOS.

After starting the app, the live video feed begins streaming immediately. You can now see the drone’s perspective while flying it.

For such a small system, the experience feels surprisingly immersive.

Simple Hardware Connection

The hardware connection is extremely simple. The camera module only needs power to operate.

The VCC pin of the camera module connects to the drone’s VBUS line, while the ground pin connects to the drone’s common ground.

There is no data connection required between the camera and the flight controller. The camera handles video streaming through its own WiFi network.

This makes the setup lightweight and easy to implement.

Why Not Use ESP32-CAM?

Some makers might wonder if an ESP32-CAM module could replace the WiFi camera.

Technically it can, but it introduces additional complexity. The ESP32-CAM requires a stable 5V supply and typically draws more current during operation.

When the drone motors spin up, voltage fluctuations can occur. These fluctuations may cause the ESP32-CAM to reset or drop frames during streaming.

A dedicated WiFi camera module is usually more reliable for simple live video streaming builds.

Fixing Video Noise During Flight

During testing, you may notice that the video feed looks clear when the drone is stationary but becomes noisy when the motors start spinning.

This usually happens because the motors draw large bursts of current. Those sudden loads can cause voltage drops that affect the camera module.

The easiest solution is to use a LiPo battery with a higher C-rating.

A higher C-rating allows the battery to deliver current more steadily during rapid motor changes. This helps stabilize the power supply and significantly reduces video jitter.

Why This Project Is Fun

This drone project highlights the creativity involved in building custom hardware. A simple modification transforms a basic drone into a live-streaming aerial platform.

It is not meant to replace professional camera drones. Instead, it is perfect for learning, experimenting, and exploring new ideas.

Seeing real-time video from a drone you modified yourself is surprisingly satisfying. And once you try it, you will probably start thinking about the next upgrade.
for more info : Adding a Wi-Fi Camera to the LiteWing ESP32 Drone for Hobby Flights

Control a DC Motor Remotely Using GSM and Arduino

David Thomas — Fri, 13 Mar 2026 09:56:55 +0000

Automation is everywhere today. From smart homes to industrial machines, systems are increasingly designed to operate without direct human interaction. One of the easiest ways to add remote control to a system is through GSM communication, which allows devices to be controlled using simple SMS messages.

In this project, we build a DC Motor Speed Control using GSM. Instead of pressing buttons or using wired switches, you can control the speed and direction of a DC motor by sending text messages from your phone.

It’s a simple idea, but it demonstrates how powerful remote automation can be.

What This Project Does

This system allows you to control a DC motor remotely using SMS commands.

A user sends a predefined message from a mobile phone.

The GSM module receives that message.

Arduino reads the command and decides what the motor should do.
Then the motor driver executes the action.

For example, you can send commands like:

FWD200 rotates the motor forward at speed level 200.
REV150 rotates the motor in reverse direction.
STOP immediately halts the motor.

Short commands. Clear actions.
This makes the system easy to control even from basic mobile phones.

Components Used

The project uses commonly available components, making it beginner-friendly.

Arduino Uno
SIM800L GSM Module
L298N Motor Driver
DC Motor
Logic Level Shifter
Breadboard
Jumper Wires
External Power Supply
Arduino IDE

How the System Works

The entire process happens in a few simple steps.

First, the system powers on.
The GSM module connects to the cellular network and enters standby mode.
Arduino continuously monitors incoming data from the GSM module.
When a user sends an SMS command, the GSM module receives it and forwards the message to Arduino.
Arduino reads the text and checks whether it matches predefined commands.
If the message starts with FWD, Arduino rotates the motor forward.
If it starts with REV, the motor rotates in reverse.
If the command is STOP, the motor stops immediately.
Speed control works using PWM signals.
PWM stands for Pulse Width Modulation.
By changing the duty cycle of the signal (values between 0 and 255), Arduino controls how fast the motor spins.

Higher PWM value → faster motor speed.
Lower PWM value → slower motor speed.

Simple logic.
Effective control.

Why a Logic Level Shifter Is Needed

The GSM module and Arduino operate at different voltage levels.
Arduino uses 5V logic.
SIM800L works with lower logic voltage.
Connecting them directly could damage the GSM module.

That’s why a logic level shifter is used.

It safely converts the signal levels between the two devices.

Real-World Applications

GSM-based motor control systems have many practical uses.

Industrial Automation
Agricultural Pump Control
Gate and Barrier Automation
Home Automation

Devices like motorized curtains, ventilation systems, or shutters can be controlled using simple SMS commands.

Building a DC Motor Speed Control using GSM is a great way to understand remote automation. By combining Arduino, a GSM module, and a motor driver, you can control motor speed and direction from anywhere using simple SMS commands.

The project is simple to build, easy to understand, and highly practical. Even better, it does not require Wi-Fi or internet connectivity. All you need is an active SIM card and GSM network coverage.

Building an Automatic Toll Gate System Using Arduino and RFID

David Thomas — Wed, 11 Mar 2026 08:10:10 +0000

Modern toll systems are becoming faster and smarter thanks to automation. Instead of manual payment and gate operation, microcontrollers and sensors can handle the entire process automatically.

In this project, we build an Automatic Toll Gate System using Arduino, RFID technology, and sensors. The system detects vehicles, verifies payment using an RFID card, and automatically opens or closes the toll gate.

This project is simple, beginner-friendly, and a great way to understand how automation works in real-world systems like highways, parking gates, and access control systems.

What This Project Does

The system automates toll collection using a few simple components.

When a vehicle arrives at the toll booth:

An IR sensor detects the vehicle at the entry point.
The driver taps an RFID card on the RFID reader.
Arduino reads the card's unique ID and checks if it is valid.
If the card has sufficient balance, the toll amount is deducted.
The servo motor opens the gate and the green LED turns ON.
A second IR sensor detects when the vehicle passes.
The gate closes automatically and the system resets.

This creates a fully automated toll gate system without manual intervention.

Components Required

The project uses affordable and easily available components.

Arduino Uno
RFID RC522 Reader Module
RFID Cards / Tags
Two IR Sensor Modules
SG90 Servo Motor
Red LED
Green LED
Breadboard
Jumper Wires
USB Cable or 5V Power Supply

These components are commonly used in Arduino projects, making the system easy to assemble.

How the System Works

The toll system follows a simple workflow.

1. Vehicle Detection

The entry IR sensor detects when a vehicle arrives.

2. RFID Authentication

The driver taps an RFID card on the reader.

3. Card Validation

Arduino compares the scanned card UID with stored IDs.

4. Balance Verification

If the card has enough balance, the toll amount is deducted.

5. Gate Operation

If payment is successful:

Green LED turns ON
Servo motor opens the gate

If payment fails:

Red LED turns ON
Gate remains closed

6. Vehicle Exit Detection

The exit IR sensor detects when the vehicle leaves.

7. System Reset

The gate closes automatically and the system waits for the next vehicle.

Circuit Connection Overview

The circuit connects multiple components to the Arduino.

RFID Reader (SPI Communication)

SDA → Pin 10
SCK → Pin 13
MOSI → Pin 11
MISO → Pin 12
RST → Pin 9
VCC → 3.3V
GND → GND

IR Sensors

Entry Sensor → Pin 2
Exit Sensor → Pin 3

LEDs

Red LED → Pin 6
Green LED → Pin 7

Servo Motor

Signal → Pin 5
VCC → 5V
GND → GND

All components share a common ground connection.

Real-World Applications

Automated toll gate systems are widely used in many places.

Highway Toll Booths RFID systems allow vehicles to pass quickly without stopping for cash payments.
Smart Parking Systems Parking garages use automated gates for entry and exit.
Gated Communities Residents use RFID cards for secure access.
Industrial Facilities Factories use automated gates to track vehicle movement.
College Campuses Universities use similar systems for parking management.

Troubleshooting Tips

RFID Reader Not Detecting Cards
Ensure the module is powered using 3.3V, not 5V.

Servo Motor Not Moving
Check the signal pin connection and ensure the Servo library is included.

IR Sensors Always Triggered
Adjust the sensitivity potentiometer on the IR sensor module.

Gate Closes Too Early
Move the exit IR sensor slightly further from the gate.

Future Improvements

This project can be expanded with more advanced features.

Add a 16×2 LCD display to show balance and toll messages
Integrate ESP8266 or ESP32 for IoT data logging
Build a mobile app for balance monitoring
Store transaction data using an SD card module
Add number plate recognition using a camera module
Use solar power for remote toll booths

These upgrades can transform the project into a full smart toll management system.

This Automatic Toll Gate System using Arduino demonstrates how simple electronics can automate real-world processes. By combining RFID technology, sensors, and servo control, the system handles vehicle detection, payment verification, and gate operation automatically.