Banner publicitario de PCBWay

Tutorial TelegramBot

torres.electronico

torres.electronico

Well-known-Alfil
No soy muy partidario de depender de conexiones a internet para tener control sobre las cosas, dado que te hace esclavo de una condición, y si no hay conexión, te quedas sin poder hacer nada... Pero estoy haciendo a modo hobbie un sistema de seguridad donde en un grupo de Telegram, mi grupo familiar puede ver video o sacar fotos con un esp32 cam (el video solo se puede ver dentro de la misma red wifi), activar/desactivar una central de alarma armada con un esp8266 con un teclado 12c, un relay que controla una sirena y dos esp01 con sensor magnético para verificar apertura de dos puertas... en paralelo le sume comandos para ver estado de batería de los esp01 y sirena de pánico....

tutorialTelegramBot_1.png tutorialTelegramBot_2.png tutorialTelegramBot_3.png tutorialTelegramBot_4.png

Es largo el proyecto y me ayudo a matar esas noches de insomnio que tengo; Así que para darles una base de como pueden hacer algo similar ustedes, arranco con este minitutorial de como trabajar la librería "TelegramBot"...
En este ejemplo, la idea general es:

-Tenemos tres ESP8266 que comparten el mismo token y chat_id Telegram (ESP8266_1,ESP8266_2 y ESP8266_3)-
-Cada ESP8266 tiene un pulsador, y una de estas placas (el ESP8266_3) tiene un relay además del pulsador, a diferencia del resto.
-Cuando un pulsador sea presionado en cualquiera de los ESP8266 se envía un mensaje Telegram indicando encendido/apagado.
-El ESP8266_3 que tiene un relay escucha esos comandos (por Telegram o pulsadores) y activa/desactiva el relay.
-También se pueden usar comandos via Telegram /encender y /apagar para controlar el relay.
-En caso de que se caiga la conexión de internet y no podamos implementar Telegram, automáticamente seguimos funcionando por intermedio de la red wifi internamente...

Paso 1: Librerías y configuración inicial común a los 3 ESP8266
CSS: 
#include <ESP8266WiFi.h>         // Permite conectar el ESP8266 a WiFi.
#include <WiFiUdp.h>             // Permite enviar/recibir mensajes UDP en red local.
#include <WiFiClientSecure.h>    // Permite conexiones seguras (usadas por Telegram).
#include <TelegramBot.h>         // Permite comunicar con el bot de Telegram.

// Configuración WiFi (nombre de red y clave, igual en todos los ESP).
const char* ssid = "TU_SSID";           // Cambia por el nombre de tu red WiFi.
const char* password = "TU_PASSWORD";   // Cambia por la clave de tu red.

// Telegram: token y chat_id (son iguales para todos los ESP).
#define BOTtoken "TU_BOT_TOKEN"         // Token de tu bot Telegram (BotFather).
#define CHAT_ID "TU_CHAT_ID"            // chat_id para enviar/recibir mensajes de Telegram.

// Cliente seguro para Telegram (comunicación cifrada).
WiFiClientSecure client;
TelegramBot bot(BOTtoken, client);      // Instancia de la librería TelegramBot con tu token.

// UDP: configuración para la red local.
WiFiUDP udp;                            // Instancia UDP para enviar mensajes localmente.
const unsigned int localUdpPort = 4210; // Puerto que usarán todos los ESP para UDP (4210 recomendado).

// Dirección IP de ESP con relay, IP fija (modifica según tu red y device).
IPAddress relayIP(192, 168, 1, 100);    // IP fija del ESP8266_3, el único que controla relay.

// Pulsador, configurado en todos (pin puede cambiar según tu conexión).
const int buttonPin = D1;               // Pin físico donde conectás el pulsador.
bool lastButtonState = HIGH;            // Estado anterior del pulsador (para detectar cambios).

// Variable relay solo en el ESP con relay.
bool relayState = false;                // Estado lógico del relay: false=apagado.

