Contiki Webserver und CGI/ServerSkripte

Hat jemand verstanden wie man im Webserver in Contiki CGI/ServerSkripte implementiert?
Nach dem Quellcode zu urteilen, macht der Contiki Webserver etwas,
wenn er Skripte erkennt. Aber ich kriege es nicht konfigiriert.
Hat damit schon mal jemand rumgespielt?
Ich würde gern Prozesse aus dem Webserver heraus starten, um z.B. einen Temperatursensor auszulesen
und in der Webseite anzuzeigen.

Vom Source Code her kann er mehr.
aber der Code ist nicht so leicht zu verstehen.
Er kann auch .shtml Seiten und behandelt diese gesondert.
Da Contiki für viele Plattformen gebaut ist, muss man sich durch
die Ausnahmen hangeln.

neu Erkenntnis: leider
Für die Plattform c64 wird nicht der httpd.c webserver gebaut, sondern
der einfache httpd-cfs.c ( cfs steht für Contiki File System).
Dieser Webserver kennt keine shtml oder Skripte.
Schade.

Mal sehen ob ich den httpd-cfs ggf. ein wenig erweitern kann.
Man müsste beim Lesen des HTML Files auf %! scannen.
Das kostet aber viel Zeit.

es soll ja nicht irgendwo erscheinen, sondern im webbrowser des Clients. Dazu
muss man den HTML source code erweitern, oder eine virtuelle Seite erzeugen, die
dynamisch aufgebaut wird. Dann kann man die Info mit nem iframe einbetten.

Ich werde wohl letzteren Weg gehen, da das Parsen onthefly zu viel Ressourcen kostet.

Neben Temeperatur kann natürlich alles Mögliche eingebettet werden, was man so an
die Schnittstelle hängen kann.

Ne Webcam ist auch denkbar aber overkill. Mein Userport Videoscanner braucht 4-5s pro Bild
in Graustufen. Das will man nicht wirklich.

Ein paar I/Os könnte man zur Heimautomatisierung nehmen.Fenster zu?

Zitat von Vernunftmensch

sowas geht natürlich nicht,

aber die ziffern 0-9 als gif kostet nicht sooooo viel speicherplatz

und anders als andere c64-contiki-anwendungen hat der webserver viele kb übrig gelassen um die entstehende http seite zu programmieren während sie rausgestreamt wird.

oh, schöne Idee! Die Ziffern als Gif sähen cooler aus!
Platz hat der webserver tatsächlich gelassen.
mal schauen wohin es führt. ywenn klappt kommen sourcen und Beispiele in diesen Thread

OK, hat mich ein wenig Zeit gekostet den Webserver von Contiki zu verstehen.
Es gibt eigentlich zwei Webserver:
- der eine liest die HTML Files direkt von der Diskette
- der andere hat ein im Speicher statisch abgelegtes Filesystem

Unterscheiden tuun sie sich beim Bauen:
Der eine Webserver mit dem CFS Disketten basierten Fileformat wird mit
make -C contiki-2.5/examples/webserver disk TARGET=c64 HTTPD-CFS=1
gebaut. Der andere mit
make -C contiki-2.5/examples/webserver disk TARGET=c64 HTTPD-CFS=0

Beide haben ihre Vor- und Nachteile.

beim CFS=1 basierten, kann man die ganze Diskette mit Daten vollschreiben.
Dafür ist er (selbst mit SD-Karte) recht langsam. Die Daten müssen ja bei jedem
Aufruf von der Diskette gelesen werden. Große Bilder sollte man da nicht nehmen. Da
kann der Seitenaufbau schon mal 30 Sekunden und länger dauern.

beim CFS=0 basierten, kann man zwar nicht so viele Files ablegen, der Speicher
ist ja begrenzt und schnell voll (da merkt man erst, wie verschwenderisch HTML doch ist).
Dafür kann diese Variante SSI, d.h. es kann CGI "Skripte" ausführen.
Dabei ist "Skripte" zu viel gesagt. Man kann eingebaute Befehle im HTML Code aufrufen.
Im Moment sin 3 definiert:
- files: zeigte die Anzahl der Zugriffe auf die gespeicherten Dateien an
- processes: zeigt Infos zu den laufenden Contiki Prozessen an
- tcp_status: zeigt ein paar TCP/IP Infos an

Man kann aber sehr einfach, sich einen eigenen webserver bauen (auf Baisis des Beispiels unter "examples")
und diesen sehr einfach um eigene CGI Befehle erweitern.

