1. Home

Getting Started with Arduino LVGL for ESP32 Display

Submitted by Anand D on

In this tutorial, we are going to see how you can create a custom Graphical User Interface(GUI) using  LVGL and our favourite Arduino IDE. You can use any kind of microcontroller for this project; the only thing you need to do is to include the right pins in the Arduino code. Here, I’m using an ESP32-C3 based smartwatch for the demonstration. This has a display, touch, controller and everything integrated inside, so we don't want to make any messy wiring. Whether you are a hobbyist building a home-automation dashboard or a product developer prototyping a wearable UI, mastering LVGL on ESP32 with Arduino is one of the highest-leverage skills you can add to your embedded toolkit.

Table of Contents

What Is LVGL? - Introduction to the Light and Versatile Graphics Library

LVGL stands for Light and Versatile Graphics Library, which is an open-source library that supports a wide variety of microcontrollers and displays. It’s a collection of components required to build a Graphical User Interface (GUI), mostly in embedded systems where custom UIs are needed. Examples include a Smart Home Automation & Monitoring Hub, a Desk32 Smart Hub for deep work focus, or even a Smart Wellness Clock that shows health metrics at a glance.

You will be able to see GUIs built on top of LVGL around you, like your smartwatch screens or display dashboards of some Attendance Systems in some offices. Developers use LVGL in a wide variety of ways, like some build GUIs using raw code while some others use some Drag-and-Drop visual editors like Square Line Studio or EEZ Studio that support LVGL. Here in this tutorial, we will use example code snippets provided by LVGL in their documentation to build a GUI out of it.

LVGL at a Glance

  Feature                  Detail
Full nameLight and Versatile Graphics Library
LanguageC99 (C++ wrappers available)
LicenseMIT — free for commercial use
Minimum RAM~32 kB (typical embedded target)
Minimum Flash~128 kB
Supported MCUsESP32, STM32, RP2040, Arduino, NXP and more
Display interfacesSPI, Parallel, RGB, MIPI-DSI
Visual editorsSquareLine Studio, EEZ Studio
Arduino libraryAvailable in Arduino Library Manager

Hardware Used - ESP32-2424S012 Round Display Development Board

Let’s talk a little bit about the ESP32 C3 based development board that we use in this tutorial. First of all, it has an ESP32-C3 at its core. It has a 1.28” 240 * 240 round LCD display on top. The display uses the famous GC9A01 display driver, which is seen in many hobby-level round display modules. It uses the 7-pin SPI interface (SCL, SDA, DC, CS, RST, 3V3, GND) for communication. The touch IC used is CST816D. It has a battery charging IC, which is IP5306. You can use any display or controller for this tutorial; the only thing you need to do is modify the configurations to match your device.

ESP32-2424S012 round display development board front view showing GC9A01 LCD and ESP32-C3 chip

What Do You Need Before Getting Started?

  • An ESP32-based development board that has either SPI or a parallel display connection.
  • Capacitive/Resistive Touch Controller – optional but strongly advised.
  • USB-C or Micro-USB cable for programming.
  • 3.7V LiPo Battery – optional (in case of standalone functionality).

