Controlar varios arduinos en remoto

Buenos días

No se si este es el subforo adecuado.

Estoy metido en un proyecto para automatizar algunos puzzles en una sala de escape. Los puzzles están desarrollados con arduino (uno y mega) y me han pedido que el game master pueda controlar todos ellos (activar en caso de error, resetear, etc) remotamente sin necesidad de tirar cables hasta la sala de GM (no queda otra que a través de wifi o bluetooth).

Estoy viendo ejemplos en internet y me asusta la posibilidad de tener que usar wifi porque lo que estoy viendo del esp8266 es complejo, aunque sino queda mas remedio.... Lo que no se es como debería montar todo.
Necesitaria un maestro y definir todos los puzzles como esclavos?
Podría controlar todos los puzzles con el esp8266 desde un html?
Es mejor utilizar un HC-05 por bluetooth?

Estoy bastante perdido. He estado viendo tantas cosas que al final no se muy bien que hacer... Alguien puede echarme una mano para ver que puedo utilizar mejor?

La verdad es que el concepto maestro esclavo sólo tiene sentido si hay cables, lo que necesitas es establecer una comunicación, lo primero que tienes que resolver, y luego debes tener un controlador central (server) y que este envíe señales a los otros arduinos (clientes de red)

1º logra la comunicación
2º establece los mensajes que te interesan
3º decidir el planteamiento filosófico del problema (El server envía órdenes como un maestro, los clientes de red piden órdenes en vez de esperarlas), porque eso determinará la resolución software a utilizar

Gracias por la respuesta @TonyDiana

Al final, despues de mucho leer y empaparme creo que me voy a decidir por utilizar una placa WeMos y un broker tipo Mosquitto usando protocolo MQTT

Con esto, consigo tener acceso wifi y subscribir/publicar mensajes para controlar los puzzles. Realmente lo que quiero hacer simplemente es un "reset" o "resolver" el puzzle directamente desde el game master. Utilizaré un cliente MQTT para Android o PC para que el propio GM pueda interactuar.

No se que tal lo veis...

Tienes varias opciones:

WIFI : si puedo alimentarlos con fuente AC es una opción muy adecuada.
Bluetooth : nunca me gustó y jamás siquiera la considero. Módulos caros y lo que necesito lo hago con la siguiente opción.
Radio : es la que casi siempre uso. Si el alcance es limitado tipo ;<50 mts uso nRF24 si es mayor considero nRF69 o incluso LoRA.

Cuando uso WIFI uso MQTT
Cuando uso nRF24 entre ellos se comunican via las librerías TMRh20 pero luego uso un gateway que convierte eso a MQTT que es lo que finalmente me resuelve todo.

Luego en el Master rara vez uso un Arduino, generalmente es un Raspberry corriendo Mosquitto, Node-Red, etc etc MySQL, o InfluxDB, y tantas cosas mas que facilitan las cosas.

Por ahora ese es mi enfoque.
Hasta tengo mezcladas cosas con WIFI, y nRF24 mas Node-Red en una Pi o una Notebook con UBUNTU corriendo linux por supuesto.

Amo los ESP8266 sea el 01 o el 12 (nodemcu). Si vale la pena uso el ESP32 pero es caro y no suelo usarlo porque lo malaprovecho. Es demasiado potente para hacer cosas simples.
El ESP01 o sea el ESP8266-01 es un caballito de batalla. Lo uso mucho con WIFI y le he sacado mucho provecho a sus pines que parecen pocos pero son sufientes para las necesidades que se presentan.
Ejemplo. Nunca tienes que leer mas de un sensorr en un punto, o accionar un rele, o ambas cosas. Eso lo hace tranquilamente un ESP01.
Si necesistas mas pines, se pueden usar RX y TX ya que una vez programados no los requires mas, asi que tiens 4 pines… No es tan facil porque los pines en el ESP01 arrancan de un modo esperando situaciones de programación y eso puede compliar las cosas.
Siempre es un desafio asi que si no tienes la habilidad o experiencia mejor ir con cosas mas seguras como el nodemcu o el Wemos. basicamente lo mismo. Comodidad de pines y opciones.