Wenn ich die zeit finde, werde ich einen Blog aufsetzen und alles dort beschreiben. Bis dahin einfach bei Interesse hier fragen.

PS: Wichtiger Punkt (der mich fast 2 Tage gekostet hat): Wenn man mit CGI Skripten arbeiten will,
dann muss das HTML File zum einen .shtml heißen und es muss im Unix Format gespeichert sein,
nicht im DOS Format!

Ja, eine REU wäre gut. Aber die müsste mit dem RR-Net harmonieren. Müsste man mal ausprobieren, ob die den gleichen IO Bereich benutzen,
sonst wird das nix. Ich habe nur einen RR-Net MK3 zu Hause. Wenn die nicht zusammenarbeiten, bräuchte man eine
Netzwerkkarte am User-Port.

Ein Schritt nach dem anderen.

Ich habe einen Blog bei Tumblr aufgesetzt, in dem ich alle Schritte hin zu einem Webserver in einer Brotbox dokumentieren werde.
Er wird in Englisch sein (auch wenn das bestimmt ein schreckliches Englisch sein wird).
Für Anmerkungen etc. bin ich offen. Der Blog wird sich Schritt für Schritt und nach und nach entwickeln.
Auch wenn ich heute schon weiter bin, muss ich die ganzen Schritte erst mal nachdokumentieren.

https://commodore64breadbox.tumblr.com/

Neue brauchbare Zwischenergebnisse werde ich auch hier poten

Wenn es draußen heiß wird, soll man ja im kühlen Zimmer bleiben. Also habe ich mich nochmal an die CGI Geschichte gewagt.
War gar nicht so schwer.
Wie schon oben geschrieben muss man den Contiki Webserver mit
make -C contiki-2.5/examples/webserver disk TARGET=c64 HTTPD-CFS=0
übersetzen. Dann hat man zwar nicht das SD-Karten Filesysstem, sondern nur das In-Memory File-System,
aber dafür volle CGI Kontrolle.
Ich habe mal einen Webserver aufgesetzt, der Temperaturwerte über den Userport einliest und das ganze mittels AJAX dynamisch
im Browser darstellen kann.
im Detail werde ich es auf jedem Fall in meinem Blog beschreiben: https://commodore64breadbox.tumblr.com
Hier schon mal die Highlights:
Als Basis für meinen Webserver habe ich das Beispiel aus den Contiki Examples genommen. Ich bin noch bei Contiki 2.5,
da dieses Version ja noch supported wurde. Später ggf. mal auf 3.0 migrieren.

Wenn man also den Webserver ohne das CFS Filesystem übersetzt, kann man nur auf die In-Memeory Files zugreifen.
Diese zu erzeugen sind ganz einfach. Man muss sich nur aus dem Verzeichnis
....\contiki-2.5\apps\webserver
den Ordner httpd-fs und die Datei httpd-fsdata.c kopieren. In der C Datei liegen die Dateien aus dem Ordner als ASCII Arrays abgelegt.
Das muss man machen, da der Compiler normale Printausgaben in PETSCII ausliefert. Das versteht jedoch kein Browser
Mit dem Perl-Skript makefsdata aus dem Contiki Toolverzeichnis läßt sich einfach der komplette Ordner in diese Form bringen:
perl ....\tools\makefsdata -d httpd-fs

Beim nächsten make werden dann diese neuen Files eincompiliert und stehen dann zur Verfügung. Coole Idee

Natürlich muss man bei den File-Endungen aufpassen. Denn der Webserver muss ja in der HTTP Antwort den Content-Type richtig setzen.

Und leider kennt der Webserver noch keinen Javaskript (JS) und liefert diese dann als "Plain" aus. Das gefällt nicht jedem Browser.

War aber leicht zu patchen.

Um nun seine eigenen CGi Skripte aufrufen zu können, muss man nur einen CGI Handler schreiben.

Sieht dann in etwa so aus:

#include <stdio.h> /* For printf() */
#include <string.h>
#include <stdlib.h>
#include "contiki-net.h"
#include "httpd.h"
#include "httpd-cgi.h"

#include "lib/petsciiconv.h"

#include "webserver-nogui.h"
#include "webserver-strings.c"
#include "tempvalues.h"

int nMyTemperatur=20;
int nMyTemperaturDecimal=0;

PROCESS(get_temp_process,"get temperature process");

/*---------------------------------------------------------------------------*/

