En este proyecto vamos a crear un sistema de notificaciones por SMS con el módulo T-Call ESP32 SIM800L que envía un SMS cuando las lecturas de un sensor están por encima o por debajo de un umbral determinado.
En este ejemplo, usaremos un sensor de temperatura DS18B20, y enviaremos un mensaje de texto cuando la temperatura esté por encima de 28 ºC. Una vez que la temperatura haya descendido por debajo del umbral, enviaremos otra alerta por SMS.
Para enviar un SMS con el módulo T-Call ESP32 SIM800L, solo necesitas usar modem.sendSMS(SMS_TARGET, smsMessage) después de inicializar un objeto modem para el módulo SIM800L (usando la librería TinyGSM).
Importante: el SIM800L funciona en redes 2G, así que solo funcionará en tu país si las redes 2G están disponibles. Comprueba si tienes red 2G en tu país; de lo contrario, no funcionará.
Resumen del proyecto
Este tutorial está dividido en dos secciones: enviar un SMS con el TTGO T-Call ESP32 SIM800L (aprenderás a enviar un mensaje simple de “Hello World”) y sistema de notificación por SMS con lecturas de sensores (enviar un mensaje cada vez que las lecturas de temperatura crucen el valor umbral).
¿Cómo funciona el sistema de notificación?
El flujo del sistema de alertas es el siguiente: el ESP32 obtiene nuevas lecturas de temperatura cada 5 segundos. Comprueba si la temperatura está por encima del valor umbral. Si está por encima del valor umbral, envía un SMS de alerta con el valor de temperatura actual. Cuando la temperatura baja por debajo del umbral, envía otra alerta. El ESP32 envía solo un SMS cada vez que las lecturas de temperatura cruzan el valor umbral.
Puedes modificar este proyecto para tu caso específico. Por ejemplo, puedes poner el ESP32 en modo deep sleep y enviar un SMS cada hora con las lecturas actuales de temperatura, etc.
La placa TTGO T-Call ESP32 SIM800L
El TTGO T-Call es una placa de desarrollo ESP32 que combina un módulo SIM800L GSM/GPRS. Puedes conseguirla por aproximadamente 11 dólares.
Además de Wi-Fi y Bluetooth, puedes comunicarte con esta placa ESP32 usando SMS, llamadas telefónicas o conectarla a internet. En este tutorial, aprenderás cómo enviar una notificación por SMS.
Requisitos previos
1. Complemento ESP32 en Arduino IDE: Vamos a programar el ESP32 usando Arduino IDE. Necesitas tener el complemento ESP32 instalado en tu Arduino IDE.
2. Tarjeta SIM prepago (con plan de SMS): Para usar la placa TTGO T-Call ESP32 SIM800L, necesitas una tarjeta nano SIM. Recomendamos usar una tarjeta SIM con plan prepago o mensual, para que sepas exactamente cuánto vas a gastar.
3. Librerías necesarias: Para este proyecto también necesitas instalar la librería TinyGSM para interactuar con el módulo SIM800L y la librería One Wire de Paul Stoffregen y la librería Dallas Temperature para obtener lecturas del sensor DS18B20.
Instalar la librería TinyGSM
Abre tu Arduino IDE y ve a Programa > Incluir Librería > Gestionar Librerías. Busca TinyGSM. Selecciona la librería TinyGSM de Volodymyr Shymanskyy e instálala.
Instalar las librerías del DS18B20
En el Gestor de Librerías de Arduino IDE, escribe “onewire” en el cuadro de búsqueda e instala la librería OneWire de Paul Stoffregen. Después, busca “Dallas” e instala la librería DallasTemperature de Miles Burton. Después de instalar las librerías, reinicia tu Arduino IDE.
Componentes necesarios
Para seguir este tutorial necesitas: una placa TTGO T-Call ESP32 SIM800L, una tarjeta nano SIM con plan de SMS, un cable USB-C, una antena (opcional), un sensor de temperatura DS18B20, una resistencia de 4,7 kΩ, una protoboard y cables jumper.
Nota: tuvimos algunos problemas de intensidad de señal con la antena que venía con el paquete de la placa, así que usamos otra antena y todos esos problemas de conexión se resolvieron. Si tienes problemas de cobertura, considera probar con una antena externa de mejor calidad.
Enviar SMS con el T-Call ESP32 SIM800L
En esta sección, te mostraremos cómo enviar un SMS con la placa T-Call ESP32 SIM800L. Construiremos un ejemplo simple que envía un mensaje “Hello from ESP32!” a tu smartphone.
Copia el siguiente código en tu Arduino IDE. Pero no lo subas todavía: necesitas insertar el número de teléfono del destinatario en el código.
/*
Rui Santos
Detalles completos del proyecto en https://RandomNerdTutorials.com/esp32-sim800l-send-text-messages-sms/
*/
// PIN de la tarjeta SIM (dejar vacío si no está definido)
const char simPIN[] = "";
// Tu número de teléfono para enviar SMS: + (signo más) y código de país,
// para Portugal +351, seguido del número de teléfono
// Ejemplo de SMS_TARGET para Portugal +351XXXXXXXXX
#define SMS_TARGET "+351XXXXXXXXX"
// Configura la librería TinyGSM
#define TINY_GSM_MODEM_SIM800 // El módem es SIM800
#define TINY_GSM_RX_BUFFER 1024 // Establece el buffer RX a 1Kb
#include <Wire.h>
#include <TinyGsmClient.h>
// Pines del TTGO T-Call
#define MODEM_RST 5
#define MODEM_PWKEY 4
#define MODEM_POWER_ON 23
#define MODEM_TX 27
#define MODEM_RX 26
#define I2C_SDA 21
#define I2C_SCL 22
// Establece el serial para la consola de depuración (al Monitor Serie, velocidad por defecto 115200)
#define SerialMon Serial
// Establece el serial para comandos AT (al módulo SIM800)
#define SerialAT Serial1
// Define la consola serie para impresiones de depuración, si es necesario
//#define DUMP_AT_COMMANDS
#ifdef DUMP_AT_COMMANDS
#include <StreamDebugger.h>
StreamDebugger debugger(SerialAT, SerialMon);
TinyGsm modem(debugger);
#else
TinyGsm modem(SerialAT);
#endif
#define IP5306_ADDR 0x75
#define IP5306_REG_SYS_CTL0 0x00
bool setPowerBoostKeepOn(int en){
Wire.beginTransmission(IP5306_ADDR);
Wire.write(IP5306_REG_SYS_CTL0);
if (en) {
Wire.write(0x37); // Set bit1: 1 enable 0 disable boost keep on
} else {
Wire.write(0x35); // 0x37 is default reg value
}
return Wire.endTransmission() == 0;
}
void setup() {
// Establece la velocidad de baudios de la consola
SerialMon.begin(115200);
// Mantén la alimentación cuando funcione con batería
Wire.begin(I2C_SDA, I2C_SCL);
bool isOk = setPowerBoostKeepOn(1);
SerialMon.println(String("IP5306 KeepOn ") + (isOk ? "OK" : "FAIL"));
// Establece los pines de reset, enable y power del módem
pinMode(MODEM_PWKEY, OUTPUT);
pinMode(MODEM_RST, OUTPUT);
pinMode(MODEM_POWER_ON, OUTPUT);
digitalWrite(MODEM_PWKEY, LOW);
digitalWrite(MODEM_RST, HIGH);
digitalWrite(MODEM_POWER_ON, HIGH);
// Establece la velocidad de baudios del módulo GSM y los pines UART
SerialAT.begin(115200, SERIAL_8N1, MODEM_RX, MODEM_TX);
delay(3000);
// Reinicia el módulo SIM800, tarda bastante tiempo
// Para omitirlo, llama a init() en lugar de restart()
SerialMon.println("Initializing modem...");
modem.restart();
// usa modem.init() si no necesitas el reinicio completo
// Desbloquea tu tarjeta SIM con un PIN si es necesario
if (strlen(simPIN) && modem.getSimStatus() != 3 ) {
modem.simUnlock(simPIN);
}
// Para enviar un SMS, llama a modem.sendSMS(SMS_TARGET, smsMessage)
String smsMessage = "Hello from ESP32!";
if(modem.sendSMS(SMS_TARGET, smsMessage)){
SerialMon.println(smsMessage);
}
else{
SerialMon.println("SMS failed to send");
}
}
void loop() {
delay(1);
}
Cómo funciona el código paso a paso
Inserta el PIN de tu tarjeta SIM en la siguiente variable. Si no está definido, puedes dejar esta variable vacía.
const char simPIN[] = "";
Después, añade el número de teléfono al que quieres enviar el SMS. El número debe estar en formato internacional, de lo contrario, no funcionará: signo más (+) y código de país, para Portugal +351, seguido del número de teléfono. Ejemplo para Portugal: +351XXXXXXXXX.
#define SMS_TARGET "+351XXXXXXXXXXXX"
Se configura la librería TinyGSM para trabajar con el módem SIM800L. Se incluyen las librerías necesarias. Las siguientes líneas definen los pines usados por el módulo SIM800L.
Se inicializa una comunicación serie para interactuar con el Monitor Serie y otra para interactuar con el módulo SIM800L.
En el setup(), se inicializa el Monitor Serie. Se configuran los pines del SIM800L en un estado adecuado para operar. Se inicializa una comunicación serie con el módulo SIM800L. Se inicializa el módulo SIM800L y se desbloquea el PIN de la tarjeta SIM si es necesario.
Para enviar un SMS, solo necesitas usar el método sendSMS() en el objeto modem y pasar como argumentos el número de teléfono del destinatario y el mensaje.
modem.sendSMS(SMS_TARGET, smsMessage);
En este caso, el mensaje es “Hello from ESP32!”, pero puede ser reemplazado con otra información como datos de sensores.
Demostración
Con la tarjeta nano SIM insertada en el módulo, sube el código a tu placa T-Call ESP32 SIM800L. Ve a Herramientas > Placa y selecciona ESP32 Dev Module. Ve a Herramientas > Puerto y selecciona el puerto COM al que está conectada tu placa. Finalmente, pulsa el botón de subir para cargar el código en tu placa.
Nota: en este momento, no hay una placa específica para el T-Call ESP32 SIM800L, pero hemos seleccionado ESP32 Dev Module y ha funcionado bien.
Después de subir el código, abre el Monitor Serie a 115200 baudios para ver qué está pasando. Después de unos segundos, deberías recibir un SMS en el número de teléfono del destinatario.
Solución de problemas
Si en este punto no recibes un SMS, puede estar causado por una de las siguientes razones:
Este módulo solo funciona si 2G es compatible en tu país. El número de teléfono puede tener una errata o no estar correctamente formateado con el signo más (+) y el código de país. La antena puede no estar funcionando correctamente. En nuestro caso, la reemplazamos por otra. Puede que necesites salir al exterior para obtener mejor cobertura de señal. O puede que no estés suministrando suficiente corriente al módulo. Si estás conectando el módulo a tu ordenador usando un hub USB, puede que no proporcione suficiente corriente para operar.
Sistema de notificación por SMS con el ESP32
En esta sección, te mostraremos cómo construir un sistema de notificación por SMS que envía un mensaje de texto cuando las lecturas del sensor cruzan un valor umbral de temperatura predeterminado.
Esquema de conexión
Antes de continuar, conecta el sensor de temperatura DS18B20 a la placa T-Call ESP32 SIM800L. Conectamos el pin de datos del DS18B20 al GPIO 13. Recuerda que el DS18B20 requiere una resistencia pull-up de 4,7 kΩ entre el pin de datos y 3,3 V para funcionar correctamente.
Código completo del sistema de alertas
Copia el siguiente código en tu Arduino IDE. Inserta el número de teléfono del destinatario y establece el valor umbral. Después, puedes subir el código a la placa T-Call ESP32 SIM800L.
/*
Rui Santos
Detalles completos del proyecto en https://RandomNerdTutorials.com/esp32-sim800l-send-text-messages-sms/
*/
// PIN de la tarjeta SIM (dejar vacío si no está definido)
const char simPIN[] = "";
// Tu número de teléfono para enviar SMS: + (signo más) y código de país
#define SMS_TARGET "+351XXXXXXXXX"
// Define tu umbral de temperatura (en este caso es 28.0 grados Celsius)
float temperatureThreshold = 28.0;
// Variable de bandera para mantener constancia de si se envió el SMS de alerta o no
bool smsSent = false;
// Configura la librería TinyGSM
#define TINY_GSM_MODEM_SIM800 // El módem es SIM800
#define TINY_GSM_RX_BUFFER 1024 // Establece el buffer RX a 1Kb
#include <Wire.h>
#include <TinyGsmClient.h>
#include <OneWire.h>
#include <DallasTemperature.h>
// GPIO donde está conectado el DS18B20
const int oneWireBus = 13;
// Configura una instancia oneWire para comunicarse con cualquier dispositivo OneWire
OneWire oneWire(oneWireBus);
// Pasa nuestra referencia oneWire al sensor Dallas Temperature
DallasTemperature sensors(&oneWire);
// Pines del TTGO T-Call
#define MODEM_RST 5
#define MODEM_PWKEY 4
#define MODEM_POWER_ON 23
#define MODEM_TX 27
#define MODEM_RX 26
#define I2C_SDA 21
#define I2C_SCL 22
// Establece el serial para la consola de depuración
#define SerialMon Serial
// Establece el serial para comandos AT
#define SerialAT Serial1
// Define la consola serie para impresiones de depuración, si es necesario
//#define DUMP_AT_COMMANDS
#ifdef DUMP_AT_COMMANDS
#include <StreamDebugger.h>
StreamDebugger debugger(SerialAT, SerialMon);
TinyGsm modem(debugger);
#else
TinyGsm modem(SerialAT);
#endif
#define IP5306_ADDR 0x75
#define IP5306_REG_SYS_CTL0 0x00
bool setPowerBoostKeepOn(int en){
Wire.beginTransmission(IP5306_ADDR);
Wire.write(IP5306_REG_SYS_CTL0);
if (en) {
Wire.write(0x37);
} else {
Wire.write(0x35);
}
return Wire.endTransmission() == 0;
}
void setup() {
SerialMon.begin(115200);
Wire.begin(I2C_SDA, I2C_SCL);
bool isOk = setPowerBoostKeepOn(1);
SerialMon.println(String("IP5306 KeepOn ") + (isOk ? "OK" : "FAIL"));
pinMode(MODEM_PWKEY, OUTPUT);
pinMode(MODEM_RST, OUTPUT);
pinMode(MODEM_POWER_ON, OUTPUT);
digitalWrite(MODEM_PWKEY, LOW);
digitalWrite(MODEM_RST, HIGH);
digitalWrite(MODEM_POWER_ON, HIGH);
SerialAT.begin(115200, SERIAL_8N1, MODEM_RX, MODEM_TX);
delay(3000);
SerialMon.println("Initializing modem...");
modem.restart();
if (strlen(simPIN) && modem.getSimStatus() != 3 ) {
modem.simUnlock(simPIN);
}
// Inicia el sensor DS18B20
sensors.begin();
}
void loop() {
sensors.requestTemperatures();
// Temperatura en grados Celsius
float temperature = sensors.getTempCByIndex(0);
SerialMon.print(temperature);
SerialMon.println("*C");
// Comprueba si la temperatura está por encima del umbral y si necesita enviar el SMS de alerta
if((temperature > temperatureThreshold) && !smsSent){
String smsMessage = String("Temperature above threshold: ") +
String(temperature) + String("C");
if(modem.sendSMS(SMS_TARGET, smsMessage)){
SerialMon.println(smsMessage);
smsSent = true;
}
else{
SerialMon.println("SMS failed to send");
}
}
// Comprueba si la temperatura está por debajo del umbral y si necesita enviar el SMS de alerta
else if((temperature < temperatureThreshold) && smsSent){
String smsMessage = String("Temperature below threshold: ") +
String(temperature) + String("C");
if(modem.sendSMS(SMS_TARGET, smsMessage)){
SerialMon.println(smsMessage);
smsSent = false;
}
else{
SerialMon.println("SMS failed to send");
}
}
delay(5000);
}
Cómo funciona el código paso a paso
En el ejemplo anterior, ya hemos explicado cómo inicializar el SIM800L y todas las configuraciones requeridas. Así que pasemos a las partes relevantes para este proyecto.
Primero, escribe el PIN de tu tarjeta SIM. Si no está definido, puedes dejar esta variable vacía. Después, añade el número de teléfono al que quieres enviar el SMS. El número debe estar en formato internacional, de lo contrario no funcionará.
Define tu umbral de temperatura. Lo hemos establecido a 28 grados Celsius.
float temperatureThreshold = 28.0;
Se crea una variable para mantener constancia de si se envió un SMS o no.
bool smsSent = false;
El sensor de temperatura está conectado al GPIO 13, pero puedes usar cualquier otro GPIO.
En el loop(), se obtienen las lecturas de temperatura. Por defecto, la temperatura está en grados Celsius, pero puedes descomentar las líneas correspondientes para usar la temperatura en grados Fahrenheit. Entonces, también deberías ajustar el valor umbral para que coincida con tus unidades de temperatura.
Después, hay una condición que comprueba si el valor actual de temperatura está por encima del umbral definido y si no se ha enviado un SMS de alerta.
if((temperature > temperatureThreshold) && !smsSent){
Si esa condición es verdadera, se envía un SMS diciendo “Temperature above threshold: ” y el valor actual de temperatura.
Como puedes ver, para enviar un mensaje de texto, usas el método sendSMS() en el objeto modem. Solo necesitas pasar como argumentos el número de teléfono al que quieres enviar el SMS y el contenido del mensaje.
Después de enviar el mensaje, se establece la variable smsSent a true para evitar múltiples alertas por SMS por el mismo umbral alcanzado.
Cuando la temperatura baja por debajo del umbral, también recibimos un SMS. Esta vez, se establece la variable smsSent a false, para que dejemos de recibir mensajes por debajo del umbral.
Estas condiciones se comprueban cada 5 segundos, pero puedes cambiar el tiempo de delay.
Subir el código
Después de insertar el número de teléfono del destinatario y el código PIN de la tarjeta SIM, sube el sketch a tu ESP32. Ve a Herramientas > Placa y selecciona ESP32 Dev Module. Después, ve a Herramientas > Puerto y selecciona el puerto COM al que está conectado el ESP32. Después, pulsa el botón de subir. Después de unos segundos, el código debería subirse con éxito.
También puedes abrir el Monitor Serie a 115200 baudios para ver las lecturas actuales del sensor.
Si pongo mi dedo encima del sensor, la temperatura empezará a aumentar. Cuando supere los 28 ºC, se envía un SMS. Cuando la temperatura baje por debajo del umbral, recibiré otro SMS.
Conclusión: lo que has aprendido
Con este proyecto has aprendido cómo enviar SMS con el módulo T-Call ESP32 SIM800L. Ahora puedes usar este proyecto en una aplicación real y dejarlo enviando notificaciones por SMS cuando se alcance el valor umbral o enviar SMS con lecturas de sensores cada hora, por ejemplo.
Para hacer este proyecto alimentado por batería, recomiendo usar el modo deep sleep y despertar el ESP32 cada hora para comprobar la temperatura actual, porque si usas el código de este proyecto agotarás la batería rápidamente. La combinación de deep sleep + SIM800L es la base de los sistemas de monitorización remota autónomos, capaces de funcionar durante meses en ubicaciones sin cobertura Wi-Fi ni acceso a la red eléctrica.
El T-Call ESP32 SIM800L es la herramienta perfecta para proyectos IoT en campo abierto, zonas rurales o cualquier lugar sin infraestructura de red. Combinado con sensores de todo tipo, puede construir sistemas de alerta temprana, monitorización agrícola, seguimiento de activos o cualquier aplicación donde la conectividad celular sea la única opción viable.
Este artículo queda listo para publicar sin imágenes, con las descripciones de la placa, el sensor, la antena y las demostraciones convertidas en texto explicativo. Cuando quieras, pásame el siguiente. 🚀
Descubre más desde CIBERED
Suscríbete y recibe las últimas entradas en tu correo electrónico.