SIM800L com Arduino: envie SMS, controle um relé e faça ligações

O módulo GSM SIM800L é um modem 2G minúsculo e muito barato, do tamanho de um selo, que dá ao seu projeto com Arduino uma linha telefônica própria. Com um micro SIM dentro, você pode enviar e receber SMS, fazer ligações e mandar pequenas quantidades de dados para a internet via GPRS. Em lugares onde Wi-Fi e Bluetooth não chegam, como um sítio, uma estufa, um depósito ou um veículo, juntar um SIM800L a um Arduino é o jeito mais simples de controlar um aparelho a distância de qualquer lugar com sinal de celular. O módulo conversa com o Arduino por uma ligação serial de dois fios (UART) e é controlado com comandos de texto curtos chamados comandos AT.

Dito isso, o SIM800L é um dos módulos que mais dão dor de cabeça a quem está começando, e quase todo problema vem de duas coisas: alimentação inadequada e cobertura 2G. Neste guia você vai aprender a alimentar o módulo corretamente para a faixa de 3,4–4,4 V e o pico de corrente de 2 A, o que a frequência das piscadas do LED da placa está dizendo, como testá-lo passo a passo com comandos AT e como enviar um SMS com um Arduino Uno, ligar e desligar um relé por SMS e montar um circuito que liga para você quando um alarme dispara. Depois você vai fazer o mesmo com um ESP32, com a placa pronta TTGO T-Call e com um Raspberry Pi Pico e, no fim, vai encontrar em uma tabela as soluções para problemas de registro na rede.

O que é o SIM800L e como ele funciona?

O SIM800L é um módulo GSM/GPRS fabricado pela SIMCom que mede só 17,8 × 15,8 mm. A placa vermelha que você compra é uma pequena breakout que acrescenta em volta dele um slot de SIM, uma ligação de antena, um LED de status e barras de pinos. O módulo varre automaticamente as quatro bandas GSM (850, 900, 1800 e 1900 MHz), se registra na rede como um celular e depois executa os comandos que recebe pela porta serial: “envie esta mensagem para este número”, “ligue para este número”, “me passe as mensagens que chegarem” e assim por diante. Pense nele como um celular sem tela nem teclado; o Arduino faz o papel dos dois. Ligue um microfone e um alto-falante nos pinos MIC e SPK e você consegue até fazer uma ligação de voz de verdade.

Pinagem do SIM800L

A antena em mola espiral que vem no saquinho é soldada no furo NET, no canto da placa; algumas placas também têm um pequeno conector u.FL (IPEX) para antena externa. Sem antena, o módulo não encontra a rede e a intensidade do sinal fica perto de zero; se a recepção for fraca em ambientes fechados, uma antena GSM adesiva com cabo faz uma diferença notável em relação à mola. O cartão micro SIM vai no slot do verso, com o canto cortado coincidindo com o desenho do suporte. Antes de colocar o cartão, desative o pedido de PIN em um celular e confira se a linha consegue enviar SMS, fazer ligações e tem crédito suficiente.

Alimentação: 3,4–4,4 V e pico de corrente de 2 A

A alimentação é a parte mais crítica do SIM800L e a que as pessoas mais erram. O GSM funciona por divisão de tempo: em cada quadro de 4,615 ms, o módulo só transmite durante o seu próprio intervalo de 577 µs. Nesses momentos curtos ele puxa até 2 A e, logo depois, volta para algumas dezenas de miliampères. Se a fonte não consegue entregar essa corrente súbita, a tensão desaba. Segundo o datasheet da SIMCom, quando a tensão cai para 3,5 V o módulo escreve UNDER-VOLTAGE WARNNING na porta serial e, abaixo de 3,4 V, escreve UNDER-VOLTAGE POWER DOWN e se desliga (o WARNNING com erro de grafia vem do firmware do fabricante). No limite superior, você recebe OVER-VOLTAGE WARNNING em 4,3 V e, acima de 4,4 V, o módulo desliga de novo. Em algumas versões de firmware esse desligamento automático vem desativado por padrão e é ativado com AT+CBATCHK=1; mesmo assim, fora desses limites o módulo fica instável e reinicia o tempo todo. É por isso que o pino 5V do Arduino é alto demais para o SIM800L. O pino 3.3V fica abaixo do mínimo e oficialmente só aguenta 50 mA; além disso, a porta USB de um computador não fornece mais que 500 mA.

O que o LED está dizendo? Os códigos de piscada explicados

Crie o hábito de usar o LED como ferramenta de diagnóstico: ver o módulo passar a piscar a cada 3 segundos antes de escrever qualquer código já descarta metade dos problemas possíveis. Se o módulo continuar piscando uma vez por segundo por minutos, não adianta mexer no software; confira primeiro a seção de registro na rede mais abaixo. Os maiores pulsos de corrente vêm no momento do registro, quando o módulo conversa com a estação rádio base pela primeira vez; se a fonte for fraca, o módulo desliga exatamente nessa hora e o ciclo recomeça.

