[RESOLU] Contrôle analogique d'une LED a très longue distance.

Bonjour à tous !

Malgré de longues recherches j'ai eu du mal à trouver réponse à cette question un peu bête : ::slight_smile:

Est-il possible avec un arduino d'à la fois lire des données analogiques venant d'une source externe et envoyées par réseau et d'en même temps les écrire ?

Par exemple puis-je contrôler en temps réel l'intensité lumineuse d'une LED (Arduino2 - analogWrite) au moyen d'un potentiomètre (Arduino 1 - analogRead) situé dans une autre ville ?
Faut-il une carte à double coeur type ESP32 ou Arduino 101 afin de pouvoir gérer à la fois la lecture son traitement et son écriture ?

Merci d'avance !

il faut 2 arduino bien entendu, un dans chaque ville et un moyen de communiquer entre les 2.

en fonction de vos contraintes et capacité de connexion (IP fixe accessible de l'extérieur, interface SMS, LoRa, plateforme iOT) il vous faudra bidouiller plus ou moins

Bonjour J-M-L,

Merci pour cette réponse rapide.

Je vais préciser davantage ma question qui n'était pas bien claire.

Outre la question de la transmission des data, comment gérer à la fois la lecture de ces données et leur sortie analogique dans mon arduino n°2 ?

Par exemple si je pars d'un protocole de communication MQTT + Web Sockets (pour le temps réel notamment) je comprends comment réceptionner ces données dans le moniteur serie mais pas comment les transformer en commande analogique directe. :slight_smile:

Encore merci !

votre arduino pédale vite... donc il peut lire les entrées, écouter internet, poster sur internet et piloter des sorties le tout sans soucis. une luminosité d'une LED de base se commande en PWM par exemple

Bonjour J-M-L, bonjour tout le monde,

J’ai maintenant en place :

  • Un MQTT broker sur mon Raspberry
  • Un arduino #1 client MKR1010 + shield ethernet connecté à un potentiomètre (A1)
  • Un arduino #2 client MKR1010 en wifi connecté à une led (5)

Si j’arrive à envoyer les données analogRead du potentiomètre Arduino #1 à mon broker ainsi qu’au moniteur série de mon Arduino#2, je ne saisis toujours pas comment ré-exploiter ces données vers une sortie PWM: la led de mon Arduino#2.

Dans mes recherches je n’ai pas trouvé d’exemple ressemblant à mon projet mais j’ai cru comprendre que cela était possible en envoyant les données sous formes de string (qui semblent très critiquées sur les forums) ou de Json objects que l’on sérialiserait et déserialiserait mais à nouveau : pas de commade de sortie à l’horizon…

Voici le code, tiré des exemples de la librairie PubSubClient, intégré à mon client Arduino#1 équipé du potentiomètre et dans lequel je ne fais que que publier les données.

Merci de votre aide !

/*
  Basic MQTT example with WIFI SUB:PUB
*/

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

char buffer[20];


byte mac[]    = {  0x90, 0xA2, 0xAA, 0x0D, 0x7D, 0xEE};
IPAddress ip(192, 168, 1, 48);                           
IPAddress server(192, 168, 1, 25);  


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++) {
    Serial.print((char)payload[i]);
  }
}

EthernetClient ethClient;
PubSubClient client(server, 1883, callback, ethClient);


void setup()
{
 
  Serial.begin(9600);
  Ethernet.begin(mac,ip);

  if (client.connect("Mkr Eth Client")) {
    client.publish("led","Mkr Eth connected");
    Serial.println("connected");
    client.subscribe("led");
  }

delay (5000);
}

void loop()
{
 int  sensorValue = analogRead(A1);

   
sprintf(buffer,"%d",sensorValue);
client.publish("led", buffer);

}

"Si j'arrive à envoyer les données analogRead du potentiomètre Arduino #1 à mon broker ainsi qu'au moniteur série de mon Arduino#2, je ne saisis toujours pas comment ré-exploiter ces données vers une sortie PWM: la led de mon Arduino#2."
Si vous y arrivez, il faudra voir la/les variables (et leur nature : Strings?) qui alimentent le moniteur série de Arduino II... et en extraire un entier, prêt à nourrir la PWM.

Jbek:
Bonjour J-M-L,

Merci pour cette réponse rapide.

Je vais préciser davantage ma question qui n’était pas bien claire.

Outre la question de la transmission des data, comment gérer à la fois la lecture de ces données et leur sortie analogique dans mon arduino n°2 ?

Par exemple si je pars d’un protocole de communication MQTT + Web Sockets (pour le temps réel notamment) je comprends comment réceptionner ces données dans le moniteur serie mais pas comment les transformer en commande analogique directe. :slight_smile:

Encore merci !

Bonjour
MQTT est un vecteur interessant
Ton arduino commandant la led en pwm doit etre en subscribe (ecoute/lecture en permanence) du topic
aprés ça se limite juste à +/- un appel régulier à çà

