Indian Currency Recognition using ESP32-CAM and Edge Impulse

 

Artificial Intelligence is no longer limited to powerful computers or cloud servers. Today, even compact and affordable boards like the ESP32-CAM can perform real-time image recognition. In this project, we build an ESP32 CAM Currency Recognition capable of identifying currency denominations using Edge AI (TinyML) directly on the device.

This system captures images using the ESP32-CAM, processes them locally using a trained machine-learning model, and identifies the currency note placed in front of the camera. LEDs provide instant visual feedback, while the Serial Monitor displays the detected denomination.

What You’ll Learn

• TinyML and Edge AI concepts
• ESP32-CAM camera interfacing
• Dataset collection and labelling
• Model training using Edge Impulse
• Deploying AI models on microcontrollers

How ESP32-CAM Currency Recognition Works

The ESP32-CAM captures an image of the currency note and runs a trained machine-learning model locally. Instead of sending images to the cloud, processing happens directly on the device — known as AI on Edge.

The trained model recognises visual features such as:

• Colour patterns
• Text layout
• Design elements
• Security markings

Once a denomination is detected:

• The corresponding LED glows
• The detected value appears in the Serial Monitor

This enables fast, private, and offline recognition.

Components Required

• ESP32-CAM Module
• USB-to-Serial Converter
• LEDs (for denomination indication)
• 100Ω Resistors
• Breadboard
• Jumper Wires
• Arduino IDE
• Edge Impulse Studio

System Workflow

The project follows three major stages:

1. Dataset Collection

Images of Indian currency notes (₹10, ₹20, ₹50, ₹500, etc.) are captured using the ESP32-CAM web interface.
A plain background and proper lighting improve accuracy.

2. Model Training using Edge Impulse

Images are uploaded and labelled in Edge Impulse.
The platform:

• Processes image features
• Trains an object detection model
• Evaluates accuracy using performance metrics

The trained model is then exported as an Arduino library.

3. Deployment on ESP32-CAM

The trained model is uploaded through Arduino IDE.
After deployment, the system works completely offline.

Hardware Setup

The ESP32-CAM connects to a USB-to-Serial converter for programming. LEDs are connected to GPIO pins through resistors, where each LED represents a specific currency denomination.

When a note is placed under the camera:

• Image is captured
• Model processes the frame
• Matching denomination LED turns ON

Real-World Performance

For reliable detection:

• Keep the camera fixed at a stable angle
• Maintain consistent lighting
• Ensure the full note is visible

Under proper conditions, the system successfully recognises different Indian currency notes in real time.

Applications

• Assistive device for visually impaired users
• Automated retail currency validation
• Smart vending machines
• Currency counting systems

This ESP32-CAM Currency Recognition project demonstrates how embedded AI and TinyML can bring intelligent vision capabilities to low-cost hardware. Using Edge Impulse simplifies the entire workflow - from data collection to deployment - making edge AI accessible even for students and hobbyists.

By combining computer vision with microcontrollers, this project opens the door to real-world applications in automation, accessibility, and smart financial systems. It’s a powerful example of how modern embedded systems can see, analyse, and respond intelligently - all without the cloud.

Robotics Projects |Arduino Projects | Raspberry Pi Projects|
ESP32 Projects | AI Projects | IoT Projects 

DIY Arduino Game Controller using Arduino Uno R4

 

Gaming is one of the best ways to relax and refresh the mind. Classic joystick-based games gave us simple and direct control using physical buttons and sticks. In this project, we recreate that experience by building a DIY Game Controller using Arduino Uno R4, combining retro-style control with modern electronics.

This Arduino Game Controller project is a great way to learn USB HID communication, input proce uses a joystick module and push buttons to control games on a computer. When connected through USB, the Arduino Uno R4 acts like a keyboard device, allowing games to detect inputs instantly without installing drivers.

Components Required

• Arduino Uno R4
• Joystick Module
• 4 Push Buttons
• Veroboard
• Jumper Wires

Working Principle

The joystick provides X and Y axis analog signals, which Arduino converts into arrow key movements.
Push buttons are mapped to keys like W, A, S, and D for game actions.

Using the Keyboard.h library, the Arduino sends real-time key press signals to the PC, making the setup function like a real game controller.

Hardware Connection

• Joystick X → A0
• Joystick Y → A1
• Buttons → Digital Pins 2–5
• Power → 5V & GND

Buttons use internal pull-up resistors, so no extra components are needed.

