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
 
torres.electronico dijo:
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
Hacer clic para expandir...
Hola, te comento algo que tengo funcionando desde hace algún tiempo(desde que llego Starlink a la Argentina) para administrar los dispositivos de diferentes redes detrás de CGNAT como la de Starlink inclusive.

Uso alguno de los productos de Mikrotik que posea como núcleo controlador de RouterOS un ARM/ARM 64(solo en estos dispositivos esta activa esa función de esta forma descripta). Los hay de diferentes categorías/precios desde un simple Router, Switch y/o CPE.

Lo conecto a la red del ISP, activo la opción del Cloud DNS dentro del apartado de las IP, después activo BTH(Back To Home) y a continuación escaneo para agregar en la aplicación correspondiente(esta para PC, Android y creo IOS también) a dicha VPN a través de WireWard el túnel encriptado punta a punta que se crea automaticamente.

Cuando quieres acceder desde cualquier parte del mundo/ISP activas la aplicación y si esta todo en lineal navegas como si estuvieras en red remota teniendo acceso a todos los dispositivos dentro de ellas sin necesidad de abrir puertos en el router del ISP.

Obviamente toda la red/Wifi debe estar administrado por este Router Mikrotik y la del ISP solo la uso para acceder a Internet sin ningún otro dispositivo conectado a ella.

Saludos.
Eje2.jpg


Con respecto al Bot de Telegrama, lo tengo funcionando hace unos cuantos años para que me avise si se "caen"(salen de línea o entran de nuevo) algunos DVR/cámaras de seguridad.
Aprovecho la posibilidad de programar script en esta marca de Router que corren y verifican mediante ping programados en una herramienta la respuesta o no de ciertos dispositivos dentro de la red e infórmalos al Chatboot de Telegram mediante otro script.


Código: 
:global telegramMessage
:local botid
:local chatid

set botid "xxXXX:NNH7p5MJFCCOcQL3FMq3oK123EZPS3NVcxEc"
set chatid "-000000000"
if ($telegramMessage != "") do={
   /tool fetch url="https://api.telegram.org/bot$botid/sendMessage?chat_id=$chatid&text=$telegramMessage" keep-result=no
}


Con el uso de esta herramienta que ya esta incluida en estos router que es "Netwatch"

Código: 
/tool netwatch
add down-script="global telegramMessage \"DVR Mi_Casa se desconecto de la red\"\r\
    \n/system script run SendToTelegram" host=192.168.XX.XXX interval=5s \
    up-script="global telegramMessage \"DVR Mi_Casa se conecto a la red\"\r\
    \n/system script run SendTelegram"
 
Última edición:
torres.electronico dijo:
Si señor, acá está!!! No encuentro la fuente, pero ya veo como resolverlo
Ver el archivo adjunto 333788. Ver el archivo adjunto 333789. Ver el archivo adjunto 333790
Estoy medio a media máquina por qué le pegué derecho 🫣 pero con esta data, sabes cómo le pegó derecho hasta la noche?!
Hacer clic para expandir...
Lo que pasa es que ese modelo (RB750GR3) Router no tiene un micro ARM, fíjate en Routerboard en la parte de System que esta la descripción del micro, memoria, etc. La consecuencia es que si bien te no te aparecerán las pestañas de BTH, si el cloud DNS que es gratuito y funciona en todos los Mikrotik desde hace años.

Me parece que el que estoy usando yo(hAP ac2) y mostré las capturas es el mas económico que tiene ARM, ya después tenes el hAP ax2 o el hAP ac3 o mejor el hAP ax3 que ya tiene micro de 64bit 1Gb de memoria, etc.

Tengo alguno de ellos pero los descarte porque el ac2 tiene un puerto USB y le podes colgar una memoria o disco rígido o SSD y tenes un lugar donde almacenar cosas en la red.

Nunca probé si corre bien "conteiner" para agregarle un servidor multimedia de red en el router directamente y apagar el que tengo echo con Debian12 y una PC antigua corriendo.

Desde que entre en la "Jubileta" mas algunos ruleros puestos es como que me estoy aplacando un poco :) .
 

Temas similares

torres.electronico
Comunicación Bluetooth con HC-05, OLED128x64 I2C y ELM327
Respuestas
4
Visitas
324
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