SIM800L con Arduino: enviar SMS, controlar un relé y llamar

El módulo GSM SIM800L es un módem 2G diminuto y muy barato, del tamaño de un sello, que le da a tu proyecto con Arduino su propia línea de teléfono. Con una tarjeta micro SIM puedes enviar y recibir SMS, hacer llamadas y mandar pequeñas cantidades de datos a internet por GPRS. En lugares donde no llegan el Wi-Fi ni el Bluetooth, como una casa de campo, un invernadero, un almacén o un vehículo, combinar un SIM800L con Arduino es la forma más sencilla de controlar un dispositivo a distancia desde cualquier sitio con cobertura móvil. El módulo se comunica con Arduino por una conexión serie de dos cables (UART) y se maneja con comandos de texto cortos llamados comandos AT.

Eso sí, el SIM800L es uno de los módulos que más quebraderos de cabeza da a quienes empiezan, y casi todos los problemas vienen de dos sitios: una alimentación insuficiente y la cobertura 2G. En esta guía aprenderás a alimentar el módulo correctamente según su rango de 3,4–4,4 V y sus picos de 2 A, qué te indica la frecuencia de parpadeo del LED de la placa, cómo probarlo paso a paso con comandos AT, cómo enviar un SMS con Arduino Uno, encender y apagar un relé por SMS y montar un circuito que te llame cuando salte una alarma. Después harás lo mismo con ESP32, la placa TTGO T-Call y la Raspberry Pi Pico, y al final encontrarás en una tabla las soluciones a los problemas de registro en la red.

¿Qué es el SIM800L y cómo funciona?

El SIM800L es un módulo GSM/GPRS fabricado por SIMCom que mide solo 17,8 × 15,8 mm. La placa roja que compras es una pequeña breakout que le añade un zócalo SIM, una conexión de antena, un LED de estado y tiras de pines. El módulo explora automáticamente las cuatro bandas GSM (850, 900, 1800 y 1900 MHz), se registra en la red igual que un móvil y después ejecuta las órdenes que le llegan por el puerto serie: «envía este mensaje a este número», «llama a este número», «pásame los mensajes entrantes», etc. Piensa en él como un teléfono sin pantalla ni teclado; Arduino hace el trabajo de ambos. Si conectas un micrófono y un altavoz a los pines MIC y SPK, incluso puedes mantener una llamada de voz real.

Pines del SIM800L

La antena en espiral que viene en la bolsa se suelda al orificio NET de la esquina de la placa; algunas placas tienen además un pequeño conector u.FL (IPEX) para una antena externa. Sin antena, el módulo no encuentra la red y la intensidad de señal sale casi a cero; si dentro de casa la señal es débil, una antena GSM adhesiva con cable marca una diferencia clara frente a la espiral. La micro SIM va en el zócalo de la parte trasera, con la esquina cortada en la posición que indica el dibujo del zócalo. Antes de insertarla, desactiva la petición del PIN en un móvil y comprueba que la línea puede enviar SMS, hacer llamadas y tiene saldo suficiente.

Alimentación: 3,4–4,4 V y picos de 2 A

La alimentación es el punto más crítico del SIM800L y donde más se falla. GSM funciona por reparto de tiempo: dentro de cada trama de 4,615 ms, el módulo solo transmite durante su propia ranura de 577 µs. En esos instantes consume hasta 2 A y justo después vuelve a unas decenas de miliamperios. Si la fuente no puede entregar esa corriente repentina, la tensión se hunde. Según la hoja de datos de SIMCom, cuando la tensión baja a 3,5 V el módulo escribe UNDER-VOLTAGE WARNNING por el puerto serie, y por debajo de 3,4 V escribe UNDER-VOLTAGE POWER DOWN y se apaga (la errata de WARNNING viene del firmware del fabricante). Por arriba, a 4,3 V aparece el aviso OVER-VOLTAGE WARNNING y por encima de 4,4 V el módulo también se apaga. En algunas versiones de firmware este apagado automático viene desactivado de fábrica y se activa con AT+CBATCHK=1; aun así, fuera de estos límites el módulo funciona de forma inestable y se reinicia una y otra vez. Por eso el pin 5V de Arduino es demasiado alto para el SIM800L. El pin 3.3V está por debajo del mínimo y oficialmente solo da 50 mA; además, el puerto USB de un ordenador no entrega más de 500 mA.

¿Qué te dice el LED? Significado de los parpadeos

Acostúmbrate a usar el LED como herramienta de diagnóstico: ver que el módulo pasa a parpadear cada 3 segundos antes de escribir código descarta de entrada la mitad de los problemas. Si el módulo sigue parpadeando una vez por segundo durante minutos, no tiene sentido tocar el software; revisa primero la sección sobre el registro en la red. Los mayores picos de corriente llegan justo en el registro, cuando el módulo habla por primera vez con la estación base; si la alimentación es débil, el módulo se apaga justo en ese momento y el ciclo vuelve a empezar.

