Problèmes de connexion ponctuel arduino ethernet shield

Bonjour à tous,

Je suis en train de developer une petite APP pour contrôler un relais à partir de mon téléphone portable.

En gros, l'arduino va chercher toute les secondes, une page html, et si la page renvoie "1" le relais s'allume et si elle renvoie 0, il se coupe. Jusqu'à là, pas de problème.

seulement, des fois l'arduino n'arrive pas à se connecter sur la plage, pendant plusieurs seconde et après il repart. Pas de problème de coupure sur le réseau, car avec mon pc j’accède bien à la page et pas de perte de ping.

Avez vous déjà rencontré ce genre de problème ?

Sur la ligne de commande "client.connect(server, 80)" est il possible de faire un timeout? Ou relancer la connection à partir de 500ms par exemple ?

Merci à tous.

Le bug est ligne 42 et il me semble que votre fil rouge est mal câblé...

enfin c’est ce que je vois

:slight_smile:

Blague à part... vous pensez nous avoir donné assez d’info?

En gros, l'arduino va chercher toute les secondes, une page html, et si la page renvoie "1" le relais s'allume et si elle renvoie 0, il se coupe. Jusqu'à là, pas de problème.

J'ai l'impression que tu prends le problème à l'envers.
Tel qu'exposé dans ta phrase, l'ARDUINO lit une page HTML sur un serveur (PC je suppose ?), interprète cette page et agit en conséquence.
Ce n'est pas vraiment comme cela que l'on procède en général. Normalement l'ARDUINO est serveur et embarque la page HTML, et pas le contraire.
Ou alors je n'ai pas compris la phrase et dans ce cas il faut reformuler.

@+

J-M-L:
Le bug est ligne 42 et il me semble que votre fil rouge est mal câblé...

enfin c’est ce que je vois

:slight_smile:

Blague à part... vous pensez nous avoir donné assez d’info?

Merci pour ton retour. Je veux bien t'envoyer mon code, mais il fait 200 lignes.

Je voulais juste savoir, si il y avait une fonction timeout existait ou si des problèmes de stabilité de connexion existait.

Merci encore

Comment envoyez vous votre requête ? Avec quelle librairie (il en existe qui ont une fonction setClientTimeout() par exemple)

Mais dans l’absolu vous pouvez gérer cela vous meme - vous envoyez le GET et notez la valeur de millis() puis si vous n’avez pas de réponse au bout d’un certain temps vous considérez cette requête comme perdue

Ensuite il peut y avoir 1000 autres soucis dans votre code, une perte d’adresse IP (maintenez vous la connexion ?), si vous utilisez des Strings (avec un S majuscule) vous pouvez morceler votre mémoire et planter votre Arduino etc...

merci à tous pour votre aide.

Je vous donne mon code utilié, si vous voyez un truc :confused:

Merci

// ******************* START librairies ******************* 
#include <SPI.h>
#include <Ethernet2.h>

#define DEBUG 1   ; //Debug activation ON = 1 ; OFF = 0

// ******************* END librairies ******************* 

// ******************* START VAR ******************* 
char DataRead[50];
char DataSize[4];
//char Data[4];
int i,j,m;
// ******************* END VAR ******************* 

// ******************* START Ethernet ******************* 
char server[] = "www.domaine.fr";    // name address for Google (using DNS)

// Set the static IP address to use if the DHCP fails to assign
byte mac[] = { 0x90, 0xA2, 0xDA, 0x11, 0x23, 0xA6 }; // Mac address 99-B8-DC-A0-72-F2

IPAddress dnServer(8, 8, 8, 8);
IPAddress gateway(192, 168, 2, 1);
IPAddress subnet(255, 255, 255, 0);
IPAddress ip(192, 168, 2, 195);

EthernetClient client;                              // Type mode between Server and Client

// ******************* END Ethernet *******************

// ******************* START Setup ******************* 
void setup() {

// Start Serial cable
  Serial.begin(9600);     // Open serial communications and wait for port to open:
  while (!Serial) {;}     // wait for serial port to connect. Needed for Leonardo only

// Mode Relais
pinMode(4, OUTPUT);
digitalWrite(4, LOW);

// Start Ethernet
  if (Ethernet.begin(mac) == 0) { // start the Ethernet connection:
    Serial.println("Failed to configure Ethernet using DHCP");    // no point in carrying on, so do nothing forevermore:
    //Ethernet.begin(mac, ip);    // try to congifure using IP address instead of DHCP:
    Ethernet.begin(mac, ip, dnServer, gateway, subnet);
  }
#ifdef DEBUG
  Serial.print("My IP address: ");
  Serial.println(Ethernet.localIP());
#endif
}
// ******************* END Setup ******************* 

