[Risolto] Arduino yun problema sd e wifi

La settimana scorsa mio padre mi ha regalato un Arduino yun. Ho un problema con la sd e il wifi. Con l'esempio TemperatureWebPanel funziona correttamente come web server, con l'esempio Datalogger riesco correttamente a scrivere e leggere dalla SD, ma se provo a inserire un web server che restituisce le pagine dalla SD non funziona. Compila correttamnte, riesco correttamente ad inizializzare la SD con

 Bridge.begin();
FileSystem.begin();

, quando arriva una richiesta il web server restituisce una pagina che legge dalla SD. il file si apre correttamente con File mioFile = FileSystem.open("/mnt/sd/arduino/www/mioprogramma/datalog.txt",  FILE_READ); però quando scrivo if (mioFile.available()) { il loop si ferma in quel punto e non esegue nient' altro. Grazie

esiste un pin che se attivato accende la SD, e un altro che se attivato accende la ethernet. Cioè, non è che li accende, ma dice che i messaggi inviati sono per loro (sia la SD che la ethernet comunicano sullo stessu BUS, il SPI). Quindi o parli con uno o parli con l'altro, e devi essere tu a scegliere con chi parlare di volta in volta.

@lesto, qui si parla della Yun. SD e Ethernet/WiFi sono tutte sul processore linux

@mili1807: non sono sicuro di aver capito cosa intendi. Potresti allegare uno sketch che riproduce questo problema?

Ha che indirizzo ti colleghi nel browser? Con: arduino.local/sd dovresti vedere il contentuo della tua SD se hai fatto tutto correttamente.

[quote author=Federico Vanzati link=topic=193029.msg1429389#msg1429389 date=1381834482] @lesto, qui si parla della Yun. SD e Ethernet/WiFi sono tutte sul processore linux [/quote]

wops, ignoranza mia, scusate

Innanzitutto grazie per le risposte.
Mi collego digitando l’ip dello Yun sul browser: 192.168.100.4 cosi accedo al pannello di configurazione dello Yun. Su 192.168.100.4/sd posso sfogliare i file sulla Sd e con 192.168.100.4/arduino/comando risponde il programma che ho caricato.
Ecco un programma che riproduce l’errore:

#include <Console.h>
#include <Bridge.h>
#include <YunServer.h>
#include <YunClient.h>
#include <FileIO.h>

#define GRAFICO1_FILE “/mnt/sd/arduino/www/programma/grafico1.txt”
#define GRAFICO2_FILE “/mnt/sd/arduino/www/programma/grafico2.txt”
#define DATALOG_FILE “/mnt/sd/arduino/www/programma/datalog.txt”

YunServer server;

unsigned long tempDatalog;
int sensor;
boolean prev_console; //usato nel messaggio di benvenuto nella console

int posizione;
boolean posizione_stato;

void setup() {
//variabili
prev_console = false;

//inizializza le librerie
Bridge.begin();
if (!FileSystem.begin()) {
Console.begin();
Console.println(“errore inizializza filesystem”);
}
server.listenOnLocalhost();
server.begin();
Console.begin();
}

void loop() {
//il web server
YunClient client = server.accept();
if (client) {
Console.println(“nuova richiesta”);
rispondi_richiesta(client);
client.stop();
}

//ogni secondo salva un dato in sd
if (tempDatalog <= (millis() - 1000)) {
tempDatalog = millis();
scriviDati();
}
}

String getTimeStamp() {
String result;
Process time;
// date is a command line utility to get the date and the time
// in different formats depending on the additional parameter
time.begin(“date”);
time.addParameter("+%T"); // parameters: D for the complete date mm/dd/yy
// T for the time hh:mm:ss
time.run(); // run the command

// read the output of the command
while(time.available()>0) {
char c = time.read();
if(c != ‘\n’){
if(c == ‘:’){
result += “,”;
}
else {
result += c;
}
}
}
result += “,0”;
return result;
}

void rispondi_richiesta(YunClient client) {
client.readString();
client.print("Current time on the Yún: ");
client.println(getTimeStamp());
//
//
File dataFile = FileSystem.open(GRAFICO1_FILE, FILE_READ);
Console.println(“file aperto”);
while (dataFile.available()) {
Console.println(“Carattere disponibile”);
client.write(dataFile.read());
}
dataFile.close();
//
//
/*
Console.println(“Sto aprendo il file”);
posizione = 0;
while (1) {
File grafico1File = FileSystem.open(GRAFICO1_FILE, FILE_APPEND);
Console.println(“file aperto”);
posizione_stato = grafico1File.seek(posizione);
if (posizione_stato == true) {
Console.println(“impostata posizione”);
Console.println(grafico1File.peek());
if (grafico1File.peek() != -1) {
Console.println(“carattere disponibile”);
int carattere = grafico1File.read();
posizione = grafico1File.position();
grafico1File.close();
client.write(carattere);
}
else {
Console.println(“errore file”);
grafico1File.close();
break;
}
Console.println(“filechiuso”);
}
else {

grafico1File.close();
break;
}
}
*/
client.print("
Arduino Yun");

}

void scriviDati() {
String dataString;
dataString += “[[”;
dataString += getTimeStamp();
dataString += “]”;
dataString += “,”;
sensor = analogRead(A1);
dataString += String(sensor);
dataString += “],”;
// The FileSystem card is mounted at the following “/mnt/FileSystema1”
File dataFile2 = FileSystem.open(DATALOG_FILE, FILE_WRITE);
if (dataFile2) {
Console.println(dataString);
dataFile2.println(dataString);
dataFile2.close();
}
else {
Console.println(“error opening datalog.txt”);
}
}

Il file datalog.txt viene scritto correttamente ogni secondo con un nuovo valore letto su un ingresso analog, il problema è che se Arduino tenta di leggere un file mentre sta rispondendo a una richiesta web si ferma su :

while (dataFile.available()) {

senza neanche eseguire il ciclo while.

Grazie in anticipo.

Ciao. sei sicuro che si tratti di un problema di contemporaneità SD-wifi? io ho praticamente lo stesso problema ma non uso nessuna funzionalità di rete, tranne ovviamente la console. spiego brevemente la mia situazione e come ho "risolto", magari può esserti utile.

ho un file .ini nella sd e cerco di parsarlo. Il file è il seguente:

[General]
active = true
temp = 23.0

Lo leggo riga per riga, assegnando di volta in volta i byte letti ad una stringa. Il codice funziona correttamente. tuttavia se cerco di leggere questo file:

[General]
activescrivounacosapiulunga = true
temp = 23.0

si comporta esattamente come dici, ovvero non risponde mai la chiamata file.available() un estratto dello sketch che si occupa della lettura:

  File settingsFile = FileSystem.open("/mnt/sd/arduino/settings.ini", FILE_READ);
  if(settingsFile) {
    String row = "";
    while(settingsFile.available() > 0) {
      char c = settingsFile.read();
      if(c == '\n') {
        //row complete
        Console.println("Row read: " + row);
        row = "";
      } else {
        row += c;
      }
    }
  }
  settingsFile.close();

La mia ipotesi è che si tratti di un qualche tipo di buffer overflow sulla gestione dell'append sulla stringa, ma devo ancora investigare in tal senso

Probabilmente la risposta è questa: https://github.com/amicojeko/Arduino-Yun-Gmail-Check/blob/master/GmailCheckLED.ino

la stringa su cui si fa buffer per appendere la riga deve essere allocata.

char buffer[256];
String str_buf;
 str_buf = String(buffer);

File file = FileIO.open ...
while ... {
  Char c = file.read();
  str_buf += c;
}

non l'ho ancora provato ma al 99% risolve il problema

Più probabilmente il problema è questo: http://forum.arduino.cc//index.php?PHPSESSID=tt2uci8mkj2uo4ug9ajp4n7c26&topic=188877.0

Grazie whites11, Seguendo il tuo link ho risolto. Era da parecchio che cercavo una soluzione.

Per spiegare meglio a futuri utenti che dovessero giungere a questo topic, i problemi di lettura "strana" dei file con arduino YUN sono causati da un bug di arduino IDE versione 1.5.4 e risolti con la (attualmente non rilasciata) versione 1.5.5 (per essere precisi un buffer overflow nel codice della libreria Bridge). Confermo che, una volta aggiornato alla versione GIT dell'IDE il problema si è risolto. (poniamo questo thread come RISOLTO?)

In realta io non avevo alcuna lettura strana perche, semplicemente quando chiamavo la funzione file.read() o file.available() il loop si fermava e non eseguiva più nulla, quindi non riuscivo a leggere se non piccoli file. Grazie