Este artigo mostra como utilizar as placas de desenvolvimento Arduino Mega 2560 e um modem SIM7600G em um nó IoT celular capaz de coletar dados de rede, GPS e status do SIM, empacotá-los em JSON, que futuramente enviará para qualquer back-end.

Por que um Mega 2560 + SIM7600G?

• SRAM abundante (8 kB) — gera JSON, mantém buffers e ainda sobra para lógica de aplicação; um UNO ficaria no limite.
• UART dedicada (Serial1) — o Mega oferece portas seriais extras, isolando o tráfego do modem do console USB.
• SIM7600G — cobre 2G/3G/4G e GNSS no mesmo chip, simplificando o hardware.

A pinagem utilizada para este projeto está explicada em outro post.

Estrutura do projeto

arduino-mobile-sensor/
├─ src/                // sketch principal
├─ include/            // headers próprios
├─ lib/                // bibliotecas internas
└─ .pio/               // cache do PlatformIO

Código-fonte e arquivos do projeto: https://gitlab.com/mfs.eng.br/hardware-quirks/arduino-sim7600-telemetry

Anatomia do código em C++

Inclusões mínimas

#include <Arduino.h>        // HAL AVR
#include <avr/pgmspace.h>   // PROGMEM
#include <ArduinoJson.h>    // Única lib externa

Definições constantes

constexpr uint32_t USB_BAUD   = 115200;
constexpr uint32_t MODEM_BAUD = 115200;
constexpr uint16_t TIMEOUT_MS = 1500;
#define OUTPUTDEBUG 0

/* ------------ buffer de recepção ----------------------------- */
static char   respBuf[160];
static size_t respLen = 0;

• constexpr garante avaliação em compile-time;
• flags #define ativam logs sem custo quando desligadas;
• buffers globais (char respBuf[160]) vivem em BSS, evitando uso de heap.

Strings AT em Flash

/* ------------ comandos em flash ------------------------------ */
const char CMD_CGSN[]    PROGMEM = "AT+CGSN";
const char CMD_CIMI[]    PROGMEM = "AT+CIMI";
const char CMD_CGMM[]    PROGMEM = "AT+CGMM";
const char CMD_CSPN[]    PROGMEM = "AT+CSPN?";
const char CMD_CSQ[]     PROGMEM = "AT+CSQ";
const char CMD_CREG[]    PROGMEM = "AT+CREG?";
const char CMD_COPS[]    PROGMEM = "AT+COPS?";
const char CMD_CGPADDR[] PROGMEM = "AT+CGPADDR";
const char CMD_CGDCONT[] PROGMEM = "AT+CGDCONT?";
const char AT_GPSINFO[]  PROGMEM = "AT+CGPSINFO";

PROGMEM poupa SRAM; cada comando moraria no Flash.

Compatibilidade Flash-print

#ifndef FPSTR
  #define FPSTR(p) (reinterpret_cast<const __FlashStringHelper *>(p))
#endif

Isso permite que Serial.println() imprima strings guardadas em Flash.

Máquina de leitura/escrita dos comandos AT (sendAT)

Envio

Serial1.println(cmd); // já inclui \r\n

Coleta em bloco

// Loop principal: fica ativo enquanto o tempo decorrido for menor que 'tout'
while (millis() - t0 < tout)
{
    // Loop de leitura: executa enquanto houver bytes no UART *e*
    // ainda houver espaço no buffer (deixa 1 byte livre para o '\0')
    while (Serial1.available() && respLen < sizeof(respBuf) - 1)
        // Lê um byte da porta Serial1 e armazena na posição atual do buffer,
        // depois incrementa 'respLen' para apontar para o próximo espaço livre
        respBuf[respLen++] = Serial1.read();

    // Coloca terminador nulo na posição atual, transformando respBuf
    // em uma string C válida (necessário para usar funções de <string.h>)
    respBuf[respLen] = '\0';

    // Verifica se a resposta já traz um "\nOK" ou "\nERROR"
    // — padrões que sinalizam fim de resposta AT.
    // Se encontrar, sai imediatamente do loop externo (timeout não é mais necessário)
    if (strstr(respBuf, "\nOK") || strstr(respBuf, "\nERROR"))
        break;
}