// ******************* START loop ******************* 
void loop()
{
//*************************** END Read g.php Ethernet Data *************************** 
#ifdef DEBUG
  Serial.println("connecting to g.php...");
#endif

client.stop();

if (client.connect(server, 80)) {

#ifdef DEBUG
  Serial.println("connected");
#endif

client.print("GET /g.php");
client.println(" HTTP/1.1");
client.println("HOST: www.domaine.fr");
client.println("User-Agent: arduino-ethernet");
client.println("Connection: close");
client.println();

j=0;
i=0;
m=0;

delay(500);

  // if there are incoming bytes available
  // from the server, read them and print them:
  while(client.available()) {
      //Serial.print(client.read());
      //char c = client.read();
      //Serial.print(c);
    if (client.read() == '\n') {
      if (client.read() == '\r')
      {
        client.read();
        //Serial.println("DataSize : ");
        while(client.available()) {
            char c = client.read();
            if(c=='\r')
              break;
            DataSize[j]=c;
            j++;
            //Serial.print(c);
         }

        client.read();
        //Serial.println("Data : ");
        while(client.available()) {
            char c = client.read();
            
            if(c=='\r'){
              break;
              DataRead[i]='\0';}
              
            DataRead[i]=c;
            i++;
            //Serial.print(c);
         }
      }
    }
    if(j==1)
      break;
  }

// if the server's disconnected, stop the client:
if (!client.connected()) {
#ifdef DEBUG
    Serial.println("Disconnecting to g.php.");
#endif
client.stop();}

//*************************** start Send XBee Data ***************************
uint32_t msdw, lsdw;
char CharAddr64[17];
char Data[2];
memcpy( CharAddr64, DataRead, 16 );

CharAddr64[16] = '\0';
uint8_t len = strlen(CharAddr64);
memcpy( Data, &DataRead[len+1], 16 );
Data[2] = '\0';

int pos = atoi(Data);

  lsdw = strtoul(&DataRead[len-8], NULL, 16);
  DataRead[len-8] = '\0';
  msdw = strtoul(DataRead, NULL, 16);

#ifdef DEBUG
Serial.println("*******************");

Serial.print("DataRead: ");
for (i = 0; i < sizeof(DataRead); i++) {
            Serial.print(DataRead[i]);
          }
Serial.println("");

//*************************** START DATA traitement ***************************
Serial.print("Adresse char : ");
Serial.println(CharAddr64);
Serial.print("len : ");
Serial.println(len);
Serial.print("len-8 : ");
Serial.println(Data);
Serial.print("pos : ");
Serial.println(pos);

Serial.print("Adresse : ");
Serial.print(msdw, HEX);
Serial.print(" - ");
Serial.print(lsdw, HEX);
Serial.println("");
#endif

switch (pos) {
  case 01:
    Serial.println("OFF");
    digitalWrite(4, LOW);
    break;
  case 11:
    Serial.println("ON");
    digitalWrite(4, HIGH);
    break;
}

  }
  else {
    // kf you didn't get a connection to the server:
#ifdef DEBUG
    Serial.println("connection failed");
#endif
  }
//*************************** END Read g.php Ethernet Data ***************************

}

Vous lisez des data sur le Client qui ne sont peut être pas dispo et dans l’absolu vous envoyez votre requête et testez juste après une demi seconde si vous avez la réponse ce qui n’est pas forcément le cas ...

Vous devriez restructurer cela comme une machine à Etat

Envoyer la commande
Attendre la réponse ou le timeout
Si réponse traiter l’information

D’après mon premier débug, ça bloque à la connexion avec la commande : client.connect(server, 80)

L’arduino a du mal à se connecter, mais une fois connecté, y a pas trop de problème. Mais des fois elle bloque et j’ai un fail connection.

Merci

Ne vous connectez pas à chaque tour de loop mais envoyez des requêtes uniquement quand vous avez proprement traité la réponse précédente