WebServer mit Html-Seiten von der SD Karte

[Rainer_R]

Wer hat einmal mit der aktuellen Hardware (Mega+EtherShield R3) einen WebServer aufgebaut und getestet der HTML-Seiten von der SD Karte verwendet.
Gibt es mit der notwendigen Umschaltung des SPI Bus (W5100 and SD card share the SPI bus) Probleme?
Da das Lesen des Html-File von der SD und schreiben der Daten über den Ethernet-Kanal unmittelbar nacheinander erfolgt.

[pylon]

http://code.google.com/p/webduino/

[Rainer_R]

Leider nix dabei ..... =(

[pylon]

Leider nix dabei .....

Das ist ein Webserver, der die Webseiten von der SD-Karte holt. Das war genau das, was Du nachgefragt hast. Sollte es Deine Erwartungen nicht erfüllen, rate ich Dir dringendst, diese auch auszuformulieren, meine Hellseherin vom Dienst streikt wieder einmal.

[mkl0815]

Stimmt nicht ganz. Es gibt keine Funktion, welche Webseiten von einer SD-Karte liest. Zumindest habe ich keine gefunden. Es wäre nun zu prüfen, ob das trotzdem klappt.
Selbst beim Image-Beispiel wurde das Bild in den Code gepackt.

[Rainer_R]

Stimmt  - das zuvor genannte Beispiel ist keines.

Bin gerade dabei das einmal zu versuchen:
Wobei ich vorher die SD Card freigebe.

void readHtmlFile( EthernetServer server)
{
 char c;
 char FileName[] = "HtmlFile.html";

 if (SD.exists(FileName))
 {
   File htmlfile;
   
   htmlfile = SD.open(FileName);
   if (htmlfile)  
   {
     while ((c = htmlfile.read()) > 0) { server.print((char)c);  }
     htmlfile.close();
   }
 }else{
   Serial.println("Html-File nicht vorhanden");
 }
}

Ob das wohl funktioniert ?

[mkl0815]

Code: [Select]


File htmlfile;
   
    file = SD.open(FileName);
    if (htmlfile) 


Da ist noch ein kleiner Fehler drin: "htmlfile = SD.open(...)" statt "file= SD.open...)"

[pylon]

Was ist mit diesem Projekt?

https://github.com/ovidiucp/TinyWebServer

"Serving files from the SD card"

Das Problem liegt mehr im Speicherverbrauch. Die SD-Bibliothek braucht 512 Byte als Puffer für den Kartenbetrieb, da muss sich der Webserver ganz schön zurück nehmen und darf kein Byte verschenken, sonst wird's auf einem UNO schnell mal eng.

[Rainer_R]

Diese Info bringt nichts und trifft wohl eher auch nicht zu - man kann ja ein Mega-Board  nehmen.

Welcher mögliche Vorteil wäre es, umfangreiche Webseiten extern zu speichern und nur zum Senden abzurufen,
gegenüber dem Speichern dieser Seite bzw. mehrer Seiten und diese über Progmem zu flashen.
Auch die Änderungsfreundlichkeit dieser WebSeiten auf der SD Card gegenüber dem erneuten Flashen ist ein wichtiger Punkt.

Aber leider in hier im ganzen Forum (nicht nur unter Deutsch) wenige bis keine Antworten zu diesem Thema zu finden.

[Trib]

Hallo Rainer_R,

was genau möchtest du denn bewirken?
Der Betrieb eines Webservers mit den Daten von der SD-Karte ist kein Problem. Es muss halt alles nur wie schon beschrieben nacheinander passieren. Codes dafür gibt es wie Sand am Meer. Z.B. diesen
Allerdings ist dazu er Arduino nur im Einzelbetrieb einsetzbar. Sobald mehrere Leute gleichzeitig zugreifen wollen oder die Seiten ein paar KB überschreiten, muss man auf eine andere Lösung setzen.

Und was spricht gegen einen Hybriden? Die Seite(n) und Bilder auf einen Webserver legen und auf deiner Seite auf der SD-Karte einbetten.
Auch kann man über ein simples JavaScript Daten vom Arduino auslesen. Das ist auch mit einer extern gelagerten Seite kein Problem und wurde im Forum auch schon ausreichend beschrieben.

Aus eigener Erfahrung kann ich sagen, um eine Webseite zum steuern und anzeigen von ein paar Daten des Arduino eignet sich diese Lösung noch. Für mehr muss man dann auslagern und ggf. sogar die Daten des Arduinos in einer Datenbank ablegen wenn viele Nutzer erwartet werden.

[Rainer_R]

Hallo Trib,

danke für deine umfangreiche Antwort.

Die Beispiele unter deinem Link "ethfiles" gehen in die Richtung, entspricht jedoch nicht meiner Frage.
Die hier gezeigen Beispiele holen Datei-Namen von der SD Card und senden diese dann mittels Webserver.
Hier kann man, wie du richtig beschreibst, alles der Reihe nach abarbeiten. Das funktioniert und ist getestet.
In diese Richtung gibt es in der Tat Beispiele wie Sand am Meer - diese sind jedoch alle irgendwo gleich.

Mit einer HTML-Seite auf der SD Card ist das aber was anderes -->  hier wird "gleichzeitig" der File, evt. Zeichen für Zeichen
oder evt. über einen kleinen Buffer, von der Karte gelesen und gesendet. Ob hier der SPI Bus im Wege das ist die Kernfrage.
Ich kenn keine Arduino-Applikation (im Netz) das diese Möglichkeit aufzeigt, es realisiert hat bzw. eine Lösung  bietet.

Grundsätzlich kann ich auch auf ein anderes System wechseln - falls der ADRDUINO überfordert ist.
Das beantwortet jedoch nicht meine Frage.
Denn falls das mit HTML-Seiten von der SD Card funktioniert, wäre ich einen großen Schritt weiter.

Welcher "Hybrid" käme denn für eine weitergehende Anwendung in Frage?

[Trib]

Guten Morgen Rainer_R,

jetzt verstehe ich! Das liegt sicherlich damit zusammen, dass ich den Sketch schon vor längerer Zeit angepasst habe und die Funktion die Seite direkt darzustellen als "gegeben" hingenommen habe.

Folgender Code öffnet die Datei und gibt im Falle einer HTML-Seite auch den entsprechenden Header mit:

Code: [Select]

while (client.connected())
    {   
      if (client.available())
      {     
        char c = client.read();
       
        // If it isn't a new line, add the character to the buffer
        if (c != '\n' && c != '\r')
        {
          clientline[index] = c;
          index++;
          // are we too big for the buffer? start tossing out data
          if (index >= BUFSIZ)
            index = BUFSIZ -1;
         
          // continue to read more data!
          continue;
        }
       
        // got a \n or \r new line, which means the string is done
        clientline[index] = 0;
               
        // Look for substring such as a request to get the root file
        if (strstr(clientline, "GET / ") != 0)
        {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("<html><body bgcolor='#444444' text='#c0c0c0'>");
          client.println();
         
          // print all the files, use a helper to keep it clean
          client.println("<h2>Files:</h2>");
          ListFiles(client, LS_SIZE);
          client.println("<p><a href='INDEX.HTM'>zur&uuml;ck</a></p></body></html>");
        }
        else if (strstr(clientline, "GET /") != 0)
        {
          // this time no space after the /, so a sub-file!
          char *filename;
         
          filename = clientline + 5; // look after the "GET /" (5 chars)
          // a little trick, look for the " HTTP/1.1" string and
          // turn the first character of the substring into a 0 to clear it out.
          (strstr(clientline, " HTTP"))[0] = 0;
         
          // print the file we want
//          Serial.println(filename);
          // File couldn´t be opened
          if (! file.open(&root, filename, O_READ))
          {           
            //If it is an command, work with it
            if(filename[0] == '?')
            {
              //Command to control Arduino Pins
              ProcessWebInput(client, filename);
              break;
            }             
            else
            {
            // Print 404
            client.println("HTTP/1.1 404 Not Found");
            client.println("Content-Type: text/html");
            client.println();
            client.println("<h2>File Not Found!</h2>");
            }
            break;           
          }
         
          //It really is a File
//          PgmPrint("Opened!");                   
          client.println("HTTP/1.1 200 OK");
         
          if(strstr(clientline, "HTM") != 0 || strstr(clientline, "TML") != 0)
            client.println("Content-Type: text/html");         
          else
            client.println("Content-Type: text/plain");
          client.println();
         
          int16_t c;
          while ((c = file.read()) > 0)
          {
              // uncomment the serial to debug (slow!)
              //Serial.print((char)c);
              client.print((char)c);
          }
          file.close();
        }
        else
        {
          // everything else is a 404
          client.println("HTTP/1.1 404 Not Found");
          client.println("Content-Type: text/html");
          client.println();
          client.println("<h2>File Not Found!</h2>");
        }
        break;
      }
    }
(Die Anpassung stammt aus meinen Anfängen beim Arduino. Es gibt sicherlich schönere Lösungen mit den Strings.)

Damit kann man die Seiten darstellen, Bilder öffnen oder auch Textdateien im Browser anzeigen.
Der Trick ist halt der Content-Type: text/html.

Bzgl. Hybrid:
Die Dateien, die ich selten bis nie anfasse liegen bei mir auf einem uralten gratis Webserver. Icons und Bilder, JavaScript-Dateien und eine Seite, in deren iFrame die HTML-Seite von der SD-Karte eingebettet wird.
Alleine die Auslagerung des Seiten-Icons hat die Performance beim Laden verdoppelt

[Rainer_R]

Auch Guten Morgen Trib,

danke für den Sketch - ist soweit auch verstanden.
Jedoch eine Frage noch zu deinem Code hätte ich.
Wo ist definiert und was ist : ProcessWebInput(client, filename);

[Trib]

Diesen IF-Zweig kannst du eigentlich löschen.

Das ist eine Anpassung, die ich für meine Steuerung benötige.
Per Web-Interface kann ich Pins an- und ausschalten, Werte vom Analog-Pin auslesen, die Farbe und das Muster von meinem LED-Tisch ändern, usw.
Dazu habe ich eine HTML-Formular, welches dann die Entsprechenden Werte übermittelt.
Wie ich das gelöst habe, kannst du hier nachschauen.
Wie die Farbe umgestellt werden kann, habe ich im englischen Bereich mal "beleuchtet"

Wobei ich gerade sehe, dass dies noch eine veraltete Version ist. Die sollte ich dort mal aktualisieren

[Rainer_R]

Herzlichen Dank für all' die Infos.