Software Prerequisites

  • Arduino IDE 2.x – download from Arduino.cc.
  • ESP32 board package – available on Arduino Boards Manager (https://raw.githubusercontent.com/espressif/arduino-esp32/gh pages/package_esp32_index.json).
  • LVGL for Arduino library – available from Arduino Library Manager ("lvgl").
  • Driver files of the display and touch controller - CST816D.h, CST816D.cpp – obtain from project GitHub repo.

Knowledge Prerequisites

  • Basic syntax of Arduino C++ code – setup/loop methods.
  • I²C/SPI protocol knowledge.
  • GPIO mapping knowledge of the ESP32 board.

ESP32-2424S012 Full Specifications

ModelESP32-C3 1.28" IPS Round Display
ESP32 SeriesESP32-2424S012
ProcessorESP32-C3 is a Single-Core RISC-V
Display DriverGC9A01 
Touch DriverCST816S 
Frequencyup to 240MHz
Wi-FiSupports 2.4GHz
Display1.28inch
Touch displayCapacitive
Resolution240×240
Dimensions(D*H)45.5*11mm
Weight20g

You can power the module either via the Type-C connector that’s available on board or using a 3.7V LiPo battery by connecting it to the 2-pin JST connector in the back of the module.

ESP32-2424S012 back view showing JST LiPo connector and IP5306 battery charging IC ESP32-2424S012 - back view with JST LiPo connector

Step-by-Step Setup: LVGL Arduino GUI on ESP32

Step 1 ⇒ Install the LVGL Library in Arduino IDE

You need to go to the Arduino Library Manager and search for lvgl. Install the latest release by kisvegabor. Now, you need to head over to the official documentation of LVGL.

LVGL official documentation website showing widget library and example gallery for Arduino and ESP32 projects

Step 2 ⇒ Browse the LVGL Widget Documentation

In this tutorial, we are going to build a simple switch project using LVGL and Arduino IDE.
We can make this project in several different ways - meaning using LVGL and without using LVGL. From my experience, if we build a custom GUI using LVGL, we get a smartphone app kind of quality for the UI. This is because LVGL has a mature set of design components and animations that outperform any other competitors like TFT_eSPI.
Now, let’s go to All Widgets > Button
This opens the button widgets available in LVGL. You can see a lot of example widgets for buttons.

LVGL documentation page showing the Button widget section with multiple button style examples for Arduino GUI projects

 

Let’s scroll down and go to the first example. You can see options for Preview - meaning see how the button functions, and Code - meaning see the code snippet for that particular button. 

LVGL documentation code snippet for button widget showing lv_example_button_1 function ready to copy for Arduino ESP32 sketch

 

Step 3⇒ Copy the Code Snippet 

Let’s open the code snippet part of the example, which reveals the code behind the preview.
 

Step 4⇒ Understand the Project Folder Structure

Let’s copy the code from that section. If you check out the GitHub repo mentioned below, you will be able to download all the code for this project.  You will be able to see three files along with the main Arduino code, as shown below.

 

You have the main Arduino code, then the LVGL configuration file named lv_conf and then the touch configuration files, which are CST816D.cpp and CST816D.h. For this tutorial, we just need to modify the main Arduino code with the code snippet that we just copied. You may need to modify the pin configurations as per your setup.

Step 5⇒ Paste the Snippet into the Arduino Sketch

Once the Arduino code is opened, you can see a section asking for “SNIPPET FROM THE LVGL WEBSITE  DOCUMENTATION”. Paste the code snippet in this section. This code now gives the same button transitions in the display as we saw in the preview in the documentation.

The modified code snippet is attached to the code provided on GitHub.
Select the right board and right port in your Arduino IDE and hit the upload button.

Step 7 ⇒ Test the Result
Once the code is successfully uploaded, you can see the screen displaying the buttons exactly in the same way as shown in the preview in the LVGL documentation. You can see the button animations as well when you press the buttons. As we modified the code to change the screen background to white when the toggle button is turned on, you can see the background colour turning to white and black when we turn on and off the toggle button, as shown below. This is an excellent LVGL ESP32 project to study after completing the basic tutorial.

VirtualTorch LVGL project on ESP32 round display showing torch button with circular arc brightness slider before and after activation

You can see another folder in the same repo named VirtualTorch. This project is shared for your future reference.  It’s an advanced version of this tutorial that has a button for the torch and a slider around the button to adjust the brightness, too. Below are the two screens of the VirtualTorch project, before the button is pressed and after the button is pressed and the slider adjusted.

VirtualTorch LVGL project on ESP32 round display showing torch button with circular arc brightness slider before and after activation

Code Explanation: How the LVGL Arduino Sketch Works

1. Library Includes and Configuration

#define LV_CONF_INCLUDE_SIMPLE   
#include <lvgl.h>
#include <SPI.h>
#include <Wire.h>
#include "CST816D.h

Include the essential libraries, the configuration file, which is lv_config.h and the touch driver, which is CST816D.

2. GPIO Pin Definitions

#define LCD_CLK  6
#define LCD_MOSI 7
#define LCD_DC   2
#define LCD_CS   10
#define LCD_BL   3
#define TP_SDA   4
#define TP_SCL   5
#define TP_INT   0
#define TP_RST   1
#define LCD_W    240
#define LCD_H    240

3. Low-Level Display Helper Functions

Configure the GPIO pins of the display and touch with the ESP32.

static void lcd_cs(bool sel)  { digitalWrite(LCD_CS, sel ? LOW : HIGH); }
static void lcd_cmd(uint8_t c){ digitalWrite(LCD_DC, LOW);  SPI.transfer(c); }
static void lcd_dat(uint8_t d){ digitalWrite(LCD_DC, HIGH); SPI.transfer(d); }

4. LVGL Porting / Flush Callback

Helper functions for talking to the GC9A01 display.

static void gc9a01_init(void) {
 lcd_cs(true);
 lcd_cmd(0xEF);
 lcd_cmd(0xEB); lcd_dat(0x14);
 lcd_cmd(0xFE);
 lcd_cmd(0xEF);
 lcd_cmd(0xEB); lcd_dat(0x14);
 lcd_cmd(0x84); lcd_dat(0x40);
 lcd_cmd(0x85); lcd_dat(0xFF);
 lcd_cmd(0x86); lcd_dat(0xFF);
 lcd_cmd(0x87); lcd_dat(0xFF);
 lcd_cmd(0x88); lcd_dat(0x0A);
 lcd_cmd(0x89); lcd_dat(0x21);
 lcd_cmd(0x8A); lcd_dat(0x00);
 lcd_cmd(0x8B); lcd_dat(0x80);
 lcd_cmd(0x8C); lcd_dat(0x01);
 lcd_cmd(0x8D); lcd_dat(0x01);
 lcd_cmd(0x8E); lcd_dat(0xFF);
 lcd_cmd(0x8F); lcd_dat(0xFF);
 lcd_cmd(0xB6); lcd_dat(0x00); lcd_dat(0x20);
 lcd_cmd(0x36); lcd_dat(0x08);    
 lcd_cmd(0x3A); lcd_dat(0x05);    
 lcd_cmd(0x90); lcd_dat(0x08); lcd_dat(0x08); lcd_dat(0x08); lcd_dat(0x08);
 lcd_cmd(0xBD); lcd_dat(0x06);
 lcd_cmd(0xBC); lcd_dat(0x00);
 lcd_cmd(0xFF); lcd_dat(0x60); lcd_dat(0x01); lcd_dat(0x04);
 lcd_cmd(0xC3); lcd_dat(0x13);
 lcd_cmd(0xC4); lcd_dat(0x13);
 lcd_cmd(0xC9); lcd_dat(0x22);
 lcd_cmd(0xBE); lcd_dat(0x11);
 lcd_cmd(0xE1); lcd_dat(0x10); lcd_dat(0x0E);
 lcd_cmd(0xDF); lcd_dat(0x21); lcd_dat(0x0C); lcd_dat(0x02);
 lcd_cmd(0xF0); lcd_dat(0x45); lcd_dat(0x09); lcd_dat(0x08);
                lcd_dat(0x08); lcd_dat(0x26); lcd_dat(0x2A);
 lcd_cmd(0xF1); lcd_dat(0x43); lcd_dat(0x70); lcd_dat(0x72);
                lcd_dat(0x36); lcd_dat(0x37); lcd_dat(0x6F);
 lcd_cmd(0xF2); lcd_dat(0x45); lcd_dat(0x09); lcd_dat(0x08);
                lcd_dat(0x08); lcd_dat(0x26); lcd_dat(0x2A);
 lcd_cmd(0xF3); lcd_dat(0x43); lcd_dat(0x70); lcd_dat(0x72);
                lcd_dat(0x36); lcd_dat(0x37); lcd_dat(0x6F);
 lcd_cmd(0xED); lcd_dat(0x1B); lcd_dat(0x0B);
 lcd_cmd(0xAE); lcd_dat(0x77);
 lcd_cmd(0xCD); lcd_dat(0x63);
 lcd_cmd(0x70); lcd_dat(0x07); lcd_dat(0x07); lcd_dat(0x04);
                lcd_dat(0x0E); lcd_dat(0x0F); lcd_dat(0x09);
                lcd_dat(0x07); lcd_dat(0x08); lcd_dat(0x03);
 lcd_cmd(0xE8); lcd_dat(0x34);
 lcd_cmd(0x62); lcd_dat(0x18); lcd_dat(0x0D); lcd_dat(0x71);
                lcd_dat(0xED); lcd_dat(0x70); lcd_dat(0x70);
                lcd_dat(0x18); lcd_dat(0x0F); lcd_dat(0x71);
                lcd_dat(0xEF); lcd_dat(0x70); lcd_dat(0x70);
 lcd_cmd(0x63); lcd_dat(0x18); lcd_dat(0x11); lcd_dat(0x71);
                lcd_dat(0xF1); lcd_dat(0x70); lcd_dat(0x70);
                lcd_dat(0x18); lcd_dat(0x13); lcd_dat(0x71);
                lcd_dat(0xF3); lcd_dat(0x70); lcd_dat(0x70);
 lcd_cmd(0x64); lcd_dat(0x28); lcd_dat(0x29); lcd_dat(0xF1);
                lcd_dat(0x01); lcd_dat(0xF1); lcd_dat(0x00); lcd_dat(0x07);
 lcd_cmd(0x66); lcd_dat(0x3C); lcd_dat(0x00); lcd_dat(0xCD);
                lcd_dat(0x67); lcd_dat(0x45); lcd_dat(0x45);
                lcd_dat(0x10); lcd_dat(0x00); lcd_dat(0x00); lcd_dat(0x00);
 lcd_cmd(0x67); lcd_dat(0x00); lcd_dat(0x3C); lcd_dat(0x00);
                lcd_dat(0x00); lcd_dat(0x00); lcd_dat(0x01);
                lcd_dat(0x54); lcd_dat(0x10); lcd_dat(0x32); lcd_dat(0x98);
 lcd_cmd(0x74); lcd_dat(0x10); lcd_dat(0x85); lcd_dat(0x80);
                lcd_dat(0x00); lcd_dat(0x00); lcd_dat(0x4E); lcd_dat(0x00);
 lcd_cmd(0x98); lcd_dat(0x3E); lcd_dat(0x07);
 lcd_cmd(0x35);              
 lcd_cmd(0x21);              
 lcd_cmd(0x11); delay(120); 
 lcd_cmd(0x29); delay(20);  
 lcd_cs(false);
}
static void gc9a01_set_window(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
 lcd_cmd(0x2A); lcd_dat(x0 >> 8); lcd_dat(x0 & 0xFF); lcd_dat(x1 >> 8); lcd_dat(x1 & 0xFF);
 lcd_cmd(0x2B); lcd_dat(y0 >> 8); lcd_dat(y0 & 0xFF); lcd_dat(y1 >> 8); lcd_dat(y1 & 0xFF);
 lcd_cmd(0x2C);
}
// LVGL Porting Layer Setup
static lv_display_t *g_disp;
static uint8_t g_buf1[LCD_W * 20 * 2];
static uint8_t g_buf2[LCD_W * 20 * 2];
static void flush_cb(lv_display_t *disp, const lv_area_t *area, uint8_t *px_map) {
 uint32_t npx = (uint32_t)(area->x2 - area->x1 + 1) * (area->y2 - area->y1 + 1);
 lcd_cs(true);
 gc9a01_set_window(area->x1, area->y1, area->x2, area->y2);
 digitalWrite(LCD_DC, HIGH);
 SPI.writeBytes(px_map, npx * 2);
 lcd_cs(false);
 lv_display_flush_ready(disp);
}
CST816D touch(TP_SDA, TP_SCL, TP_RST, TP_INT);
static void touch_read_cb(lv_indev_t *indev, lv_indev_data_t *data) {
 uint16_t tx, ty; uint8_t gesture;
 if (touch.getTouch(&tx, &ty, &gesture)) {
   data->point.x = (int16_t)tx;
   data->point.y = (int16_t)ty;
   data->state   = LV_INDEV_STATE_PR;
 } else {
   data->state   = LV_INDEV_STATE_REL;
 }
}

Above is the LVGL interface layer, which interfaces our hardware, the ESP32 display and touch with THE LVGL library.

5. Event Handler and Button Widget (LVGL Snippet)

static void event_handler(lv_event_t * e)
{
   lv_event_code_t code = lv_event_get_code(e);
   lv_obj_t * target = (lv_obj_t *)lv_event_get_target(e); // Get which widget was interacted with
   if(code == LV_EVENT_CLICKED) {
       Serial.println("Clicked");
   }
   else if(code == LV_EVENT_VALUE_CHANGED) {
       Serial.println("Toggled");
       // Check if the widget that fired the event is currently checked (turned ON)
       if(lv_obj_has_state(target, LV_STATE_CHECKED)) {
           // Toggle is ON -> Turn active screen background to White
           lv_obj_set_style_bg_color(lv_screen_active(), lv_color_white(), LV_PART_MAIN);
       } else {
           // Toggle is OFF -> Turn active screen background back to Black/Dark slate
           lv_obj_set_style_bg_color(lv_screen_active(), lv_color_hex(0x151525), LV_PART_MAIN);
       }
   }
}
void lv_example_button_1(void)
{
   lv_obj_t * label;
   lv_obj_t * btn1 = lv_button_create(lv_screen_active());
   lv_obj_add_event_cb(btn1, event_handler, LV_EVENT_ALL, NULL);
   lv_obj_align(btn1, LV_ALIGN_CENTER, 0, -40);
   lv_obj_remove_flag(btn1, LV_OBJ_FLAG_PRESS_LOCK);
   label = lv_label_create(btn1);
   lv_label_set_text(label, "Button");
   lv_obj_center(label);
   lv_obj_t * btn2 = lv_button_create(lv_screen_active());
   lv_obj_add_event_cb(btn2, event_handler, LV_EVENT_ALL, NULL);
   lv_obj_align(btn2, LV_ALIGN_CENTER, 0, 40);
   lv_obj_add_flag(btn2, LV_OBJ_FLAG_CHECKABLE);
   lv_obj_set_height(btn2, LV_SIZE_CONTENT);
   label = lv_label_create(btn2);
   lv_label_set_text(label, "Toggle");
   lv_obj_center(label);
}

Above is the snippet that we copied from the LVGL Documentation. It has two parts or two functions. First is an event_handler(), which is the UI part of the snippet. It builds the two buttons using the same widget template that we chose from the documentation.

6. setup() - Hardware and LVGL Initialisation
The second part is the lv_example_button_1(), which performs the whole logic of the two buttons.

void setup(void) {
 Serial.begin(115200);
 
 pinMode(LCD_BL, OUTPUT); 
 analogWrite(LCD_BL, 128); // Turn on display backlight
 SPI.begin(LCD_CLK, -1, LCD_MOSI, -1);
 SPI.beginTransaction(SPISettings(40000000, MSBFIRST, SPI_MODE0));
 pinMode(LCD_CS, OUTPUT); digitalWrite(LCD_CS, HIGH);
 pinMode(LCD_DC, OUTPUT); digitalWrite(LCD_DC, HIGH);
 gc9a01_init();
 Wire.begin(TP_SDA, TP_SCL);
 touch.begin();
 // Initialize display engine
 lv_init();
 g_disp = lv_display_create(LCD_W, LCD_H);
 lv_display_set_color_format(g_disp, LV_COLOR_FORMAT_RGB565_SWAPPED);
 lv_display_set_flush_cb(g_disp, flush_cb);
 lv_display_set_buffers(g_disp, g_buf1, g_buf2, sizeof(g_buf1), LV_DISPLAY_RENDER_MODE_PARTIAL);
 // Initialize touch input pointer
 static lv_indev_t * indev = lv_indev_create();
 lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
 lv_indev_set_read_cb(indev, touch_read_cb);
 // Set dark canvas background
 lv_obj_set_style_bg_color(lv_screen_active(), lv_color_hex(0x151525), LV_PART_MAIN);
 // EXECUTE COPIED SNIPPET
 lv_example_button_1();
}

This is the setup() loop that fires exactly once when the device boots. It initialises the hardware in a sequential order, like turning on the display backlight, then initialising the display engine, then the touch.

7. loop() - LVGL Tick and Timer

void loop(void) {
 lv_tick_inc(5);
 lv_timer_handler();
 delay(5);
}

Once setup() completes, the ESP32 executes the loop() continuously that runs the app.

Modern Arduino Display System using LVGL - Full Tutorial with Video

Troubleshooting Common LVGL Arduino ESP32 Issues

Symptom     Likely Cause                                             Fix
Blank white screenWrong SPI pins or backlight not enabledVerify LCD_CLK, LCD_MOSI, LCD_CS, LCD_DC; add digitalWrite(LCD_BL, HIGH);
Touch not respondingWrong SDA/SCL pins or missing touch.begin()Check TP_SDA / TP_SCL defines; ensure touch.begin(); is inside setup()
lv_conf.h: No such file or directorylv_conf.h missing from sketch folderCopy lv_conf_template.h to the sketch folder, rename to lv_conf.h, set #if 1
Sketch too big / out of flashUnused LVGL widgets are consuming flashDisable unused widgets in lv_conf.h: #define LV_USE_CHART 0
Display colours wrong/ invertedIncorrect colour format settingTry LV_COLOR_FORMAT_RGB565 instead of LV_COLOR_FORMAT_RGB565_SWAPPED
Touch coordinates mirroredDisplay and touch orientation mismatchSwap X/Y or negate the axis in touch_read_cb()

LVGL vs TFT_eSPI

Factor                         LVGLTFT_eSPI
Widget systemFull widget library (buttons, sliders, charts…)None — manual drawing only
Animation engineBuilt-in, hardware-acceleratedNone built-in
Touch input handlingBuilt-in input device abstractionManual polling required
Memory overheadHigher (frame buffer + widget tree)Lower
Learning curveModerate (port layer setup required)Low (simple API)
UI quality ceilingSmartphone-gradeBasic / custom shapes
Visual editorsSquareLine Studio, EEZ StudioNone
Best forProduct UIs, dashboards, wearablesSimple graphics, gauges, fonts

Arduino LVGL GitHub

Explore open-source Arduino and LVGL projects on GitHub to build modern embedded GUI applications with touch-enabled displays. Find libraries, sample interfaces, and hardware integration examples that simplify creating responsive and visually rich IoT dashboards.

Arduino LVGL GitHubArduino LVGL Download Zip

Conclusion

From this tutorial, we came to understand how to properly use the free and open-source graphical library called LVGL, which is used to develop GUIs for embedded systems. We can use our own hobby-level microcontrollers like the ESP32 or similar ones to run such programs. The future is endless, you can create your own embedded systems projects, home automations or any other projects requiring custom GUIs. You can refer to the codes provided in the GitHub repo for any future references. If you would like to see how we can implement LVGL in a real-life project, check out our Voice-Activated LED Controller using ESP32S3 project. For inspiration, take a look at how display-based interfaces can be applied in a radar-based human presence and fall detection system, a great example of combining sensor data with a meaningful on-screen interface. 

Frequently Asked Questions

⇥ Why is LVGL used with Arduino?
The LVGL (Light and Versatile Graphics Library), which is an open-source C library for developing touch-interactive GUIs on microcontrollers, can be used with Arduino, as it integrates well with the Arduino platform; is compatible with the ESP32 and many other popular boards; and produces smartphone-quality animations and widgets without a separate GPU.

⇥ Can I use LVGL with Arduino IDE?
Yes, LVGL works with Arduino IDE. You just need the LVGL Library installed.

⇥ What is lv_conf.h?
lv_conf.h is the LVGL configuration file.

⇥ Why do we need CST816D.cpp and CST816D.h?
These files are the touch controller driver. They help the ESP32 communicate with the CST816D touch IC using I2C.

⇥ Which communication protocols are used here?
SPI for display communication, I2C for touch communication and UART for serial programming.

⇥ Can I use another display instead of GC9A01?
Yes, you only need the correct display driver and pin configurations of your display.

⇥ Can I make custom UIs instead of using widgets?
Yes, LVGL allows custom drawing, animations, gradients, gauges, etc...

Touch-Based GUI Projects

Explore interactive touch-enabled GUI projects built using modern microcontrollers and display modules for smart control, automation, and real-time monitoring applications. These projects demonstrate intuitive user interfaces with responsive controls, animations, and sensor integration for a seamless embedded experience.

Getting Started with Image Processing using MATLAB

Getting Started with Image Processing using MATLAB

MATLAB can perform many advanced image processing operations, but for getting started with Image processing in MATLAB, here we will explain some basic operations like RGB to Grey, rotating the image, binary conversion, etc.

Raspberry Pi Based Jarvis themed Speaking Alarm Clock

Raspberry Pi-Based Jarvis-Themed Speaking Alarm Clock

At the end of this project, we will create a very basic GUI using which we can set an alarm and when the alarm goes off, we will have a voice which tells us the current time and day with some pre-defined text. Sounds cool, right!! So let us build one.

How to Set a Static IP on Raspberry Pi?

How to Set a Static IP on Raspberry Pi?

If your Raspberry Pi IP address static configuration is changing too often, this complete guide is going to demonstrate how to configure a Raspberry Pi to use static IP through NetworkManager (using nmcli) and desktop GUI methods.

Have any question related to this Article?

Wi-SUN Explained: The Wireless Mesh Network Powering Smart Cities

At Electronica 2026, while exploring the Silicon Labs booth, I came across a wireless networking technology that was surprisingly new to me, Wi-SUN. As embedded engineers, most of us are already familiar with technologies like BLE, Zigbee, Matter, Thread, and LoRa when it comes to IoT connectivity.

Building a Robotics Company in India: Insights from Kikobot Founder Raghvendra Sutar

Submitted by Staff on

At a recent community webinar focused on building robotics companies in India, Raghvendra Sutar, founder of Kikobot, discussed how he started the company, the products it has developed, the challenges of manufacturing robotics hardware, and the company’s plans to expand into industrial robotics.

From Not Knowing What a Pitch Deck Is to Deploying Service Robots | Zinikus

Submitted by Abhishek on

Adviteey Mehaindroo, the founder and CEO of Zinikus, credits CircuitDigest as one of his earliest learning grounds. Now he's sitting down with the same platform, talking about running a robotics company with a half-million-dollar valuation. He describes Zinikus as “a robotics company focused mainly on humanoids, but also catering to the advertising and hospitality sectors with robotics.”

Can You Build Efficient Motors Without Rare-Earth Magnets? Gati Drives Thinks So

Submitted by Abhishek on

As I sit down to write this piece, I notice the fan whirring above and, for the first time, it occurs to me that it runs on an induction motor. So does every other fan in my office and my home. These motors have been around for a long time, not because they’re the best options out there, but because they’re cheap and do the job. BLDC motors have gained a bit of popularity, but are pricier and usually come with an import dependency problem.

FNIRSI-1014D Oscilloscope Teardown

Authors
Divya Sambhayanamath, Kumudini Balobal, Mahantesh Hosur, Shivanand G Holi
Guide & Review
Sandeep Patil, CTO at RedNerds

Model Name: FNIRSI-1014D
Abstract :
An oscilloscope that retails at INR 13K basically covers all of the hands-on subjects a 4-year engineering syllabus teaches in theory. The only issue is that none of this is practiced. We barely get past MCUs hands-on.
This oscilloscope though has
1. MCU: GD32E230. Well, the pattern is repeating. Any guesses as to which other MCU family this resembles?
2. FPGA: EF2L45LG144 FPGA for heavy-duty processing.
3. SoC: Allwinner F1C100s CPU + RAM + video + audio in one chip
4. Power supply
Check this teardown to get insights into the build, how it all comes together, tool chain for development and what the ballpark cost at 100K volume.

Table of Contents

1. Introduction

A digital storage oscilloscope (DSO) is a critical instrument used in electronics for analyzing electrical signals over time. Modern oscilloscopes integrate high-speed analog front-ends, digital signal processing hardware, and graphical user interfaces to provide accurate waveform visualization and measurement.

The FNIRSI-1014D is a dual-channel digital storage oscilloscope designed for portable measurement and educational use. It features a 100 MHz bandwidth, a 1 GS/s sampling rate, and dual input channels, allowing simultaneous measurement of two signals. The device integrates multiple embedded subsystems, including an FPGA for high-speed signal processing, an ARM-based system controller, and a microcontroller dedicated to user interface management.

This teardown study aims to analyze the internal structure of the FNIRSI-1014D oscilloscope by physically disassembling the device and examining the internal hardware architecture. The report explores the following aspects:

  • Mechanical structure of the oscilloscope
  • PCB layout and internal subsystems
  • Signal processing architecture
  • Display system structure
  • User interface hardware
  • Firmware architecture
  • Estimated component cost

The analysis helps understand how modern oscilloscopes integrate analog electronics, digital processing, and embedded computing systems to perform high-speed signal measurement.

2. External Overview of the Oscilloscope

The FNIRSI-1014D oscilloscope is housed in a plastic enclosure designed for handheld or bench operation. The front panel contains the display, input connectors, and control knobs. The rear panel contains labeling and structural support elements.

The device is designed for ergonomic operation with dedicated controls for waveform scaling, triggering, and signal acquisition.

External Structural Views

The device was inspected from multiple orientations to understand its mechanical design.

  1. Front View – Contains display, knobs, and connectors
  2. Top View—Houses' ventilation and structural support
  3. Bottom View – Contains mounting points and base supports
  4. Back View – Includes product information and identification labels

 

3. Technical Specifications

The FNIRSI-1014D oscilloscope includes several performance parameters that define its signal acquisition capability.

PARAMETERSPECIFICATION
ModelFNIRSI-1014D
Bandwidth100 MHz
Sampling Rate1 GS/s
Number of Channels2
Input Impedance1 MΩ
Rise Time3 ns
Storage Depth240 Kbit
Sensitivity Range50 mV – 500 V
Time Base50 s – 10 ns
Trigger ModesSingle / Normal / Auto

These specifications determine the oscilloscope's ability to capture fast signals while maintaining accurate timing and voltage measurement.

4. PCB Architecture and Internal Hardware Layout

The oscilloscope uses a multi-layer FR-4 printed circuit board integrating analog, digital, and power subsystems on a single board.
The PCB can be divided into five major subsystems:

  1. Input Signal Interface
  2. Analog Front End and Sampling System
  3. FPGA-based Signal Processing Unit
  4. System Control Processor
  5. Power Regulation Network

The board design includes extensive ground planes, copper pours, and via stitching to reduce electromagnetic interference and maintain signal integrity during high-speed operation.

5. Input Processing Architecture

The input processing block is responsible for receiving external signals and preparing them for digital conversion.

The block consists of:

  • BNC input connectors
  • Analog front-end conditioning circuits
  • Relay-based voltage range selection
  • Signal attenuation networks
  • Trigger detection logic

The front panel includes rotary encoders and buttons, which are read by a GD32E303 microcontroller responsible for interpreting user commands.

The decoded commands are then forwarded to the FPGA and system controller.

Flow of Input Processing

  1. The user rotates knobs or presses buttons.
  2. MCU interprets user inputs.
  3. Analog signal enters through BNC connectors.
  4. The analog front-end conditions the signal.
  5. FPGA receives sampled data.
  6. Data is sent to the system processor for display.

This architecture allows the oscilloscope to respond quickly to user commands while maintaining high-speed signal acquisition.

6. FPGA-Based Data Processing

The core signal processing engine of the oscilloscope is the ANLOGIC EF2L45 FPGA.
Field Programmable Gate Arrays are widely used in oscilloscopes because they can process signals in parallel hardware logic, enabling extremely high processing speeds.

The FPGA performs several critical operations:

  • High-speed signal acquisition
  • Trigger detection
  • Timing synchronization
  • Waveform buffering
  • Digital signal processing

Internal FPGA resources include:

  • DSP blocks
  • Block RAM buffers
  • Clock management units
  • High-speed system buses

Data Processing Flow

  1. ADC samples incoming signal
  2. FPGA receives digital samples
  3. Trigger logic detects capture condition
  4. Waveform data stored in memory buffers
  5. Data transferred to system controller

This hardware-level parallel processing enables real-time waveform acquisition.

7. Display and User Interface Processing

The Allwinner F1C100s system-on-chip serves as the main system controller.
This processor performs the following functions:

  • User interface management
  • Waveform rendering
  • Menu system control
  • Storage management
  • System communication

The processor includes several hardware interfaces, such as:

  • SPI
  • UART
  • USB
  • GPIO
  • SDIO

The SoC converts waveform samples received from the FPGA into graphical waveform plots displayed on the LCD screen.

8. LCD Display System Architecture

The oscilloscope uses a 7-inch TFT LCD display with a resolution of 800×480 pixels.
The display is composed of several layered optical structures that allow light modulation to form visible images.

LCD Layer Structure

The display consists of multiple layers arranged from back to front:

  1. LED Backlight
  2. Diffuser Layer
  3. Rear Polarizer
  4. Liquid Crystal Layer
  5. RGB Color Filters
  6. Front Polarizer
  7. Protective Glass Layer

9. LCD Display Working Principle

The TFT LCD operates using the principle of polarized light modulation through liquid crystal molecules.

Display Operation

  1. An LED backlight generates white light.
  2. A diffuser spreads light uniformly.
  3. The rear polarizer aligns light polarization.
  4. Liquid crystal molecules rotate polarization when voltage is applied.
  5. RGB filters create colored pixels.
  6. Front polarizer controls light transmission.
  7. Glass cover protects the display.

This process converts electrical signals into visible graphical waveforms.

10. Front Panel Control System

The oscilloscope includes several user interface controls that allow the user to interact with the measurement system.

Main Controls

Power Button
Activates the device and powers the internal electronics.
USB Host Interface
Used for exporting captured waveform images and measurement data.
Vertical Controls
Adjust voltage scaling (V/div) and channel positioning.
Horizontal Controls
Control time base (s/div) and waveform scrolling.
Trigger Controls
Determine the starting point for waveform capture.
Input Ports
BNC connectors provide electrical signal input.

11. Rotary Encoder Control Mechanism

The control knobs use incremental rotary encoders that generate quadrature pulses when rotated.

Encoder Operation

  1. Encoder rotation generates digital pulses.
  2. MCU reads pulse direction and count.
  3. MCU converts movement into parameter adjustments.
  4. Commands sent to FPGA.
  5. FPGA modifies signal processing parameters

12. Complete System Architecture

The complete oscilloscope system integrates multiple hardware subsystems working together.

Signal Flow

  1. The signal enters through BNC input connector
  2. The analog front-end conditions the signal
  3. ADC samples a signal.
  4. FPGA processes waveform data
  5. ARM SoC renders a waveform.
  6. LCD displays the waveform.

This architecture separates high-speed hardware processing from user interface control, improving overall performance.

13. Firmware Architecture

The oscilloscope uses a multiprocessor firmware architecture.

Microcontroller Firmware (GD32F303)

  • Reads knobs and buttons
  • Controls relay switching
  • Sends control commands to FPGA

FPGA Logic

  • High-speed signal acquisition
  • Trigger detection
  • Waveform buffering

System Processor Software

  • Runs embedded Linux
  • Manages display graphics
  • Handles file storage

14. Cost Analysis of Components

Based on an estimated production volume of 100,000 units, the approximate component cost is:

COMPONENTESTIMATED COST
FPGA₹950
Soc Processer₹270
Microcontroller₹140
Power Management₹135
PCB₹625
External Parts₹550
TFT LCD Display₹1950

Total Estimated Cost: ₹4620 per unit

15. Conclusion

The teardown analysis of the FNIRSI-1014D oscilloscope reveals a well-integrated embedded measurement system combining analog electronics, digital hardware, and embedded software.

The architecture uses three main processing elements:

  • FPGA for high-speed signal processing
  • ARM SoC for display and system control
  • Microcontroller for user interface management

This distributed architecture enables the oscilloscope to achieve high sampling rates while maintaining responsive user interaction.

The multi-layer PCB design, controlled impedance routing, and dedicated power regulation ensure stable operation and accurate signal acquisition. The FNIRSI-1014D demonstrates how modern oscilloscopes integrate multiple computing platforms and specialized hardware to deliver high-performance measurement capabilities at relatively low manufacturing cost.

You may reach out to the RedNerds team for custom product development here: http://www.therednerds.com/

Have any question related to this Article?

How to activate Airtel M2M IoT SimCard with Geolinker ESP32

Airtel M2M IoT SIM Activation – Quick Overview

  1. Log in to Circuit Digest Cloud & open the GeoLinker dashboard
  2. Enter ICCID and mobile number, verify OTP.
  3. Submit KYC documents (within 7 days)
  4. KYC verified by Airtel
  5. Whitelist up to 4 numbers for SMS/Voice

Table of Contents

What is an Airtel M2M SIM Card?

An Airtel M2M SIM card is specifically developed for communicating from one machine to another using the cellular networks. The Airtel M2M SIM is designed specifically for IoT and embedded devices that do not require a human operator or user to operate autonomously.

Feature           Airtel M2M SIMRegular SIM
Primary UseIoT devices, GPS trackers, automationPersonal voice and data use
Number RegulationDoT-mandated whitelisting (max 4 numbers)Open communication with all numbers
KYC RequirementMandatory within 7 days of activationRequired at purchase
ManagementRemote via Circuit Digest Cloud platformVia carrier app or store
Included Plan3-month free plan (GeoLinker bundle)Varies by plan

Accessing the Airtel M2M SIM Dashboard on Circuit Digest Cloud

The Airtel SIM Management feature allows you to manage your IoT SIM cards directly from the Circuit Digest Cloud Platform. You can view SIM details, monitor data usage, submit KYC documents, and track device connectivity. To access the Airtel M2M dashboard, log in to your Circuit Digest Cloud Account. Once logged in, you can click on the view button under the GeoLinker section. The Airtel M2M SIM card is a specialised IoT SIM designed for machine-to-machine communication over India's cellular network. This makes it ideal for secure, internet-independent projects such as GPS trackers, remote automation systems, and GSM-based IoT devices. Before you can use the SIM for voice calls, SMS, or data, you need to complete the Airtel M2M SIM activation process through the Circuit Digest Cloud platform.

Circuit Digest Cloud dashboard showing the GeoLinker IoT SIM management section for Airtel M2M SIM card

Step 1 ⇒ How to Activate Your Airtel M2M IoT SIM Card

Once you are in the GeoLinker Dashboard, click on the Airtel IOT SIM, which will redirect you to the Airtel IOT SIM  dashboard. This is where you can see all the activated SIM card details. To activate a SIM card, click on the Activate SIM button in the top right corner.

Airtel IoT SIM dashboard showing total SIM count, active SIMs, and data usage with the Activate SIM button highlighted

In the activation page, enter the ICCID and your mobile number. The ICCID can be found on the SIM package, mentioned as SIM number, or you can get it from the serial output when you insert the SIM into the GL868_ESP32 with factory firmware. Check the Factory firmware section for more details. If you are using the number from the package, avoid the last alphabet; only the numeric number is needed. Click on send OTP to receive the OTP on your entered mobile number.

GeoLinker SIM activation screen showing ICCID entry field, mobile number input, and OTP verification for Airtel M2M SIM card

Once the OTP is verified, you will be redirected to the KYC submission page.

Step 2 ⇒ Completing KYC for Your Airtel M2M SIM Card

Airtel M2M SIM KYC verification screen on Circuit Digest Cloud showing document upload options and selfie capture

IMPORTANT: While you can start using the SIM immediately after OTP verification, you must complete the full KYC process within 7 days to avoid deactivation.

For KYC, you can use any of the KYC documents given in the table below. Once the KYC is completed, you can continue using the Airtel IOT M2M SIM card with the GL868_ESP32. If you choose to submit the KYC documents later, you can access the KYC submission page by going to the SIM details page and then clicking on the View KYC button.

Required DocumentsAllowed Documents
Identity Proof- Aadhaar Card
- PAN Card
- Passport
- Driving License
- Voter ID

Circuit Digest Cloud SIM details page with the View KYC button highlighted for Airtel M2M SIM card KYC submission

Enter your mobile number to receive OTP.

KYC phone number linking screen for Airtel M2M SIM on Circuit Digest Cloud showing OTP input field

Once the OTP is verified, you will be asked to upload your identity proof. Select document type and upload front and back images.

Airtel M2M SIM KYC document upload screen showing front and back file upload options for identity proof on Circuit Digest Cloud

In the next stage, you will have to upload a live selfie. 

Note: Your browser will ask for camera permission; please click "Allow" to proceed.

 

Airtel M2M SIM KYC selfie verification process showing camera access prompt, live capture, and preview confirmation steps

Once the selfie is captured, provide your current residential address, and finally review your details, accept the consent declaration and click on Submit KYC Documents. The KYC verification will be done within 28-48 hours.

TIP: You have a 7-day window from the initial activation to submit these documents. We recommend doing it immediately to ensure uninterrupted service. "Allow" to proceed.

Step 3 ⇒Viewing Your Airtel IoT SIM Card Details

In the SIM card details page, you can see all the details related to your Airtel IOT M2M SIM card, like whether it's active or not, KYC status, ICCID and IMSI, start and end dates of your plan and the remaining time until your plan expires.

Circuit Digest Cloud SIM card details page showing Airtel M2M SIM active status, KYC verification, ICCID, IMSI, and plan expiry date

Step 4 ⇒ Setting Up SMS and Voice Whitelisting for Airtel M2M SIM

As per DoT regulations, IoT SIMs are restricted to communicating only with whitelisted numbers. So mobile number whitelisting is required to enable calls to and from the M2M number, as well as to send and receive SMS messages. With an Airtel M2M SIM, you can whitelist up to four numbers. To white list numbers, click on the Manage Whitelisting button on the SIM Card Details page.

Airtel M2M SIM whitelisting management screen on Circuit Digest Cloud showing SMS and voice number configuration options

In the Whitelisting Management page, enter the number you want to whitelist, select the type (Voice, SMS or Both) and direction(Incoming, Outgoing or  Both Ways) and click on Save Changes. The whitelisting will immediately take effect, and you can use the SMS and voice services.

Note: The Airtel IoT SIM card includes a 3-month promotional plan. After the promotional period ends, you can recharge the SIM card from here (link will be updated soon).

Airtel M2M SIM Whitelisting Options at a Glance

OptionChoices Available
Communication TypeVoice / SMS / Both
DirectionIncoming / Outgoing / Both Ways
Maximum NumbersUp to 4 mobile numbers
EffectImmediately after Save Changes

Frequently Asked Questions

⇥ Where can I find my Airtel M2M SIM card ICCID?
The ICCID is located on the package, with the SIM number listed as the SIM Number. If using GeoLinker GL868, insert the SIM and check the Serial Monitor; factory firmware will show the ICCID automatically when powered on. When you read the ICCID from the package, only enter the numerals and do not include the letter(s) at the end of the number.

⇥  How long does it take for Airtel to verify KYC (Know Your Customer) for M2M SIM Cards?
Airtel will complete verification of your KYC document submission through the Circuit Digest Cloud platform within 48 to 28 hours after submission. You may continue to use the SIM during this time, provided that your KYC document submission occurred within 7 days of the SIM's initial activation.

⇥  What is the maximum number of phone numbers that I can whitelist on the Airtel M2M SIM Card?
Whitelisting for up to 4 mobile numbers is available on your Airtel M2M IoT SIM. By using Whitelisting of each number, you also choose how you want to communicate (Voice, SMS or Both) and which way (Incoming, Outgoing or Both Ways). Whitelisting is effective immediately after you click Save Changes on the Circuit Digest Cloud dashboard.

⇥  Where can I find my Airtel M2M SIM card ICCID?
The ICCID is located on the package, with the SIM number listed as the SIM Number. If using GeoLinker GL868, insert the SIM and check the Serial Monitor; the factory firmware will show ICCID automatically when powered on. When you read the ICCID from the package, only enter the numerals and do not include the letter(s) at the end of the number.

⇥  How long does it take for Airtel to verify KYC (Know Your Customer) for M2M SIM Cards?
Airtel will complete verification of your KYC document submission through the Circuit Digest Cloud platform within 48 to 28 hours after submission. You may continue to use the SIM during this time, provided that your KYC document submission occurred within 7 days of the SIM's initial activation.

⇥  What is the maximum number of phone numbers that I can whitelist on the Airtel M2M SIM Card?
Whitelisting for up to 4 mobile numbers is available on your Airtel M2M IoT SIM. By using Whitelisting of each number, you also choose how you want to communicate (Voice, SMS or Both) and which way (Incoming, Outgoing or Both Ways). Whitelisting is effective immediately after you click Save Changes on the Circuit Digest Cloud dashboard.

Have any question related to this Article?

Low-Cost Offline Voice Recognition Module Alternatives to VC-02

Submitted by Vedhathiri on

Voice control technology has become an important part of modern human-machine interaction. It allows users to control electronic devices and systems using simple spoken commands instead of traditional input methods such as buttons, switches, or touch screens. This type of interaction makes devices easier to use, more accessible, and more convenient in many applications such as smart homes, automation systems, and assistive technologies. Many existing voice recognition systems depend on cloud-based processing. In these systems, the user’s voice is recorded and sent to a remote server through the internet, where the voice is processed and converted into commands. While this method can provide powerful voice recognition capabilities, it also introduces several limitations. These systems require a constant internet connection, and if the network connection is slow or unavailable, the system may not work properly. Cloud-based processing can also cause delays (latency) in response time and may raise privacy concerns, since voice data is transmitted and processed on external servers.

To overcome these challenges, offline voice recognition modules have been developed. These modules are designed to process and recognize voice commands directly on the device without needing any internet connection. This makes the system faster, more reliable, and more secure, since the voice data remains within the local device. Offline voice recognition is especially useful in embedded systems, automation projects, and environments where internet access may not always be available.

In this project, an offline voice command system is implemented using the SU-03T Offline Voice Recognition Module. The VC-02 is an official module by Ai-Thinker, offering well-defined firmware, proper documentation, and SDK support for customizing and training voice commands, making it suitable for advanced development. In contrast, the SU-03T is a more generic module produced by various manufacturers, and it is preferred due to its low cost, making it an economical choice for simple voice control applications. In this system, when the user speaks a command, the SU-03T processes the voice input and compares it with its stored command set. If a match is detected, the module triggers the corresponding action. In this project, the recognised voice commands are used to control LEDs, turning them on or off. Also check out ESP32 Offline Voice Recognition System using Edge Impulse, which provides hands-on experience in edge AI and TinyML deployment on microcontrollers. This guide is based on hands-on testing with the SU-03T offline voice recognition module at the Circuit Digest lab. The SU-03T is used here as a practical, low-cost alternative to the VC-02 for offline voice command projects. Offline voice recognition modules solve this problem by processing and recognising voice commands entirely on-device, with no internet connection required. In this project, we implement an offline voice command system using the SU-03T Offline Voice Recognition Module, one of the cheapest alternatives to the VC-02/VC020 on the market today.

Table of Contents

Overview 

Our tutorial has been created using the SU-03T Offline Voice Recognition Module at the Circuit Digest lab for real-time testing. The SU-03T is used here as a practical, low-cost alternative to the VC-02 for offline voice command projects. The offline voice command modules have been designed to allow you to use an offline voice recognition module with no requirement for an internet connection for the voice command to be processed and recognised. In this project, we implement an offline voice command system using the SU-03T Offline Voice Recognition Module, one of the cheapest alternatives to the VC-02 on the market today.

SU-03T vs VC-02 – Quick Comparison

If you're evaluating an alternative offline voice module for the VC-02 or VC020, the table below summarises the key differences to help you choose the right IC for your project:

FeatureSU-03TVC-02 (Ai-Thinker)
Internet required?NoNo
Price (approx.)Very low (generic)Low (branded)
SDK / Firmware toolAi-Thinker SDK portalAi-Thinker SDK portal
English command supportYes (via Ai-Thinker SDK)Yes
GPIO output controlYesYes
PWM supportYesYes
Wake-free commandsUp to 10Up to 10
Documentation qualityLimitedGood
Best suited forBudget projects, prototypesProduction, advanced dev

Components Required

The components which are listed below are the ones required to build the complete setup. All items are widely available from electronics distributors such as DigiKey, Robu.in, and AliExpress.

S.NOComponentsQuantity                             Purpose
1.SU-03T1It is the main module used in the setup
2.Mic1Used to recognize the commands from the user
3.Speaker1Used to reply with the predefined reply words
4.USB to Serial Converter1Used to deploy the code to the module
5.LED(Green and Red)2(Each 1)For observing the output
6.100 Ohms Resistor2For resisting the current
7.Breadboard1Used for the temporary connection between components
8.Jumper WiresRequired amountUsed to connect all the components

Circuit Diagram

The circuit diagram shows the connection of the microphone and speaker to the voice module, along with LEDs connected to its GPIO pins via resistors. It also includes the USB-to-TTL interface for firmware uploading and communication. The circuit diagram shows the complete hardware connections for this offline voice recognition project.

Circuit diagram showing SU-03T offline voice recognition module connected to microphone, speaker, two LEDs with 100Ω resistors, and USB-to-TTL converter Circuit diagram of the SU-03T offline voice recognition module with microphone, speaker, LEDs, and USB-to-TTL interface

Pin Connection Summary

SU-03T Pin        Connects To                           Notes
VCC (3.3 V)USB-to-TTL 3.3 V outputDo not exceed 3.3 V; module is not 5 V tolerant
GNDCommon ground (USB-TTL)Shared ground for all components
TXUSB-to-TTL RXUART communication/firmware flashing
RXUSB-to-TTL TXUART communication firmware flashing
MIC+ / MIC−Electret microphoneDifferential analog audio input
SPK+ / SPK−8 Ω speakerBuilt-in amplifier output
GPIO1Green LED → 100 Ω → GNDControlled by the "Turn on LED" command
GPIO2Red LED → 100 Ω → GNDControlled by the "Turn off LED" command

Hardware Connection for the Offline Voice Recognition Module   

The SU-03T Offline Voice Recognition Module is connected to a USB-to-Serial converter for power supply and programming. A microphone and speaker are interfaced with the module to handle voice input and audio output. The GPIO pins of the module are connected to LEDs through current-limiting resistors to perform output actions.

Physical hardware connection of SU-03T offline voice module showing breadboard wiring with microphone, speaker, LEDs, resistors, and USB-to-TTL converter Hardware connections for the SU-03T module: microphone (audio input), speaker (audio output), LEDs with resistors (GPIO output), and USB-to-TTL (power and programming)

How the SU-03T Offline Voice Recognition Module Works

The working of this project is based on the SU-03T Offline Voice Recognition Module, which is designed to recognize voice commands without requiring an internet connection. The module is connected to a mic, speaker and an internal processor that can analyse voice inputs and match them with predefined commands stored in its memory. Before using the module, the required voice commands must be configured and loaded into the module. 

Once the commands are configured and uploaded to the module, the SU-03T continuously listens for voice input through the microphone. When a user speaks a command, the module captures the audio signal and converts it into digital data. The internal voice recognition engine then processes this signal and compares it with the stored voice command patterns. If the spoken command matches one of the predefined commands, the module identifies it and immediately triggers the corresponding action. The module then controls the GPIO output pins connected to external components such as LEDs. Actually, there is a website called https://smartpi.cn/#/ where we can flash the SU-03T. However, it has a limitation, it only accepts correct Chinese words, and English words are often ignored. So, we are using the steps and website given below to flash our module. If you have time, you can explore that page for future use.

Step-by-Step: Configure and Flash the SU-03T Offline Voice Recognition Module

This same workflow is compatible with the VC-02 and serves as the recommended offline voice recognition SDK configuration process for all Ai-Thinker-compatible modules.

Step 1: Register on the Ai-Thinker Voice SDK Portal

http://voice.ai-thinker.com/#/SdkVersionList

Click the website (translate it to English)and log in to the website if you don’t have an account. Register for the account after that, you can see “Create the product” in the top left corner, click that.

Ai-Thinker voice SDK portal home page showing the Create Product button in the top-left corner Ai-Thinker voice SDK portal – the starting point for generating offline voice recognition firmware for the SU-03T and VC-02

Step 2: Create a Pure Offline Product Profile
In that, click on other products and select the scene as “Pure Offline”, Module as “VC-02”, then give any name for the product and language as English, now click save.

Ai-Thinker SDK product creation dialog with Pure Offline scene, VC-02 module, and English language selected Creating a Pure Offline product profile in the Ai-Thinker SDK – select VC-02 as the module type for SU-03T compatibility

Step 3: Review Pin and SDK Configuration
After the previous step, it will take you to the voice SDK section, where you need to set the configurations for pins and also set the commands. No need to change anything in the pin configuration section.

Ai-Thinker SDK voice configuration page showing GPIO pin settings and SDK options for the offline voice module Voice SDK configuration page – GPIO pin assignments and module settings for the offline voice recognition system

Step 4: Configure the Wake Word
In the custom wake word section, you can set any wake word you prefer, like “Hai” or “hello”, and you also need to set the wake-up reply like “hello buddy” or “hello Circuit Digest”.

Wake word configuration section in the Ai-Thinker SDK showing the input field for the wake word and wake-up reply text Wake word setup in the Ai-Thinker SDK – choose a short, phonetically distinct word for reliable offline wake word detection

Step 5: Add Offline Voice Recognition Commands
Set the behaviour words as “turnonled” or “turnoffled” like this for then for the command words give the words which you prefer like “Turn on led” or “lights on” like this also give the appropriate reply sentence like “turning on the led” or “turning lights off”. Near the basic information tab, you can see the control details tab. Click that, and see the configuration as per your requirement, like low or high. Here, you can also set the pulse.

Offline voice recognition command control settings showing behaviour word, command phrase, reply text, and GPIO HIGH/LOW configuration Command configuration: set the behaviour word, user-spoken phrase, audio reply, and GPIO output action for each offline voice recognition command

Step 6: Configure Wake-Free Commands
After setting all configurations, scroll down, and you can see the wake-free commands section, where we can set only 10 wake-free command words. After that, we need to tell the wake-up word first and use the command after that so we can able to select which and all commands are wake-free commands in this by selecting.

Wake-free command selection table in the Ai-Thinker SDK showing checkboxes to enable up to 10 commands that work without a wake word Wake-free command configuration – select up to 10 offline voice commands that can be triggered without repeating the wake word

Step 7: Select Voice Actor and Audio Settings
After that, you can set your preferred voice actor in the voice actor configuration section and also able to set the brightness of the voice, speed, and volume.

Voice actor configuration page in Ai-Thinker SDK showing voice selection dropdown and sliders for volume, speed, and brightness Voice actor and TTS audio configuration – customise volume, speech rate, and tone for the module's spoken replies

Step 8: Add Startup Announcement and Exit Commands
In the other configurations section, you can add the startup announcement, exit reply, voluntary withdrawal exit command and exit reply as per your need.

Other configurations section showing startup announcement text field and voluntary withdrawal exit command settings in Ai-Thinker SDK Startup announcement and exit command configuration for the SU-03T offline voice module

Step 9: Generate Firmware
After setting all things, click the generate a new version and give a description for it. After that, it will take you to the voice SDK section, where you can see your product. Click the generate SDK " tab. It will generate your SDK or firmware within 30 to 35 minutes max. Now download the firmware it generated and extract the file.

Ai-Thinker SDK firmware generation section showing the Generate New Version button and the firmware download list Firmware generation section in the Ai-Thinker SDK – allow 30–35 minutes for compilation before downloading the offline voice firmware

Step 10: Download the UniOneUpdateTool Flash Utility

Download the Unicommon.dll, UniCommunicateSwitch.dll and UniOneUpdateTool.exe from Hummingbird-M-Update-Tool V1.0

After installing, click the UniOneUpdateTool.exe and, as per the circuit diagram, connect all the components. Then connect the USB to TTL to the USB port of the laptop. Now you can see the port COM appear in the window of the UniOneUpdateTool.

Download page for UniOneUpdateTool (Hummingbird-M-Update-Tool V1.0) showing Unicommon.dll, UniCommunicateSwitch.dll, and UniOneUpdateTool.exe files Download the UniOneUpdateTool flash utility – three files are required: Unicommon.dll, UniCommunicateSwitch.dll, and UniOneUpdateTool.exe

Step 11: Flash Firmware to the SU-03T Module

UniOneUpdateTool window showing the bin file selection and burn button for flashing firmware to the SU-03T offline voice recognition module Flashing firmware using UniOneUpdateTool – select the uni_app_release_update.bin file, click Burn, and wait for all ports to turn yellow before re-powering the SU-03T

In the UniOneUpdateTool window, you can see the option like this 选择(Choose). Click this option and go to the extracted firmware folder, select the uni_app_release_update.bin file, then you can see the 烧录（Programming/Burning. Click this and wait till all ports are filled with yellow. When all is finished, remove the power pin jumper from the USBs to TTL converter, then again insert it. Now you can see the firmware is getting flashed into the module. Also, spare some time to take a look at our electronics projects to get more ideas in the field of electronics

Working Demo of  Offline Voice Recognition Module

Applications of Offline Voice Recognition Modules

1. Smart Home Automation
Offline voice recognition modules can be used to control home appliances such as lights, fans, and other electronic devices using voice commands. This allows users to operate devices easily without using switches or mobile applications.
2. Assistive Technology
Voice-controlled systems can help elderly people and individuals with physical disabilities control electronic devices more conveniently. Simple voice commands can allow them to turn lights on or off without needing physical interaction.
3. Industrial Automation
In industrial environments, voice control can be used to operate certain machines or indicators where manual operation may be difficult. Offline voice systems improve reliability since they do not depend on internet connectivity.
4. Automotive Control Systems
Offline voice recognition can be integrated into vehicles to control features such as lights, music systems, or navigation functions. This allows drivers to operate systems hands-free, improving safety and convenience. Low-cost
5. Educational and Embedded System Projects
Offline voice modules are widely used in educational projects and research to demonstrate voice-based human-machine interaction

Application           How Offline Voice Recognition HelpsDevices Controlled
Smart Home AutomationLocal control without cloud dependency; works during internet outagesLights, fans, curtains, sockets
Assistive TechnologyEnables hands-free device control for elderly and differently-abled usersLamps, TV, door locks
Industrial AutomationReliable in offline factory environments; no latency from cloud callsIndicators, alarms, and conveyors
Automotive SystemsIn-car voice control without mobile data; instant responseLighting, HVAC, infotainment
Educational & Maker ProjectsLow-cost entry point for voice HMI projects; no API keys neededLEDs, servos, buzzers, displays

Troubleshooting the SU-03T Offline Voice Recognition Module

Issue 1: Voice command is not recognised
Solution:

This may occur if the spoken command does not exactly match the predefined command stored in the module. Ensure that the command is spoken clearly and with proper pronunciation. Also, check whether the correct voice command dataset has been uploaded to the module using the official configuration tool.

Issue 2: The LED does not turn ON or OFF
Solution:

Check the wiring between the SU-03T module and the LED. Make sure the LED is connected to the correct GPIO pin with a current-limiting resistor. Also, verify that the output pin configuration in the software matches the actual hardware connection.

Issue 3: Module is not responding to voice input
Solution:

This can happen if the microphone is not detecting sound properly or if the module is not powered correctly. Ensure that the module receives the required power supply and that the microphone area is not blocked. Speaking closer to the module can also improve detection.

Issue 4: PWM control is not working properly
Solution:

If the LED brightness or motor speed does not change, verify that the PWM pin is correctly configured in the software. Check whether the PWM output pin is properly connected to the device and confirm that the duty cycle settings are correctly applied.

Issue 5: Module not detected while configuring through the computer
Solution:

Ensure that the USB-to-Serial converter or programming interface is properly connected. Install the correct drivers and verify that the correct COM port is selected in the configuration software. Restarting the software or reconnecting the module may also resolve the issue.

Future Enhancements

  • Multi-Device Control
    The system can be expanded to control multiple devices such as fans, motors, and home appliances using different voice commands.

  • communication/firmware Smartcommunication/firmware Home Integration
    It can be integrated with a complete smart home system to control lighting, security systems, and other automation devices.

  • Mobile Application Interface
    A mobile application can be added to monitor and control devices along with voice commands.

  • Motor and Appliance Control
    The system can be enhanced to control motors, pumps, and other electrical appliances using voice commands.

  • Custom Voice Command Expansion
    More voice commands can be added to increase the functionality and control more operations in the system.

Conclusion

This project demonstrates the implementation of a simple offline voice-controlled system using the SU-03T voice recognition module. The system shows how voice commands can be used to control electronic devices without requiring an internet connection. It highlights the advantages of offline voice recognition, such as faster response, improved reliability, and better privacy. By configuring voice commands through the Ai-Thinker offline voice recognition SDK and flashing the firmware with UniOneUpdateTool, you get a reliable, private, low-latency voice control system that requires zero internet connectivity. The project also shows how GPIO and PWM outputs can be used to control devices like LEDs through voice commands. Overall, the system provides a practical example of voice-based human-machine interaction in embedded systems. Such systems can be further expanded for automation and smart control applications in the future. We invite you to look into our projects like “Building a Voice Controlled Home Automation System with Arduino”, which focuses on voice-based appliance control, and “Voice Controlled Lights using Raspberry Pi”, which demonstrates smart lighting automation using speech commands and GPIO interfacing.

Frequently Asked Questions

⇥ Does the module require an internet connection to work?
No, the module works completely offline. All voice commands are processed inside the module, which makes the system faster and more reliable.

⇥ How are voice commands added to the module?
Voice commands can be configured and uploaded using the official configuration tools and SDK available on the platform provided by Ai-Thinker.

⇥ What are the main advantages of using an offline voice recognition module?
Offline voice recognition provides faster response time, improved privacy, and better reliability since it does not depend on internet connectivity.

⇥  Can the module control devices other than LEDs?
Yes, the module can control various devices such as motors, relays, fans, and other appliances through its GPIO pins, depending on the circuit design.

⇥  Is it possible to change or update the voice commands later?
Yes, voice commands can be modified or updated by reconfiguring the settings in the SDK platform and uploading the new firmware to the module.

⇥  How long does it take for the Ai-Thinker SDK portal to generate new firmware for the SU-03T?
After you click 'Generate New Version', the firmware will compile on an Ai-Thinker cloud server in about 30-35 minutes. At this point, you will be able to download the ZIP file (which contains the compiled firmware) in the SDK version list. After downloading the ZIP file, unzip it and locate the uni_app_release_update.bin file for the flashing process.

⇥  What's the recommended flashing tool for the SU-03T voice module?
The recommended flashing tool for the SU-03T is the UniOneUpdateTool (part of the Hummingbird M Update Tool V1.0 package). Connect your SU-03T to your computer through a USB to TTL converter, select the firmware .bin file in the tool, click Burn, wait for all ports to be yellow and then power cycle the SU-03T after the process completes.

Voice-Controlled Projects

Previously, we have explored several voice-controlled projects using platforms like Amazon Alexa and hardware such as ESP8266 and Raspberry Pi. If you want to learn more about these implementations, the links are provided below.

HomePod S3 - A Smart Desk companion

HomePod S3 - A Smart Desk companion

Offline smart desk companion with touch, voice, timer, to-do, medicine reminders and local web control powered by ESP32-S3.

Alexa Voice Controlled LED using Raspberry Pi and ESP12

Alexa Voice Controlled LED using Raspberry Pi and ESP12

In this DIY tutorial, we are making an IoT project to control home appliances from anywhere in the world using AlexaPi and ESP12E.

IOT based Voice Controlled Home Automation using ESP8266 and Android App

IOT-based Voice Controlled Home Automation using ESP8266 and Android App

Voice-controlled home automation using an ESP8266 Wi-Fi module, where you can control your Home AC appliances using your voice through an Android App from anywhere in the world.

Have any question related to this Article?

The Indian Startup Making Robots Do Construction Work | Pace Robotics

Submitted by Abhishek on

Pace Robotics makes robots that paint… just not something you’d hang up at a gallery. As a part of our visit to this Bengaluru-based startup, we got to witness one of those robots in action at an actual construction site. They call it the Centa Painter, and it can spray putty, perform sanding, and apply paint on interior walls and ceilings, all things humans have been doing by hand forever and would rather not.

Subscribe to