Bonjour à tous,

je viens vers vous aujourd'hui car je n'arrives pas à comprendre comment faire pour afficher uniquement la valeur de mon fichier txt en ligne. Le code que j'ai marche en lui même mais affiche affiche les tags http avec la valeur du fichier txt

l'affichage dans le Serial ce fait par 

Serial.print(c); //prints byte to serial monitor

Sauf que cette ligne affiche également les données HTTP de connection .. 

Connaissez-vous une solution pour ne pas afficher le résultat de la requête HTTP ?

Merci de votre attention et de votre aide.

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

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
char serverName[] = "www.la-referencerie.fr";
EthernetClient client;

void setup(){

  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    while(true);
  }

  Serial.begin(9600);
}

void loop(){
      
      if (client.connect(serverName, 80)) {
        Serial.println("connected");
        client.println("GET /unnicoin/unnicoin.txt HTTP/1.0");
        client.println("Host: www.la-referencerie.fr");
        client.println();
      } 
      else {
        Serial.println("connection failed");
        Serial.println();
      }
    
      while(client.connected() && !client.available()) delay(1); //waits for data
      while (client.connected() || client.available()) { //connected or data available
        char c = client.read(); //gets byte from ethernet buffer
        Serial.print(c); //prints byte to serial monitor

      }

      client.stop();
      
}

A part rediriger ton texte vers un navigateur html, je ne vois pas beaucoup de solutions. Tu peux aussi filtrer les balises en n’affichant pas les « < » et les « > » et ce qu’il y a entre les deux, mais tu devras rajouter quelques lignes de code.

Attends de voir peut-être d’autres réponses plus pertinentes.

Tu peux passer les entêtes HTTP en attendant la ligne vide qui précède le corps de la réponse.

En gros, tu as:

• la première ligne qui t'indique si la requête pointe quelque chose de valide (ex: "HTTP/1.1 200 OK"), terminée par CRLF ("\r\n"),
• une ou plusieurs lignes d'entêtes, terminées par CRLF 
• une ligne vide, terminée par CRLF
• ton fichier texte (ou ce que tu as demandé).

Tu dois donc au moins vérifier le contenu de la première ligne, pour savoir si la requête est correcte, puis chercher 2 CRLF ("\r\n\r\n") en suivant qui indiquent le début du corps de la réponse (en sachant que les CR, '\r' peuvent ne pas être présents sur certains serveurs qui ne respectent pas la norme et que la norme elle-même conseille d'accepter aussi des "\n" sans "\r").

Salut alexisdm merci pour ta réponse mais comment traite tu la comparaison avec un affichage caractère par caractère ? Sinon merci beaucoup pour ta réponse

Par exemple:

#include <SPI.h>
#include <Ethernet.h>
 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
char serverName[] = "www.la-referencerie.fr";
char serverPath[] = "/unnicoin/unnicoin.txt";

EthernetClient client;
 
void setup(){
  Serial.begin(9600);
  Serial.println("Test Ethernet");
 
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    while(true);
  }
 
  
}

void send_request() {
    client.print("GET "); client.print(serverPath); client.println(" HTTP/1.0");
    client.print("Host: "); client.println(serverName);
    client.println();
}
enum HttpParserError {
  HTTP_OK,
  HTTP_RESPONSE_INVALID,
  HTTP_STATUS_NOT_OK,
  HTTP_HEADER_TIMEOUT,
  HTTP_HEADER_INVALID,
  HTTP_BODY_TIMEOUT
  
};
// A cause du type de retour défini ci-dessus, il faut déclarer 
// la fonction séparément, parce que le préprocesseur .ino -> C++ 
// rajoute les déclarations des fonctions avant la déclaration des types.
HttpParserError handle_response();

int lastHttpStatus;

HttpParserError handle_response() {
    char response[11];

    // Lit la première ligne de la réponse ex: "HTTP/1.0 200 OK"
    // - lit jusqu'au premier espace (protocole et version)
    int size = client.readBytesUntil(' ', response, 10);
    response[size] = 0; // ajoute le '\0' de fin de chaîne
    
    if(size!=8 || strncmp(response, "HTTP", 4)!=0) {    
      return HTTP_RESPONSE_INVALID;  
    }
    // - lit jusqu'au 2e espace (code de status)
    size = client.readBytesUntil(' ', response, 10);
    response[size] = 0;
    // transforme le code texte en nombre
    lastHttpStatus = 0;
    for(int i = 0; i < size && response[i] >= '0' && response[i] <= '9'; ++i) {
      lastHttpStatus = lastHttpStatus*10 + response[i]-'0';
    }
    if(size!=3 || lastHttpStatus != 200) { // code 200 = OK            
      return HTTP_STATUS_NOT_OK;      
    }

    // - ignore la fin de la ligne et toutes les entêtes jusqu'à la ligne vide
    // comme on ne lit pas les entêtes, le premier '\r' n'a pas à être extrait
    // donc on peut considérer qu'il faut attendre \n\r\n ou \n\n (LFCRLF ou LFLF)
    enum ParserState {       
      Wait_for_LF,         // Attente du 1er '\n'
      Wait_for_CR_or_LF_2, // Attente du 2nd '\n' ou si la réponse est bien formée du 2nd '\r'
      Wait_for_LF2,        // Attente du 2nd '\n' s
      End_of_header
    } state = Wait_for_LF;   
    unsigned long last_char_time = millis();   
    
    while(client.connected() && state != End_of_header) {      
      // Si on n'a pas reçu de caractère depuis plus d'une seconde, on arrête la recherche
      if(millis() - last_char_time > 1000) {        
        return HTTP_HEADER_TIMEOUT;        
      }      
      while(client.available() && state != End_of_header) {               
        last_char_time = millis();
        char c = client.read();
        if (c == '\n') {
          if (state == Wait_for_LF) {
            state = Wait_for_CR_or_LF_2;          
          } else if (state == Wait_for_CR_or_LF_2 || state == Wait_for_LF2) {
            state = End_of_header;
          }
        } else if (c == '\r' && state == Wait_for_CR_or_LF_2) {
          state = Wait_for_LF2;                     
        } else if (c == '\r' && state == Wait_for_LF2) { 
          return HTTP_HEADER_INVALID; // au cas où on aurait "\n\r\r\n"
        } else {// pour tous les autres cas on recommence la recherche à 0
          state = Wait_for_LF;
        }
      }             
    }

    // Si on arrive ici, ce qui suit est le corps de la réponse HTTP
    // (idem qu'au dessus, on doit gérer l'éventuel timeout manuellement, 
    // pour éviter de bloquer l'arduino, quand on n'utilise pas les fonctions 
    // readBytesUntil, find...).      
    last_char_time = millis();
    while(client.connected()) {
      if(millis() - last_char_time > 1000) {        
        return HTTP_BODY_TIMEOUT;        
      } 
      while(client.available()) {
         last_char_time = millis();
         char c = client.read();
         Serial.print(c);          
      }      
    }
    
    return HTTP_OK;
}

 
void loop(){       
      if (client.connect(serverName, 80)) {
        Serial.println("connected");
        send_request();
        
        int result = handle_response();
        if(result != HTTP_OK) {
          Serial.print("Erreur n°: ");
          Serial.println(result);
        }
        client.stop();
      }
      else {
        Serial.println("connection failed");
        Serial.println();
      }
          
      // Pour éviter de lancer la même requête en boucle pendant les tests du code
      // à remplacer par un appel à delay si nécessaire
      while(1);       
}