La verdad es que tienes que enviar tan pocos datos que el WIFI puede que no sea la opción, pero si manejas bien el protocolo TCP/IP, el wifi es más sencillo, claro, cuando sabes manejarlo, como es mi caso, y lo otro no, sobre todo porque puedes comunicarte por paquetes Json y te importa un comino si mandas números o letras

Gracias

Estoy en ello. De momento me he liado la manta a la cabeza y estoy desarrollando el proyecto con Node-red, un broker (mosquitto) y con la placa WEMOS D1 R2 que he pillado en Amazon.

De momento desde Node-Red con mosquitto bien..... no consigo que desde la WEMOS se conecte, pero será cuestion de tiempo

Todo es cuestion de tiempo siempre.

Bueno, al final lo he conseguido… no ha costado mucho, hay bastantes tutoriales en la web… solo hay que buscar.

Si alguien necesita mas detalles que no dude en consultarme.

Gracias a todos por los aportes

Os dejo el código que seguramente a alguien le solucione algun problema

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "**************";
const char* password = "******************+";
const char* mqtt_server = "broker.mqtt-dashboard.com";

WiFiClient espClient;
PubSubClient client(espClient);
//unsigned long lastMsg = 0;
//#define MSG_BUFFER_SIZE  (50)
//char msg[MSG_BUFFER_SIZE];
int value = 0;

const byte redLED = 2;        // GPIO2 --> D4 
const byte yellowLED = 0;     // GPIO0 --> D3
const byte greenLED = 4;      // GPIO4 --> D2
const byte whiteLED = 5;      // GPIO5 --> D1

int pot = A0;
int potData = 0;
static char potReading;

// Timers auxiliar variables
long now = millis();
long lastMeasure = 0;


void setup_wifi() {

  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  randomSeed(micros());

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    char receivedChar = (char)payload[i];
    Serial.print(receivedChar);
    ctrlLEDs(topic, receivedChar);
  }
  Serial.println();
}

void ctrlLEDs(String topic, byte receivedChar){
  if (topic == "ledStatus/red"){ 
    if(receivedChar == '1'){
      Serial.println(redLED);
      digitalWrite(redLED, HIGH);
    }
    else if (receivedChar == '0'){
      digitalWrite(redLED, LOW);
    }
    else{
      analogWrite(redLED, int(receivedChar));
    }
  }
  if (topic == "ledStatus/yellow"){
    if(receivedChar == '1'){
      digitalWrite(yellowLED, HIGH);
    }
    else if (receivedChar == '0'){
      digitalWrite(yellowLED, LOW);
    }
    else{
      analogWrite(yellowLED, int(receivedChar));
    }
  }
  if (topic == "ledStatus/green"){
    if(receivedChar == '1'){
      digitalWrite(greenLED, HIGH);
    }
    else if (receivedChar == '0'){
      digitalWrite(greenLED, LOW);
    }
    else{
      analogWrite(greenLED, int(receivedChar));
    }
  }
  if (topic == "ledStatus/white"){
    if(receivedChar == '1'){
      digitalWrite(whiteLED, HIGH);
    }
    else if (receivedChar == '0'){
      digitalWrite(whiteLED, LOW);
    }
    else{
      analogWrite(whiteLED, int(receivedChar));
    }
  }
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);
    // Attempt to connect
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");
      // Once connected, publish an announcement...
      // ... and resubscribe
      client.subscribe("ledStatus/red");
      client.subscribe("ledStatus/yellow");
      client.subscribe("ledStatus/green");
      client.subscribe("ledStatus/white");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  pinMode(redLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(whiteLED, OUTPUT);

}

void loop() {

  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  now = millis();
 // Publishes new pot reading every 5 seconds
 if (now - lastMeasure > 5000) {
   lastMeasure = now;
   // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
   potData = analogRead(pot);

   // Check if any reads failed and exit early (to try again).
   if (isnan(potData)) {
     Serial.println("Failed to read from Potentiometer!");
     return;
   }
   static char potReading[7];
   dtostrf(potData, 6, 2, potReading);

   // Publishes potentiometer values to the topic "sensor/potentiometer"
   client.publish("sensor/potentiometer", potReading);
 }
}

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.