¿Te imaginas poder enviar datos a la nube sin necesidad de una conexión WiFi? Con la tecnología de la TTGO T-Call ESP32 SIM800L ahora es posible. En este artículo te mostraremos cómo esta plataforma revolucionaria permite a los usuarios publicar datos en la nube de forma eficiente y sin complicaciones. ¡Descubre más sobre esta increíble innovación en el mundo de la tecnología!
Este proyecto muestra cómo conectar la placa TTGO T-Call ESP32 SIM800L a Internet usando un plan de datos de tarjeta SIM y publicar datos en la nube sin usar WiFi. Programaremos esta placa usando Arduino IDE.
Mira el vídeotutorial
Puede ver el video tutorial o seguir leyendo para obtener instrucciones completas del proyecto.
Presentamos el TTGO T-Call ESP32 SIM800L
El TTGO T-Call es una nueva placa de desarrollo ESP32 que combina un módulo GSM/GPRS SIM800L. Puedes conseguirlo por unos 11$..
Además de Wi-Fi y Bluetooth, también puedes comunicarte con esta placa ESP32 mediante SMS o llamada telefónica y conectarla a Internet utilizando el plan de datos de tu tarjeta SIM. Esto es ideal para proyectos de IoT que no tienen acceso a un enrutador cercano.
Importante: El SIM800L funciona en redes 2G y, por lo tanto, solo funcionará en su país si hay redes 2G disponibles. Comprueba si tienes una red 2G en tu país, de lo contrario no funcionará.
Para utilizar las funciones de esta placa, necesitará una tarjeta nano SIM con un plan de datos y un cable USB-C para cargar el código al tablero.
Viene con algunos cabezales de pines, un conector de batería y una antena externa que debes conectar a tu placa.
Sin embargo, como tuvimos algunos problemas con esta antena, decidimos cambiar a otro tipo de antena y todos los problemas se solucionaron. La siguiente imagen muestra la nueva antena.
Descripción del proyecto
La idea de este proyecto es publicar datos de sensores desde cualquier lugar a cualquier servicio en la nube. El ESP32 no necesita tener acceso WiFi a un router ya que nos conectamos a internet mediante un plan de datos de una tarjeta SIM.
En un proyecto anterior, creamos nuestro propio dominio de servidor con una base de datos para mostrar los valores de los sensores en gráficos a los que puede acceder desde cualquier parte del mundo.
En este proyecto publicamos los valores de los sensores en este servidor. También puedes publicar las lecturas de tus sensores en cualquier otro servicio como ThingSpeak, IFTTT, etc.
Si desea realizar este proyecto exacto, primero debe seguir el tutorial anterior para preparar su propio dominio de servidor. Luego cargue el código proporcionado en este proyecto a su placa ESP32.
En resumen, el proyecto funciona de la siguiente manera:
- La placa T-Call ESP32 SIM800L está en modo de suspensión profunda.
- Se activa y se conecta a Internet utilizando el plan de datos de tu tarjeta SIM.
- Publica los valores del sensor en el servidor y vuelve a dormir.
En nuestro ejemplo, el tiempo de descanso es de 60 minutos, pero puedes cambiarlo fácilmente en el código.
Nosotros utilizamos un sensor BME280, pero puedes utilizar cualquier otro sensor que mejor se adapte a tus necesidades.
Proveedor de alojamiento
Si no tiene una cuenta de hosting, le recomiendo que se registre en Bluehost, ya que pueden satisfacer todas las necesidades del proyecto. Si no tiene una cuenta de hosting, me encantaría que se registrara en Bluehost usando mi enlace. Esto no le cuesta nada extra y respalda nuestro trabajo.
Obtenga alojamiento y nombres de dominio en Bluehost »
requisitos
1. IDE Arduino complementario ESP32
Programamos el ESP32 con Arduino IDE. Por lo tanto, debes tener el complemento ESP32 instalado en tu IDE de Arduino. Sigue el siguiente tutorial si aún no lo has hecho.
- Instalación de la placa ESP32 en el IDE Arduino (Windows, Mac OS X, Linux)
2. Prepare el dominio de su servidor
En este proyecto le mostraremos cómo publicar datos en cualquier servicio en la nube. Usamos nuestro propio dominio de servidor con una base de datos para publicar todos los datos, pero también puedes usar cualquier otro servicio como ThingSpeak, IFTTT, etc.
Si desea hacer este proyecto exacto, debe seguir el siguiente tutorial para preparar su propio dominio de servidor.
- Visualiza los valores de tus sensores desde cualquier parte del mundo (ESP32 + MySQL + PHP)
3. Tarjeta SIM con plan de datos
Para utilizar la placa TTGO T-Call ESP32 SIM800L, necesita una tarjeta nano SIM con un plan de datos. Recomendamos usar una tarjeta SIM con un plan prepago o mensual para que sepas exactamente cuánto gastarás.
4. Detalles de APN
Para conectar su tarjeta SIM a Internet, necesita los detalles de APN de su proveedor de telefonía móvil. Necesitará el nombre de dominio, el nombre de usuario y una contraseña.
En mi caso uso Vodafone Portugal. Si usted está buscando Configuración GPRS APN seguido del nombre de su operador de telefonía móvil (en mi caso: “GPRS APN Vodafone Portugal“), normalmente puedes encontrar toda la información que necesitas en un foro o en el sitio web.
He encontrado Este sitio web Esto puede resultar muy útil para encontrar toda la información que necesita.
Si no utiliza un proveedor conocido, puede resultar un poco difícil descifrar los detalles. Por lo tanto, es posible que deba comunicarse directamente con el proveedor.
5. Bibliotecas
Necesita instalar estas bibliotecas para continuar con este proyecto: Adafruit_BME280, Adafruit_Sensor Y PequeñoGSM. Siga las siguientes instrucciones para instalar estas bibliotecas.
Instalación de la biblioteca Adafruit BME280
Abra su IDE de Arduino y vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas. El administrador de la biblioteca debería abrirse.
Buscar «Adafruit BME280 ”en el campo de búsqueda e instale la biblioteca.
Instalación de la biblioteca de sensores de Adafruit
Para utilizar la biblioteca BME280, también debe tener la Biblioteca Adafruit_SensorSiga los siguientes pasos para instalar la biblioteca en su IDE de Arduino:
Ir a Bosquejo > incluir biblioteca > Administrar bibliotecas y escribe “Sensor unificado de Adafruit”en el campo de búsqueda. Desplácese hacia abajo para buscar e instalar la biblioteca.
Instalación de la biblioteca TinyGSM
Buscar en el Administrador de bibliotecas Arduino IDE PequeñoGSM. Seleccione la biblioteca TinyGSM de Volodymyr Shymanskyy.
Después de instalar las bibliotecas, reinicie su IDE de Arduino.
Piezas requeridas
Para crear este proyecto necesitarás las siguientes partes:
- TTGO T-Call ESP32 SIM800L
- cable USB-C
- antena (Opcional)
- Módulo de sensores BME280 (Instrucciones para BME280 con ESP32)
- tablero de circuitos
- Cables de puente
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Representación esquemática
Conecte el BME280 a la placa T-Call ESP32 SIM800L como se muestra en el diagrama de cableado a continuación.
Conectamos el pin SDA a GPIO18 y el pin SCL GPIO 19. No utilizamos los GPIO I2C estándar, ya que los utiliza el IC de administración de energía de la batería de la placa T-Call ESP32 SIM800L.
código
Copie el siguiente código en su IDE de Arduino, pero no lo cargue todavía. Primero necesitas hacer algunos cambios para que funcione.
/*
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp32-sim800l-publish-data-to-cloud/
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
// Your GPRS credentials (leave empty, if not needed)
const char apn[] = ""; // APN (example: internet.vodafone.pt) use https://wiki.apnchanger.org
const char gprsUser[] = ""; // GPRS User
const char gprsPass[] = ""; // GPRS Password
// SIM card PIN (leave empty, if not defined)
const char simPIN[] = "";
// Server details
// The server variable can be just a domain name or it can have a subdomain. It depends on the service you are using
const char server[] = "example.com"; // domain name: example.com, maker.ifttt.com, etc
const char resource[] = "/post-data.php"; // resource path, for example: /post-data.php
const int port = 80; // server port number
// Keep this API Key value to be compatible with the PHP code provided in the project page.
// If you change the apiKeyValue value, the PHP file /post-data.php also needs to have the same key
String apiKeyValue = "tPmAT5Ab3j7F9";
// TTGO T-Call pins
#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
// BME280 pins
#define I2C_SDA_2 18
#define I2C_SCL_2 19
// Set serial for debug console (to Serial Monitor, default speed 115200)
#define SerialMon Serial
// Set serial for AT commands (to SIM800 module)
#define SerialAT Serial1
// Configure TinyGSM library
#define TINY_GSM_MODEM_SIM800 // Modem is SIM800
#define TINY_GSM_RX_BUFFER 1024 // Set RX buffer to 1Kb
// Define the serial console for debug prints, if needed
//#define DUMP_AT_COMMANDS
#include <Wire.h>
#include <TinyGsmClient.h>
#ifdef DUMP_AT_COMMANDS
#include <StreamDebugger.h>
StreamDebugger debugger(SerialAT, SerialMon);
TinyGsm modem(debugger);
#else
TinyGsm modem(SerialAT);
#endif
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
// I2C for SIM800 (to keep it running when powered from battery)
TwoWire I2CPower = TwoWire(0);
// I2C for BME280 sensor
TwoWire I2CBME = TwoWire(1);
Adafruit_BME280 bme;
// TinyGSM Client for Internet connection
TinyGsmClient client(modem);
#define uS_TO_S_FACTOR 1000000UL /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP 3600 /* Time ESP32 will go to sleep (in seconds) 3600 seconds = 1 hour */
#define IP5306_ADDR 0x75
#define IP5306_REG_SYS_CTL0 0x00
bool setPowerBoostKeepOn(int en){
I2CPower.beginTransmission(IP5306_ADDR);
I2CPower.write(IP5306_REG_SYS_CTL0);
if (en) {
I2CPower.write(0x37); // Set bit1: 1 enable 0 disable boost keep on
} else {
I2CPower.write(0x35); // 0x37 is default reg value
}
return I2CPower.endTransmission() == 0;
}
void setup() {
// Set serial monitor debugging window baud rate to 115200
SerialMon.begin(115200);
// Start I2C communication
I2CPower.begin(I2C_SDA, I2C_SCL, 400000);
I2CBME.begin(I2C_SDA_2, I2C_SCL_2, 400000);
// Keep power when running from battery
bool isOk = setPowerBoostKeepOn(1);
SerialMon.println(String("IP5306 KeepOn ") + (isOk ? "OK" : "FAIL"));
// Set modem reset, enable, power pins
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);
// Set GSM module baud rate and UART pins
SerialAT.begin(115200, SERIAL_8N1, MODEM_RX, MODEM_TX);
delay(3000);
// Restart SIM800 module, it takes quite some time
// To skip it, call init() instead of restart()
SerialMon.println("Initializing modem...");
modem.restart();
// use modem.init() if you don't need the complete restart
// Unlock your SIM card with a PIN if needed
if (strlen(simPIN) && modem.getSimStatus() != 3 ) {
modem.simUnlock(simPIN);
}
// You might need to change the BME280 I2C address, in our case it's 0x76
if (!bme.begin(0x76, &I2CBME)) {
Serial.println("Could not find a valid BME280 sensor, check wiring!");
while (1);
}
// Configure the wake up source as timer wake up
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
}
void loop() {
SerialMon.print("Connecting to APN: ");
SerialMon.print(apn);
if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
SerialMon.println(" fail");
}
else {
SerialMon.println(" OK");
SerialMon.print("Connecting to ");
SerialMon.print(server);
if (!client.connect(server, port)) {
SerialMon.println(" fail");
}
else {
SerialMon.println(" OK");
// Making an HTTP POST request
SerialMon.println("Performing HTTP POST request...");
// Prepare your HTTP POST request data (Temperature in Celsius degrees)
String httpRequestData = "api_key=" + apiKeyValue + "&value1=" + String(bme.readTemperature())
+ "&value2=" + String(bme.readHumidity()) + "&value3=" + String(bme.readPressure()/100.0F) + "";
// Prepare your HTTP POST request data (Temperature in Fahrenheit degrees)
//String httpRequestData = "api_key=" + apiKeyValue + "&value1=" + String(1.8 * bme.readTemperature() + 32)
// + "&value2=" + String(bme.readHumidity()) + "&value3=" + String(bme.readPressure()/100.0F) + "";
// You can comment the httpRequestData variable above
// then, use the httpRequestData variable below (for testing purposes without the BME280 sensor)
//String httpRequestData = "api_key=tPmAT5Ab3j7F9&value1=24.75&value2=49.54&value3=1005.14";
client.print(String("POST ") + resource + " HTTP/1.1rn");
client.print(String("Host: ") + server + "rn");
client.println("Connection: close");
client.println("Content-Type: application/x-www-form-urlencoded");
client.print("Content-Length: ");
client.println(httpRequestData.length());
client.println();
client.println(httpRequestData);
unsigned long timeout = millis();
while (client.connected() && millis() - timeout < 10000L) {
// Print available data (HTTP response from server)
while (client.available()) {
char c = client.read();
SerialMon.print(c);
timeout = millis();
}
}
SerialMon.println();
// Close client and disconnect
client.stop();
SerialMon.println(F("Server disconnected"));
modem.gprsDisconnect();
SerialMon.println(F("GPRS disconnected"));
}
}
// Put ESP32 into deep sleep mode (with timer wake up)
esp_deep_sleep_start();
}
Antes de cargar el código, debes ingresar los datos de tu APN, el PIN de la tarjeta SIM (si corresponde) y el dominio de tu servidor.
Importante: La mayoría de los servicios de hosting requieren solicitudes HTTPS. este codigo no es compatible con HTTPS. Para que funcione, debe deshabilitar HTTPS en su servidor o habilitar HTTP y HTTPS (comuníquese con su proveedor de alojamiento). Aunque esta placa admite solicitudes HTTPS, no pudimos hacerla funcionar. Aún puedes probar este boceto de ejemplo y ver si realizar solicitudes HTTPS funciona para tu tablero: Cliente HTTPS SIM800L.
Cómo funciona el código
Ingrese sus credenciales GPRS APN en las siguientes variables:
const char apn[] = ""; // APN (example: internet.vodafone.pt) use https://wiki.apnchanger.org
const char gprsUser[] = ""; // GPRS User
const char gprsPass[] = ""; // GPRS Password
En nuestro caso el APN es internet.vodafone.pt. El tuyo debería ser diferente. Anteriormente explicamos cómo obtener los detalles de su APN en este tutorial.
Si es necesario, ingresa el PIN de tu tarjeta SIM:
const char simPIN[] = "";
También debe ingresar los detalles del servidor en las siguientes variables. Puede ser su propio dominio de servidor u otro servidor donde desee publicar datos.
const char server[] = "example.com"; // domain name: example.com, maker.ifttt.com, etc
const char resource[] = "/post-data.php"; // resource path, for example: /post-data.php
const int port = 80; // server port number
Si utiliza su propio dominio de servidor como en este tutorial, también necesitará una clave API. En este caso Valor de clave API es solo una cadena aleatoria que puedes cambiar. Se utiliza por razones de seguridad para que solo alguien que conozca su clave API pueda publicar datos en su base de datos.
El código está ampliamente comentado para que comprenda el propósito de cada línea de código.
Las siguientes líneas definen los pines utilizados por el módulo SIM800L:
#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
Defina los pines I2C del BME280. En este ejemplo, no utilizamos los pines estándar porque ya los utiliza el IC de administración de energía de la batería de la placa T-Call ESP32 SIM800L. Entonces usamos GPIO 18 Y GPIO 19.
#define I2C_SDA_2 18
#define I2C_SCL_2 19
Defina una comunicación serial para el monitor serial y otra para la comunicación con el módulo SIM800L:
// Set serial for debug console (to Serial Monitor, default speed 115200)
#define SerialMon Serial
// Set serial for AT commands (to SIM800 module)
#define SerialAT Serial1
Configurar el PequeñoGSM Biblioteca para trabajar con el módulo SIM800L.
// Configure TinyGSM library
#define TINY_GSM_MODEM_SIM800 // Modem is SIM800
#define TINY_GSM_RX_BUFFER 1024 // Set RX buffer to 1Kb
Incluya las siguientes bibliotecas para comunicarse con el SIM800L.
#include <Wire.h>
#include <TinyGsmClient.h>
Y estas bibliotecas para usar el sensor BME280:
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
Cree una instancia de comunicación I2C para el SIM800L.
TwoWire I2CPower = TwoWire(0);
Y otra comunicación I2C para el sensor BME280.
TwoWire I2CBME = TwoWire(1);
Adafruit_BME280 bme;
Inicializar uno Cliente TinyGSM para la conexión a internet.
TinyGsmClient client(modem);
Definir el tiempo de sueño profundo en HORA DE DORMIR variable en segundos.
#define uS_TO_S_FACTOR 1000000 /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP 3600 /* Time ESP32 will go to sleep (in seconds) 3600 seconds = 1 hour */
En el configuración()inicialice el monitor serie con una velocidad de baudios de 115200:
SerialMon.begin(115200);
Inicie la comunicación I2C para el módulo SIM800L y para el módulo de sensor BME280:
I2CPower.begin(I2C_SDA, I2C_SCL, 400000);
I2CBME.begin(I2C_SDA_2, I2C_SCL_2, 400000);
Configure los pines SIM800L en el estado correcto para su funcionamiento:
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);
Inicializar la comunicación serial con el módulo SIM800L
SerialAT.begin(115200, SERIAL_8N1, MODEM_RX, MODEM_TX);
Inicialice el módulo SIM800L y desbloquee el PIN de la tarjeta SIM si es necesario
SerialMon.println("Initializing modem...");
modem.restart();
// use modem.init() if you don't need the complete restart
// Unlock your SIM card with a PIN if needed
if (strlen(simPIN) && modem.getSimStatus() != 3 ) {
modem.simUnlock(simPIN);
}
Inicialice el módulo del sensor BME280:
if (!bme.begin(0x76, &I2CBME)) {
Serial.println("Could not find a valid BME280 sensor, check wiring!");
while (1);
}
Configure el sueño profundo como fuente de vigilia:
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
Recomendaciones de literatura: Fuentes ESP32 Deep Sleep y Wake Up
En el Cinta() es donde realmente nos conectamos a Internet y realizamos la solicitud HTTP POST para publicar los datos del sensor. Desde el ESP32 al final del Cinta()sólo se ejecuta una vez.
Las siguientes líneas conectan el módulo a Internet:
SerialMon.print("Connecting to APN: ");
SerialMon.print(apn);
if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
SerialMon.println(" fail");
}
else {
SerialMon.println(" OK");
SerialMon.print("Connecting to ");
SerialMon.print(server);
if (!client.connect(server, port)) {
SerialMon.println(" fail");
}
else {
SerialMon.println(" OK");
Preparar los datos del mensaje para enviarlos mediante una solicitud HTTP POST
String httpRequestData = "api_key=" + apiKeyValue + "&value1=" + String(bme.readTemperature())
+ "&value2=" + String(bme.readHumidity()) + "&value3=" + String(bme.readPressure()/100.0F) + "";
Básicamente creamos una cadena con el valor de la clave API y todos los valores del sensor. Debes cambiar esta cadena dependiendo de los datos que quieras enviar.
Las siguientes líneas ejecutan la solicitud POST.
client.print(String("POST ") + resource + " HTTP/1.1rn");
client.print(String("Host: ") + server + "rn");
client.println("Connection: close");
client.println("Content-Type: application/x-www-form-urlencoded");
client.print("Content-Length: ");
client.println(httpRequestData.length());
client.println();
client.println(httpRequestData);
unsigned long timeout = millis();
while (client.connected() && millis() - timeout < 10000L) {
// Print available data (HTTP response from server)
while (client.available()) {
char c = client.read();
SerialMon.print(c);
timeout = millis();
}
}
Finalmente, cierra la conexión y desconéctate de Internet.
client.stop();
SerialMon.println(F("Server disconnected"));
modem.gprsDisconnect();
SerialMon.println(F("GPRS disconnected"));
Finalmente, ponga el ESP32 en modo de suspensión profunda.
esp_deep_sleep_start();
Sube el código
Después de ingresar toda la información requerida, puede cargar el código en su tablero.
Para cargar el código en tu tablero, ve a Herramientas > tablón y elige Módulo de desarrollo ESP32. Ir a Herramientas > Puerto y seleccione el puerto COM al que está conectada su placa. Finalmente, haga clic en el botón «Cargar» para cargar el código en su tablero.
Nota: Actualmente no existe una placa para el T-Call ESP32 SIM800L, pero seleccionamos el módulo de desarrollo ESP32 y funciona perfectamente.
demostración
Abra el monitor serie con una velocidad de baudios de 115200 y presione el botón RST en la placa.
Primero se inicializa el módulo y luego intenta conectarse a Internet. Tenga en cuenta que esto puede llevar algún tiempo (en algunos casos, la solicitud tardó casi 1 minuto en completarse).
Después de conectarse a Internet, se conectará a su servidor para realizar la solicitud HTTP POST.
Finalmente se desconecta la conexión al servidor e Internet y se activa la hibernación.
En este ejemplo, se publican nuevos valores de sensores cada 60 minutos. Sin embargo, también puede utilizar un retraso más corto para realizar pruebas.
Luego abra un navegador e ingrese el dominio de su servidor en el campo /esp-chart.php URL. Deberías ver los gráficos con las últimas lecturas de los sensores.
Solución de problemas
Si no puede conectar su módulo a Internet en este momento, puede deberse a una de las siguientes razones:
- Las credenciales de APN pueden ser incorrectas;
- Es posible que la antena no esté funcionando correctamente. En nuestro caso tuvimos que sustituir la antena.
- Es posible que deba salir para obtener una mejor cobertura de señal.
- O es posible que no esté proporcionando suficiente energía al módulo. Si conecta el módulo a su computadora a través de un concentrador USB sin alimentación externa, es posible que no proporcione suficiente energía para funcionar.
Envolver
Esperamos que hayas disfrutado de este proyecto. En nuestra opinion Placa T-Call SIM800 ESP32 Puede resultar muy útil para proyectos de IoT que no tienen acceso WiFi a un enrutador cercano. Puede conectar fácilmente su placa a Internet utilizando un plan de datos de tarjeta SIM.
Pronto publicaremos más proyectos en este foro (como enviar notificaciones por SMS, solicitar datos por SMS, etc.), ¡así que estad atentos!
También te puede interesar…
- $11 TTGO T-Call ESP32 con SIM800L GSM/GPRS (revisión detallada)
- Inserte datos ESP32/ESP8266 en la base de datos MySQL usando PHP y Arduino IDE
- ESP32/ESP8266 muestra los valores del sensor en gráficos en tiempo real – servidor web
- Servidor web ESP32 con BME280 – Estación meteorológica avanzada
Obtenga más información sobre el ESP32 con nuestros recursos:
- Aprende ESP32 con Arduino IDE (Curso)
- Programación MicroPython con ESP32 y ESP8266 (libro electrónico)
- Más proyectos y tutoriales de ESP32
Gracias por leer.
Publicación de datos en la nube con el TTGO T-Call ESP32 SIM800L sin WiFi
Este proyecto muestra cómo conectar la placa TTGO T-Call ESP32 SIM800L a Internet utilizando un plan de datos de tarjeta SIM y publicar datos en la nube sin usar Wi-Fi. Programaremos esta placa con Arduino IDE.
Video Tutorial
Puedes ver el tutorial en video o continuar leyendo para ver las instrucciones completas del proyecto.
Introducción al TTGO T-Call ESP32 SIM800L
El TTGO T-Call es una nueva placa de desarrollo ESP32 que combina un módulo GSM/GPRS SIM800L. Puedes conseguirla por aproximadamente $11.
Aspectos Importantes
La placa TTGO T-Call permite la comunicación a través de SMS o llamadas telefónicas y se puede conectar a Internet utilizando tu plan de datos de tarjeta SIM. Es ideal para proyectos de IoT que no tienen acceso a un enrutador cercano.
Es importante tener en cuenta que el SIM800L funciona en redes 2G, por lo que solo funcionará en tu país si hay redes 2G disponibles. Asegúrate de verificar si hay redes 2G en tu país antes de usarlo.
Resumen del Proyecto
La idea de este proyecto es publicar los datos del sensor desde cualquier lugar a cualquier servicio en la nube que desees. El ESP32 no necesita tener acceso a un enrutador a través de Wi-Fi, ya que nos conectaremos a Internet utilizando un plan de datos de tarjeta SIM.
En este proyecto, publicaremos lecturas de sensores en un servidor. Puedes publicar tus lecturas de sensor en cualquier otro servicio, como ThingSpeak, IFTTT, etc.
Proveedor de Hospedaje
Si no tienes una cuenta de hospedaje, te recomiendo registrarte en Bluehost, ya que pueden manejar todos los requisitos del proyecto. Si no tienes una cuenta de hospedaje, agradecería que te registres en Bluehost usando mi enlace. Lo cual no te cuesta nada extra y ayuda a apoyar nuestro trabajo.
Requisitos Previos
- Arduino IDE con complemento ESP32: Necesitarás tener el complemento ESP32 instalado en tu Arduino IDE para programarlo. Sigue el siguiente tutorial si aún no lo has hecho.
- Preparar tu Dominio de Servidor: En este proyecto te mostraremos cómo publicar datos en cualquier servicio en la nube. Estaremos utilizando nuestro propio dominio de servidor con una base de datos para publicar todos los datos, pero puedes usar cualquier otro servicio como ThingSpeak, IFTTT, etc.
- Tarjeta SIM con plan de datos: Para usar la placa TTGO T-Call ESP32 SIM800L, necesitas una tarjeta SIM nano con un plan de datos.
- Detalles de APN: Para conectar tu tarjeta SIM a Internet, necesitas tener los detalles de APN de tu proveedor de plan telefónico.
- Librerías: Debes instalar las librerías Adafruit_BME280, Adafruit_Sensor y TinyGSM para proceder con este proyecto.
Diagrama Esquemático
Conecta el BME280 a la placa TTGO T-Call ESP32 SIM800L como se muestra en el siguiente diagrama esquemático.
Estamos conectando el pin SDA a GPIO 18 y el pin SCL a GPIO 19. No estamos utilizando los pines I2C predeterminados porque están siendo utilizados por el IC de administración de energía de la batería de la placa TTGO T-Call ESP32 SIM800L.
Código
Copia el siguiente código a tu Arduino IDE pero no lo cargues aún. Primero necesitas hacer algunas modificaciones para que funcione. Encuentra el código completo aquí.
Cómo Funciona el Código
Inserta tus credenciales APN de GPRS, PIN de la tarjeta SIM (si corresponde) y el dominio de servidor en el código. Las líneas del código están detalladamente comentadas para que entiendas el propósito de cada una.
Subir el Código
Después de insertar todos los detalles necesarios, puedes cargar el código en tu placa. Selecciona la placa ESP32 Dev Module y el puerto COM al que está conectada tu placa. Presiona el botón de carga para subir el código a tu placa.
Demostración
Abre el Monitor Serie a una velocidad de baudios de 115200 y presiona el botón RST de la placa. Verás en el monitor el proceso de inicialización, conexión a Internet, solicitud HTTP, desconexión y posterior suspensión profunda.
Resolución de Problemas
Si tienes problemas para que tu módulo se conecte a Internet, puede deberse a varias razones como credenciales APN incorrectas, antena defectuosa, señal débil o suministro insuficiente de corriente.
Nota: en este momento, no hay una placa específica para la T-Call ESP32 SIM800L, pero hemos seleccionado la ESP32 Dev Module y ha funcionado bien.
Esperamos que te haya gustado este proyecto y que te sea de utilidad para tus proyectos de IoT. ¡Mantente atento a más proyectos relacionados con esta placa!