Ligação do SIM800L com Arduino e níveis lógicos

O SIM800L se comunica com o Arduino por UART, e as linhas de dados são cruzadas: o pino TXD do módulo vai no pino RX da placa, e o pino RXD do módulo vai no pino TX da placa. A única porta serial de hardware do Arduino Uno (D0 e D1) é usada para carregar o código pela USB e para o Monitor Serial, então ligamos o módulo em D2 e D3 com SoftwareSerial, que funciona de forma confiável a 9600 baud. No ESP32 e no Pico você não precisa de porta serial por software; usam-se as UARTs de hardware deles. Você encontra o básico da comunicação serial no nosso guia comunicação serial UART.

Primeiro teste com comandos AT

1. Ligue o módulo como mostra a tabela, coloque a antena e insira um micro SIM com o pedido de PIN desativado.
2. Ligue a alimentação e observe o LED: depois de piscar uma vez por segundo por alguns segundos, ele deve passar a piscar uma vez a cada 3 segundos.
3. Carregue no Arduino o sketch de ponte abaixo; a SoftwareSerial vem com o Arduino IDE, então não é preciso biblioteca extra.
4. Abra o Monitor Serial, ajuste a velocidade para 9600 baud e o final de linha para Ambos, NL e CR.
5. Digite AT e aperte Enter. O módulo se adapta à sua velocidade com o autobauding; as primeiras tentativas podem ficar sem resposta, então repita até ver OK.
6. Depois, confira um a um o cartão SIM, a intensidade do sinal e o registro na rede com os comandos da tabela abaixo.

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);        // RX = D2 (SIM800L TXD), TX = D3 (SIM800L RXD, bölücüyle / via divider)
4
5void setup() {
6  Serial.begin(9600);               // Seri Monitör hızı / Serial Monitor speed
7  sim800.begin(9600);               // SIM800L bu hıza kendini ayarlar / SIM800L autobauds to this rate
8  Serial.println(F("AT yaz ve Enter'a bas / Type AT and press Enter"));
9}
10
11void loop() {
12  if (Serial.available()) sim800.write(Serial.read());   // bilgisayar → modül / PC → module
13  if (sim800.available()) Serial.write(sim800.read());   // modül → bilgisayar / module → PC
14}

Você pode converter o primeiro número da resposta do AT+CSQ em dBm: dBm ≈ −113 + 2 × valor. Por exemplo, 18 significa cerca de −77 dBm, o que é bem bom; abaixo de 10 é fraco, e abaixo de 5 é um sinal em que até um SMS tem dificuldade para passar. Uma resposta 99 significa que o módulo ainda não conseguiu medir. O comando AT+CBC é ideal para flagrar problemas de alimentação: se você vê cerca de 4,0 V com o módulo em espera, mas ele desliga ao enviar um SMS ou ligar, o problema com certeza é a capacidade de corrente da sua fonte. No modo autobaud padrão, o módulo não escreve nada ao iniciar; se você fixar a velocidade com AT+IPR=9600 e salvar com AT&W, a configuração fica guardada na memória não volátil e o módulo avisa que está pronto com RDY, +CFUN: 1 e +CPIN: READY toda vez que liga.

Não registra na rede? Cobertura 2G, SIM e IMEI

O SIM800L só usa a rede 2G (GSM/GPRS); ele não conhece 3G, 4G nem 5G. O 2G está sumindo em muitos países: nos EUA, a última rede 2G foi desligada em agosto de 2026, Austrália e Suíça desligaram o 2G há anos, as operadoras francesas vão desligá-lo até o fim de 2026 e, na Alemanha, a Telekom mira 2028, enquanto Japão e Coreia do Sul nunca usaram GSM. No Reino Unido, as operadoras disseram que o 2G vai durar mais, com desligamento final até 2033 no máximo, e na Turquia o desligamento está previsto para 2029. Onde não há 2G, o SIM800L não consegue se registrar, por melhor que esteja alimentado; nessas regiões você precisa de um módulo 4G LTE como o SIM7600 ou o A7670, ou de um módulo LTE-M/NB-IoT como o SIM7080G. Ao investigar o registro, siga esta ordem:

