A7670 LTE Cat 1 Module

#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, 1);
    vTaskDelay(1000 / portTICK_PERIOD_MS); // HIGH pulse for 1 second: the board's NPN pulls the module's PWRKEY low
    gpio_set_level(PWRKEY_PIN, 0);  // idle LOW releases PWRKEY
}

// SIMCom's A7670 hardware design gives 11.2 s (typical) from power-on to UART ready, so poll with AT
// until the module answers OK instead of waiting a fixed time.
static bool wait_for_modem(int timeout_ms) {
    char reply[64];
    for (int waited = 0; waited < timeout_ms; waited += 1000) {
        uart_flush_input(UART_PORT);
        uart_write_bytes(UART_PORT, "AT\r\n", 4);
        int len = uart_read_bytes(UART_PORT, reply, sizeof(reply) - 1, 1000 / portTICK_PERIOD_MS);
        if (len > 0) {
            reply[len] = '\0';
            if (strstr(reply, "OK") != NULL) return true;
        }
    }
    return false;
}

void app_main(void) {
    init_uart();
    power_on_a7670();
    if (!wait_for_modem(20000)) {
        printf("No OK from the module within 20 s - check power, wiring and baud rate\n");
    }

    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) - 1, 100 / portTICK_PERIOD_MS);
        if (len > 0) {
            data[len] = '\0';
            printf("Response: %s\n", data);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

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()' ]

[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, HIGH);
    delay(1000); // HIGH pulse for 1 second: the board's NPN pulls the module's PWRKEY low
    digitalWrite(PWRKEY, LOW);  // idle LOW releases PWRKEY
}

// SIMCom's A7670 hardware design gives 11.2 s (typical) from power-on to UART ready, so poll with AT
// until the module answers OK instead of waiting a fixed time.
bool wait_for_modem(unsigned long timeout_ms) {
    unsigned long start = millis();
    while (millis() - start < timeout_ms) {
        a7670.println("AT");
        String reply;
        unsigned long sent = millis();
        while (millis() - sent < 1000) {
            while (a7670.available()) reply += (char)a7670.read();
        }
        if (reply.indexOf("OK") >= 0) return true;
    }
    return false;
}

void setup() {
    Serial.begin(115200);
    a7670.begin(115200, SERIAL_8N1, 16, 17); // RX, TX
    power_on_a7670();
    if (!wait_for_modem(20000)) {
        Serial.println("No OK from the module within 20 s - check power, wiring and baud rate");
    }

    // 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
}

from machine import UART, Pin
import time

# Initialize UART
uart = UART(2, baudrate=115200, tx=17, rx=16)
pwrkey = Pin(4, Pin.OUT)

def power_on_a7670():
    pwrkey.value(1)
    time.sleep(1)  # HIGH pulse for 1 second: the board's NPN pulls the module's PWRKEY low
    pwrkey.value(0)  # idle LOW releases PWRKEY

def wait_for_modem(timeout_s=20):
    # SIMCom's A7670 hardware design gives 11.2 s (typical) from power-on to UART ready, so poll with AT
    # until the module answers OK instead of waiting a fixed time
    start = time.ticks_ms()
    while time.ticks_diff(time.ticks_ms(), start) < timeout_s * 1000:
        uart.write('AT\r\n')
        time.sleep(1)
        reply = uart.read()
        if reply and b'OK' in reply:
            return True
    return False

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()
if not wait_for_modem():
    print('No OK from the module within 20 s - check power, wiring and baud rate')

# 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))