// Solo en ESP con relay se habilita este pin.
#ifdef RELAY_DEVICE
const int relayPin = D2;                // Pin físico del relay (D2 ejemplo).
#endif

Paso 2: setup() - Inicialización hardware, red, UDP y relay si aplica
CSS: 
void setup()
  {
  Serial.begin(115200);                     // Inicia comunicación serie para ver mensajes de depuración.
  pinMode(buttonPin, INPUT_PULLUP);         // Configura el pin del pulsador en modo entrada con resistencia Pullup (estabilidad y evita falsos positivos).
 
  #ifdef RELAY_DEVICE                       // Sólo en ESP con relay:
  pinMode(relayPin, OUTPUT);              // Configura el pin del relay como salida digital.
  digitalWrite(relayPin, LOW);            // Relay inicia apagado.
  relayState = false;                     // Variable inicia apagado.
  #endif

  #ifdef ESP8266
  client.setInsecure();                   // Permite ignorar certificados SSL (Telegram), necesario en ESP8266, simplifica conexión.
  #endif

  // Antes de conectar WiFi, asigna IP fija:
  IPAddress local_IP(192, 168, 1, xxx);     // Cambia xxx por 100 (relay), 101 (ESP1) ó 102 (ESP2) según el equipo.
  IPAddress gateway(192, 168, 1, 1);        // Dirección del router/gateway.
  IPAddress subnet(255, 255, 255, 0);       // Máscara de subred (común).
  IPAddress dns(8, 8, 8, 8);                // DNS de Google (puede cambiarse).

  WiFi.config(local_IP, gateway, subnet, dns); // Asigna IP fija antes de conectar.
  WiFi.begin(ssid, password);                  // Inicia conexión WiFi.

  while (WiFi.status() != WL_CONNECTED)        // Espera hasta conectarse a la red.
       {   
        delay(500);                            // Espera medio segundo.
        Serial.print(".");                     // Muestra puntos de progreso en Serial.
       }
  Serial.println("\nWiFi conectado");         // Muestra mensaje una vez conectado.
  Serial.print("IP asignada: ");              // Muestra IP local por Serial.
  Serial.println(WiFi.localIP());

  udp.begin(localUdpPort);                    // Inicia comunicación UDP en el puerto definido.
  Serial.println("UDP iniciado en puerto " + String(localUdpPort)); // Mensaje de confirmación.
  }

Paso 3: Función para enviar mensajes UDP al ESP con relay (ESP8266_1 y ESP8266_2)
CSS: 
void sendUdpCommand(const char* cmd)
   {
    udp.beginPacket(relayIP, localUdpPort);         // Prepara el envío a la IP (ESP con relay) y el puerto UDP.
    udp.write((const uint8_t*)cmd, strlen(cmd));    // Escribe el comando (string) en el paquete UDP.
    udp.endPacket();                                // Finaliza y envía el paquete UDP por la red.
    Serial.println("Enviado UDP: " + String(cmd));  // Muestra por Serial el comando enviado.
   }

Paso 4: Función para leer y procesar mensajes UDP recibidos (solo ESP con relay)
CSS: 
void checkUdpMessages()
  {
   int packetSize = udp.parsePacket();          // Verifica si llegó un paquete UDP.
   if (packetSize)                              // Si hay datos recibidos...
      {                         
       char incomingPacket[255];                  // Buffer para el comando recibido.
       int len = udp.read(incomingPacket, 255);   // Lee el contenido del paquete UDP.
       if (len > 0) incomingPacket[len] = 0;      // Termina el string recibido correctamente.
       String cmd = String(incomingPacket);       // Convierte a tipo String para comparaciones.
       Serial.println("Recibido UDP: " + cmd);    // Muestra el comando recibido.
       if (cmd == "ENCENDER")
          {
           setRelay(true);                        // Si el comando es "ENCENDER", activa el relay.
          }
        else if (cmd == "APAGAR")
          {
           setRelay(false);                       // Si es "APAGAR", apaga el relay.
          }
       }
  }

