Temperature web server

Ciao tutti,
sto utilizzando questo codice per il mio progetto di monitoraggio della temperatura ma ho qualche difficoltà a risolvere due problemi.

  1. dopo qualche minuto in cui il sistema funziona, improvvisamente smette di visualizzare la temperatura e il browser non riesce più a connettersi. Come mai?
  2. nei momenti di funzionamento il sistema alterna ai valori di temperatura a quelli con scritte incomprensibili. Come mai? Quali comandi posso inserire per migliorare il debugging?

Vi posto il codice affinche qualcuno della comunity possa aiutarmi e magari spiegare come risolvere questo problema.

Inserisco anche la fonte dalla quale mi sono ispirato
Arduino Temperature Web Server

Inserisco l’immagine del browser

Grazie

/*
 Temperature Web Server 
 
 Modified from the Arduino 1.0 examples
 
 TMP36 is connected to Analog port 0
 */

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

int temperaturePin=0;

unsigned long lastConnectionTime=0;
const unsigned long connectionInterval=10000;

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x03 };
IPAddress ip(192,168,0,120);

// Initialize the Ethernet server library
// with the IP address and port you want to use 
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() { // Start setup
  Serial.begin(9600); // Open serial communications
  delay(1000); // Delay to let system boot
    
  // Start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("\nserver is at ");
  Serial.println(Ethernet.localIP());
} // End setup

void loop() { // Start loop
  
  // Listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connnection: close"); // the connection will be closed after completion of the response
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");

          // add a meta refresh tag, so the browser pulls again every 5 seconds:
          client.println("<meta http-equiv=\"refresh\" content=\"5\">");
          client.print("Hi Mary Alice!");   
          client.println("
"); 
          
          // read in the temperature  
          float temperature = getTemperature(temperaturePin);
          temperature = (temperature-.5) * 100; // correct for offset and 10mv per degree
          client.print("Temperature: ");
          client.print(temperature);
          client.print(" degrees Celsius");
          client.println("
");
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } 
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("\nclient disonnected");
  }
}

// function to retrieve temperature
float getTemperature(int pin){
return (analogRead(pin) * .004882814); // converting from a 0 to 1023 digital range
                                       // to 0 to 5 volts (each 1 reading equals ~ 5 millivolts
}

001.webserver.jpg

002.webserver.jpg

Purtroppo non ho quella scheda e sarei curioso di giocarci.

Quello che farei io e spezzare il programma in più parti e verificare ogni singolo 'pezzo' inviando un msg alla seriale , per dire "Ora sono qui".