Conexión del SIM800L con Arduino y adaptación de niveles

El SIM800L se comunica con Arduino por UART y las líneas de datos se cruzan: el pin TXD del módulo va al pin RX de la placa y el pin RXD del módulo va al pin TX de la placa. El único puerto serie por hardware del Arduino Uno (D0 y D1) se usa para cargar código por USB y para el Monitor Serie, así que conectamos el módulo a D2 y D3 con SoftwareSerial, que funciona de forma fiable a 9600 baudios. En ESP32 y Pico no hace falta un puerto serie por software: se usan sus UART por hardware. Tienes los fundamentos de la comunicación serie en nuestra guía sobre comunicación serie UART.

Primera prueba con comandos AT

1. Conecta el módulo como en la tabla, pon la antena e inserta una micro SIM con la petición de PIN desactivada.
2. Dale alimentación y observa el LED: tras unos segundos parpadeando una vez por segundo, debería pasar a parpadear cada 3 segundos.
3. Carga en Arduino el sketch puente de abajo; SoftwareSerial viene con el IDE de Arduino, no hace falta ninguna librería extra.
4. Abre el Monitor Serie, pon la velocidad en 9600 baudios y el fin de línea en Both NL & CR («Ambos NL & CR»).
5. Escribe AT y pulsa Enter. El módulo se adapta a tu velocidad con la detección automática de baudios; puede que los primeros intentos no reciban respuesta, repite hasta ver OK.
6. Después comprueba uno a uno la tarjeta SIM, la intensidad de señal y el registro en la red con los comandos de la tabla siguiente.

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}

Con el primer número de la respuesta a AT+CSQ puedes calcular la señal en dBm: dBm ≈ −113 + 2 × valor. Por ejemplo, 18 equivale a unos −77 dBm, que está bastante bien; por debajo de 10 es débil, y por debajo de 5 hasta un SMS cuesta que salga. Una respuesta de 99 indica que el módulo aún no ha podido medir. El comando AT+CBC es ideal para detectar problemas de alimentación: si en reposo ves unos 4,0 V pero el módulo se apaga al enviar un SMS o al llamar, el problema está sin duda en la capacidad de corriente de tu fuente. En el modo de detección automática que viene por defecto, el módulo no escribe nada al arrancar; si fijas la velocidad con AT+IPR=9600 y la guardas con AT&W, el ajuste queda en la memoria permanente y el módulo avisa de que está listo con RDY, +CFUN: 1 y +CPIN: READY cada vez que se enciende.

¿No se registra en la red? Cobertura 2G, SIM e IMEI

El SIM800L solo usa la red 2G (GSM/GPRS); no conoce 3G, 4G ni 5G. En España, MasOrange ha anunciado que mantendrá el 2G hasta finales de 2030, mientras que Movistar y Vodafone aún no han dado una fecha definitiva; en Latinoamérica la situación cambia mucho según el país y el operador. En otros lugares ya no hay 2G: en Estados Unidos la última red se apagó en agosto de 2026, Australia y Suiza lo retiraron hace años y en Francia los operadores lo apagan antes de que termine 2026. Donde no hay 2G, el SIM800L no puede registrarse por bien alimentado que esté; ahí necesitas un módulo 4G LTE como el SIM7600 o el A7670, o uno LTE-M/NB-IoT como el SIM7080G. Para resolver problemas de registro, sigue este orden:

• ¿Hay 2G donde estás? En los ajustes de red móvil de tu teléfono, pon como tipo de red preferido solo 2G e intenta llamar con la misma tarjeta SIM. Si el móvil no encuentra red en 2G, el SIM800L tampoco la encontrará.
• ¿Se lee la tarjeta SIM? AT+CCID debe devolver un número y AT+CPIN? debe responder +CPIN: READY. Si da error, vuelve a insertar la tarjeta en la posición correcta; si usas una nano SIM con adaptador, asegúrate de que el adaptador no presione mal los contactos.
• ¿Es suficiente la señal? AT+CSQ debería dar al menos 10. Suelda la antena o pon una externa y acerca el módulo a una ventana.
• ¿Se deniega el registro? Si AT+CREG? responde 0,3, la red rechaza el módulo: la línea puede estar dada de baja o el IMEI del equipo bloqueado.
• Registro del IMEI: Algunos países bloquean los equipos cuyo IMEI no está registrado; en Turquía, por ejemplo, los dispositivos importados sin registrar se cortan tras un periodo de gracia, y en varios países de Latinoamérica también existen registros de IMEI. Lee el IMEI del módulo con AT+GSN y, si estás en uno de esos países, compra a un vendedor local que ofrezca módulos con el IMEI registrado.
• ¿Es suficiente la alimentación? Si el módulo se reinicia justo al registrarse, el problema no es la red sino la alimentación; vuelve a la sección de alimentación.