• Existe 2G onde você está? Nas configurações de rede móvel do celular, defina o tipo de rede preferido como só 2G e tente fazer uma ligação com o mesmo cartão SIM. Se o celular não encontrar rede em 2G, o SIM800L também não vai encontrar.
• O cartão SIM está sendo lido? O AT+CCID deve retornar um número e o AT+CPIN? deve responder +CPIN: READY. Se der erro, coloque o cartão de novo do jeito certo; se estiver usando um nano SIM com adaptador, confira se o adaptador não está pressionando os contatos de forma irregular.
• O sinal é forte o bastante? O AT+CSQ deve ser de pelo menos 10. Solde a antena ou coloque uma externa e leve o módulo para perto de uma janela.
• O registro está sendo negado? Se o AT+CREG? responder 0,3, a rede está recusando o módulo: a linha pode estar inativa ou o IMEI do aparelho pode estar bloqueado.
• Registro do IMEI: alguns países bloqueiam aparelhos cujo IMEI não está registrado; na Turquia, por exemplo, aparelhos trazidos do exterior sem registro são cortados depois de um prazo de carência. Leia o IMEI do módulo com AT+GSN e, se você estiver em um país assim, compre de um vendedor local que ofereça módulos com IMEI registrado.
• A alimentação é adequada? Se o módulo reinicia no momento do registro, o problema não é a rede, e sim a alimentação; volte à seção de alimentação acima.

Enviando um SMS com Arduino

Para enviar um SMS, primeiro você passa para o modo texto com AT+CMGF=1. Depois envia AT+CMGS="+905551112233"; escrever o número com o código do país é a escolha mais segura (+90 no exemplo é o código da Turquia; use +55 para o Brasil, +351 para Portugal, +44 para o Reino Unido, +1 para os EUA e assim por diante). O módulo responde com um prompt > para mostrar que está esperando o texto da mensagem. Depois de digitar o texto, em vez de Enter você envia o caractere Ctrl+Z (ASCII 26, 0x1A); quando a rede aceita a mensagem, o módulo retorna um número de referência como +CMGS: 12 seguido de OK. Essa confirmação pode levar alguns segundos, ou até 60 segundos com sinal fraco. O sketch abaixo sincroniza com o módulo, espera o registro na rede e envia um único SMS; coloque o seu número na linha PHONE:

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);                // RX = D2 ← SIM TXD, TX = D3 → SIM RXD
4const char PHONE[] = "+905551112233";      // kendi numaran, uluslararası biçimde / your number, international format
5
6// ok gelirse 1, ERROR gelirse -1, süre dolarsa 0 / 1 on ok, -1 on ERROR, 0 on timeout
7int waitReply(const char *ok, unsigned long timeoutMs) {
8  const char *err = "ERROR";
9  byte m1 = 0, m2 = 0;
10  unsigned long start = millis();
11  while (millis() - start < timeoutMs) {
12    if (!sim800.available()) continue;
13    char c = sim800.read();
14    Serial.write(c);                        // modülün cevabını göster / show the module's reply
15    m1 = (c == ok[m1]) ? m1 + 1 : (c == ok[0] ? 1 : 0);
16    if (ok[m1] == '\0') return 1;
17    m2 = (c == err[m2]) ? m2 + 1 : (c == err[0] ? 1 : 0);
18    if (err[m2] == '\0') return -1;
19  }
20  return 0;
21}
22
23// Şebeke kaydını bekle: +CREG: 0,1 (ev ağı) ya da 0,5 (dolaşım) / wait for registration: home or roaming
24bool waitForNetwork(unsigned long timeoutMs) {
25  unsigned long start = millis();
26  while (millis() - start < timeoutMs) {
27    sim800.println("AT+CREG?");
28    String reply = "";
29    unsigned long t = millis();
30    while (millis() - t < 1000) {
31      while (sim800.available()) reply += (char)sim800.read();
32    }
33    Serial.print(reply);
34    if (reply.indexOf("+CREG: 0,1") >= 0 || reply.indexOf("+CREG: 0,5") >= 0) return true;
35    delay(2000);
36  }
37  return false;
38}
39
40bool sendSms(const char *number, const char *text) {
41  sim800.print("AT+CMGS=\"");
42  sim800.print(number);
43  sim800.print("\"\r");
44  if (waitReply(">", 5000) != 1) return false;   // metin istemi gelmedi / no text prompt
45  sim800.print(text);
46  sim800.write(26);                               // Ctrl+Z (0x1A): mesajı gönder / send the message
47  return waitReply("+CMGS:", 60000) == 1;         // ağ onayı 60 sn sürebilir / network ack may take 60 s
48}
49
50void setup() {
51  Serial.begin(9600);
52  sim800.begin(9600);
53  delay(3000);                                    // modül açılsın / let the module boot
54
55  bool alive = false;
56  for (byte i = 0; i < 10 && !alive; i++) {       // otomatik baud için birkaç kez AT / several ATs for autobaud
57    sim800.println("AT");
58    alive = (waitReply("OK", 1000) == 1);
59  }
60  if (!alive) {
61    Serial.println(F("\nModul cevap vermiyor / Module not responding"));
62    return;
63  }
64
65  sim800.println("AT+CMGF=1");                    // SMS metin modu / SMS text mode
66  waitReply("OK", 1000);
67
68  Serial.println(F("\nSebeke bekleniyor / Waiting for network"));
69  if (!waitForNetwork(60000)) {
70    Serial.println(F("Sebekeye kayit olunamadi / Not registered"));
71    return;
72  }
73
74  if (sendSms(PHONE, "BlueGrays: SIM800L calisiyor!")) Serial.println(F("\nSMS gonderildi / SMS sent"));
75  else Serial.println(F("\nSMS gonderilemedi / SMS failed"));
76}
77
78void loop() {
79  if (sim800.available()) Serial.write(sim800.read());   // sonraki mesajları göster / show later messages
80}

