Getting Started with Quectel EC200U 4G LTE Cat 1 IoT board using the QNavigator and the QuecOpen SDK

CNXSoft: This is a guest post by Eicut showing how to get started with a Quectel EC200U 4G TLE Cat 1 IoT development board using QNavigator and the QuecOpen SDK.

In IoT projects—and across embedded systems in general—we’ve seen a growing demand for higher data exchange rates, along with broader frequency band coverage. These advancements are critical for enhancing the reliability of a device’s communication link with the network. As a result, 4G modules with fallback capability to 2G and 4G networks have emerged as a leading solution in this space. But the key question remains: Which modules should we use to leverage this technology, and what features do they offer?

Exploring the Quectel EC200U LTE Cat 1 Module for IoT

In this section of the EC200U tutorial, we’ll take a closer look at one of the most popular and dependable options in the IoT space—Quectel’s EC200U module. If you’ve worked with LTE Cat 1 modules before, you’ve likely come across this one (or even developed products using it). But if you’re new to the EC200U, here’s a quick introduction.

The EC200U is a series of LTE Cat 1 modules optimized for M2M and IoT applications. It supports fallback to 2G networks when 4G isn’t available, ensuring reliable connectivity, and delivers speeds of up to 10 Mbps downlink and 5 Mbps uplink over LTE-FDD (Frequency-Division Duplexing) and speeds of up to 8.96 Mbps downlink and 3.1 Mbps uplink over LTE-TDD (Time-Division Duplexing).

Key Features & Variants

• Mini PCIe form factor for broad industry compatibility
• Three regional models:
  • EC200U-CN (China/ India)
  • EC200U-EU (EMEA/ Australia/ New Zealand)
  • EC200U-AU (Latin America)

Each variant covers the frequency bands required for its target market. The module supports a wide range of protocols and interfaces, along with USB drivers for Windows 8.1/10/11, Linux, and Android, making it ideal for applications like POS systems, POC devices, and other IoT solutions.

Beyond basic connectivity, the EC200U offers:

• Global LTE & GSM/GPRS coverage
• Multiple application interfaces
• Analog voice support
• Built-in GNSS (GPS/GLONASS/BeiDou/Galileo)
• Wi-Fi scanning, Bluetooth, and FOTA (Firmware Over-the-Air updates)

Three Versions: AB vs AA vs AC

The EC200U comes in two versions (AB, AA, and AC), which we’ll compare in detail later. The best part? All versions share the exact same footprint and software layer, meaning you can swap them in a project without any compatibility issues.

Feature	EC200U-EU AB	EC200U-EU AA	EC200U-EU AC
LTE Category	Cat 1	Cat 1	Cat 1
Max Download Speed	10 Mbps	10 Mbps	10 Mbps
Max Upload Speed	5 Mbps	5 Mbps	5 Mbps
GNSS Support	No	Yes	No
BLE	Yes	Yes	No
Form Factor	LCC Package	LCC Package	LCC Package

QuecOpen development platform

One of the module’s standout features—and the focus of this tutorial series—is QuecOpen, a functionality similar to OpenCPU (which you might know from Quectel’s 2G modules like the MC60 and M66).

With QuecOpen, you can develop your device’s firmware directly on the module, eliminating the need for an external microcontroller in many cases. This not only simplifies design but also reduces costs—something we’ve seen before in Quectel’s 2G lineup but now supercharged for LTE applications. For a full breakdown of the EC200U’s hardware and software specs, check out the datasheet.

Getting Started with Quectel EC200U Development Board

You’ll need a hardware platform based on the Quectel EC200U module. This tutorial relies on Eicut’s EC200U Evaluation Board (pictured below), but you could also make use of the official QuecPython EC200U evaluation board reproduced by a few companies, for example, Waveshare’s C4-P01 board. Note that Quectel EC200U mini PCIe modules won’t work here, because the interface lacks lots of peripherals, and the USB BOOT key is not exposed, preventing us from flashing the OS.