Paso 5: Función para cambiar el estado del relay (solo en ESP con relay)
CSS: 
void setRelay(bool on)
    {
     #ifdef RELAY_DEVICE                         // Solo ejecuta en ESP con relay.
     relayState = on;                          // Actualiza estado lógico interno.
     digitalWrite(relayPin, on ? HIGH : LOW);  // Cambia estado físico del relay.
     String status = on ? "encendido" : "apagado"; // Prepara texto para enviar.
     Serial.println("Relay " + status);        // Informa en consola el nuevo estado.
     bot.sendMessage(CHAT_ID, "Relay " + status); // Envía mensaje por Telegram al chat para confirmar cambio.
     #endif
    }

Paso 6: loop() - Principal: lee pulsador, envía comandos por Telegram o UDP según conexión
CSS: 
void loop()
    {
     bot.checkForNewMessages();                      // Mantiene la conexión y chequea nuevos mensajes Telegram.
     bool currentButtonState = digitalRead(buttonPin); // Lee el estado actual del pulsador.
     // Flanco descendente: pulsador presionado (transición de HIGH a LOW)
     if (lastButtonState == HIGH && currentButtonState == LOW)
        {
         // Si está conectado a WiFi y Telegram responde...
         if (WiFi.status() == WL_CONNECTED && isTelegramAvailable())
            {
             // Si relay está encendido, manda comando para apagar; si está apagado, para encender.
             if (relayState) sendTelegramCommand("/apagar");
             else sendTelegramCommand("/encender");
            }
            else
            {
             // Si no hay Telegram, usa UDP local: avisa al relay encender o apagar según su estado.
             if (relayState) sendUdpCommand("APAGAR");
             else sendUdpCommand("ENCENDER");
            }
         delay(200);                    // Delay de estabilidad (debounce del pulsador).
        }
     lastButtonState = currentButtonState; // Actualiza estado previo del pulsador.
     // Si es el ESP con relay, chequea UDP entrante por si ESP1/ESP2 envían comandos.
     #ifdef RELAY_DEVICE
     checkUdpMessages();
     #endif
     handleTelegramMessages();              // Procesa todos los comandos Telegram entrantes.
     delay(10);                            // Delay pequeño para estabilidad.
  }

Paso 7: Funciones auxiliares de Telegram
CSS: 
bool isTelegramAvailable()
    {
     // Comprueba si hay conexión real con Telegram (actualiza y verifica si hay error interno)
     int newMessages = bot.getUpdates(bot.last_message_received + 1);
     return (newMessages >= 0);        // Si no es error, hay conexión.
    }

CSS: 
// Envía mensaje de comando por Telegram
void sendTelegramCommand(const char* command)
   {
    bot.sendMessage(CHAT_ID, command);                 // Envía el comando (/encender, /apagar) al chat definido.
    Serial.println("Enviado Telegram: " + String(command)); // Muestra por consola.
   }

CSS: 
// Procesa todos los mensajes recibidos desde Telegram (por comandos /encender o /apagar)
void handleTelegramMessages()
    {
     int numNewMessages = bot.getUpdates(bot.last_message_received + 1); // Obtiene nuevos mensajes del bot de Telegram.
     while (numNewMessages) {                                            // Mientras haya mensajes...
     for (int i = 0; i < numNewMessages; i++)
         {
          String text = bot.messages[i].text;        // Extrae comando (/encender, /apagar)
          String chat_id = bot.messages[i].chat_id;  // Verifica que el chat sea el esperado.
          if (chat_id == CHAT_ID)
             {                  // Solo procesa mensajes de nuestro chat.
              if (text == "/encender")
                 {
                  setRelay(true);                        // Activa relay si el comando es /encender
                 }
              else if (text == "/apagar")
                 {
                  setRelay(false);                       // Apaga relay si el comando es /apagar
                 }
             }
          }
     numNewMessages = bot.getUpdates(bot.last_message_received + 1); // Vuelve a pedir mensajes nuevos por si hay más.
    }
  }