No sketch, a função waitReply() mostra no Monitor Serial cada caractere que vem do módulo enquanto procura a resposta esperada (OK, > ou +CMGS:) e a palavra ERROR, para você ver o resultado de cada comando. waitForNetwork() espera até a resposta do +CREG mostrar 0,1 (rede de origem) ou 0,5 (roaming), porque um SMS enviado antes do registro falha. No modo texto, um SMS pode ter no máximo 160 caracteres. Os caracteres que você digita no Arduino IDE são codificados em UTF-8, então letras acentuadas e não latinas chegam embaralhadas; fique com texto ASCII simples, como o exemplo do código.

Controlando um relé por SMS e alternando-o com uma ligação

Para ler as mensagens recebidas, usamos AT+CNMI=1,2,0,0,0: com essa configuração, o módulo não guarda os SMS novos no cartão SIM, mas os mostra direto na porta serial em duas linhas. A primeira linha, como +CMT: "+905551112233","","26/10/30,14:05:12+12", traz o número do remetente e o horário (o +12 no final é o fuso horário em quartos de hora, ou seja, UTC+3), e a segunda linha traz a própria mensagem. O sketch abaixo controla um módulo relé no D7 com as mensagens “ROLE AC” (ligar o relé), “ROLE KAPA” (desligar o relé) e “DURUM” (status), envia um SMS de resposta depois de cada comando e só aceita mensagens do seu próprio número; você pode, claro, renomear os comandos no código para LIGA, DESLIGA e STATUS. Além disso, graças ao AT+CLIP=1, quando você liga para o módulo do seu número, a ligação é rejeitada sem ser atendida e o relé alterna; como uma ligação não atendida não é cobrada, esse é o interruptor remoto mais barato que existe. Algumas redes passam o número do remetente no formato nacional (começando com 0) em vez do internacional; se os comandos forem ignorados, veja a linha +CMT no Monitor Serial e escreva OWNER no mesmo formato.

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);                 // RX = D2 ← SIM TXD, TX = D3 → SIM RXD
4const byte RELAY_PIN = 7;                    // röle modülü IN / relay module IN
5const bool RELAY_ON = HIGH;                  // düşük seviyeli modülde LOW yap / set LOW for active-low modules
6const char OWNER[] = "+905551112233";        // komut kabul edilen tek numara / the only accepted number
7
8char line[100];                              // gelen satır tamponu / incoming line buffer
9byte lineLen = 0;
10bool bodyNext = false;                       // sonraki satır SMS metni mi? / is the next line the SMS text?
11bool fromOwner = false;
12bool relayState = false;
13
14int waitReply(const char *ok, unsigned long timeoutMs) {
15  const char *err = "ERROR";
16  byte m1 = 0, m2 = 0;
17  unsigned long start = millis();
18  while (millis() - start < timeoutMs) {
19    if (!sim800.available()) continue;
20    char c = sim800.read();
21    Serial.write(c);
22    m1 = (c == ok[m1]) ? m1 + 1 : (c == ok[0] ? 1 : 0);
23    if (ok[m1] == '\0') return 1;
24    m2 = (c == err[m2]) ? m2 + 1 : (c == err[0] ? 1 : 0);
25    if (err[m2] == '\0') return -1;
26  }
27  return 0;
28}
29
30bool sendSms(const char *number, const char *text) {
31  sim800.print("AT+CMGS=\"");
32  sim800.print(number);
33  sim800.print("\"\r");
34  if (waitReply(">", 5000) != 1) return false;
35  sim800.print(text);
36  sim800.write(26);                          // Ctrl+Z: gönder / send
37  return waitReply("+CMGS:", 60000) == 1;
38}
39
40void setRelay(bool on) {
41  relayState = on;
42  digitalWrite(RELAY_PIN, on ? RELAY_ON : !RELAY_ON);
43}
44
45void handleCommand(char *text) {
46  for (char *p = text; *p; p++) *p = toupper(*p);       // büyük harfe çevir / convert to upper case
47  if (strstr(text, "ROLE AC")) {
48    setRelay(true);
49    sendSms(OWNER, "Role ACILDI / Relay ON");
50  } else if (strstr(text, "ROLE KAPA")) {
51    setRelay(false);
52    sendSms(OWNER, "Role KAPANDI / Relay OFF");
53  } else if (strstr(text, "DURUM")) {
54    sendSms(OWNER, relayState ? "Role ACIK / Relay ON" : "Role KAPALI / Relay OFF");
55  }
56}
57
58void handleLine() {
59  Serial.println(line);
60  if (bodyNext) {                            // +CMT satırından sonraki satır SMS metnidir / the line after +CMT is the SMS text
61    bodyNext = false;
62    if (fromOwner) handleCommand(line);
63  } else if (strncmp(line, "+CMT:", 5) == 0) {
64    fromOwner = (strstr(line, OWNER) != NULL);           // gönderen kontrolü / sender check
65    bodyNext = true;
66  } else if (strncmp(line, "+CLIP:", 6) == 0 && strstr(line, OWNER) != NULL) {
67    sim800.println("ATH");                   // aramayı reddet, ücret yazılmaz / reject the call, nothing is charged
68    setRelay(!relayState);                   // her çağrıda aç-kapa / toggle on every call
69  }
70}
71
72void setup() {
73  pinMode(RELAY_PIN, OUTPUT);
74  setRelay(false);
75  Serial.begin(9600);
76  sim800.begin(9600);
77  delay(3000);
78  for (byte i = 0; i < 10; i++) {            // otomatik baud eşleşmesi / autobaud sync
79    sim800.println("AT");
80    if (waitReply("OK", 1000) == 1) break;
81  }
82  const char *initCmds[] = {"ATE0", "AT+CMGF=1", "AT+CNMI=1,2,0,0,0", "AT+CLIP=1"};
83  for (byte i = 0; i < 4; i++) {
84    sim800.println(initCmds[i]);             // yankı kapalı, metin modu, SMS'i ilet, arayanı göster / echo off, text mode, push SMS, caller ID
85    waitReply("OK", 1000);
86  }
87  Serial.println(F("\nHazir / Ready"));
88}
89
90void loop() {
91  while (sim800.available()) {
92    char c = sim800.read();
93    if (c == '\r') continue;
94    if (c == '\n') {                         // satır tamamlandı / line complete
95      line[lineLen] = '\0';
96      if (lineLen > 0) handleLine();
97      lineLen = 0;
98    } else if (lineLen < sizeof(line) - 1) {
99      line[lineLen++] = c;
100    }
101  }
102}

