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:
 

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