The MAX32672FTHR is a compact development platform built around the MAX32672 for embedded evaluation and prototyping. It provides the key hardware resources needed for development, including onboard debugging, power management, user interface peripherals, and Feather-compatible expansion headers.
If you are working on IoT projects, you already know the importance of an M2M IoT SIM card for remote monitoring and tracking. For those who are new and wondering why you need a special M2M SIM card when you can just use your normal SIM card, here are two strong reasons to consider one.
Cost: If you are running a remote IoT device for a year and sending just a few MB of data every month, you will still have to spend at least 300 INR per month recharging your normal SIM cards (assuming Airtel and JIO have not increased their basic plans again). These standard user plans include voice, 2GB data per day, and subscriptions to OTT platforms, but all of this is wasted when using your SIM card with an IoT device. You will hardly consume a few MB of data every day, but still be forced to pay for a full package just to keep your SIM and device active. But with an M2M IoT SIM card, you can get data plans for as low as 30 INR per month if you are only using data.
Scaling: Now, say you are building a small pilot lot to test your own fleet of GPS trackers that you have just built; it is not feasible to manage multiple consumer SIM cards for each of your devices.
Now, apart from solving the above two problems, there are also other benefits in using an M2M SIM card, like better reliability, security, multi-network roaming, eSIM/embedded SIM support, downtime notifications, and centralized management when you are using an M2M SIM card compared to normal consumer SIM cards.
At CircuitDigest, we wanted our GeoLinker GPS modules, like the GL868 ESP32 GSM module, to be sold with M2M IoT SIM cards, so that every maker and small-scale startup can enjoy the benefits of M2M SIM cards. And after spending months figuring out registrations, telecom onboarding, whitelisting, KYC handling, and deployment challenges, we finally got everything set up (more on that later). The journey was quite a ride, so we thought it would make sense to document the entire process for others trying to build connected hardware in India.
Also, if you are completely new here, GeoLinker is a GPS tracking and cellular monitoring cloud platform with both software and hardware stack from CircuitDigest. Basically, GeoLinker GPS visualizer is a free tool on CircuitDigest Cloud that allows you to store and visualise GPS coordinates on a neat map. GeoLinker also has hardware modules, like the GL868 ESP32 GSM/GPS module that comes with a M2M SIM IoT card and tons of other interesting features. That being said, let’s get back to our story of M2M IoT SIM cards.
An M2M (Machine-to-Machine) SIM card is basically a SIM card designed specifically for machines instead of human users. Unlike the SIM card inside your smartphone, these SIMs are meant for devices like GPS trackers, smart meters, industrial sensors, fleet monitoring systems, and other cellular IoT products.
The difference is not just in pricing. The entire network architecture around M2M SIM cards is different. Normal SIM cards are designed assuming a human is using the device for browsing websites, making calls, watching videos, and moving between towers constantly.
But IoT devices behave very differently. For example, a GPS tracker sitting inside a vehicle might only send a few kilobytes every few minutes. A remote sensor might wake up once an hour, upload data, and go back to sleep. Telecom operators treat these deployments differently, which is why M2M infrastructure exists in the first place.
This is something most tutorials on the internet never really explain properly. Using a normal SIM card for a single prototype is fine, and most people still do it during early testing. But once the project becomes serious, where you want to keep it running 24x7 or scale it across multiple deployed devices, consumer SIM cards slowly become painful to manage.
The biggest issue is that consumer plans are not optimised for IoT usage at all. Imagine paying for 1 GB or 2 GB monthly plans when your actual device only consumes 100 MB. You are essentially paying for voice calls, entertainment bundles, and mobile usage patterns that your hardware will never use.
Then comes the operational side of things. Once you have multiple deployed devices, keeping track of recharges becomes frustrating. Some SIMs expire, some go inactive, and sometimes you discover a device stopped reporting simply because the recharge validity ended weeks ago. Debugging connectivity issues becomes difficult because you are never sure whether the problem is hardware, firmware, server-side, or simply the SIM itself.
We also noticed that some telecom networks behave differently when consumer SIM cards are continuously used inside GSM modules or embedded devices. Again, this is not usually a problem during prototyping, but for long-term deployments, it starts becoming unreliable. This is exactly the problem M2M IoT SIM cards are designed to solve.
After understanding the importance of M2M SIM cards, we decided that all GeoLinker boards should eventually be sold along with an M2M SIM card. And honestly, we assumed M2M SIM cards would be easy to obtain. We thought it would be similar to getting a corporate SIM connection or maybe a postpaid enterprise plan. It turned out to be much more complicated.
In India, M2M services are offered by major telecom operators like Bharti Airtel, Reliance Jio, and Vodafone Idea, but directly obtaining these SIM cards as a small company or startup is not straightforward at all.
Even today, if you search online for “M2M IoT SIM Card India,” you mostly end up finding random resellers, unclear IndiaMART listings, enterprise vendors with almost no documentation, and expensive industrial providers. The biggest problem is that nobody clearly explains the actual process.
After bumping around for quite some time, we finally found that we had to work directly with a telecom operator and register ourselves as an M2MSP (M2M Service Provider), after which we would become eligible to get M2M SIM cards and distribute them with our GeoLinker modules.
So yes, if you want to directly get M2M IoT SIM cards from telecom operators in India, you should be registered as an M2M Service Provider (M2MSP). And to become an M2MSP, you would need to register through the SARAL Sanchar Portal on the Department of Telecommunications website and obtain your SARAL number.
For this registration, your company should be a registered business in India, and you would typically need to submit a GST certificate, PAN card, Certificate of incorporation, MoA documents, Aadhaar, Company address proof on a company letterhead with seal and signature
After getting the SARAL number approved, you can register with a telecom operator to become an M2MSP. All this might sound easier said than done, but it took us almost 6 months for everything to be completed, so expect some delays if you are planning to go through the process yourself.
From there, you can raise a PO for the type of plans you need on your M2M SIM cards, get the SIM cards issued, activate them, and start using them with your IoT GSM modems. At least, that’s what we thought until we discovered whitelisting.
This was honestly one of the most confusing parts when we first started using M2M SIM cards. With a normal mobile SIM, you can access almost anything on the internet without thinking twice. But M2M SIM cards often operate in a more controlled environment.
In simple terms, the SIM card may only allow access to whitelisted servers, domains, IP addresses, or services. Not just internet access, even to send an SMS or make a call from your M2M SIM card, you may have to whitelist the receiver’s number before it works.
At first, this feels restrictive, but after understanding the reason behind it, it actually makes sense. These SIMs are designed for industrial deployments where security and controlled communication matter much more than unrestricted browsing.
For large OEMs building thousands of devices, this is normal. They already know exactly which cloud server or backend infrastructure their device will communicate with. But for makers, startups, and developers experimenting with different platforms, this quickly becomes frustrating.
During development, you constantly switch between services like MQTT brokers, cloud dashboards, automation platforms, and testing servers. Managing whitelisting manually for every deployment becomes painful very quickly.
At some point, we realized we were spending more time solving telecom and deployment problems than actually building hardware. That frustration is honestly what led to GeoLinker.
GeoLinker is part of the CircuitDigest Cloud ecosystem and was built as a GPS tracking and cellular IoT platform that combines both hardware and cloud infrastructure together. Instead of treating connectivity as a separate complicated process, we wanted developers to simply power up a module and start building. That is where the GeoLinker GL868 came in.
The GL868 is an ESP32-based GPS tracking and cellular IoT module built around the SIMCom SIM868 modem. When you purchase the module, it is sold with an M2M IoT SIM card, along with 3 months of free data and voice plans (120MB/month | 200 SMS | 100 outgoing minutes) already included. You can check out the article on how to activate the GeoLinker M2M IoT sim card if you have already purchased a GeoLinker board and are interested in seeing how to activate the sim card and start building.
Since the SIM868 modem already supports GSM and GNSS functionality, the module can handle both cellular communication and location tracking together. Developers can use it for vehicle tracking, remote monitoring, asset tracking, telemetry, and general IoT applications without having to combine multiple separate modules together.
One thing we wanted to avoid was forcing users through telecom-level paperwork just to test a hardware module with an M2M SIM card. So instead of making developers manually figure out activation workflows, the SIM onboarding process was simplified through the GeoLinker portal itself.
The activation flow is intentionally simple. Users receive the module with the M2M SIM card already included. They can then link the SIM with an existing phone number through OTP verification and activate it through the portal.
In most cases, activation happens within a few minutes or, at worst, a couple of hours. KYC can later be completed to continue long-term usage.
The goal here was not to hide the telecom process completely, because that is still required legally, but rather to remove unnecessary friction for developers trying to build and test products quickly.
One thing we quickly realized is that most developers do not want to spend days dealing with network whitelisting during prototyping. So we pre-whitelisted many commonly used IoT and cloud platforms on the network side itself.
This includes popular services like AWS IoT, Arduino Cloud, Firebase, Adafruit IO, ThingsBoard, Blynk, Google Cloud, IFTTT, and many other commonly used IoT platforms.
For custom deployments, users can also request additional domains or IPs to be approved after verification. Similarly, phone numbers for SMS and voice communication can also be managed through the platform.
Again, the idea here was simple: developers should spend more time building hardware and less time fighting telecom infrastructure.
Just like prepaid SIM cards, IoT M2M SIM cards also have different plans that developers can select based on their requirements. But here is a small catch: these plans have to be pre-approved by the telecom operator before they can be activated.
This means that when you get M2M SIM cards from the telecom provider, you have to raise a PO and specify what plans are needed for those SIM cards. Only the plans mentioned there will be available for activation. However, once a SIM is active, you can later switch between supported plans whenever required.
The image below shows the Airtel M2M plans that can be used with M2M IoT SIM cards.
Another important thing to note here is that, as a registered M2MSP, you will get the M2M IoT SIM cards free of cost from Airtel. But as soon as you activate a SIM under a plan, billing starts from day one. These charges will be added to your account irrespective of whether the SIM is actively being used or not.
Once activated under a monthly plan, recurring deductions will continue automatically.
If you are an M2MSP, you can suspend a SIM card to avoid full charges, but even in the suspended state, you still have to pay around Rs. 10/month. If you want to completely stop charges, the SIM card has to be terminated by the M2MSP. Once terminated, the SIM becomes unusable and cannot be reactivated later.
For our GeoLinker range of boards, we are currently using Airtel M2M IoT SIM cards. A typical Airtel IoT SIM card looks like the one shown below.
On top of the SIM card cover, you will find the SIM Number and IMSI Number printed on it. On the actual SIM card itself, you can again find the SIM Number printed.
Do note that these numbers should be kept confidential, and they should not be confused with the actual phone number of your M2M IoT SIM card.
For a typical consumer SIM card, the phone number is normally +91 followed by 10 digits. But for IoT M2M SIM cards, you may get a 13-digit number, and this phone number is usually assigned only after activation through the portal and is not printed anywhere on the SIM card.
If you have purchased our GeoLinker board with an M2M IoT SIM card, you can check out our separate article on how to activate an Airtel M2M IoT SIM card using GeoLinker.
Currently, all GeoLinker boards are sold with physical SIM cards from Airtel, but we also have plans to introduce MFF2 SIM cards (SIM cards in VQFN chip packages) and eSIM support with our future radio modules and boards.
Getting MFF2 SIM cards in India still remains slightly confusing for us, and eSIM support is currently limited to a few high-end radio modules from Quectel and Nordic Semiconductor, so that is something we will continue exploring in the future.
If you are using the Airtel M2M IoT SIM card from GeoLinker, you get free data, calls, and SMS for the first three months. You can activate it by entering your IMSI number, shown on the SIM cover, along with your personal phone number and verifying the OTP as shown below.
After the SIM is activated, you will be able to use it immediately. However, within a week of activation, you have to complete the KYC process by submitting your ID proof and picture verification through the GeoLinker portal itself.
By default, all popular platforms are already whitelisted by us. If you want to whitelist a particular phone number to send SMS or make calls, you can do that through the GeoLinker dashboard as shown below.
After three months of usage, you will get a notification to recharge your SIM card and extend your plan, which again can be done directly from the GeoLinker dashboard itself. If there is no active recharge, your SIM card will eventually be terminated within a week.
1. Can I use a normal SIM card for IoT projects?
Yes, for basic prototyping, you can use a normal SIM card. But for long-term deployment, scalability, and industrial reliability, M2M IoT SIM cards are much better.
2. What is the difference between an M2M SIM and a normal SIM?
M2M SIM cards are designed specifically for machine communication and industrial deployments, whereas normal SIM cards are optimised for consumer smartphone usage.
3. Why does M2M SIM require whitelisting?
Whitelisting improves security, prevents misuse, and allows telecom operators to maintain controlled industrial-grade network access.
4. Can I use M2M SIM with ESP32?
Yes. M2M SIM cards work well with ESP32-based GSM and cellular IoT modules.
5. Does the GeoLinker GL868 support GPS?
Yes. The module supports GPS, GLONASS, Galileo, and BeiDou GNSS positioning.
6. Can M2M SIM cards send SMS and make calls?
Yes. Depending on the selected plan, M2M SIM cards can support Data, SMS, Incoming calls, and Outgoing calls
7. Do I need SARAL registration to get M2M SIM cards?
If you want to directly source M2M SIM cards from telecom operators in India, SARAL registration and M2MSP onboarding are generally required.
8. Where can I get M2M IoT SIM cards in India?
You can either register directly with telecom operators as an M2MSP, Work with authorised providers or use integrated IoT ecosystems like GeoLinker that simplify onboarding and activation
Explore these exciting GPS tracking and IoT projects originally built using 2G GSM modules. Now, with Circuit Digest’s M2M IoT SIM solutions, these projects can be upgraded with more reliable connectivity, easier deployment, and better support for real-world IoT applications.
Build a Real-Time GPS Tracker with Raspberry Pi Pico & SIM800L GSM Module
Learn how to build a Raspberry Pi Pico GPS Tracker using the Neo 6M GPS module and SIM800L. This hands-on guide covers interfacing, real-time data logging, and API-based location updates
Arduino Location Tracker using SIM800L GSM Module and NEO-6M GPS Module
Learn how to build a GPS tracker using Arduino UNO, SIM800L GSM module, and NEO-6M GPS with GeoLinker. This DIY project offers real-time location tracking, historical
Interfacing the A7672S 4G LTE GNSS Module with Arduino
Learn how to use the A7672S 4G LTE GNSS module with Arduino for GPS tracking and IoT communication. This guide covers pinout, interfacing, AT commands, and HTTPS data upload.
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.
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.
| Feature | Detail |
| Full name | Light and Versatile Graphics Library |
| Language | C99 (C++ wrappers available) |
| License | MIT — free for commercial use |
| Minimum RAM | ~32 kB (typical embedded target) |
| Minimum Flash | ~128 kB |
| Supported MCUs | ESP32, STM32, RP2040, Arduino, NXP and more |
| Display interfaces | SPI, Parallel, RGB, MIPI-DSI |
| Visual editors | SquareLine Studio, EEZ Studio |
| Arduino library | Available in Arduino Library Manager |
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.
Software Prerequisites
Knowledge Prerequisites
| Weight | 20g |
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.
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.
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.
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.
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.
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.
1. Library Includes and Configuration
#define LV_CONF_INCLUDE_SIMPLE
#include <lvgl.h>
#include <SPI.h>
#include <Wire.h>
#include "CST816D.hInclude 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 2403. 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.
| Symptom | Likely Cause | Fix |
| Blank white screen | Wrong SPI pins or backlight not enabled | Verify LCD_CLK, LCD_MOSI, LCD_CS, LCD_DC; add digitalWrite(LCD_BL, HIGH); |
| Touch not responding | Wrong 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 directory | lv_conf.h missing from sketch folder | Copy lv_conf_template.h to the sketch folder, rename to lv_conf.h, set #if 1 |
| Sketch too big / out of flash | Unused LVGL widgets are consuming flash | Disable unused widgets in lv_conf.h: #define LV_USE_CHART 0 |
| Display colours wrong/ inverted | Incorrect colour format setting | Try LV_COLOR_FORMAT_RGB565 instead of LV_COLOR_FORMAT_RGB565_SWAPPED |
| Touch coordinates mirrored | Display and touch orientation mismatch | Swap X/Y or negate the axis in touch_read_cb() |
| Factor | LVGL | TFT_eSPI |
| Widget system | Full widget library (buttons, sliders, charts…) | None — manual drawing only |
| Animation engine | Built-in, hardware-accelerated | None built-in |
| Touch input handling | Built-in input device abstraction | Manual polling required |
| Memory overhead | Higher (frame buffer + widget tree) | Lower |
| Learning curve | Moderate (port layer setup required) | Low (simple API) |
| UI quality ceiling | Smartphone-grade | Basic / custom shapes |
| Visual editors | SquareLine Studio, EEZ Studio | None |
| Best for | Product UIs, dashboards, wearables | Simple graphics, gauges, fonts |
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.
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.
⇥ 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...
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
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
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?
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.
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.
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.”
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.
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.
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:
The analysis helps understand how modern oscilloscopes integrate analog electronics, digital processing, and embedded computing systems to perform high-speed signal measurement.
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.
The device was inspected from multiple orientations to understand its mechanical design.
The FNIRSI-1014D oscilloscope includes several performance parameters that define its signal acquisition capability.
| PARAMETER | SPECIFICATION |
| Model | FNIRSI-1014D |
| Bandwidth | 100 MHz |
| Sampling Rate | 1 GS/s |
| Number of Channels | 2 |
| Input Impedance | 1 MΩ |
| Rise Time | 3 ns |
| Storage Depth | 240 Kbit |
| Sensitivity Range | 50 mV – 500 V |
| Time Base | 50 s – 10 ns |
| Trigger Modes | Single / Normal / Auto |
These specifications determine the oscilloscope's ability to capture fast signals while maintaining accurate timing and voltage measurement.
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:
The board design includes extensive ground planes, copper pours, and via stitching to reduce electromagnetic interference and maintain signal integrity during high-speed operation.
The input processing block is responsible for receiving external signals and preparing them for digital conversion.
The block consists of:
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.
This architecture allows the oscilloscope to respond quickly to user commands while maintaining high-speed signal acquisition.
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:
Internal FPGA resources include:
This hardware-level parallel processing enables real-time waveform acquisition.
The Allwinner F1C100s system-on-chip serves as the main system controller.
This processor performs the following functions:
The processor includes several hardware interfaces, such as:
The SoC converts waveform samples received from the FPGA into graphical waveform plots displayed on the LCD screen.
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.
The display consists of multiple layers arranged from back to front:
The TFT LCD operates using the principle of polarized light modulation through liquid crystal molecules.
This process converts electrical signals into visible graphical waveforms.
The oscilloscope includes several user interface controls that allow the user to interact with the measurement system.
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.
The control knobs use incremental rotary encoders that generate quadrature pulses when rotated.
The complete oscilloscope system integrates multiple hardware subsystems working together.
This architecture separates high-speed hardware processing from user interface control, improving overall performance.
The oscilloscope uses a multiprocessor firmware architecture.
Based on an estimated production volume of 100,000 units, the approximate component cost is:
| COMPONENT | ESTIMATED 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
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:
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/
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 SIM | Regular SIM |
| Primary Use | IoT devices, GPS trackers, automation | Personal voice and data use |
| Number Regulation | DoT-mandated whitelisting (max 4 numbers) | Open communication with all numbers |
| KYC Requirement | Mandatory within 7 days of activation | Required at purchase |
| Management | Remote via Circuit Digest Cloud platform | Via carrier app or store |
| Included Plan | 3-month free plan (GeoLinker bundle) | Varies by plan |
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.
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.
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.
Once the OTP is verified, you will be redirected to the KYC submission page.
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 Documents | Allowed Documents |
| Identity Proof | - Aadhaar Card - PAN Card - Passport - Driving License - Voter ID |
Enter your mobile number to receive OTP.
Once the OTP is verified, you will be asked to upload your identity proof. Select document type and upload front and back images.
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.
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.
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.
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.
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).
| Option | Choices Available |
| Communication Type | Voice / SMS / Both |
| Direction | Incoming / Outgoing / Both Ways |
| Maximum Numbers | Up to 4 mobile numbers |
| Effect | Immediately after Save Changes |
⇥ 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.
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.
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.
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:
| Feature | SU-03T | VC-02 (Ai-Thinker) |
| Internet required? | No | No |
| Price (approx.) | Very low (generic) | Low (branded) |
| SDK / Firmware tool | Ai-Thinker SDK portal | Ai-Thinker SDK portal |
| English command support | Yes (via Ai-Thinker SDK) | Yes |
| GPIO output control | Yes | Yes |
| PWM support | Yes | Yes |
| Wake-free commands | Up to 10 | Up to 10 |
| Documentation quality | Limited | Good |
| Best suited for | Budget projects, prototypes | Production, advanced dev |
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.NO | Components | Quantity | Purpose |
| 1. | SU-03T | 1 | It is the main module used in the setup |
| 2. | Mic | 1 | Used to recognize the commands from the user |
| 3. | Speaker | 1 | Used to reply with the predefined reply words |
| 4. | USB to Serial Converter | 1 | Used to deploy the code to the module |
| 5. | LED(Green and Red) | 2(Each 1) | For observing the output |
| 6. | 100 Ohms Resistor | 2 | For resisting the current |
| 7. | Breadboard | 1 | Used for the temporary connection between components |
| 8. | Jumper Wires | Required amount | Used to connect all the components |
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.
| SU-03T Pin | Connects To | Notes |
| VCC (3.3 V) | USB-to-TTL 3.3 V output | Do not exceed 3.3 V; module is not 5 V tolerant |
| GND | Common ground (USB-TTL) | Shared ground for all components |
| TX | USB-to-TTL RX | UART communication/firmware flashing |
| RX | USB-to-TTL TX | UART communication firmware flashing |
| MIC+ / MIC− | Electret microphone | Differential analog audio input |
| SPK+ / SPK− | 8 Ω speaker | Built-in amplifier output |
| GPIO1 | Green LED → 100 Ω → GND | Controlled by the "Turn on LED" command |
| GPIO2 | Red LED → 100 Ω → GND | Controlled by the "Turn off LED" command |
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.
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.
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.
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.
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.
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”.
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.
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.
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.
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.
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.
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.
Step 11: Flash Firmware to the SU-03T Module
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
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 Helps | Devices Controlled |
| Smart Home Automation | Local control without cloud dependency; works during internet outages | Lights, fans, curtains, sockets |
| Assistive Technology | Enables hands-free device control for elderly and differently-abled users | Lamps, TV, door locks |
| Industrial Automation | Reliable in offline factory environments; no latency from cloud calls | Indicators, alarms, and conveyors |
| Automotive Systems | In-car voice control without mobile data; instant response | Lighting, HVAC, infotainment |
| Educational & Maker Projects | Low-cost entry point for voice HMI projects; no API keys needed | LEDs, servos, buzzers, displays |
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.
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.
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.
⇥ 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.
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
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
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
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.
Your email is safe with us, we don’t spam.
Be a part of our ever growing community.
