Sensors/ SIM/ A7670

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.

A7670 LTE Cat 1 Module image
A7670 · UART
UART
Interface
9pins
Connections
3.4-4.2V
Supply
-40 to +85 °C
Operating temp
$31.16
Typical price
On this page

A7670 pinout

9 pins · UART

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.

View:
A7670 LTE Cat 1 Module pinout
PinTypeDescriptionNotes
VBATPowerPower supply input (3.4V to 4.2V)Requires stable power with peak current up to 2A
GNDGroundGround connectionCommon ground
TXDUART TXUART Transmit Data (connects to microcontroller RX)Default baud rate: 115200 bps
RXDUART RXUART Receive Data (connects to microcontroller TX)Default baud rate: 115200 bps
PWRKEYControlPower on/off control (active low)Pull low for at least 500ms to power on
NETLIGHTStatusNetwork status indicationLED indicator for network registration
STATUSStatusModule operating status indicationShows module power state
ANT_MAINAntennaMain antenna connection for LTE/GSMRequires external LTE antenna
ANT_GPSAntennaAntenna connection for GPSRequires 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

7 connections · 2 optional

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 LTE Cat 1 Module wiring with ESP32
A7670 pinESP32 pinPurpose
VBAT3.7V-4.2V Power SupplyProvide stable power (NOT from ESP32 pin)
GNDGNDCommon ground connection
TXDGPIO16 (RX2)A7670 TX to ESP32 RX
RXDGPIO17 (TX2)A7670 RX to ESP32 TX
PWRKEYGPIO4Power control (pull low to power on) · optional
ANT_MAINExternal LTE AntennaConnect LTE/GSM antenna
ANT_GPSExternal GPS AntennaConnect 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

5 platforms
Platform:

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

Copy
uart:
  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
src/main.cppCopy
#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

Copy
from 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

From the datasheet
Frequency Bands
LTE-TDD, LTE-FDD, GSM, GPRS, EDGE
Data Rates
LTE Cat 1: 10 Mbps (DL), 5 Mbps (UL); EDGE: 236.8 Kbps (DL/UL); GPRS: 85.6 Kbps (DL/UL)
Operating Voltage
3.4V to 4.2V
Operating Temperature
-40°C to +85°C
Dimensions
24mm x 24mm x 2.3mm

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

5 common issues

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

A7670 LTE Cat 1 Module
A7670 LTE Cat 1 Module
$31.16per unit, typical
Amazon and AliExpress links are affiliate links - buying through them supports the site at no extra cost to you.

Resources

Similar sensors