Notas finales y consideraciones
IP fija: Todos los ESP usan siempre la misma IP (ejemplo: ESP8266_1 → 192.168.1.101, ESP8266_2 → 192.168.1.102, ESP8266_3 → 192.168.1.100).
Relay: Se controla solo en ESP8266_3 para evitar conflictos; los otros solo envían comandos (UDP o Telegram).
Telegram: Se usa cuando hay internet; si se pierde, el sistema sigue funcionando localmente por UDP.

Ejemplo completo y funcional:



ESP8266_1 (Pulsador, SIN relay)
CSS: 
// ================== ESP8266_1 ==================
// ---- 1: Librerías ----
#include <ESP8266WiFi.h>         // Maneja conexión WiFi
#include <WiFiUdp.h>             // Para enviar comandos UDP en red local
#include <WiFiClientSecure.h>    // Requerido por TelegramBot.h
#include <TelegramBot.h>         // Bot de Telegram para interactuar

// ---- 2: Configuración WiFi/IPs ----
const char* ssid = "TU_SSID";          // Cambia por tu red WiFi
const char* password = "TU_PASSWORD";  // Cambia por tu contraseña

// Asignamos IP fija al ESP8266_1
IPAddress local_IP(192, 168, 1, 101);     // IP fija de este equipo
IPAddress gateway(192, 168, 1, 1);        // IP del router/gateway
IPAddress subnet(255, 255, 255, 0);       // Máscara de subred
IPAddress dns(8, 8, 8, 8);                // DNS Google

// ---- 3: Telegram ----
#define BOTtoken "TU_BOT_TOKEN"           // Token del bot de Telegram
#define CHAT_ID "TU_CHAT_ID"              // chat_id común para todos

WiFiClientSecure client;
TelegramBot bot(BOTtoken, client);

// ---- 4: UDP (comunicación local) ----
WiFiUDP udp;
const unsigned int localUdpPort = 4210;        // Puerto UDP compartido en la red local
IPAddress relayIP(192, 168, 1, 100);           // IP fija de ESP8266_3 (el del relay)

// ---- 5: Hardware ----
const int buttonPin = D1;       // Pin físico del pulsador
bool lastButtonState = HIGH;    // Estado previo pulsador (para detectar cambio)
bool relayVirtualState = false; // Estado virtual para alternar comando enviado

// ---- 6: setup ----
void setup()
   {
    Serial.begin(115200);                       // Arranca la consola serial
    pinMode(buttonPin, INPUT_PULLUP);           // Configura pulsador con Pullup para evitar falsos
    client.setInsecure();                       // Ignora certificados para Telegram (evita errores SSL)
    WiFi.config(local_IP, gateway, subnet, dns);// Configura IP fija antes de conectar
    WiFi.begin(ssid, password);                 // Conecta al WiFi
    while (WiFi.status() != WL_CONNECTED)       // Espera hasta conectar
        {
         delay(500);
         Serial.print(".");
        }
     Serial.println("\nWiFi conectado!");
     Serial.print("IP local: ");
     Serial.println(WiFi.localIP());
     udp.begin(localUdpPort);                    // Inicia UDP
     Serial.println("UDP iniciado en puerto " + String(localUdpPort));
  }

// ---- 7: Funciones control UDP/Telegram ----
void sendUdpCommand(const char* cmd)
   {
    udp.beginPacket(relayIP, localUdpPort);               // Prepara envío al ESP con relay
    udp.write((const uint8_t*)cmd, strlen(cmd));          // Escribe comando en el paquete UDP
    udp.endPacket();                                      // Envía UDP
    Serial.println("[UDP] Comando enviado: " + String(cmd));
   }