void callback(char* topic, byte* message, unsigned int length) {
Serial.print("Message arrived on topic: “);
Serial.print(topic);
Serial.print(”. Message: ");
String messageTemp;

for (int i = 0; i < length; i++) {
Serial.print((char)message*);*
_ messageTemp += (char)message*;_
_
}_
_
Serial.println();_
_
int ledpw,_
_
ledpw = messageTemp.toInt(); // recup valeur pwm*_
}[/quote]

Merci à tous pour votre aide précieuse, j’avance pas à pas !

J’ai réussi à extraire un entier de ces réceptions et à les sortir en PWM…

mais seulement pour 2 minutes quand j’ai de la chance ! Ensuite le client Arduino chargé de sortir les données freeze complètement (que la commande de sortie PWM soit active ou non) ainsi que l’IDE qui ne répond plus tant que la carte reste branchée.
Mon broker, lui, reste égal à lui-même et semble bien lire toutes les data.
J’en conclus que le problème se situe au niveau de mon récepteur.

Peut-être est-ce du au trop grand nombre de valeur que j’envoie ?
Je ne peux malheureusement pas réduire leur nombre puisque ce projet est en fait voué à traduire en lumière un signal analogique complet issus de capteur biométriques, je souhaite donc avoir le spectre des valeurs.

Voici le programme de mon Arduino récepteur en espérant qui’il vous inspire quelque chose :

#include <WiFiNINA.h>
#include <PubSubClient.h>


const char* ssid = "Freebox-590EC0";
const char* password = "tereundo2-aurei83-requieturi-temonis";
const char* mqtt_server = "192.168.1.25";
int ledPin = 5;      // select the pin for the LED


WiFiClient espClient;
PubSubClient client(espClient);


void setup_wifi() {

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

  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 reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "MKRWifi1010";
    clientId += String(random(0xffff), HEX);
    // Attempt to connect
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");
      // Once connected, publish an announcement...
      client.publish("led", "MKR WIFI");
      // ... and resubscribe
      client.subscribe("led");
    } 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(9600);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  pinMode(ledPin, OUTPUT);     // Initialize the ledPin pin as an output
}

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++) {
    Serial.print((char)payload[i]);
  }
  int Val = atoi((char *)payload);
  analogWrite (ledPin,Val);
}
void loop() {

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

l’autre n’a pas changé :

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

char buffer[20];


byte mac[]    = {  0x90, 0xA2, 0xAA, 0x0D, 0x7D, 0xEE};
IPAddress ip(192, 168, 1, 48);                           
IPAddress server(192, 168, 1, 25);  


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++) {
    Serial.print((char)payload[i]);
  }
}

EthernetClient ethClient;
PubSubClient client(server, 1883, callback, ethClient);


void setup()
{
 
  Serial.begin(9600);
  Ethernet.begin(mac,ip);

  if (client.connect("Mkr Eth Client")) {
    client.publish("led","Mkr Eth connected");
    Serial.println("connected");
    client.subscribe("led");
  }

delay (5000);
}

void loop()
{
 int  sensorValue = analogRead(A1);

   
sprintf(buffer,"%d",sensorValue);
client.publish("led", buffer);

}

Jbek:
Merci à tous pour votre aide précieuse, j'avance pas à pas !

J'ai réussi à extraire un entier de ces réceptions et à les sortir en PWM..

mais seulement pour 2 minutes quand j'ai de la chance ! Ensuite le client Arduino chargé de sortir les données freeze complètement (que la commande de sortie PWM soit active ou non) ainsi que l'IDE qui ne répond plus tant que la carte reste branchée.
Mon broker, lui, reste égal à lui-même et semble bien lire toutes les data.
J'en conclus que le problème se situe au niveau de mon récepteur.

Peut-être est-ce du au trop grand nombre de valeur que j'envoie ?

Je regarde çà rapidement d'une oreille distraite :grin:

Mais vite fait , je ne vois pas dans le loop d'appel regulier à la lecture du topic "renseigné"

void loop() { // emetteur
 int  sensorValue = analogRead(A1);

   
sprintf(buffer,"%d",sensorValue);
client.publish("led", buffer);

}

Votre emetteur emet à une cadence infernale (le ADC échantillonne plus de 10 000 fois par seconde, le sprintf est ultra rapide; reste client.publish())
Est ce que votre recepteur ne va pas être gavé?

Bonjour à tous et merci pour vos réponses !

Effectivement les MQTT ne supportent pas une telle cadence et c'est bien cela qui faisait crashé mon arduino. En diminuant cette cadence le spectre de données en pâti trop et ma lumière en output devient très "mécanique" donc pas très glamour.

Je vais donc m'orienter vers une autre méthode et donc clore ce topic !

Encore merci à tous pour votre aide !