Carte com arduino

[Circuitbreaker]

Bonjour à  la confédération des électro-bidouillleurs.
J'ai le projet de me créer un serveur web domotique à  partir d'un arduino.
Ce projet est surtout ludique et je ne suis pas sûr d'avoir les capacités de le mener à  terme mais je souhaiterais avoir votre aide sur quelques points primordiaux.
Le premier serait de savoir si un Arduino Uno peut servir de serveur web pour un smartphone Androïde.
Le second est de savoir combien de cartes peut on embrocher sur l'arduino car j'aurais besoin d'une com rs485 et d'une carte ethernet.
Pour l'instant j'étudie la faisabilité donc si vous pouvez éclairer mes lumières je vous en remercie d'avance.

[Cécile]

Bonjour,

Le premier serait de savoir si un Arduino Uno peut servir de serveur web pour un smartphone Androïde.

pour un serveur, un raspberry pie serait plus adapté, non? Il y a beaucoup d'exemples sur le  net

pour savoir si c'est "embrochable", il  nous faudrait savoir quelles cartes (shields??) vous voudriez mettre dessus.

Cécile

[Circuitbreaker]

 Bonjour Cécile.
Merci pour ton intérêt à  mon sujet, l'idée est de créer une interface web entre mon unité de télégestion d'ancienne génération (acquisitions TOR, ANA, automatisme et sortie TOR) et mon smartphone.
Donc j'ai besoin d'une carte com RS485 qui va communiquer en modbus vers ma télégestion et une carte Ethernet.
Comment j'en suis encore à  définir la faisabilité du projet je suis prêt à  utiliser un raspberry pie si c'est mieux adapté à  mon projet.
Laurent.

[Mdtdamien]

Bonjour Circuitbreaker,
j'ai réalisé un circuit similaire communiquer avec un compteur d'énergie modbus.

j'ai utilisé un Arduino Uno avec une carte Shields Ethernet.
pour communiquer avec le compteur modbus, j'ai utilisé une liaison série software avec un convertisseur RS485 modbus.

pour l'interface, j'utilise Blynk, qui est disponible sur IOS et Android.

Cordialement

[rikigeek]