void sendTelegramCommand(const char* command)
   {
    bot.sendMessage(CHAT_ID, command);                    // Envía comando por Telegram
    Serial.println("[Telegram] Enviado: " + String(command));
   }

// Chequea conectividad a Telegram
bool isTelegramAvailable()
   {
    int res = bot.getUpdates(bot.last_message_received + 1);
    return (res >= 0);
   }

// ---- 8: loop principal ----
void loop()
    {
     bot.checkForNewMessages();                            // Opcional: chequea mensajes
     bool currentButtonState = digitalRead(buttonPin);     // Lee pulsador
     // Flanco descendente = pulsador presionado
     if (lastButtonState == HIGH && currentButtonState == LOW)
        {
         relayVirtualState = !relayVirtualState;             // Alterna el estado virtual del relay
         if (WiFi.status() == WL_CONNECTED && isTelegramAvailable())
            {
             if (relayVirtualState) sendTelegramCommand("/encender"); // Enciende relay por Telegram
             else sendTelegramCommand("/apagar");                     // Apaga relay por Telegram
            }
            else
            {
             if (relayVirtualState) sendUdpCommand("ENCENDER");       // Enciende relay por UDP local
             else sendUdpCommand("APAGAR");                           // Apaga relay por UDP local
            }
         delay(250);                                    // Anti-rebote físico del pulsador
        }
    lastButtonState = currentButtonState;            // Acumula el estado
    delay(10);                                      // Pequeño delay
   }

ESP8266_2 (Pulsador, SIN relay)
Solo cambia la IP fija y identificador en comentarios; el resto es igual al anterior.

CSS: 
// ================== ESP8266_2 ==================
// (Idéntico a ESP8266_1 excepto IP fija)

// ---- 2: Configuración WiFi/IPs ----
IPAddress local_IP(192, 168, 1, 102);     // IP fija de este equipo (cambia el último número)

// El resto es IGUAL al anterior;
// cambias la IP fija, mantienes la misma lógica y comentarios.


CSS: 
// ================== ESP8266_3 ==================
// ---- 1: Librerías ----
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <WiFiClientSecure.h>
#include <TelegramBot.h>

// ---- 2: Configuración WiFi/IPs ----
const char* ssid = "TU_SSID";
const char* password = "TU_PASSWORD";

// IP fija de este equipo (relay principal)
IPAddress local_IP(192, 168, 1, 100);     // IP fija del ESP8266 con relay
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
IPAddress dns(8, 8, 8, 8);

// ---- 3: Telegram ----
#define BOTtoken "TU_BOT_TOKEN"
#define CHAT_ID "TU_CHAT_ID"

WiFiClientSecure client;
TelegramBot bot(BOTtoken, client);

// ---- 4: UDP ----
WiFiUDP udp;
const unsigned int localUdpPort = 4210;

// ---- 5: Hardware ----
#define RELAY_DEVICE               // Habilita el control físico del relay en este ESP
const int relayPin = D2;           // Pin físico relay
const int buttonPin = D1;          // Pin físico pulsador
bool lastButtonState = HIGH;        // Estado previo pulsador
bool relayState = false;            // Estado actual relay

// ---- 6: setup ----
void setup()
    {
     Serial.begin(115200);                                // Conexión serial
     pinMode(relayPin, OUTPUT);                           // Define pin del relay como salida
     digitalWrite(relayPin, LOW);                         // Establece relay apagado al inicio
     pinMode(buttonPin, INPUT_PULLUP);                    // Define pulsador con Pullup para evitar falsos
     client.setInsecure();                                // Ignora certificados para Telegram
     WiFi.config(local_IP, gateway, subnet, dns);         // Configura IP fija
     WiFi.begin(ssid, password);                          // Conecta WiFi
     while (WiFi.status() != WL_CONNECTED)
          {
           delay(500);
           Serial.print(".");
          }
     Serial.println("\nWiFi conectado!");
     Serial.print("IP local (desde relay): ");
     Serial.println(WiFi.localIP());
     udp.begin(localUdpPort);                             // Inicia UDP para recibir comandos
     Serial.println("UDP (relay) iniciado en puerto " + String(localUdpPort));
    }