The EC200U Evaluation Board is a compact development platform for the Quectel EC200U series LTE Cat-1 module for IoT prototyping.

Key peripherals for testing:

• SIM card and SD card slots
• 3x IPEX connectors for 4G and GNSS, WiFi/Bluetooth ceramic antenna
• Support for multiple communication protocols
• 14-pin header with UART, I2C, ADC, 5V, GND

Communicating with the Module

Beyond QuecOpen (discussed earlier), the EC200U supports AT commands via:

• Serial port (primary communication interface)
• USB port

Initial Setup with QNavigator

For basic testing and sending AT commands, we’ll use Quectel’s QNavigator software. QNavigator is only used to test Quectel modules. By using this tool, you will become familiar with the working process of main functions like Call, SMS, TCP/UDP, PPP, and QuceLocator even if you do not know any AT commands.

• Windows users: Connect the board via USB and launch QNavigator directly.
• Linux users: Requires Wine to run the Windows-based software.

Driver Installation (Windows Only)

Connect the module to your PC, and if your system doesn’t automatically recognize the module:

1. Unzip the Quectel Windows driver. (To obtain the driver, please contact Quectel support)
2. Run the Setup file and follow the installation prompts.

 

Connecting to the Module

1. Open QNavigator and select the correct COM port (shown in the software interface).
2. Click Connect—if successful, you’ll see live data exchange between the software and module.

When your module is functioning correctly, you should see output similar to the screenshot above with a few AT commands in the serial console. After completing these basic tests, you can proceed with the next steps in the tutorial.

Testing Key Features

1. Sending an SMS:
   • Select the SMS function from the left menu.
   • Enter your phone number in the Receiver field, your message in the Input field, and click Send message.
   • If sent successfully, you’ll see a confirmation in the console (and receive the SMS on your phone).
2. Making a Call:
   • Use the call feature to test voice connectivity.
   • Enter your number in the box and click CALL.
   • Troubleshooting: Errors may indicate issues with your SIM card, antenna, or power supply.
3. Custom AT Commands:
   • For advanced tasks, use the AT Command section to manually send instructions (all supported commands are listed here).

Next Steps

After some tests with the module, we are now ready to dive into:

• EC200U’s SDK
• Developing with QuecOpen

EC200U Tutorial Part 2 – SDK Setup and Hello World Project

In our previous part, we covered the EC200U module basics and communication methods. Now, we’ll dive into using the module’s SDK and walk through a simple “Hello World” project to help you get comfortable programming the module directly.

The good news? Quectel has done most of the heavy lifting for you! Their SDK comes packed with ready-to-use code examples for all major module features:

• Calling and SMS functionality
• Communication protocols (including MQTT)
• Remote firmware updates
• Power management
• And more

Note: This tutorial uses Debian Linux, but Windows users can follow along too – we’ll point out any differences along the way.

Setting Up Your Development Environment

Tools You’ll Need:

1. SDK – For writing and building your code
2. QLoader (Linux) or QFlash (Windows) – For uploading programs to the module

Note: To obtain the SDK, QLoader, and QFlash tools, please contact Quectel support.

Linux Setup Guide

1. Download and extract the SDK
2. Prepare the build environment:
   
   # Make the build script executable chmod 777 build_all.sh # Edit the script (we're changing the shebang line) nano ./build_all.sh

   1 2 3 4 5

   # Make the build script executable chmod 777 build_all.sh   # Edit the script (we're changing the shebang line) nano ./build_all.sh

   
   Ensure the first line reads: #!/bin/bash

   

3. Build the project:
   
   ./build_all.sh new EC200UEU_AA V01

   1	./build_all.sh new EC200UEU_AA V01

Windows users: You can skip the Linux-specific steps above – we’ll cover your setup in the next section.

Flashing Your Program to the EC200U Module

For Linux Users