Enviar un SMS con Arduino

Para enviar un SMS, primero pasas a modo texto con AT+CMGF=1. Después envías AT+CMGS="+905551112233"; lo más seguro es escribir el número con el prefijo del país (el +90 del ejemplo es Turquía; para España usa +34 y para México +52). El módulo responde con el indicador > para mostrar que espera el texto. Tras escribirlo, en lugar de Enter envías el carácter Ctrl+Z (ASCII 26, 0x1A); cuando la red acepta el mensaje, el módulo devuelve un número de referencia como +CMGS: 12 seguido de OK. Esta confirmación puede tardar unos segundos, o hasta 60 segundos con poca señal. El sketch de abajo se sincroniza con el módulo, espera el registro en la red y envía un único SMS; pon tu número en la línea 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}

En el sketch, la función waitReply() escribe en el Monitor Serie cada carácter que llega del módulo mientras busca la respuesta esperada (OK, > o +CMGS:) y la palabra ERROR, así que ves el resultado de cada comando. waitForNetwork() espera hasta que la respuesta +CREG muestra 0,1 (red propia) o 0,5 (itinerancia), porque un SMS enviado antes del registro falla. En modo texto un SMS puede tener como máximo 160 caracteres. Los caracteres que escribes en el IDE de Arduino van codificados en UTF-8, así que las tildes, la ñ y los signos ¿ ¡ llegan deformados; escribe los mensajes sin ellos, como en el ejemplo.

Controlar un relé por SMS y activarlo con una llamada

Para leer los mensajes entrantes usamos AT+CNMI=1,2,0,0,0: con este ajuste, el módulo no guarda los SMS nuevos en la SIM, sino que los escribe directamente en el puerto serie en dos líneas. La primera, como +CMT: "+905551112233","","26/10/30,14:05:12+12", contiene el número del remitente y la hora (el +12 final es la zona horaria en cuartos de hora, aquí UTC+3), y la segunda contiene el mensaje. El sketch de abajo controla un módulo de relé en D7 con los mensajes «ROLE AC» (relé encendido), «ROLE KAPA» (relé apagado) y «DURUM» (estado), envía un SMS de respuesta tras cada orden y solo acepta mensajes de tu número; por supuesto, puedes cambiar las órdenes a ON, OFF y ESTADO en el código. Además, gracias a AT+CLIP=1, cuando llamas al módulo desde tu número la llamada se rechaza sin contestar y el relé cambia de estado; como una llamada no contestada no se cobra, es el interruptor remoto más barato que existe. Algunas redes envían el número del remitente en formato nacional, sin prefijo de país; si las órdenes no se ejecutan, mira la línea +CMT en el Monitor Serie y escribe OWNER con el mismo 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}

Hacer llamadas con el SIM800L: que te llame cuando salte la alarma

Para llamar, escribes el número y un punto y coma después del comando ATD: ATD+905551112233;. El punto y coma final indica que es una llamada de voz; si lo olvidas, el módulo inicia una llamada de datos y no se establece la llamada de voz. Si la otra parte rechaza la llamada o la conversación termina, el módulo escribe NO CARRIER o BUSY; si nadie contesta, NO ANSWER; y sin red, NO DIALTONE. ATH cuelga en cualquier momento. Un móvil sonando llama mucho más la atención que un SMS cuando se trata de una alarma. El sketch de abajo envía un SMS cuando se activa un sensor de movimiento PIR conectado a D4, luego hace sonar tu móvil durante un máximo de 20 segundos y espera 2 minutos entre dos alarmas:

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}

El sketch tampoco avisa durante los primeros 2 minutos tras encenderse; ese tiempo permite que el sensor PIR se estabilice y que tú salgas de casa. Si contestas, la llamada se establece; con un micrófono electret y un altavoz pequeño de 8 Ω en los pines MIC y SPK del SIM800L puedes hablar a través del dispositivo. Para contestar automáticamente las llamadas entrantes, basta con enviar ATA cuando aparezca la línea RING. Durante una llamada el módulo consume de media entre 130 y 220 mA y sigue teniendo picos de 2 A; si tu fuente aguanta los SMS pero el módulo se apaga en las llamadas, pon un condensador mayor o una fuente más potente.

SIM800L con ESP32 y la placa TTGO T-Call