Fazendo ligações com o SIM800L: faça ele ligar para você quando um alarme disparar

Para fazer uma ligação, você escreve o número e um ponto e vírgula depois do comando ATD: ATD+905551112233;. O ponto e vírgula final indica que é uma ligação de voz; se você esquecer, o módulo inicia uma chamada de dados e nenhuma ligação de voz é feita. Se o outro lado rejeitar a ligação ou a conversa terminar, o módulo escreve NO CARRIER ou BUSY; se ninguém atender, NO ANSWER; e sem rede, NO DIALTONE. O ATH encerra a ligação a qualquer momento. Em alarmes, um celular tocando chama muito mais atenção que um SMS. O sketch abaixo envia um SMS quando um sensor de movimento PIR no D4 dispara, depois faz o seu celular tocar por até 20 segundos e espera 2 minutos entre dois alarmes:

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);                 // RX = D2 ← SIM TXD, TX = D3 → SIM RXD
4const byte SENSOR_PIN = 4;                   // PIR çıkışı / PIR output
5const char OWNER[] = "+905551112233";        // aranacak numara / number to call
6const unsigned long RING_MS = 20000;         // en fazla 20 sn çaldır / ring for at most 20 s
7const unsigned long COOLDOWN_MS = 120000;    // iki alarm arası 2 dk; açılışta da 2 dk bekler / 2 min between alarms, also after power-up
8unsigned long lastAlarm = 0;
9
10int waitReply(const char *ok, unsigned long timeoutMs) {
11  const char *err = "ERROR";
12  byte m1 = 0, m2 = 0;
13  unsigned long start = millis();
14  while (millis() - start < timeoutMs) {
15    if (!sim800.available()) continue;
16    char c = sim800.read();
17    Serial.write(c);
18    m1 = (c == ok[m1]) ? m1 + 1 : (c == ok[0] ? 1 : 0);
19    if (ok[m1] == '\0') return 1;
20    m2 = (c == err[m2]) ? m2 + 1 : (c == err[0] ? 1 : 0);
21    if (err[m2] == '\0') return -1;
22  }
23  return 0;
24}
25
26bool sendSms(const char *number, const char *text) {
27  sim800.print("AT+CMGS=\"");
28  sim800.print(number);
29  sim800.print("\"\r");
30  if (waitReply(">", 5000) != 1) return false;
31  sim800.print(text);
32  sim800.write(26);                          // Ctrl+Z: gönder / send
33  return waitReply("+CMGS:", 60000) == 1;
34}
35
36void callOwner() {
37  sim800.print("ATD");
38  sim800.print(OWNER);
39  sim800.println(";");                       // sondaki ; sesli arama demektir / the trailing ; means a voice call
40  waitReply("NO CARRIER", RING_MS);          // açıp kapatırsan erken biter / ends early if you answer and hang up
41  sim800.println("ATH");                     // aramayı sonlandır / hang up
42  waitReply("OK", 2000);
43}
44
45void setup() {
46  pinMode(SENSOR_PIN, INPUT);
47  Serial.begin(9600);
48  sim800.begin(9600);
49  delay(3000);
50  for (byte i = 0; i < 10; i++) {            // otomatik baud eşleşmesi / autobaud sync
51    sim800.println("AT");
52    if (waitReply("OK", 1000) == 1) break;
53  }
54  sim800.println("AT+CMGF=1");               // SMS metin modu / SMS text mode
55  waitReply("OK", 1000);
56}
57
58void loop() {
59  if (digitalRead(SENSOR_PIN) == HIGH && millis() - lastAlarm > COOLDOWN_MS) {
60    lastAlarm = millis();
61    Serial.println(F("Hareket! / Motion!"));
62    sendSms(OWNER, "ALARM: Hareket algilandi / Motion detected");
63    callOwner();
64  }
65  while (sim800.available()) Serial.write(sim800.read());
66}

