next topic »

[on:]

Ciao a tutti,
ho provato a postare anche sul forum internazionale, senza pero' arrivare ad una soluzione. Probabilmente non mi sono spiegato bene.

Sto usando un ArduinoUno con ArduinoEthernet Shield.
Ho scritto uno sketch che fa polling verso un sito e in risposta comando le uscite digitali e analogiche dell'Arduino.

Lo sketch funziona bene quando:
- uso un IP pubblico e collego lo shield direttamente alla rete esterna
- uso un IP 192.168.0.x e collego lo shield ad un PC che fa da router. Il PC fa poi riindirizzamento dei pacchetti su WiFi

Funziona solo in parte quando collego lo shield direttamente ad una porta Ethernet del router ADSL. (Lo sketch e' esattament lo stesso di quando lo collego al PC-router).
Solo in parte perche' controllando il log del server, vedo che la HTTP request arriva correttamente al server. Il server risponde ma la HTTP Response non arriva all'Arduino. Qualche volta arriva ma il contenuto sono caratteri strani.

Stesso problema provando con 3 router ADSL diversi da 3 diverse citta' e usando un Arduino Diecimila.

Provate varie configurazioni sul router:
- disabilitare il DHCP
- disabilitare l'antivirus
- far assegnare staticamente allo shield lo stesso IP usato per la skecth ogni volta che il router trova il MAC Address dello sketch (probabilmente inutile ...)
- resettare e usare la configurazione di default

Per lo shield, ho provato ad usare gli IP 192.168.0.4, 192.168.0.5, 192.168.0.50, 192.168.0.100.
Ho anche provato a ridurre il numero di pacchetti inviati riducento i comandi client.print() e client.println().
Il tutto senza successo.

Non riesco proprio a capire cosa possa essere.
Sto pensando che possa essere un bug della libreria Ethernet che crea pacchetti non completamente compatibili con i router ADSL italiani (sembra che in USA non abbiamo lo stesso problema). Magari un byte che non piace e non influisce nell'uscita ma che quando riceve impedisce il corretto reindirizzamento interno e allora lo ignorano.

Avete incontrato un problema simile? Avete qualche suggerimento da darmi?

Grazie! Ciao!

[Reply #1 on:]

Ciao,
premetto che ho riletto più volte il post, ma non mi è tutto chiaro.

Poi:
- gli ip che hai detto di utilizzare, fanno parte della tua rete?
- utilizzi la Eth shield con ip statico o in dhcp (che ide usi)?
- se statico, definisci nello sketch il gateway?
- domanda banale ma d'obbligo: alimentazione e cavi di rete sono OK?

Se posti lo sketch magari possiamo capire qualcosina di più.

[Reply #2 on:]

Ciao,
premetto che ho riletto più volte il post, ma non mi è tutto chiaro.

Con il passaggio all'italiano, le mie spiegazioni rimangono scarse  

Se mi dici quali punti in particolare, ci riprovo.

In pratica, ho uno skecth che riesce a spedire ma non a ricevere quando lo shield e' collegato ad un router adsl mentre riesce a spedire e ricevere quando e' collegato ad un pc che fa da router oppure e' collegato direttamente alla rete con un IP non NAT.

Poi:
- gli ip che hai detto di utilizzare, fanno parte della tua rete?

Si, i vari 192.168.0.X sono quelli della rete NAT-ata dietro il router ADSL. Quello pubblico e' un IP della rete aziendale.

- utilizzi la Eth shield con ip statico o in dhcp (che ide usi)?

Statico. Per l'ide, intendi quello dell'arduino? E' il 022.

- se statico, definisci nello sketch il gateway?

Provato senza e con (gateway 192.168.0.1 - mask 255.255.255.0)

- domanda banale ma d'obbligo: alimentazione e cavi di rete sono OK?

Si, sono gli stessi cavi che uso quando non lo collego al router ADSL.

Se posti lo sketch magari possiamo capire qualcosina di più.

Scusate. Eccolo. Lo ho semplificato mettendo le parti incriminate. Dietro un router ADSL non arriva mai a Serial.print(c);

Code:

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

byte mac[6] = { 0x90, 0xA2, 0xDA, 0x00, 0x36, 0x01 };
byte ip[4] = { 192, 168, 0, 4 };
const char url[]="/terms";


byte server[4] = { 156, 148, 18, 164 };
Client client(server, 80);
int i;
char c;

void setup() {
  for(i = 2; i < 10; i++){
    pinMode(i, OUTPUT);
    digitalWrite(i, LOW);
  }
  for(i = 14; i < 20; i++){
    pinMode(i, OUTPUT);
    digitalWrite(i, LOW);
  }
  Serial.begin(9600);
  Ethernet.begin(mac, ip);
  delay(1000);
}

void loop() {
  if (client.connect()) {
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.println();
    Serial.println("           ");
    Serial.println("reading ...");
    while (client.available()){
        c = client.read();
        Serial.print(c);      
     }
  }
  client.stop();
  delay(1000);
  Ethernet.begin(mac, ip);
}

[Reply #3 on:]

Dimenticavo, ho provato anche ad aumentare il delay dentro loop() siano a 3000 ... senza successo.

[Reply #4 on:]

prova a mettere un delay prima del while, e forse ci vuoloe un'altro client.println();

[Reply #5 on:]

Per la HTTP request bastano quei 2 println (quello del comando e poi uno vuoto).

Il delay non dovrebbe servire, quel while dovrebbe proprio far aspettare sino a che non e' disponibile. Comunque una prova la si fa. Grazie.

[Reply #6 on:]

Per la HTTP request bastano quei 2 println (quello del comando e poi uno vuoto).

vero, ma per sicurezza..

Il delay non dovrebbe servire, quel while dovrebbe proprio far aspettare sino a che non e' disponibile. Comunque una prova la si fa. Grazie.

questo non è vero. come fa a sapere che ci sono dei byte available? perchè è già arrivato un pacchetto, è stato analizzato e i dati sono stati messi nel buffer (più o meno), infatti available non è altro che la dimensione del buffer. Ma se questo controllo lo fai prima che arrivi il messaggio di risposta (e quindi prima di un intervallo di tempo di poco maggiore del PING) risulta che non ci sono dati disponibili, e chiudi la connessione.

[Reply #7 on:]

Da qualche parte avevo letto che client.available() era bloccante ... Non lo ho verificato nel codice.
E vedendo sul monitor, tra un "reading" e il successivo passano alcuni secondi. Non solo l'1 del delay. Per cui mi sono fidato di quello che avevo letto.

Comunque lo si prova. Magari attaccando la board al router c'e' un qualche strano ritardo.

La cosa che mi lascia un po sorpreso e' che non succede se attacco la board al PC, uso questo come router, e il PC e' connesso al router ADSL via Wi-Fi. Un pezzo in piu' dovrebbe creare un minimo ma maggiore ritardo. Boh. Ma le strane strade HW-SW sono, a volte, misteriosamente intrecciate.

[Reply #8 on:]

le info sulle librerie si prendono dal reference...
http://arduino.cc/en/Reference/Ethernet

[Reply #9 on:]

Purtroppo in quella reference non c'e' scritto se e' bloccante, non bloccante o fa x tentativi per n secondi
Per quello avrei dovuto verificare nel codice ...

[Reply #10 on:]

scusa dice che ritorna il numero di byte in attesa di essere letti... quindi non è bloccante, se non ci sono byte ritorna 0.

altrimenti sarebbe espressamente scritto

[Reply #11 on:]

Infatti faro' di sicuro la prova
lesto, grazie del suggerimento

Il dubbio che ho scritto riguarda il fatto che succeda solo collegando lo shield direttamente al router adsl, mentre aggiungendo un nodo al collegamento (pc che fa da router), non succede. Riceve bene anche se dovrebbe essere una situazione peggiore ...

[Reply #12 on:]

Grazie a lesto e ad un americano per avermi messo sulla buona strada . Con il delay(500) funzionava qualche volta.
Ho inserito un while che aspetta sino ad un massimo di 5 secondi oppure sino a che non e' disponibile un byte da leggere.
Provato per alcune ore e ha funzionato bene in tutti i casi: uso di IP pubblico, pc che da router collegato all'adsl o con chiavetta HSDPA e finalmente con la connessione diretta al router adsl.

Di seguito il codice.

Code:

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

byte mac[6] = { 0x90, 0xA2, 0xDA, 0x00, 0x36, 0x01 };
byte ip[4] = { 192, 168, 0, 4 };
const char url[]="/";


byte server[4] = { 74,125,65,99 };
Client client(server, 80);
int i;
int waiting;
char c;

void setup() {
  for(i = 2; i < 10; i++){
    pinMode(i, OUTPUT);
    digitalWrite(i, LOW);
  }
  for(i = 14; i < 20; i++){
    pinMode(i, OUTPUT);
    digitalWrite(i, LOW);
  }
  Serial.begin(9600);
  Ethernet.begin(mac, ip);
  delay(1000);
}

void loop() {
  if (client.connect()) {
    client.print("GET ");
    client.print(url);
    client.println(" HTTP/1.1");
    client.println();
    Serial.println("           ");
    Serial.println("reading ...");

    waiting = 0;
    while (!client.available() && waiting < 5000){
       delay(1);
        waiting++;
    }

    while (client.available()){
        c = client.read();
        Serial.print(c);      
     }
  }
  client.stop();
  delay(1000);
  Ethernet.begin(mac, ip);
}

[Reply #13 on:]

bella soluzione