A função singleLineAT

/* ---------- devolve primeira linha “útil” -------------------- */
bool singleLineAT(const __FlashStringHelper *cmd, char *dst, size_t dstSz)
{
  if (!sendAT(cmd)) return false;

  char *p = respBuf;
  while (*p) {
    /* pula CR/LF */
    while (*p == '\r' || *p == '\n') ++p;
    if (!*p) break;
    /* encontra fim da linha */
    char *q = p;
    while (*q && *q != '\r' && *q != '\n') ++q;

    /* copia linha para tmp */
    char line[128];
    size_t len = min((size_t)(q - p), sizeof line - 1);
    memcpy(line, p, len); line[len] = '\0';

    /* trim início */
    char *s = line;
    while (*s == ' ') ++s;

    /* descarta eco, OK, ERROR */
    if (!strncmp(s, "AT", 2) || !strcmp(s, "OK") || !strncmp(s, "ERROR", 5)) {
      p = q;
      continue;
    }

    /* achou payload */
    strncpy(dst, s, dstSz - 1);
    dst[dstSz - 1] = '\0';
    return true;
  }
  return false;
}

A rotina singleLineAT() encapsula todo o trabalho de disparar um comando AT e devolver exatamente a primeira linha útil da resposta, já limpa de ecos, quebras de linha, espaços extras e tokens de controle.

• Disparo e verificação de sucesso: if (!sendAT(cmd)) return false; reaproveita sendAT() para enviar o comando e encher respBuf. Se ocorrer ERROR ou timeout, a função já devolve false.
• Iterador p percorre o buffer bruto: char *p = respBuf; while (*p) { ... } varre o buffer até achar uma linha útil.
• Pular quebras de linha: while (*p == '\r' || *p == '\n') ++p; garante que p sempre aponte para o primeiro caractere real da linha corrente.
• Encontrar o fim da linha corrente: char *q = p; while (*q && *q != '\r' && *q != '\n') ++q; define o intervalo [p, q) da linha.
• Copiar para buffer temporário usando memcpy() e limitando o tamanho para evitar overflow.
• Copiar o payload ao destino com strncpy(dst, s, dstSz - 1); dst[dstSz - 1] = '\0';.
• Se nenhuma linha útil aparecer, o laço termina naturalmente e a função devolve false.

Boas práticas de embarcados — buffers fixos em vez de String

Funções de conversão e limpeza

Todas essas funções recebem ponteiros ou valores primitivos para otimização de memória.

Roteiro

Setup

• Abre USB e UART do modem.
• Habilita GPS automático (AT+CGPSAUTO=1).
• Define exibição numérica de operadora (AT+COPS=3,2).

Loop

• Se chegar "INFO" pelo USB, dispara sendInfoJSON() e imprime o JSON.
• Caso contrário, funciona como serial transparente PC ↔ modem.

A função sendInfoJSON() executa a sequência dos comandos AT, converte métricas e monta o JSON final.

Campos gerados e valor para telecom

O JSON completo cabe em ~300 bytes, ideal para transporte via MQTT.

Tricks and Tips

• Reaproveitar respBuf — o mesmo buffer serve à detecção de fim de comando e à análise da resposta, evitando tráfego duplicado.
• singleLineAT() universal — limpa eco e ruído em qualquer comando que retorne uma única linha.
• Strings em Flash — elimina 300+ bytes de SRAM, algo crítico em AVR.

Próximos passos sugeridos

• Publicar via MQTT/TLS.
• Gerenciar energia — desligar GPS (AT+CGPS=0) fora das janelas de leitura.
• Implementar FOTA — update de firmware remoto direto no módulo.

Conclusão

Esse é o primeiro passo: entender o diálogo “AT” e convertê-lo em dados de negócio. No próximo artigo, veremos como transmitir essa telemetria de forma segura e escalável para a nuvem.