// ---- 7: Control de relay ----
void setRelay(bool on)
    {
     relayState = on;                                    // Actualiza estado lógico interno
     digitalWrite(relayPin, on ? HIGH : LOW);            // Cambia activación física del relay
     String status = on ? "encendido" : "apagado";
     Serial.println("Relay " + status);                  // Muestra por consola
     bot.sendMessage(CHAT_ID, "Relay " + status);        // Envía confirmación por Telegram
    }

// ---- 8: Procesa mensajes UDP desde otros ESP ----
void checkUdpMessages()
    {
     int packetSize = udp.parsePacket();
     if (packetSize)
        {
         char incomingPacket[255];
         int len = udp.read(incomingPacket, 255);
         if (len > 0) incomingPacket[len] = 0;
         String cmd = String(incomingPacket);
         Serial.println("[UDP] Recibido: " + cmd);
         if (cmd == "ENCENDER") setRelay(true);
         else if (cmd == "APAGAR") setRelay(false);
        }
     }

// ---- 9: Procesa comandos Telegram ----
void handleTelegramMessages()
    {
     int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
     while (numNewMessages)
          {
           for (int i = 0; i < numNewMessages; i++)
              {
               String text = bot.messages[i].text;
               String chat_id = bot.messages[i].chat_id;
               if (chat_id == CHAT_ID)
                  {
                   if (text == "/encender") setRelay(true);
                   else if (text == "/apagar") setRelay(false);
                  }
               }
     numNewMessages = bot.getUpdates(bot.last_message_received + 1);
     }
   }

  bool isTelegramAvailable()
      {
       int res = bot.getUpdates(bot.last_message_received + 1);
       return (res >= 0);
      }
void sendTelegramCommand(const char* command)
    {
     bot.sendMessage(CHAT_ID, command);
     Serial.println("[Telegram] Enviado: " + String(command));
    }

// ---- 10: loop principal ----
void loop()
    {
     bot.checkForNewMessages();                          // Mantiene comunicación Telegram
     bool currentButtonState = digitalRead(buttonPin);   // Lee pulsador local
     if (lastButtonState == HIGH && currentButtonState == LOW)
        {
         relayState = !relayState;                         // Alterna el estado
         if (WiFi.status() == WL_CONNECTED && isTelegramAvailable())
            {
             if (relayState) sendTelegramCommand("/encender");
             else sendTelegramCommand("/apagar");
             setRelay(relayState);                           // Cambia el relay
             }
        else {
              setRelay(relayState);                           // Cambia relay directo, sin Telegram
             }
        delay(250);                                      // Anti-rebote físico del pulsador
       }
   lastButtonState = currentButtonState;
   checkUdpMessages();                                 // Recibe comandos UDP desde otros ESPs
   handleTelegramMessages();                           // Procesa comandos Telegram recibidos
   delay(10);                                         // Pequeño delay de estabilidad
}

A. Como crear el Bot y Obtener el Token

Paso 1: Abre la aplicación de Telegram en tu teléfono o PC.
Paso 2: Busca el usuario oficial BotFather (es el administrador de todos los bots en Telegram).
Escribí en la barra de búsqueda “BotFather” y elegí el usuario verificado.
Paso 3: Inicia chat con BotFather y escribe el comando:

Código: 
/newbot

Paso 4: BotFather te pedirá un nombre para tu bot (puede ser cualquiera, por ejemplo: “AlarmaCasaBot”).
Paso 5: Ahora te preguntará por un “nombre de usuario único” para el bot. Debe terminar en bot (ejemplo: alarmacasa_bot).
Paso 6: Cuando confirmas, BotFather te responde con el mensaje:

Código: 
textDone! Congratulations on your new bot…

Y te da un “Token” como este (ejemplo):

Código: 
123456789:ABCDefGhijklmNOpQrSTUVwxyZ123456789

Ese es el BOTtoken que debes pegar en tu código Arduino.

B. Obtener el chat_id
El chat_id es el identificador de la conversación que vas a usar para que el bot envíe mensajes a tu usuario (o grupo).
Para obtener tu chat_id personal podemos:

Opción A) Métodos fáciles usando bots de terceros:
Abre Telegram y busca el bot "@getidsbot",“userinfobot” o “myidbot”.
Inicia el chat, toca “start” y te manda tu ID personal.
Guarda ese número; ese es tu chat_id.

Opción B) Métodos manuales:
Escribe cualquier mensaje a tu bot creado.
Usá un ejemplo de código Arduino de TelegramBot.h para procesar mensajes y muestra el chat_id en Serial cada vez que el bot reciba algo.
Así:

Código: 
void handleTelegramMessages()
    {
     int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
     for (int i = 0; i < numNewMessages; i++)
        {
         Serial.println("Chat ID: " + bot.messages[i].chat_id); // Muestra el chat_id en la consola
       }
    }

Abre el monitor serie del Arduino y cuando envíes por Telegram cualquier texto al bot, verás el chat_id en la consola.

3. Resumen paso a paso
-Creas el bot usando BotFather y recibes el TOKEN.
-Consigues tu chat_id usando "@getidsbot",“userinfobot” o “myidbot”., o leyendo el valor en el Serial Monitor con código Arduino.
-Colocas esos datos en tu código:

Código: 
#define BOTtoken "tu_token_obtenido"
#define CHAT_ID "tu_chat_id_obtenido"

Recursos en video:
1. Video - Crear Bot y Token (Telegram + Arduino)
2. Video - Obtener tu chat_id en Telegram
3. Video - Tutorial Arduino/TG paso a paso
4.Video - Ejemplo y pasos para hacerte bots de Telegram con Botones

Si llego a mas de 50 (y), comparto mi proyecto completo del sistema de seguridad con cámara, sensores inalambricos, etc... Pero no hagan mucho ruido 😶 :silbando: :no:
 
Yo jugué un poco con el bot de Telegram para el trabajo que necesitamos una base de datos. Lo había conectado con una aplicación web hecho en PHP, pero nunca lo terminé...

Tu idea está buenísima. La IP fija solo configuras en los ESP, o también en el modem/router?
 
DJ T3 dijo:
Yo jugué un poco con el bot de Telegram para el trabajo que necesitamos una base de datos. Lo había conectado con una aplicación web hecho en PHP, pero nunca lo terminé...

Tu idea está buenísima. La IP fija solo configuras en los ESP, o también en el modem/router?
Hacer clic para expandir...
lamentablemente movistar no me deja meter mano en el modem/router... si pudiera meter mano abro puertos y veria video fuera de casa... me estoy rompiendo el coco con ngrok-v3... no pude hacerlo correr; Esa podria ser una posible solucion para poder sacar el video fuera de casa
 

Temas similares

torres.electronico
Comunicación Bluetooth con HC-05, OLED128x64 I2C y ELM327
Respuestas
4
Visitas
323
torres.electronico
torres.electronico
miborbolla
Obtener datos de un string obtenido via http en Arduino ?
Respuestas
1
Visitas
2K
cosmefulanito04
cosmefulanito04
Meta
No funciona flecha indicadora para elegir submenús en el LCD
Respuestas
9
Visitas
3K
Meta
Meta
DownBabylon
Duda con error en codigo de Arduino Ide
Respuestas
1
Visitas
2K
Scooter
Scooter
jmth
Arduino Ethernet + SD POST
Respuestas
6
Visitas
2K
jmth
jmth
Atrás
Arriba