Quando non comunica potresti provare a pingare la scheda oppure verificare prima che il problema non sia nella tua rete

 if (client.available()) {
char c = client.read();

Ad esempio , ma è solo un esempio in quanto non l'ho mai utilizzata , nel codice sopra riportata potresti srivere un msg verso la tua seriale e capire se si "blocca" dopo aver visto il client e così via..

Verificare che la tua libreria sia aggiornata

Potresti provare un altro codice più semplice e vedere se si comporta allo stesso modo, diciamo che se non hai molta esperienza con quella scheda puoi affrontarlo in vari modi , ma a piccoli passi

In pratica devi vedere il programma come un flowchart e verificare ogni singolo rettangolo :slight_smile:

Victor795:
Quando non comunica potresti provare a pingare la scheda

Ciao,
purtroppo le mie conoscenze informatiche sono limitate e senza l'aiuto di un esperto non saprei come fare in debug.
Quello che posso fare è il ping della scheda e postare il risultato per analizzare la con voi il problema, sempre che ci sia qualcuno disposto ad aiutare.

C:\Users\Antonio>ping 192.168.0.120

Esecuzione di Ping 192.168.0.120 con 32 byte di dati:
Risposta da 192.168.0.120: byte=32 durata=1ms TTL=128
Risposta da 192.168.0.120: byte=32 durata=2ms TTL=128
Risposta da 192.168.0.120: byte=32 durata=1ms TTL=128
Risposta da 192.168.0.120: byte=32 durata=2ms TTL=128

Statistiche Ping per 192.168.0.120:
    Pacchetti: Trasmessi = 4, Ricevuti = 4,
    Persi = 0 (0% persi),
Tempo approssimativo percorsi andata/ritorno in millisecondi:
    Minimo = 1ms, Massimo =  2ms, Medio =  1ms

Mentre il monitor seriale

server is at 0.0.0.0

Grazie mille

Non sono un esperto comunque ,Ti avevo risposto ma ho perso il testo.Sintetizzo in attesa di altre risposte:

che messaggio ti restituisce la pagina ?

nome dell scheda shield?

versione arduino ?

usi una libreria ehternet differente ?

devi pingare quando si presenta il problema

Hai verificato che non ci siano due ip uguali nella rete?

il cavo ethernet è difettoso ?

Victor795:
Non sono un esperto comunque ,Ti avevo risposto ma ho perso il testo.Sintetizzo in attesa di altre risposte:
che messaggio ti restituisce la pagina?

A volte browser mi restituire pezzi di testo contenuto nelle virgolette ma in maniera casuale mentre altre volte perde la connessione e visualizza il messaggio "Tempo per la connessione esaurito". L'unico modo per riprendere la connessione è quello di spegnere arduino.

Nome dell scheda shield?

Aukru Ethernet Shield W5100 per Arduino UNO mega 2560 1280 328

Versione arduino?

Arduino UNO

usi una libreria ehternet differente?

Non saprei, quella presente è la Ethernet by Arduino Version 1.1.1

devi pingare quando si presenta il problema

ecco il risultato del ping quando si presenta il messaggio "Tempo per la connessione esaurito"

C:\Users\Antonio>ping 192.168.0.120

Esecuzione di Ping 192.168.0.120 con 32 byte di dati:
Risposta da 192.168.0.120: byte=32 durata=12ms TTL=128
Risposta da 192.168.0.120: byte=32 durata=1ms TTL=128
Risposta da 192.168.0.120: byte=32 durata=1ms TTL=128
Risposta da 192.168.0.120: byte=32 durata=1ms TTL=128

Statistiche Ping per 192.168.0.120:
    Pacchetti: Trasmessi = 4, Ricevuti = 4,
    Persi = 0 (0% persi),
Tempo approssimativo percorsi andata/ritorno in millisecondi:
    Minimo = 1ms, Massimo =  12ms, Medio =  3ms

Hai verificato che non ci siano due ip uguali nella rete?

No, non ci sono IP uguali. La verifica l'ho fatta con Advanced IP Scanner.

il cavo ethernet è difettoso?

No, sempre funzionato.

Prova a cambiare esempio , il più semplice possibile senza acquisire nessun dato e poi testa il tempo di connessione

comunque googlando ho trovato questo

Ho ottenuto maggioni informazioni dal monitor seriale apportanto alcune modifiche.

Ad esempio modificando il codice in:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x03 };
byte ip[] = { 192,168,0,120 };

ottengo una serie di risposte dal monitor seriale.

In principio visualizzo le risposte del setup,

Temperature Web Server

server is at 192.168.0.120

poi se apro il browser all'indirizzo ip visualizzo le risposte del loop

Modem temperature
Temperature: 32.52 C
client disonnected

Mentre se chiudo il browser il loop si interrompe.

Domani con Amazon prime dovrebbe arrivarmi l 'Aukru Ethernet Shield W5100

son curioso di provare :smiley:

Victor795:
Domani con Amazon prime dovrebbe arrivarmi l 'Aukru Ethernet Shield W5100 son curioso di provare :smiley:

Benissimo,
fammi sapere come ti trovi.

Mi hanno confermato martedì :o

tu hai risolto qualcosa nel frattempo ?

Ho

Victor795:
Prova a cambiare esempio, il più semplice possibile senza acquisire nessun dato e poi testa il tempo di connessione.

Ho provato ad usare uno sketch di esempio. Quello che fa al mio caso potrebbe essere web server?

Grazie

Victor795:
Mi hanno confermato martedì :o

tu hai risolto qualcosa nel frattempo ?

No, dopo qualche ora di funzionamento il browser non si collega e in alcuni casi non riesco nemmeno a navigare. :o :o :o
Che siano le impostazioni del modem?

Grazie

prova questo

appena mi arriva inzio anche io , vediamo se insieme riusciamo a capirci qualcosa :smiley:

Stai chiedendo aiuto su un forum Arduino, "Aukru Ethernet Shield W5100" (che costa 1/10) è un prodotto con marchio Arduino?

pablos:
Stai chiedendo aiuto su un forum Arduino, "Aukru Ethernet Shield W5100" (che costa 1/10) è un prodotto con marchio Arduino?

Non credo sia a marchio Arduino :stuck_out_tongue:

Hai risolto ?

il tuo schetck sta viaggiando sul mio shield da mezz’ora… :o

Edit:
Qui funziona ancora tutto ( ormai sono 2 ore)

quattro ore acceso nessun problema

Victor795:
quattro ore acceso nessun problema

Ciao,
purtroppo sono fuori città e non posso darti risposte.
Comunque ho apportato dei miglioramenti allo sketch e al ritorno non vedo l'ora di provarli.

A presto