This Arduino Game Controller project is a great way to learn USB HID communication, input processing, and human–computer interaction. It transforms basic hardware into a functional gaming device while offering a fun hands-on electronics experience.

Robotics Projects |Arduino Projects | Raspberry Pi Projects|
ESP32 Projects | AI Projects | IoT Projects 

Arduino Robotic Arm with 6 DOF

We have build a Robotic Arm using Arduino Nano, an interactive robotics system that translates human hand movements into real-time robotic motion. This Arduino Robotic Arm is for engineering students who want practical exposure to embedded systems, sensors, and real-time control.

Components Used

• Arduino UNO
• 3 × MG995 High-Torque Servo Motors
• 3 × Micro Servo Motors
• Breadboard
• Jumper Wires
• 3D Printed Parts
• Screws & Assembly Hardware
• External 5V Power Supply

Robotic Arm Fundamentals

Robotic Arm Joints

Joints allow bending and rotation, similar to human elbows and wrists. In a 6-axis arm, six joints work together to achieve complex 3D positioning.

Degrees of Freedom (DOF)

DOF represents independent movements.

• 1 DOF → One direction movement
• 3 DOF → Basic 3D movement
• 6 DOF → Human-like flexibility

Servo Motor Control

Servo motors rotate to specific angles (0°–180°) using PWM signals. Proper torque selection is important for lifting weight safely.

Power Management

Multiple servos require an external 5V power supply. USB power from Arduino is not sufficient.

3D Design & Printing

The robotic arm structure is fabricated using 3D printing for lightweight and easy assembly.

Real-World Applications

Although this project appears simple, its core concept is widely used in advanced systems -

• Industrial robotic manipulators
• Remote-controlled robotic systems
• Prosthetic hand control systems
• Hazardous material handling robots
• Surgical robotic systems

The Arduino Robotic Arm using Arduino UNO is more than a DIY robotics build - it’s a stepping stone into real-world automation and intelligent systems.

If you're serious about robotics, automation, or mechatronics, this is exactly the kind of project that strengthens your fundamentals while staying exciting and hands-on.

Robotics Projects |Arduino Projects | Raspberry Pi Projects|
ESP32 Projects | AI Projects | IoT Projects 

PCA9306 Module with Arduino Uno: Bidirectional I2C Level Shifting Guide

The PCA9306 Module with Arduino Uno is a bidirectional logic level translator designed specifically for I²C bus communication. It allows devices operating at different voltage levels - such as 5V microcontrollers and 3.3V sensors - to communicate safely and reliably. Instead of using discrete MOSFET-based level-shifting circuits, the PCA9306 integrates this functionality into a single IC, ensuring consistent signal integrity and a simpler, more reliable hardware design.

This module automatically handles voltage translation in both directions and preserves standard I²C features such as clock stretching, arbitration, and timing accuracy. Since it uses an open-drain architecture, it remains compatible with most I2C devices. Once powered and enabled, the PCA9306 starts working immediately without any software configuration.

What You’ll Learn from This Project

• Understanding the PCA9306 pinout and working principle
• How to interface the PCA9306 with Arduino Uno
• Reading data from a 3.3V I²C sensor using a 5V Arduino
• Correct wiring practices for reliable I²C communication
• Common issues and troubleshooting tips for I²C level shifting

Understanding the PCA9306 Level Shifter Module

The PCA9306 manages two separate I2C voltage domains:

• VREF1 defines the low-voltage side (typically 3.3V)
• VREF2 defines the high-voltage side (typically 5V)

Each side has its own SDA and SCL pins, allowing seamless bidirectional signal translation. A common ground between both devices is mandatory, as it provides a shared reference point for voltage levels. The EN (Enable) pin must be driven HIGH (usually tied to VREF2) to activate the module.

Most PCA9306 breakout boards include pull-up resistors on the low-voltage side, while the high-voltage side typically relies on the host controller’s pull-ups.

PCA9306 Pin Description

• VREF1 – Low-voltage reference (3.3V)
• VREF2 – High-voltage reference (5V)
• SCL1 / SDA1 – I²C lines for 3.3V devices
• SCL2 / SDA2 – I²C lines for 5V devices (Arduino A5/A4)
• GND – Common ground
• EN – Enable pin (must be HIGH)

Components Required

• Arduino Uno
• PCA9306 Level Shifter
• BMP180 Sensor
• Breadboard
• Jumper Wires
• USB Cable

Wiring the PCA9306 with Arduino Uno

To interface a 3.3V BMP180 sensor with a 5V Arduino:

• Connect VREF1 → 3.3V
• Connect VREF2 → 5V
• Connect SDA2 → A4, SCL2 → A5
• Connect SDA1 / SCL1 → BMP180
• Tie all GND pins together
• Pull EN HIGH

Once wired, no special configuration is required for the PCA9306.

Real-World Applications of PCA9306

• Connecting 3.3V sensors to 5V microcontrollers
• Interfacing EEPROMs across voltage domains
• Multi-board embedded systems
• Backplane or modular I²C designs
• Legacy hardware integration

In this project, we successfully interfaced the PCA9306 logic level shifter with an Arduino Uno to communicate with a 3.3V BMP180 pressure sensor. By using proper voltage references, correct wiring, and a shared ground, we achieved stable I2C communication without modifying the software.

The PCA9306 proves to be a reliable and efficient solution for bidirectional I²C voltage translation, especially in mixed-voltage embedded systems.

www.circuitdigest.com   

Robotics Projects |Arduino Projects | Raspberry Pi Projects|
ESP32 Projects | AI Projects | IoT Projects 

E88 Drone Teardown: Exploring the Hardware at Component Level

The E88 drone is a popular low-cost foldable quadcopter designed mainly for beginners. While it looks simple from the outside, this E88 drone teardown reveals how basic electronic components work together to provide stable flight, wireless control, and camera functionality at a very low price point.

Internal Layout and Design

Inside the E88, all electronics are built around a single main PCB. The board connects to four motors, a camera module, sensors, and the battery. This single-board design reduces manufacturing cost, weight, and complexity, which is essential for toy-grade drones.

Flight Controller and Sensors

The core of the drone is an STM32-based microcontroller, which acts as the flight controller. It continuously reads data from onboard sensors and adjusts motor speeds to keep the drone balanced.

A 3-axis gyroscope is used for orientation and stability, while a barometric pressure sensor enables basic altitude hold. These sensors allow the drone to maintain a steady hover and respond smoothly to user inputs.

Motor Control and Propulsion

The E88 uses coreless DC motors, each driven through MOSFETs on the PCB. These motors are lightweight and inexpensive, making them suitable for entry-level drones. Motor speed is controlled using PWM signals from the flight controller, allowing precise control of lift and direction.

Communication and Camera System

Wireless control is handled by a 2.4 GHz RF transceiver, providing low-latency communication between the drone and its remote controller. The front-mounted Wi-Fi camera module creates a separate wireless network that streams live video to a smartphone app. Although the video quality and latency are basic, it adds an FPV-style experience.

Power System

The drone runs on a 3.7 V Li-ion battery, typically offering 8–10 minutes of flight time. A dedicated charging IC manages USB charging, while voltage regulators ensure stable power for sensitive components.

The E88 drone teardown shows how simple electronics, efficient firmware, and low-cost components can deliver stable flight in a budget drone. While it’s not suitable for advanced modifications, it serves as a good reference for understanding the basics of consumer drone hardware and flight control systems.

www.circuitdigest.com   

Robotics Projects |Arduino Projects | Raspberry Pi Projects|
ESP32 Projects | AI Projects | IoT Projects

DIY ESP32 AI Voice Assistant with Xiaozhi MCP Framework

Voice-controlled smart devices have changed how we interact with technology, but most commercial assistants come with limitations such as privacy concerns, closed ecosystems, and limited customisation. This ESP32 AI Voice Assistant project demonstrates how you can build a fully functional, open-source, and customisable voice assistant from scratch using affordable hardware and modern embedded AI frameworks.

Built around Espressif’s powerful ESP32-S3 platform, this portable AI voice assistant combines on-device wake-word detection with cloud-based conversational AI, delivering natural voice interaction without relying on a smartphone.

This DIY AI voice assistant integrates Espressif’s Audio Front-End (AFE) framework with the Xiaozhi MCP chatbot system, creating a hybrid edge-and-cloud architecture. The ESP32-S3 handles real-time audio capture, noise suppression, and wake-word detection, while advanced natural language processing is performed by cloud-hosted large language models.

The result is a compact, always-on smart assistant capable of understanding voice commands, responding with natural speech, and controlling connected devices through standardised AI-to-hardware communication.

Core Hardware Components

• ESP32-S3-WROOM-1-N16R8 - Main controller with PSRAM and flash
• ICS-43434 MEMS microphones (×2) - Clear voice capture
• MAX98357A I²S amplifier -  Audio output
• BQ24250 Li-ion charger - Safe battery charging
• MAX20402 buck-boost converter - Stable 3.3V supply
• WS2812B RGB LEDs - Visual feedback
• USB-C connector - Power and programming