1. Verify your build output
   After a successful build, check your target/EC200UEU_AA_V01 directory. You should see files like:
   
   eicut@eicut:~/LTE01R03A04_C_SDK_U/target/EC200UEU_AA_V01$ ls 8915DM_cat1_open.elf 8915DM_cat1_open_V01_merge.pac <-- This is your flash file 8915DM_cat1_open.map app/ prepack/

   1 2 3 4 5 6

   eicut@eicut:~/LTE01R03A04_C_SDK_U/target/EC200UEU_AA_V01$ ls 8915DM_cat1_open.elf 8915DM_cat1_open_V01_merge.pac <-- This is your flash file 8915DM_cat1_open.map app/ prepack/

2. Prepare QDloader
   • Download and extract QDloader
   • Build it by running make in its directory
   • Your compiled loader will be in the out/ folder
3. Flash the module
   Copy your .pac file to QDloader’s out/ directory and run:
   
   sudo ./QDloader -s /dev/ttyUSB0 -f 8915DM_cat1_open_V01_merge.pac -g EC200U

   1	sudo ./QDloader -s /dev/ttyUSB0 -f 8915DM_cat1_open_V01_merge.pac -g EC200U

   
   Note: Adjust /dev/ttyUSB0 if your module uses a different port.

For Windows Users

• Build your project
  Open Command Prompt as Administrator, navigate to your SDK directory, and run:
  
  build_all.bat new EC200UEU_AA V01

  1	build_all.bat new EC200UEU_AA V01

  
  
• Flash using QFlash
  • Open QFlash software
  • Load your .pac file (created in the target directory 8915DM_cat1_open_V01_merge.pac)
  • Click “Start” to begin programming

 

Modifying the Module Code

Now that we’ve verified flashing works, let’s make our first code change:

• Navigate to ql_int.c:
  
  cd LTE01R02A05_C_SDK_U/components/ql-application/init/ql_int.c code . <- To open VScode

  1 2	cd LTE01R02A05_C_SDK_U/components/ql-application/init/ql_int.c code . <- To open VScode

  
  Find and uncomment:
  
  ql_ledcfg_app_init();

  1	ql_ledcfg_app_init();

• Jump to the LED configuration (in VSCode: F12, or right-click “Go to Definition”) to open led_cfg_demo.c

The LED demo code (and almost all other codes) is organized into three logical sections:

• OS Task Creation (bottom of file)
• Main code
• Log Section

The first section where the operating system task is initialized is like this:

The next section, which is the function that the OS executes:

The last section of code is the Log code. The SDK includes a helpful logging framework. These macros control debug output:

Customizing the LED Blink Pattern

Let’s modify the NET Status LED behavior. Here’s how to create a 1-second blink cycle by editing the main function:

Building and Flashing Your Changes

1. Compile the code:
   In Linux:
   
   ./build_all.sh new EC200UEU_AA V01

   1	./build_all.sh new EC200UEU_AA V01

   
   In Windows:
   
   build_all.bat new EC200UEU_AA V01

   1	build_all.bat new EC200UEU_AA V01

2.  Flash the module:
   In Linux:
   
   sudo ./QDloader -s /dev/ttyUSB0 -f target/EC200UEU_AA_V01/8915DM_cat1_open_V01_merge.pac -g EC200U

   1	sudo ./QDloader -s /dev/ttyUSB0 -f target/EC200UEU_AA_V01/8915DM_cat1_open_V01_merge.pac -g EC200U

   
   In Windows: Use QFlash as we used previously.
3. Verify success: The NET Status LED should now blink at 1-second intervals.

Next Steps

• Try modifying the sleep duration for different blink patterns
• Experiment with other GPIO pins
• Add log messages to monitor LED state changes

Support CNX Software! Donate via cryptocurrencies, become a Patron on Patreon, or purchase goods on Amazon or Aliexpress. We also use affiliate links in articles to earn commissions if you make a purchase after clicking on those links.