O sketch também fica em silêncio nos primeiros 2 minutos depois de ligado; isso dá tempo para o sensor PIR aquecer e para você sair de casa. Se você atender a ligação, ela se conecta; com um microfone de eletreto e um alto-falante pequeno de 8 Ω nos pinos MIC e SPK do SIM800L, dá para conversar pelo aparelho. Para atender ligações recebidas automaticamente, basta enviar ATA quando aparecer a linha RING. Durante uma ligação, o módulo puxa em média 130–220 mA e ainda tem picos de 2 A; se a sua fonte dá conta dos SMS, mas o módulo desliga nas ligações, use um capacitor maior ou uma fonte mais forte.

SIM800L com ESP32 e a placa TTGO T-Call

No ESP32 você não precisa de SoftwareSerial; uma das três UARTs de hardware dele pode ser atribuída a quaisquer pinos que você quiser. Para rodar os sketches do Uno acima em um ESP32, apague as linhas da SoftwareSerial, escreva HardwareSerial sim800(2); no lugar e use sim800.begin(9600, SERIAL_8N1, 16, 17); no setup(); o resto do código funciona sem mudanças. Como o ESP32 trabalha em 3,3 V, um divisor de 1 kΩ + 5,6 kΩ na linha TX é tudo de que você precisa. Se você alimentar o SIM800L pela mesma fonte fraca do ESP32, os pulsos de 2 A derrubam também a tensão do ESP32 e a placa reinicia com o erro “Brownout detector was triggered”; alimente as duas placas por fontes separadas e una só os GNDs. Explicamos esse erro em detalhes no nosso guia brownout no ESP32.

Se preferir dispensar a fiação, a placa LilyGO TTGO T-Call junta um ESP32 e um modem SIM800 em uma só placa. Ela traz um módulo ESP32-WROVER-B, um SIM800L (em alguns lotes, o SIM800H da mesma família), um slot de cartão SIM, um conector de bateria LiPo e um chip de gerenciamento de energia IP5306, que carrega a bateria e fornece a corrente de que o modem precisa. O modem é ligado e desligado por GPIOs específicos do ESP32, e não por pinos externos, então os sketches comuns do SIM800L não funcionam no T-Call do jeito que estão.

