A7670 LTE Cat 1 Module
The A7670 is a versatile LTE Cat 1 module that provides reliable communication capabilities for various IoT applications. Its compact design, high-speed data connectivity, and multiple interfaces make it an ideal choice for projects requiring cellular and GPS functionalities.

On this page
A7670 pinout
The A7670 pinout includes power supply, UART communication, control pins, status indicators, dual antenna connections (LTE/GSM and GPS), and SIM card interface pins for LTE Cat 1 cellular and GPS functionality.
| Pin | Type | Description | Notes |
|---|---|---|---|
| VBAT | Power | Power supply input (3.4V to 4.2V) | Requires stable power with peak current up to 2A |
| GND | Ground | Ground connection | Common ground |
| TXD | UART TX | UART Transmit Data (connects to microcontroller RX) | Default baud rate: 115200 bps |
| RXD | UART RX | UART Receive Data (connects to microcontroller TX) | Default baud rate: 115200 bps |
| PWRKEY | Control | Power on/off control (active low) | Pull low for at least 500ms to power on |
| NETLIGHT | Status | Network status indication | LED indicator for network registration |
| STATUS | Status | Module operating status indication | Shows module power state |
| ANT_MAIN | Antenna | Main antenna connection for LTE/GSM | Requires external LTE antenna |
| ANT_GPS | Antenna | Antenna connection for GPS | Requires external GPS antenna |
LTE Cat 1 module with multi-network support (LTE-TDD, LTE-FDD, GSM, GPRS, EDGE)
Data rates: 10 Mbps downlink, 5 Mbps uplink
Integrated multi-constellation GNSS (GPS, GLONASS, BeiDou)
Operating voltage: 3.4V to 4.2V
Peak current: 2A during transmission
Default UART baud rate: 115200 bps
Supports voice calls, SMS, and data transfer
Requires SIM card for cellular connectivity
Dual antenna connections: LTE/GSM and GPS
Wiring the A7670 to ESP32
Connect the A7670 to your ESP32 via UART for AT command communication. The module requires a stable 3.4V-4.2V power supply with sufficient current capacity (peak 2A). External antennas are required for both LTE/GSM and GPS functionality.
| A7670 pin | ESP32 pin | Purpose |
|---|---|---|
| VBAT | 3.7V-4.2V Power Supply | Provide stable power (NOT from ESP32 pin) |
| GND | GND | Common ground connection |
| TXD | GPIO16 (RX2) | A7670 TX to ESP32 RX |
| RXD | GPIO17 (TX2) | A7670 RX to ESP32 TX |
| PWRKEY | GPIO4 | Power control (pull low to power on) · optional |
| ANT_MAIN | External LTE Antenna | Connect LTE/GSM antenna |
| ANT_GPS | External GPS Antenna | Connect GPS antenna (optional) · optional |
CRITICAL: Use a dedicated power supply (3.4V-4.2V, 2A peak) - DO NOT power from ESP32 pin!
Default UART baud rate is 115200 bps
LTE Cat 1 provides 10 Mbps downlink, 5 Mbps uplink
External LTE/GSM antenna is mandatory for network connectivity
GPS antenna is optional but required for location services
Pull PWRKEY low for at least 500ms to power on the module
Monitor NETLIGHT pin for network registration status
Insert active SIM card before powering on
Supports multiple frequency bands - check local carrier compatibility
Ensure good antenna placement for optimal signal reception
Multi-constellation GNSS: GPS, GLONASS, BeiDou
A7670 code examples
A7670 Arduino example
Copy// A7670 on ESP32 UART2: module TXD -> GPIO16 (RX2), RXD -> GPIO17 (TX2), PWRKEY -> GPIO4
#define PWRKEY_PIN 4
#define MODEM_BAUD 115200
HardwareSerial modem(2); // UART2
void powerOnModem() {
pinMode(PWRKEY_PIN, OUTPUT);
digitalWrite(PWRKEY_PIN, LOW);
delay(1200); // Hold PWRKEY low to power the module on
digitalWrite(PWRKEY_PIN, HIGH);
delay(5000); // Give the module time to boot and register
}
void sendATCommand(const char *command) {
modem.println(command);
delay(500);
while (modem.available()) {
Serial.write(modem.read());
}
}
void setup() {
Serial.begin(115200);
modem.begin(MODEM_BAUD, SERIAL_8N1, 16, 17); // RX=GPIO16, TX=GPIO17
powerOnModem();
Serial.println("Testing AT communication...");
sendATCommand("AT"); // Should answer OK
sendATCommand("ATI"); // Module identification
sendATCommand("AT+CSQ"); // Signal quality
sendATCommand("AT+CREG?"); // Network registration status
}
void loop() {
// Bridge the Serial Monitor and the modem so you can type AT commands directly
while (Serial.available()) modem.write(Serial.read());
while (modem.available()) Serial.write(modem.read());
}This sketch talks to the A7670 over the ESP32's second hardware UART (UART2, RX on GPIO16, TX on GPIO17) - the ESP32 has three hardware UARTs, so the AVR-style SoftwareSerial library is neither available nor needed. GPIO4 pulses the module's PWRKEY to power it on, then a few basic AT commands verify communication, signal quality and network registration. The loop bridges the Serial Monitor to the module so you can type further AT commands interactively.
A7670 ESP-IDF example
Copy#include <stdio.h>
#include <string.h>
#include "driver/uart.h"
#include "driver/gpio.h"
#include "freertos/task.h"
#define TX_PIN 17
#define RX_PIN 16
#define PWRKEY_PIN 4
#define UART_PORT UART_NUM_1
void init_uart() {
uart_config_t uart_config = {
.baud_rate = 115200,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE
};
uart_param_config(UART_PORT, &uart_config);
uart_set_pin(UART_PORT, TX_PIN, RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
uart_driver_install(UART_PORT, 1024, 0, 0, NULL, 0);
}
void power_on_a7670() {
gpio_set_direction(PWRKEY_PIN, GPIO_MODE_OUTPUT);
gpio_set_level(PWRKEY_PIN, 0);
vTaskDelay(1000 / portTICK_PERIOD_MS); // Hold PWRKEY low for 1 second
gpio_set_level(PWRKEY_PIN, 1);
vTaskDelay(5000 / portTICK_PERIOD_MS); // Wait for the module to initialize
}
void app_main(void) {
init_uart();
power_on_a7670();
char *test_cmd = "AT\r\n";
uart_write_bytes(UART_PORT, test_cmd, strlen(test_cmd));
while (true) {
char data[128];
int len = uart_read_bytes(UART_PORT, data, sizeof(data), 100 / portTICK_PERIOD_MS);
if (len > 0) {
data[len] = '\0';
printf("Response: %s\n", data);
}
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}This ESP-IDF example initializes UART communication with the A7670 module and powers it on using the PWRKEY pin (GPIO4). The UART interface is configured with GPIO17 as TX and GPIO16 as RX. An AT command is sent to test communication, and responses from the module are printed to the console. Additional functionalities, such as SMS, GNSS data retrieval, or LTE-based internet connectivity, can be implemented.
A7670 ESPHome example
Copyuart:
tx_pin: GPIO17 # module RXD
rx_pin: GPIO16 # module TXD
baud_rate: 115200
# ESPHome's sim800l component speaks the generic SIM AT command set, which these modules share for SMS
sim800l:
on_sms_received:
- logger.log:
format: "Received '%s' from %s"
args: [ 'message.c_str()', 'sender.c_str()' ]ESPHome has no dedicated LTE-modem component, and the custom platform older examples used was removed in 2025. The sim800l component speaks the generic SIM AT command set for SMS, which the A7670 shares - wire UART2 as shown (115200 baud) and you get on_sms_received plus sim800l.send_sms actions. Data connectivity (LTE networking) is outside ESPHome's scope.
A7670 PlatformIO example
Copy[env:a7670]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200#include <HardwareSerial.h>
#include <Arduino.h>
HardwareSerial a7670(1);
#define PWRKEY 4
void power_on_a7670() {
pinMode(PWRKEY, OUTPUT);
digitalWrite(PWRKEY, LOW);
delay(1000); // Hold PWRKEY low for 1 second
digitalWrite(PWRKEY, HIGH);
delay(5000); // Wait for initialization
}
void setup() {
Serial.begin(115200);
a7670.begin(9600, SERIAL_8N1, 16, 17); // RX, TX
power_on_a7670();
// Test AT command
a7670.println("AT");
delay(1000);
while (a7670.available()) {
Serial.write(a7670.read());
}
// Send SMS
a7670.println("AT+CMGF=1"); // Set SMS to text mode
delay(1000);
a7670.println("AT+CMGS=\"+1234567890\""); // Replace with recipient's number
delay(1000);
a7670.print("Hello from A7670");
a7670.write(26); // CTRL+Z to send SMS
delay(5000);
}
void loop() {
// Handle incoming data or other functionalities
}This PlatformIO code interfaces with the A7670 module using HardwareSerial on an ESP32. The power_on_a7670 function toggles the PWRKEY pin (GPIO4) to activate the module. The AT command is sent to test communication, and SMS functionality is implemented in the setup. Additional functionalities, like GNSS data retrieval or LTE-based internet connectivity, can be added in the loop.
A7670 MicroPython example
Copyfrom machine import UART, Pin
import time
# Initialize UART
uart = UART(2, baudrate=9600, tx=17, rx=16)
pwrkey = Pin(4, Pin.OUT)
def power_on_a7670():
pwrkey.value(0)
time.sleep(1) # Hold PWRKEY low for 1 second
pwrkey.value(1)
time.sleep(5) # Wait for module to initialize
def send_at(command):
uart.write(command + '\r\n')
time.sleep(1)
while uart.any():
print(uart.read().decode('utf-8'), end='')
# Power on the module
power_on_a7670()
# Test communication
send_at('AT')
# Send SMS
send_at('AT+CMGF=1') # Set SMS to text mode
send_at('AT+CMGS="+1234567890"') # Replace with recipient's number
uart.write("Hello from A7670" + chr(26))This MicroPython code communicates with the A7670 module over UART. The power_on_a7670 function activates the module using the PWRKEY pin (GPIO4). The send_at function sends AT commands and prints the responses. The script initializes the module, tests communication, and demonstrates how to send an SMS. Additional logic for handling GNSS or LTE-based internet connectivity can be added.
A7670 specifications
About the A7670
The A7670 is SIMCom’s LTE Cat 1 module built around an ASR1803 chipset rather than the Qualcomm silicon behind the older SIM7600G series, which is what lets it sell for noticeably less while offering the same headline speed: 10 Mbps downlink and 5 Mbps uplink, with GSM/GPRS/EDGE as a 2G fallback. That price-to-spec ratio is why it shows up as the default Cat 1 choice on newer boards like LILYGO’s T-A7670 line, often replacing a SIM7600 socket in an otherwise similar design.
The catch is the same one that trips up every regional cellular module: the A7670 ships in variants with different band sets, and picking the wrong one means it never registers on a local network. The A7670C targets China with LTE-FDD B1/B3/B5/B8 plus TDD bands; the A7670E covers Europe and Africa on B1/B3/B5/B7/B8/B20; the A7670SA is the broad-coverage option with B1/B2/B3/B4/B5/B7/B8/B28/B66 and quad-band GSM, closer to what a US or South American SIM needs. None of them are interchangeable, so the variant has to match the SIM and country before wiring anything up. GNSS (GPS, GLONASS and BeiDou per SIMCom’s own application note) is built into all three.
One software gotcha worth knowing before starting a sketch: the official TinyGSM library does not list the plain A7670 among its supported modems (it lists the related A7672X instead), so most A7670 projects - including LILYGO’s own examples - pull in a community fork that adds A7670/A7608 support rather than the mainline library. As with any of these modules, budget for a supply that can source a genuine 2A burst during transmission; the ESP32’s onboard 3.3V regulator will brown out under that load. For a cheaper 2G-only fallback see the SIM800A; for a low-power LPWA alternative that trades speed for battery life, see the SIM7080G.
A7670 troubleshooting
Module Fails to Power On
›
Issue: The A7670 module does not power up or respond to commands.
Possible causes include insufficient power supply, incorrect wiring, or faulty hardware.
Solution: Ensure the module is connected to a stable power source within the recommended voltage range of 3.4V to 4.2V. Verify that all connections are secure and correctly configured. If the problem persists, consider testing the module with a different power source or replacing it.
SIM Card Not Recognized
›
Issue: The module fails to detect or register the SIM card.
Possible causes include improper SIM card insertion, unsupported SIM card type, or SIM card lock.
Solution: Ensure the SIM card is properly inserted into the module's SIM card slot and is compatible with the GSM network. Verify that the SIM card is active and unlocked. If necessary, test the SIM card in another device to confirm its functionality.
Poor Network Signal or Connectivity Issues
›
Issue: The module experiences weak signal strength or fails to maintain a stable network connection.
Possible causes include improper antenna connection, environmental interference, or network coverage limitations.
Solution: Ensure the GSM antenna is securely connected to the module and positioned for optimal signal reception. Avoid placing the module near sources of electromagnetic interference. Check the network coverage in your area to ensure adequate signal strength.
AT Commands Not Responding
›
Issue: The module does not respond to AT commands sent from the microcontroller or computer.
Possible causes include incorrect baud rate settings, faulty serial connections, or improper command syntax.
Solution: Verify that the baud rate of the module matches that of the microcontroller or computer; the default baud rate is 115200 bps. Check that the TX and RX lines are correctly connected and that there are no loose connections. Ensure that AT commands are correctly formatted and terminated with a carriage return.
GPS Functionality Not Working
›
Issue: The A7670 module fails to acquire GPS signals or provide location data.
Possible causes include improper antenna connection, obstructed view of the sky, or GPS functionality not enabled.
Solution: Ensure the GPS antenna is properly connected and has a clear view of the sky to receive satellite signals. Verify that the GPS functionality is enabled by sending the appropriate AT commands to power on the GPS engine.
Where to buy the A7670

Resources
Similar sensors