Ho appena provato ad usare uno sketch di esempio, nel mio caso Web Server trovato su www.arduino.cc ecco il link.
Ho apportato qualche modifica come ad esempio rimuovere la SD card e aggiungere le due linee di codice suggerite (le trovate nel setup).
Ho aggiunto anche dei commenti a quasi tutte le righe di comando, utili per chi si trova alle prime armi come me.
Per finire ho alimentato tutto con uno switch da 1500mA impostato su 9V.
Dopo 24 ore di funzionamento non ho avuto problemi di connessione usando solo ed esclusivamente sia l’ipad che l’iphone.

Ecco il codice completo.

/*
  Web Server

 A simple web server that shows the value of the analog input pins.
 using an Arduino Wiznet Ethernet shield.

 Circuit:
 * Ethernet shield attached to pins 10, 11, 12, 13
 * Analog inputs attached to pins A0 through A5 (optional)

 created 18 Dec 2009
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe
 modified 28 Aug 2016
 by Antonio Cannavale

 get code at https://www.arduino.cc/en/Tutorial/WebServer
 */

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

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,0,120);
// Network configuration. dns server, gateway and subnet are optional
// The DNS server ip
 IPAddress dnServer(192,168,0,1);
// The router's gateway address
 IPAddress gateway(192,168,0,1);
// The subnet
 IPAddress subnet(255,255,255,0);

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() { // Start setup
  // Disable the SD card by switching pin 4 high
  // not using the SD card in this program, but if an SD card is left in the socket,
  // it may cause a problem with accessing the Ethernet chip, unless disabled
  pinMode(4, OUTPUT);
  digitalWrite(4, HIGH);
  
  // Open serial communications and wait for port to open
  Serial.begin(9600); // Set up Serial library at 9600 bps
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
   } // end while (!Serial)
  
  // Start the Ethernet connection and the server
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("\nserver is at "); // Print out the IP address
  Serial.println(Ethernet.localIP());
} // End setup

void loop() { // Start loop
  // Listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("\nnew client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          
          // Send a standard http response header
          client.println("HTTP/1.1 200 OK"); // Status code
          client.println("Content-Type: text/html"); // Data type
          client.println("Connection: close"); // The connection will be closed after completion of the response
          client.println("Refresh: 5"); // Refresh the page automatically every 5 sec
          client.println();
          
          // Send web page
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          client.println("<head>");
          client.println("<title>Arduino WebServer</title>");
          client.println("</head>");
          client.println("<body>");
          client.println("<h1>Simple Web Server</h1>");
          client.println("<h2>A simple web server that shows the value of the analog input pins.</h2>");
          client.print("<hr>");
          // Output the value of each analog input pin
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            int sensorReading = analogRead(analogChannel);
            client.print("analog input ");
            client.print(analogChannel);
            client.print(" is ");
            client.print(sensorReading);
            client.println("
");
          } // end for (int analogChannel = 0; analogChannel < 6; analogChannel++)
          client.println("</body>");
          client.println("</html>");
          break;
        }
        // every line of text received from the client ends with \r\n
        if (c == '\n') {
          // last character on line of received text
          // starting new line with next character read
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          // a text character was received from client
          currentLineIsBlank = false;
        }
      } // end if (client.available())
    } // end while (client.connected())
    // give the web browser time to receive the data
    delay(1); // give the web browser time to receive the data
    client.stop(); // close the connection
    Serial.println("client disconnected");
  } // end if (client)
} // End loop

Grazie

Quando c'è quel problema del crash ethernet non dipende dal tempo che sta acceso, può stare acceso anche sei mesi che non si inchioda se non ci si collega, va in crash nel momento preciso della chiamata http, lo trovi piantato e ti chiedi "chissà quando si è inchiodato?" invece si è inchiodato proprio in quel momento.

Questo lo dico con certezza, perchè ho tenuto tutte le funzioni del wiznet in debug per settimane, si schiantava sempre nel momento in cui c'era una chiamata.

Inoltre con gli smartphone android il wiznet crashava ancora più velocemente rispetto ai browser dei pc, per una ragione molte semplice che sfugge:
quando chiudiamo il browser su smarphone o su tablet usiamo spesso il tasto freccia per tornare al desktop inconsapevoli che non abbiamo chiuso la connessione tantomeno l'app, questa continua a lavorare in background tenendo occupata la ethernet wiznet e la banda con ripetute richieste.
Un attento studio del traffico di rete wifi farà notare che continua ad esserci scambio di dati tra arduino e il browser android. Bisogna chiudere l'app col tasto simbolo "quadratino" per avere la certezza che la ethernet e il micro arduino siano liberi da lavori inutili.