void gettemp()
{
int* DDRB=(int*) 56579;
int* CRA=(int*) 56590;
int* PRB=(int*)56577;
int* SDR=(int*)56588;
int* ICR=(int*) 56589;
int* KEY=(int*)198;

int nValue=0;// read value from SDR register
int nTemp=0;
int xPos=0;

//First init all CIA registers
*DDRB=255;//all lines are output lines
*CRA=8+64;*CRA=8;//first clear SDR and then set it to input
*PRB=0;*SDR=0;//empty buffer
*ICR=127;//Set Interrupt flag

// toggle eight times the clock line for eight bits

for (xPos=0;xPos<8;xPos++){
*PRB=0;
*PRB=1;
}

//Wait until interrupt is set
while (*ICR!=0){}
nValue=*SDR;
nTemp=arrTemp[nValue];
//Calculate temperature
*PRB=2; //reset TLC549

nMyTemperatur=nTemp/10;
nMyTemperaturDecimal=abs(nTemp%10);

}

static unsigned short
make_temp(void *p)
{
uint16_t numprinted;
numprinted=snprintf( (char *)uip_appdata, uip_mss(),"%d.%d",nMyTemperatur,nMyTemperaturDecimal);
return numprinted;
}
/*---------------------------------------------------------------------------*/
static
PT_THREAD(MyTemp_thread(struct httpd_state *s, char *ptr))
{
PSOCK_BEGIN(&s->sout);
PSOCK_GENERATOR_SEND(&s->sout, make_temp, s->u.ptr);
PSOCK_END(&s->sout);
}

HTTPD_CGI_CALL(MyTemp, MyTemp_name, MyTemp_thread);

/*---------------------------------------------------------------------------*/
PROCESS_THREAD(get_temp_process, ev, data)
{
static struct etimer timer;
static int nCount=0;
PROCESS_BEGIN();
httpd_cgi_add(&MyTemp);

etimer_set(&timer, 1*CLOCK_SECOND);
while(1) {

PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_TIMER)
{
gettemp();
etimer_reset(&timer);
}
}

PROCESS_END();
}

/*---------------------------------------------------------------------------*/
AUTOSTART_PROCESSES(&webserver_nogui_process,&get_temp_process);
/*---------------------------------------------------------------------------*/

Für die Temepraturmessung habe ich eine alte Schaltung aus einem Bastelbuch von John Iovine aus 1980 genommen. hier der Link.

Die Schaltung und meine Bastelversuche habe ich mal dran gehängt..

Das schöne ist, dass man den TLC548 einfach dranhängen kann und 8-Bit Digitalwerte bekommt, aber ohne das

ganze Timing geraffele wie beim I2C Bus oder so. Mit nem Multiplexer könnte man sogar mehrere dran hängen, aber das kommt später

Das genaue How-To beschreibe ich im oben genannten Blog. Das wäre hier zu viel.

Wird noch ein paar Tage dauern bis ich im Blog alles drin habe. Wer vorher Infos haben will, einfach fragen.

Wenn ich meine RR-Net und Netzteile Probleme endlich im Griff habe, werde ich mit dem Server auch Online gehen. Eingerichtet ist schon alles,

aber wie in anderen Threads beschrieben, habe ich Probleme das RR-Net zum Laufen zu bekommen und Probleme mit meinem Netzteilnachbau.
Ich wollte der Rechner 24/7 laufen lassen. Aber dazu bearfs es noch ein wenig Vorbereitung, beginnend beim Netzteil.

Hallo,

habe nun meinen Blog fertig. Siehe commodore64breadbox.tumblr.com
Darin habe ich alle Schritte beschrieben (wie schon im letzten Post) wie man einen Webserver
mit Temperaturanzeige auf einem C64 aufsetzt. Der Blog erklärt zwar nicht,
wie man das schicke C64 Design hin bekommt, aber das kommt ggf. später
Aber das Webserver Prinzip und die CGI Skripte werden ausführlich erläutert.
Ggf. baut das ja einer nach.

Wenn meine Brotbox zu Hause am Internet hängt kommt der nächste Post.
Ich muss noch auf ein neues C64Netzteil warten und will eine LCD-Matrix Anzeige mit
Statusmeldungen erst ergänzen bevor die Seite live geht. Dabei ist das Netzteil am wichtigsten,
denn für einen 24/7 Betrieb traue ich meinem Türkeil nicht mehr.
Wer will schon der Versicherung erklären, was da die Ursache für das flammende Inferno war