Salut, les cartes ESP (programmables depuis l'application Arduino) fonctionnent aussi pour ce genre de travail. L'avantage est qu'elles intègrent une connexion WiFi. Par contre, je ne pense pas que les shields arduino soient compatibles (en terme de connectique). Mais sinon, fait chauffer le fer à  souder ;)

[Circuitbreaker]

 Bonjour merci pour vos réponses.
Mdtdamien est-ce que tu pourrais me partager le code Arduino pour programmer des informations de type Modbus je t'avoue que pour l'instant je n'ai pas trouvé ce que je cherchais.
je te remercie d'avance.

[Mdtdamien]

Bonjour, ci-joint le code pour la lecture d'un compteur socomec DIRIS A-14

tu auras besoin d'intégré la bibliothèque
https://github.com/syvic/ModbusMaster
enleve tous ce qui est en rapport à  blynk si tu ne souhaite pas utiliser ceci comme interface
https://blynk.io/

/*************************************************************
  This example shows how to use Arduino Ethernet Shield 2 (W5500)
  to connect your project to Blynk.

  Note: This requires Ethernet2 library
    from http://librarymanager/all#Ethernet2

        Pins 10, 11, 12 and 13 are reserved for Ethernet module.
        DON'T use them in your sketch directly!

  Feel free to apply it to any other example. It's simple!
*************************************************************/

/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial


#include <SPI.h>
#include <Ethernet2.h>
#include <BlynkSimpleEthernet2.h>
#include <ModbusMaster.h>               //Library for using ModbusMaster

#define MAX485_DE      3
#define MAX485_RE_NEG  2

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "votre clé token du projet";
  BlynkTimer timer;
  ModbusMaster noeud;                    //object node for class ModbusMaster
  WidgetLED led1(V10);
  WidgetLED led2(V11);
  WidgetLED led3(V12);
  WidgetLED led4(V13);
  WidgetLED led5(V14);
  WidgetLED led6(V15);

float U1 = 0.0;
float U2 = 0.0;
float U3 = 0.0;
float I1 = 0.0;
float I2 = 0.0;
float I3 = 0.0;
float I1Max = 0.0;
float I2Max = 0.0;
float I3Max = 0.0;
float SeuilAlarmeMiniI1 = 0.0;
float SeuilAlarmeMaxI1 = 60.0;
float SeuilAlarmeMiniI2 = 10.0;
float SeuilAlarmeMaxI2 = 60.0;
float SeuilAlarmeMiniI3 = 0.0;
float SeuilAlarmeMaxI3 = 60.0;
float HysterisieSeuilI1 = 10.0;
float HysterisieSeuilI2 = 2.0;
float HysterisieSeuilI3 = 2.0;

bool AlarmeSeuilBasI1 = LOW;
bool AlarmeSeuilHautI1 = LOW;
bool AlarmeSeuilBasI2 = LOW;
bool AlarmeSeuilHautI2 = LOW;
bool AlarmeSeuilBasI3 = LOW;
bool AlarmeSeuilHautI3 = LOW;

bool EnableSeuilBasI1 = LOW;
bool EnableSeuilHautI1 = LOW;
bool EnableSeuilBasI2 = LOW;
bool EnableSeuilHautI2 = LOW;
bool EnableSeuilBasI3 = LOW;
bool EnableSeuilHautI3 = LOW;



void preTransmission()            //Function for setting stste of Pins DE & RE of RS-485
{
  digitalWrite(MAX485_RE_NEG, 1);             
  digitalWrite(MAX485_DE, 1);
}

void postTransmission()
{
  digitalWrite(MAX485_RE_NEG, 0);
  digitalWrite(MAX485_DE, 0);
}

void blinkLedWidget()
{
    if (AlarmeSeuilBasI1 == HIGH)
      {led1.on();}
    else
      {led1.off();}
     
    if (AlarmeSeuilHautI1 == HIGH)
      {led2.on();}
    else
      {led2.off();}
     
    if (AlarmeSeuilBasI2 == HIGH)
      {led3.on();}
    else
      {led3.off();}
     
    if (AlarmeSeuilHautI2 == HIGH)
      {led4.on();}
    else
      {led4.off();}
       
    if (AlarmeSeuilBasI3 == HIGH)
      {led5.on();}
    else
      {led5.off();}
     
    if (AlarmeSeuilHautI3 == HIGH)
      {led6.on();}
    else
      {led6.off();}
}

void myTimerEvent()
{
  // You can send any value at any time.
  // Please don't send more that 10 values per second.
  Blynk.virtualWrite(V1, U1);
  Blynk.virtualWrite(V2, I1);
  Blynk.virtualWrite(V3, I1Max);
  Blynk.virtualWrite(V4, U2);
  Blynk.virtualWrite(V5, I2);
  Blynk.virtualWrite(V6, I2Max);
 
  blinkLedWidget();
}

  BLYNK_WRITE(V16)
{
    EnableSeuilBasI1 = param.asInt(); // assigning incoming value from pin V16 to a variable

  // process received value
}

  BLYNK_WRITE(V17)
{
    EnableSeuilHautI1 = param.asInt(); // assigning incoming value from pin V17 to a variable

  // process received value
}

  BLYNK_WRITE(V18)
{
    EnableSeuilBasI2 = param.asInt(); // assigning incoming value from pin V18 to a variable

  // process received value
}

  BLYNK_WRITE(V19)
{
    EnableSeuilHautI2 = param.asInt(); // assigning incoming value from pin V19 to a variable

  // process received value
}

void setup()
{
  pinMode(MAX485_RE_NEG, OUTPUT);
  pinMode(MAX485_DE, OUTPUT);
 
  pinMode(4,INPUT);
  pinMode(5,INPUT);
 
  digitalWrite(MAX485_RE_NEG, 0);
  digitalWrite(MAX485_DE, 0);
  // Debug console
  Serial.begin(9600);

  Blynk.begin(auth);
  // You can also specify server:
  //Blynk.begin(auth, "blynk-cloud.com", 80);
  //Blynk.begin(auth, IPAddress(192,168,1,100), 8080);
  // For more options, see Boards_Ethernet/Arduino_Ethernet_Manual example
 
  noeud.begin(5,Serial);            //Slave ID as 5
  noeud.preTransmission(preTransmission);         //Callback for configuring RS-485 Transreceiver correctly
  noeud.postTransmission(postTransmission);
 
  timer.setInterval(1000L, myTimerEvent);
 
}

void loop()
{
  static uint32_t i;
  uint8_t j, result;
  uint16_t data[7];
 
  i++;
 
  // slave: read (7) 16-bit registers starting at register 0xC854 to RX buffer
  result = noeud.readHoldingRegisters(0xC854, 7);
 
  Serial.println();
  Serial.print("noeud.ku8MBSuccess : ");
  Serial.print(noeud.ku8MBSuccess);
  Serial.print(" resultat : ");
  Serial.println(result);
  Serial.println();
 
  // do something with data if read is successful
  if (result == noeud.ku8MBSuccess)
  {
    for (j = 0; j < 7; j++)
    {
      data[j] = noeud.getResponseBuffer(j);
    }
      U1 = data[0]/100.0f;
      U2 = data[1]/100.0f;
      U3 = data[2]/100.0f;
      I1 = data[4]/20.0f;
      I2 = data[5]/20.0f;
      I3 = data[6]/20.0f;
      Serial.println("data : ");
      Serial.print("V1 : ");
      Serial.println(U1);
      Serial.print("V2 : ");
      Serial.println(U2);
      Serial.print("V3: ");
      Serial.println(U3);
      Serial.print("frequence : ");
      Serial.println(data[3]/100.0f);
      Serial.print("I1 : ");
      Serial.println(I1);
      Serial.print("I2 : ");
      Serial.println(I2);
      Serial.print("I3 : ");
      Serial.println(I3);
     
      //Alarme Seuil BAS I1
      if ( I1 < SeuilAlarmeMiniI1  && AlarmeSeuilBasI1 == LOW && EnableSeuilBasI1 == HIGH)
      {
        AlarmeSeuilBasI1 = HIGH;
        Blynk.notify("Alarme Seuil Bas I1");
        Serial.println("Alarme Seuil Bas I1");
      }
      else if ( I1 >= SeuilAlarmeMiniI1+HysterisieSeuilI1 || EnableSeuilBasI1 == LOW )
      {
        AlarmeSeuilBasI1 = LOW; 
      }
     
      //Alarme Seuil HAUT I1
      if ( I1 > SeuilAlarmeMaxI1  && AlarmeSeuilHautI1 == LOW && EnableSeuilHautI1 == HIGH )
      {
        AlarmeSeuilHautI1 = HIGH;
        Blynk.notify("Alarme Seuil Haut I1");
        Serial.println("Alarme Seuil Haut I1");
      }
      else if ( I1 <= SeuilAlarmeMaxI1-HysterisieSeuilI1 || EnableSeuilHautI1 == LOW  )
      {
        AlarmeSeuilHautI1 = LOW; 
      }
     
      //Alarme Seuil BAS I2
      if ( I2 < SeuilAlarmeMiniI2 && AlarmeSeuilBasI2 == LOW && EnableSeuilBasI2 == HIGH)
      {
        AlarmeSeuilBasI2 = HIGH;
        Blynk.notify("Alarme Seuil Bas I2");
        Serial.println("Alarme Seuil Bas I2");
      }
      else if ( I2 >= SeuilAlarmeMiniI2+HysterisieSeuilI2  || EnableSeuilBasI2 == LOW )
      {
        AlarmeSeuilBasI2 = LOW; 
      }
     
      //Alarme Seuil HAUT I2
      if ( I2 > SeuilAlarmeMaxI2  && AlarmeSeuilHautI2 == LOW && EnableSeuilHautI2 == HIGH  )
      {
        AlarmeSeuilHautI2 = HIGH;
        Blynk.notify("Alarme Seuil Haut I2");
        Serial.println("Alarme Seuil Haut I2");
      }
      else if ( I2 <= SeuilAlarmeMaxI2-HysterisieSeuilI2 || EnableSeuilHautI2 == LOW  )
      {
        AlarmeSeuilHautI2 = LOW; 
      }
     
      //Alarme Seuil BAS I3
      if ( I3 < SeuilAlarmeMiniI3 && AlarmeSeuilBasI3 == LOW && EnableSeuilBasI3 == HIGH )
      {
        AlarmeSeuilBasI3 = HIGH;
        Blynk.notify("Alarme Seuil Bas I3");
        Serial.println("Alarme Seuil Bas I3");
      }
      else if ( I3 >= SeuilAlarmeMiniI3+HysterisieSeuilI3 || EnableSeuilBasI3 == LOW  )
      {
        AlarmeSeuilBasI3 = LOW; 
      }
     
      //Alarme Seuil HAUT I3
      if ( I3 > SeuilAlarmeMaxI3  && AlarmeSeuilHautI3 == LOW && EnableSeuilHautI3 == HIGH  )
      {
        AlarmeSeuilHautI3 = HIGH;
        Blynk.notify("Alarme Seuil Haut I3");
        Serial.println("Alarme Seuil Haut I3");
      }
      else if ( I3 <= SeuilAlarmeMaxI3-HysterisieSeuilI3 || EnableSeuilHautI3 == LOW  )
      {
        AlarmeSeuilHautI3 = LOW; 
      }
     
  }
  else
  {
      Serial.println("erreur de lecture registre");
  }
     
  delay(500);
     
  result = noeud.readHoldingRegisters(0x9100, 6);
 
  Serial.println();
  Serial.print("node.ku8MBSuccess : ");
  Serial.print(noeud.ku8MBSuccess);
  Serial.print(" resultat : ");
  Serial.print(result);
  Serial.println();
 
  // do something with data if read is successful
  if (result == noeud.ku8MBSuccess)
  {
    for (j = 0; j < 6; j++)
    {
      data[j] = noeud.getResponseBuffer(j);
    }
    float PoidsFort=data[0];
    float PoidsFaible=data[1];
    I1Max = ((PoidsFort*65536.0)+PoidsFaible)/1000.0;
    Serial.print("I1Max : ");
    Serial.println(I1Max);
    PoidsFort=data[2];
    PoidsFaible=data[3];
    I2Max = ((PoidsFort*65536.0)+PoidsFaible)/1000.0;
    Serial.print("I2Max : ");
    Serial.println(I2Max);
    PoidsFort=data[4];
    PoidsFaible=data[5];
    I3Max = ((PoidsFort*65536.0)+PoidsFaible)/1000.0;
    Serial.print("I3Max : ");
    Serial.println(I3Max);
  }
  else
  {
    Serial.println("erreur de lecture registre");
  }


 
 
  Blynk.run();
  timer.run(); // Initiates BlynkTimer
  delay(1000);
}

[Circuitbreaker]

Bonjour Mdtdamien.
Merci pour le partage du code.
J'ai essayé de le décortiquer pour en extraire ce qui intéressais mais j'ai trop de lacune.
Ce que je souhaiterais dans un premier temps c'est récupérer des bits, mots, et double mots en modbus esclave.
Dans le maître je peux programmer des trames de bits ou mots contondant.
Il faut que je puisse aussi definir une adresse sur l'esclave entre 0 et 255.
Si j'arrivais au moins à  définir un bit qui serait écrit par le maître je pourrais dupliquer l'info.
Si tu peux m'aider merci d'avance.

[Mdtdamien]

Le code que j’ai proposé est pour une utilisation de l’arduino comme Maitre Modbus.
Quelle est ton système de télégestion. Je pensé que tu avais un appareil comme un TSX37( Schneider) qui peut être maître ou esclave.

[Circuitbreaker]

Le système que j'utilise est de type GTC (gestion technique centralisée) C'est un S50 de marque Sofrel ça ne ce fabrique plus depuis 20 ans.
C'est facile à  programmer très fiable et j'ai plein de cartes d'acquisitions d'avance mais c'est totalement incompatible avec le web.
Je joins un extrait de la doc.

C. Paramétrage d’une liaison MODBUS Maître
En mode MODBUS MAàŽTRE, S50 est utilisé comme système de surveillance d'un ou plusieurs
esclaves.
S50 peut effectuer les opérations suivantes :
• lecture d'un bit ou de plusieurs bits dans l’esclave
et affectation de ces bits en tant que TS ou TC du Poste Local,
• lecture d'un ou de plusieurs mots dans l’esclave
et affectation de ces mots en tant que TM ou TR du Poste Local,
• lecture d'un ou de plusieurs doubles-mots dans l’esclave
et affectation de ces doubles-mots en tant que TL du Poste Local.
S50 peut également émettre des consignes à  l’esclave :
• écriture d'un ou de plusieurs bits issus de TS ou TC,
• écriture d'un ou de plusieurs mots issus de TM ou TR,
• écriture d'un ou de plusieurs doubles-mots issus de TL,
• écriture d'un ou de plusieurs mots pour la mise à  l'heure d'un automate
ou d’un autre Poste Local S50 (à  partir de la version 3.20).