En el ESP32 no necesitas SoftwareSerial: cualquiera de sus tres UART por hardware puede asignarse a los pines que quieras. Para usar los sketches del Uno en un ESP32, borra las líneas de SoftwareSerial, escribe en su lugar HardwareSerial sim800(2); y usa sim800.begin(9600, SERIAL_8N1, 16, 17); en setup(); el resto del código funciona igual. Como el ESP32 trabaja a 3,3 V, basta con un divisor de 1 kΩ + 5,6 kΩ en la línea TX. Si alimentas el SIM800L con la misma fuente débil que el ESP32, los pulsos de 2 A también hunden la tensión del ESP32 y la placa se reinicia con el error «Brownout detector was triggered»; alimenta las dos placas por separado y une solo los GND. Explicamos este error en detalle en nuestra guía sobre el brownout del ESP32.

Si prefieres ahorrarte el cableado, la placa LilyGO TTGO T-Call reúne un ESP32 y un módem SIM800 en una sola placa. Lleva un módulo ESP32-WROVER-B, un SIM800L (en algunos lotes el SIM800H de la misma familia), un zócalo para la SIM, un conector de batería LiPo y el chip de gestión de energía IP5306, que carga la batería y aporta la corriente que necesita el módem. El módem se enciende y apaga mediante GPIO concretos del ESP32, no con pines externos, por eso los sketches normales del SIM800L no funcionan tal cual en la T-Call.

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}

Estos pines corresponden a las versiones T-Call SIM800L de LilyGO con IP5306. En la versión con el chip de energía AXP192, este se configura con otro código, y en la versión con SIM800C el pin de alimentación del módem es el GPIO 25; mira la fecha de versión impresa en tu placa y la tabla de pines del fabricante. La función setPowerBoostKeepOn() escribe 0x37 en el registro 0x00 del IP5306 y evita que el chip se apague solo con poca carga cuando funciona con batería. Si el módem se apaga al registrarse cuando la placa solo está conectada al USB del ordenador, conecta también la batería LiPo; ella absorbe los pulsos de 2 A. En el ESP32-WROVER, los GPIO 16 y 17 están reservados para la PSRAM interna, por eso el módem va conectado a 26 y 27. Para tareas GPRS como peticiones HTTP o MQTT, la librería TinyGSM es compatible con esta placa mediante la definición TINY_GSM_MODEM_SIM800.

SIM800L con Raspberry Pi Pico y MicroPython

En la Raspberry Pi Pico conectamos el módulo a UART0: el TXD del SIM800L va a GP1, su RXD va a GP0 a través de un divisor de 1 kΩ + 5,6 kΩ y se unen los GND. Los pines VBUS y 3V3 de la Pico no pueden alimentar el SIM800L, así que también aquí usa una fuente externa de 4 V. El código MicroPython de abajo hace lo mismo que el ejemplo del relé con Arduino: activa y desactiva el relé de GP15 por SMS y envía una respuesta. La función to_text() descarta los bytes corrompidos por el ruido y conserva solo caracteres ASCII, de modo que un error de decodificación no detiene el programa. No necesita librerías adicionales; si no sabes ejecutarlo con Thonny, lee antes nuestra guía de fundamentos de 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

Ideas de proyectos con el SIM800L

• Alarma antirrobo con SMS: un sistema que envía un SMS y después te llama cuando un sensor PIR o de puerta detecta movimiento; tienes los detalles en nuestra guía del sistema de alarma con Arduino.
• Aviso de fuga de gas: recibe un SMS en el móvil cuando el sensor de gas MQ-2 supere su umbral, aunque no haya nadie en casa.
• Localizador GPS que responde por SMS: con un módulo GPS NEO-6M, un localizador para coche o bici que responde al mensaje «UBICACION» con un enlace de Google Maps.
• Riego a distancia: un sistema para un huerto o una casa de campo que informa por SMS del valor del sensor de humedad del suelo y pone en marcha la bomba con el mensaje «REGAR».
• Vigilante de temperatura: un circuito con DS18B20 que avisa cuando un invernadero, un gallinero o un congelador se sale del rango.
• Puerta de garaje con una llamada: un mando a distancia gratuito que activa el relé un segundo solo cuando llama un número registrado.
• Aviso de corte de luz: un pequeño circuito que sigue funcionando con batería cuando se va la corriente y envía el SMS «Corte de luz».

No se conecta a la red o no envía SMS: errores frecuentes y soluciones

Bien alimentado y usado donde hay cobertura 2G, el SIM800L es la forma más barata de llegar a tus proyectos con Arduino desde cualquier distancia: basta con una fuente sólida de 4 V, un condensador grande y unos cuantos comandos AT. Si quieres comparar las otras opciones inalámbricas, echa un vistazo a nuestra guía de módulos de comunicación inalámbrica. En la app BlueGrays encontrarás proyectos que puedes ampliar fácilmente con un SIM800L, como una alarma con sensor de movimiento, una alarma de gas y llama, el control de una lámpara de 230 V, un riego inteligente y una alarma con ESP32 y avisos por Telegram, todos con esquemas de circuito y código paso a paso.