1#include <Wire.h>
2
3// LilyGO TTGO T-Call SIM800L (IP5306'lı sürüm) pinleri / pins of the IP5306 version
4#define MODEM_PWRKEY     4
5#define MODEM_RST        5
6#define MODEM_POWER_ON  23
7#define MODEM_TX        27      // ESP32 TX → modem RX
8#define MODEM_RX        26      // ESP32 RX ← modem TX
9#define I2C_SDA         21
10#define I2C_SCL         22
11#define IP5306_ADDR   0x75      // güç yönetim yongası / power management chip
12
13HardwareSerial &modem = Serial1;
14const char OWNER[] = "+905551112233";
15
16// Pille çalışırken IP5306 kendini kapatmasın / keep the IP5306 boost on when running from battery
17bool setPowerBoostKeepOn() {
18  Wire.beginTransmission(IP5306_ADDR);
19  Wire.write(0x00);             // SYS_CTL0 yazmacı / SYS_CTL0 register
20  Wire.write(0x37);             // boost keep-on biti açık / boost keep-on bit set
21  return Wire.endTransmission() == 0;
22}
23
24// token gelirse true; ERROR ya da süre dolarsa false / true on token, false on ERROR or timeout
25bool waitFor(const char *token, unsigned long timeoutMs) {
26  String reply = "";
27  unsigned long start = millis();
28  while (millis() - start < timeoutMs) {
29    while (modem.available()) reply += (char)modem.read();
30    if (reply.indexOf(token) >= 0) break;
31    if (reply.indexOf("ERROR") >= 0) break;
32  }
33  Serial.print(reply);
34  return reply.indexOf(token) >= 0;
35}
36
37bool at(const char *cmd) {
38  modem.println(cmd);
39  return waitFor("OK", 2000);
40}
41
42bool registered() {
43  modem.println("AT+CREG?");
44  return waitFor("+CREG: 0,1", 1000);       // ev şebekesine kayıtlı / registered on the home network
45}
46
47bool sendSms(const char *number, const char *text) {
48  modem.printf("AT+CMGS=\"%s\"\r", number);
49  if (!waitFor(">", 5000)) return false;
50  modem.print(text);
51  modem.write(26);                           // Ctrl+Z: gönder / send
52  return waitFor("+CMGS:", 60000);
53}
54
55void setup() {
56  Serial.begin(115200);
57  Wire.begin(I2C_SDA, I2C_SCL);
58  Serial.println(setPowerBoostKeepOn() ? "IP5306 OK" : "IP5306 yok / not found");
59
60  pinMode(MODEM_RST, OUTPUT);
61  pinMode(MODEM_PWRKEY, OUTPUT);
62  pinMode(MODEM_POWER_ON, OUTPUT);
63  digitalWrite(MODEM_RST, HIGH);             // reset bırakılmış / reset released
64  digitalWrite(MODEM_POWER_ON, HIGH);        // modemin beslemesini aç / switch on the modem supply
65  digitalWrite(MODEM_PWRKEY, HIGH);
66  delay(100);
67  digitalWrite(MODEM_PWRKEY, LOW);           // PWRKEY 1 sn düşük: modem açılır / PWRKEY low for 1 s: modem starts
68  delay(1000);
69  digitalWrite(MODEM_PWRKEY, HIGH);
70
71  modem.begin(115200, SERIAL_8N1, MODEM_RX, MODEM_TX);
72  delay(3000);
73
74  for (int i = 0; i < 10 && !at("AT"); i++) delay(500);   // otomatik baud / autobaud
75  at("AT+CMGF=1");                           // SMS metin modu / SMS text mode
76  at("AT+CNMI=1,2,0,0,0");                   // gelen SMS'i seri porta ver / push incoming SMS to the UART
77
78  unsigned long start = millis();
79  while (!registered() && millis() - start < 60000) delay(2000);
80
81  if (sendSms(OWNER, "TTGO T-Call hazir / ready")) Serial.println("\nSMS gonderildi / sent");
82}
83
84void loop() {
85  while (modem.available()) Serial.write(modem.read());   // gelen SMS ve aramalar / incoming SMS and calls
86  while (Serial.available()) modem.write(Serial.read());  // Seri Monitör'den AT komutu / AT commands from the monitor
87}

Esses pinos são das versões SIM800L do T-Call da LilyGO com o IP5306. Na versão com o chip de energia AXP192, o chip de energia é configurado com outro código e, na versão SIM800C, o pino de alimentação do modem é o GPIO 25; confira a data da versão impressa na sua placa e a tabela de pinos do fabricante. A função setPowerBoostKeepOn() grava 0x37 no registrador 0x00 do IP5306, o que impede o chip de se desligar sozinho com carga baixa quando está funcionando com a bateria. Se o modem desligar no momento do registro quando a placa estiver alimentada só pela USB do computador, ligue também a bateria LiPo; a bateria cobre os pulsos de 2 A. No ESP32-WROVER, os GPIO 16 e 17 são reservados para a PSRAM interna, e é por isso que o modem está ligado no 26 e no 27. Para tarefas GPRS como requisições HTTP ou MQTT, a biblioteca TinyGSM suporta esta placa com o define TINY_GSM_MODEM_SIM800.

SIM800L com Raspberry Pi Pico e MicroPython

No Raspberry Pi Pico, ligamos o módulo na UART0: o TXD do SIM800L vai no GP1, o RXD vai no GP0 por um divisor de 1 kΩ + 5,6 kΩ, e os GNDs são unidos. Os pinos VBUS e 3V3 do Pico não conseguem alimentar o SIM800L, então aqui também alimente o módulo com uma fonte externa de 4 V. O código MicroPython abaixo faz o mesmo trabalho do exemplo do relé com Arduino: liga e desliga por SMS o relé no GP15 e envia uma resposta. A função to_text() descarta os bytes corrompidos por ruído e mantém só caracteres ASCII, para que um erro de decodificação não pare o programa. Não é preciso biblioteca extra; se você não sabe como rodá-lo com o Thonny, leia antes nosso guia fundamentos do MicroPython.