All components are selected to balance performance, power efficiency, and compact PCB design.

How the Voice Assistant Works

Wake-Word Detection

The ESP32-S3 continuously listens for a custom wake word using a low-power neural network

Audio Capture & Processing

Voice input is captured through the microphone array and processed using AFE for noise reduction and echo cancellation.

Cloud AI Interaction

Audio is streamed to the Xiaozhi backend, where speech-to-text, language model reasoning, and text-to-speech are performed.

Response Playback

The generated voice response is streamed back and played through the speaker in real time.

Hardware Control via MCP

Voice commands can trigger GPIO actions such as turning LEDs on or off, controlling relays, or interacting with sensors.

Firmware and Development

The firmware is developed using ESP-IDF (v5.4 or higher) in Visual Studio Code. Xiaozhi’s open-source framework allows easy configuration of wake words, AI backends, and MCP tools. The system supports multiple cloud AI models and can be adapted for different use cases without modifying the core firmware.

Enclosure and Design

A custom 3D-printed enclosure completes the project, designed to:

• Improve acoustic isolation between speaker and microphones
• Provide proper ventilation for power components
• Display LED status clearly
• Support desktop or wall-mounted use

The result is a polished, professional-looking AI assistant built entirely from scratch.

Applications

• Smart home voice control
• Hands-free personal assistant
• Embedded AI learning platform
• Accessibility support through voice interaction
• Custom AI experimentation with hardware integration

This ESP32 AI voice assistant project shows how far embedded AI has come. By combining edge-level audio processing with cloud-based intelligence, it’s now possible to build responsive, conversational devices on low-cost hardware. With full access to schematics, firmware, and PCB files, this open-source project empowers makers to explore AI, embedded systems, and smart device control without relying on closed commercial platforms.

Whether you’re an electronics enthusiast, IoT developer, or AI hobbyist, this project provides a complete roadmap for building your own intelligent voice assistant using ESP32-S3.

www.circuitdigest.com   

Robotics Projects |Arduino Projects | Raspberry Pi Projects|
ESP32 Projects | AI Projects | IoT Projects

Build an ESP32 Text to Speech System without Internet

Imagine a device that can read text aloud without needing an internet connection - perfect for accessibility tools, voice alerts, or interactive embedded systems. In this project, you’ll build an ESP32 Text to Speech (TTS) system that converts plain text into spoken words using only the processing power of the ESP32 microcontroller. No cloud services, no Wi-Fi, and no dependency on mobile apps or external servers - everything runs locally.

This project is ideal for hobbyists, embedded developers, and anyone curious about making microcontrollers speak. Let’s explore how to turn an ESP32 into a standalone voice device that reads out text in natural-sounding speech.

Why an ESP32 Offline Text-to-Speech System?

Text-to-speech is commonly used in navigation systems, smart assistants, accessibility devices, and alarm systems. Most TTS implementations rely on internet services because generating natural-sounding audio can be computationally demanding. However, with modern optimized algorithms and libraries, the ESP32 - despite its humble hardware - can perform offline TTS reliably.

Doing this offline means:

• No internet connection required
• Faster response time
• Improved privacy
• Portable and standalone solution

What You’ll Need

To build your ESP32 offline TTS system, you generally need:

Hardware

• ESP32 board (e.g., Dev Module or any ESP32 with enough flash)
• I²S audio DAC / audio output module (MAX98357A or similar)
• Speaker (8Ω – 3W recommended)
• Power supply (USB or battery)
• Optional buttons or screen for user input

Software

• Arduino IDE or ESP-IDF
• Offline TTS library for ESP32 (depends on the chosen synthesis engine)

These components can be assembled quickly to form a compact voice device capable of reading text aloud.

Real -World Uses

An offline ESP32 TTS system can be used in:

• Voice alerts for alarms or sensors
• Accessibility devices for visually impaired users
• Announcements in public spaces
• Interactive voice modules for robots
• Toys or learning tools

Because it doesn’t rely on the internet, it is reliable and ideal for critical applications where connectivity is limited.

The ESP32 Text to Speech System turns a simple microcontroller into a standalone voice generator that reads text without internet dependency. It’s a powerful example of how much you can achieve with modern embedded software and the versatile ESP32 platform. Whether you want to make interactive gadgets, accessibility tools, or voice alert systems, this project gives you a solid foundation to explore speech synthesis on embedded hardware.