1from machine import UART, Pin
2import time
3
4# GP0 (TX) → SIM RXD (1k + 5,6k bölücü / divider), GP1 (RX) ← SIM TXD
5sim = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1), timeout=100, timeout_char=50)
6relay = Pin(15, Pin.OUT, value=0)              # röle modülü IN / relay module IN
7OWNER = "+905551112233"                        # yetkili numara / authorised number
8
9def to_text(raw):
10    # yalnız ASCII karakterleri al / keep ASCII characters only
11    return "".join(chr(b) for b in raw if 9 < b < 128)
12
13def wait_for(token, timeout_ms):
14    # token ya da ERROR gelene kadar oku / read until token or ERROR
15    buf = ""
16    t0 = time.ticks_ms()
17    while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
18        if sim.any():
19            buf += to_text(sim.read())
20            if token in buf:
21                return True
22            if "ERROR" in buf:
23                return False
24    return False
25
26def at(cmd, timeout_ms=2000):
27    sim.write(cmd + "\r\n")
28    return wait_for("OK", timeout_ms)
29
30def send_sms(number, msg):
31    sim.write('AT+CMGS="{}"\r'.format(number))
32    if not wait_for(">", 5000):
33        return False
34    sim.write(msg)
35    sim.write(b"\x1a")                         # Ctrl+Z: gönder / send
36    return wait_for("+CMGS:", 60000)
37
38for _ in range(10):                            # otomatik baud eşleşmesi / autobaud sync
39    if at("AT", 1000):
40        break
41at("ATE0")                                     # yankıyı kapat / echo off
42at("AT+CMGF=1")                                # SMS metin modu / SMS text mode
43at("AT+CNMI=1,2,0,0,0")                        # gelen SMS'i UART'a ver / push incoming SMS to the UART
44print("Hazir / Ready")
45
46body_next = False
47from_owner = False
48while True:
49    raw = sim.readline()
50    if not raw:
51        continue
52    line = to_text(raw).strip()
53    if not line:
54        continue
55    print(line)
56    if body_next:                              # +CMT'den sonraki satır SMS metni / line after +CMT is the text
57        body_next = False
58        cmd = line.upper()
59        if not from_owner:
60            continue
61        if "ROLE AC" in cmd:
62            relay.value(1)
63            send_sms(OWNER, "Role ACILDI / Relay ON")
64        elif "ROLE KAPA" in cmd:
65            relay.value(0)
66            send_sms(OWNER, "Role KAPANDI / Relay OFF")
67        elif "DURUM" in cmd:
68            send_sms(OWNER, "Role ACIK / ON" if relay.value() else "Role KAPALI / OFF")
69    elif line.startswith("+CMT:"):             # yeni SMS başlığı / new SMS header
70        from_owner = OWNER in line
71        body_next = True

Ideias de projetos com SIM800L

• Alarme contra ladrão com SMS: um sistema que envia um SMS e depois liga para você quando um PIR ou um sensor de porta detecta movimento; veja os detalhes no nosso guia sistema de alarme residencial com Arduino.
• Aviso de vazamento de gás: receba um SMS no celular quando o sensor de gás MQ-2 passar do limite, mesmo sem ninguém em casa.
• Rastreador GPS que responde por SMS: com um módulo GPS NEO-6M, um rastreador de carro ou bicicleta que responde a uma mensagem “LOCATION” com um link do Google Maps.
• Irrigação a distância: um sistema para jardim ou horta que informa por SMS a leitura do sensor de umidade do solo e liga a bomba com uma mensagem “WATER”.
• Vigia de temperatura: um circuito com DS18B20 que envia um aviso quando uma estufa, um galinheiro ou um freezer sai da faixa.
• Portão de garagem aberto por ligação: um controle remoto gratuito que aciona o relé por um segundo só quando um número cadastrado liga.
• Aviso de queda de energia: um pequeno circuito que continua funcionando com bateria quando falta energia e envia um SMS “Power cut” (queda de energia).

Não conecta à rede, SMS não sai: problemas comuns e soluções

Quando bem alimentado e usado onde há cobertura 2G, o SIM800L é o jeito mais barato de alcançar seus projetos com Arduino a quilômetros de distância: uma fonte firme de 4 V, um capacitor grande e meia dúzia de comandos AT são tudo de que você precisa. Se quiser comparar as outras opções sem fio, dê uma olhada no nosso guia módulos de comunicação sem fio. No app BlueGrays você encontra projetos que dá para ampliar facilmente com um SIM800L, como alarme com sensor de movimento, alarme de gás e chama, controle de lâmpada da rede elétrica, irrigação inteligente e alarme com ESP32 e notificações pelo Telegram, todos com esquemas do circuito e código passo a passo.