Roboter Simulation für Linux

Wie der Titel schon sagt fange ich gerade an ein Robotersimulationsprogramm zu schreiben. Vorstellen tu ich mir das ganze so:
Es gibt ein Grafisches Programm in dem man neue Maps laden , Roboter grund-konfiguieren und die Simulation starten kann.
Die Map besteht aus einer Datei in dem ein array[x][y] Mappoints(simulierte 10cm*10cm oder 20*20) gespeichert ist. Auf einem Point können verschiedene Objekte sein, z.B. einfach ein Gegenstand/Hinderniss, Mauern
aber auch Lichtquellen, Geräuschquellen und was mir später noch so einfällt. Jeder Point hat dadurch auch verschieden Parameter wie helligkeit, Lautstärke, höhe des Objekts usw. Map größen wird es zwei oder drei geben. Mindestens eine 5m*5m große für einen Raum und eine 20m*20m für mehrere Räume.
Später stelle ich mir zu der Mapdatei noch ein mapname Programm vor mit eigener KI, das die Map aktuallisiert. So könnten z.B. Menschen in der Karte herum gehen, Lichter gehen an und aus gehen usw.
Jeder Roboter wird ein eigenständiges Programm werden das mit dem Grafischen Programm kommuniziert, und Position sowie Sensordaten übermittelt.
Auf dem Roboter werden reale Sensoren simuliert, max. Sharp IR Sensoren mit 80cm, mit 150cm und US Sensoren mit 6m Reichweite jeweils max. 8Stck. Sicher wird es noch nen Helligkeitsradar, und Lautstärkenradar (viell. primitiv nur 4 Richtungen) zur auswahl geben. Wahrscheinlich auch einen IR Radar aus 4Stck. Sharp´s 150cm Sensoren.
Einen Roboter wird jeder schreiben können der grundlagen in C kann.
Im Grafischen Programm wählt man aus welche Sensoren auf seinem Roboter alles an sein sollen, anschließend erstellt es eine robotername_status Datei(in der ist gespeichert welche Sensoren an sind) und eine robotername.c in der eine robi_init() am Anfang immer aufgerufen wird. In robi_init() werden verschiedene Threads gestartet um die Position und Sensoren mit hilfe einer Karte zu aktuallisieren, und um die aktuelle Position usw. dem Grafischen Programm mitzuteilen.
Nach der robi_init() kommt nun der Persönliche Code. Mit verschiedenen Funktionen kann man nun seinen eigenen Roboter programmieren.
Also Funtkionen wie.
get_sensor_x()
get_kompass();
roboter_stop()
roboter_geradeaus(geschwindigkeit)
roboter_drehung(X Grad)
usw.
In der robi_init() wird auch ein Thread gestartet der überprüft ob das nächste Kommando ausgeführt werden kann oder ober er z.B. vor einer Wand steht und nicht weiter kann. Dieser Thread benutzt aber nicht die Sensorwerte sonder die Karte selbst.
Im Grafischen Programm wird der Roboter angezeigt mit den aktuellen Sensorwerten. Fast ziemlich sicher wird man auf einen Button drücken können um ein Fenstern zu starten in dem der Roboter in der Karte herumfährt.
Soviel zu meinen Vorstellungen und ich hoffe man konnnte mich verstehen.
Mein ziel ist es, möglichst realistisch zu simulieren ( nicht die Graphik), sodas man die KI vielleicht später auf echte Roboter übertragen kann.
Schreiben tu ich das ganze mit C unter Linux (Ubuntu) und benutze gtk-2.0 und die glib für das Grafische Programm. Für den Roboter wird rein Ansi-C benutzt. Bis jetzt habe ich nur das Grafische Grundprogramm und eine Teil der robi_init() für das eigentliche Roboterprogramm. Bis jetzt kann man einen Roboter erstellen und auswählen welche Sensoren an sein sollen, ihn abspeichern (bis jetzt nur robiname_stat) und anschließen wieder laden. Ein Mapladen Dialog ist vorhanden wobei biss jetzt nur angezeigt wird was man für eine Datei ausgewählt hat. Es wird sicher noch einige Zeit dauern bis eine erste Funktionsfähige Version da ist, da für mich vieles ganz neu ist/war (gkt-2.0,glib, X-Programmierung, Threadprogrammierung), und ich nur darüber gelesen hatte. Aber ich hab zur Zeit viel Freizeit, da ich gerade keine Schule oder sonstiges habe.
Wenn jemand sich denkt wieso nicht unter Windows, ich mag VisualStudio nicht, ich mag die Ungarische Notation nicht. Wobei es auch möglich ist gkt Programme unter Windows auszuführen.
Ich hab den Thread im Open Source Forum aufgemacht da ich, sobald eine lauffähige Version enstanden ist den Sourc Code hier veröffentliche. Oder auch schon früher wenn jemand interesse hat oder aus sonst einem Grund. Hoffentlich wurde es jetzt nicht zu lange.
Gruß Muraad

Hallo,
Ich finde dieses Projekt sehr interessant.
Bin mal gespannt, wie es aussieht, wenn du es in etwa soweit hast,
daß wir es testen können.

Gruß Sebastian

Danke dir izaseba für die Interesse. sowas ist immer nett.
Wenn ich so weiter mache wie bisher denke ich das in einer wocher oder zwei die erste benutzbare Version entstanden ist.
Bis dann
Gruß Muraad

Hallo

Finde Dein Projekt ebenfalls hochinteressant (bin zwar eher auf der Mikrocontrollerseite zuhause), hab einige Kleinigkeiten mit VC programmiert (programmieren müssen), mag es jedoch genauso wenig wie den Rest von MS :- Seid einiger Zeit spiel ich mich jetzt mit GTK unter Linux herum und finde die Bibliothek recht gut, daher freue ich mich schon auf dein Projekt, hoffe dabei einiges lernen zu können.

Gruß

Erstmal danke für die interesse. Freut mich immer wieder \:D/
Ist auch bei mir das erste mal das ich etwas größeres für den PC schreibe. Vorher nur kleine Konsole programme. Dann hab ich mich auch lange nur mit Mikrocontrollern beschäftigt.
Was GTK betrifft, ich liebe es jetzt schon O:) ich finde die Bibliothek so einfach logisch. Und ich mags das man nicht C++ braucht für Graphik.
Auf www.pronix.de gibts zwei Open Books. Das eine ist für Linuxsystemprogrammierung mit C, da ist auch ein Kapitel über gtk.
Und davor eins über X-Programmierung (ist die Stufe unter gtk) ist ganz interessant da erfährt man noch bisschen genauer wie das abläuft. Das Unterprogramm zur graphischen Anzeigen des Roboters (2-D Karte) werde ich wahrscheinlich damit programmieren (X-Libary). Im gtk Kapitel werden ganz gut die Grundzüge eines gtk Programms erklärt. Wobei ich einige Fehler und Probleme hatte wenn ich es später so wie in dem Buch gemacht hab. Und seitdem schau ich fast nur noch in das Gtk Tutorial auf http://www.gtk.org/tutorial/ oder in die API Referenz. Aber die Grundlagen wie Widgets Packen, Signals (connecten) usw. werden in dem Buch ganzgut erklärt.
Wenn du irgendwelche Hilfe mit gtk brauchst kannst du mich gerne Fragen.
Gruß Muraad

Danke für den Buchtipp (ist fürs Verständnis sehr hilfreich)
Wie sieht’s mit dem Projekt aus?

Gruß

Hallo,

etwas ähnliches gibt es natürlich schon.
Am bekanntesten dürfte wohl das Player/Stage Projekt sein:
http://playerstage.sourceforge.net/stage/stage.html
http://playerstage.sourceforge.net/gazebo/gazebo.html

Auch ganz schick (für Matlab):
http://www.cas.kth.se/toolbox/

das reale simulieren der sensoren ist ein traum und dann gleich mehrere.
man bekommt nur annähernd die werte. es ist dann halt ein spiel, man kann aber keine wahre auswertung fürs leben machen.
mfg pebisoft

Pebisoft simuliert nicht, also kann das nichts gescheites sein

Zitat:

---

Zitat von pebisoft

das reale simulieren der sensoren ist ein traum und dann gleich mehrere.
man bekommt nur annähernd die werte. es ist dann halt ein spiel, man kann aber keine wahre auswertung fürs leben machen.

---

Mal davon abgesehen, dass das "Leben" nur eine Simulation auf einer anderen Ebene ist (es passiert alles nur in deinem Kopf), ist es ein leichtes simulierten Sensorwerten simulierte Ungenauigkeiten hinzuzufügen. Dann kann man sehr schön testen bis zu welchem "Störlevel" ein Algorithmus stabil ist, ohne den Robby dauernd umzubauen. Selbst das Simulieren an sich kann echt spannend sein, weil ein komplexes Verhalten nicht unbeding ein komplexes Programm (=Regeln) voraussetzt (siehe zB. Schach oder Life)
ciao .. bernd

@Bernd

Dein Bemühen ehrt dich, aber ich glaube es hat keinen Sinn.
Ich habe selten jemand mit einem so engen Horizont gesehen.

Was Pebisoft macht = Gut
Alles andere = Schlecht, kann nichts sein

Ich finde so eine Einstellung sehr bedauernswert.

LG
Rubi

Zitat:

---

Zitat von Rubi

..
Was Pebisoft macht = Gut
Alles andere = Schlecht, kann nichts sein

---

stimmt schon, er macht manchmal einen -- hmm -- recht dogmatischen Eindruck. Den Küchenbrettroboter finde ich allerdings garnicht so schlecht.
Meiner wird natürlich besser, und das ist natürlich objektiv ;-)

ciao .. bernd

Zitat:

---

Zitat von bhm

Den Küchenbrettroboter finde ich allerdings garnicht so schlecht.

---

Ja der gefällt mir auch gut.
Ist eine ideale Testplatform.

Zitat:

---

Zitat von bhm

Meiner wird natürlich besser, und das ist natürlich objektiv ;-)

---

Aber wehe Du nimmst kein Küchebrett.
Übrigends es muß rote Punkte haben und Design by Pebisoft muß draufstehen, sonst kann das nichts werden.

LG
Rubi

schaut ihn euch an...neues äußeres technisches design...unter :

album.persönliche galerie.pebisoft

programmiert mit "fastavrbasic" für den avr und "BCX - The Open Source BASIC To C Translator for Windows" auf dem pc.

...gameboycam...funkfarbcam...datenspeicherung auf palm m105...raumscanner vorn und hinten (srf04)....easy-funk-modul...sharpsensoren...compasmodul....2 steckbretter....asuro als anhängsel...


einfach zusammenbaubar, modulare umbauweise...alles einfach geschraubt,
kabelverbindungen alle gesteckt...ideal für versuche mit den beiden steckbrettern auf dem robby, teile schnell auswechselbar, kann einfach umstrukturiert werden, daten und messpunkte sind überall abgreifbar und speicherbar usw...usw...


neuester spass :
kann mit einer ir-diode auf dem küchenbot den 49 euro robosapien steuern. das heisst , der küchenbot fährt los und holt den robosapien per ir-befehl nach und lässt ihn dann bestimmte arbeiten
verrichten.

jungs, das ist ein schönes hobby.

der code für einpaar scrollbalken ist aber ein bisschen aufgebläht in gtk.
in http://rjpcomputing.com/?page_id=7 geht es einfacher. schau dort einmal rein.

Code:

---

#include <gtk/gtk.h>

GtkWidget *hscale, *vscale;

static void cb_pos_menu_select( GtkWidget      *item,
                                GtkPositionType  pos )
{
    /* Set the value position on both scale widgets */
    gtk_scale_set_value_pos (GTK_SCALE (hscale), pos);
    gtk_scale_set_value_pos (GTK_SCALE (vscale), pos);
}

static void cb_update_menu_select( GtkWidget    *item,
                                  GtkUpdateType  policy )
{
    /* Set the update policy for both scale widgets */
    gtk_range_set_update_policy (GTK_RANGE (hscale), policy);
    gtk_range_set_update_policy (GTK_RANGE (vscale), policy);
}

static void cb_digits_scale( GtkAdjustment *adj )
{
    /* Set the number of decimal places to which adj->value is rounded */
    gtk_scale_set_digits (GTK_SCALE (hscale), (gint) adj->value);
    gtk_scale_set_digits (GTK_SCALE (vscale), (gint) adj->value);
}

static void cb_page_size( GtkAdjustment *get,
                          GtkAdjustment *set )
{
    /* Set the page size and page increment size of the sample
    * adjustment to the value specified by the "Page Size" scale */
    set->page_size = get->value;
    set->page_increment = get->value;

    /* This sets the adjustment and makes it emit the "changed" signal to
      reconfigure all the widgets that are attached to this signal.  */
    gtk_adjustment_set_value (set, CLAMP (set->value,
                                          set->lower,
                                          (set->upper - set->page_size)));
    g_signal_emit_by_name(G_OBJECT(set), "changed");
}

static void cb_draw_value( GtkToggleButton *button )
{
    /* Turn the value display on the scale widgets off or on depending
    *  on the state of the checkbutton */
    gtk_scale_set_draw_value (GTK_SCALE (hscale), button->active);
    gtk_scale_set_draw_value (GTK_SCALE (vscale), button->active); 
}

/* Convenience functions */

static GtkWidget *make_menu_item ( gchar    *name,
                                  GCallback  callback,
                                  gpointer  data )
{
    GtkWidget *item;
 
    item = gtk_menu_item_new_with_label (name);
    g_signal_connect (G_OBJECT (item), "activate",
                      callback, (gpointer) data);
    gtk_widget_show (item);

    return item;
}

static void scale_set_default_values( GtkScale *scale )
{
    gtk_range_set_update_policy (GTK_RANGE (scale),
                                GTK_UPDATE_CONTINUOUS);
    gtk_scale_set_digits (scale, 1);
    gtk_scale_set_value_pos (scale, GTK_POS_TOP);
    gtk_scale_set_draw_value (scale, TRUE);
}

/* makes the sample window */

static void create_range_controls( void )
{
    GtkWidget *window;
    GtkWidget *box1, *box2, *box3;
    GtkWidget *button;
    GtkWidget *scrollbar;
    GtkWidget *separator;
    GtkWidget *opt, *menu, *item;
    GtkWidget *label;
    GtkWidget *scale;
    GtkObject *adj1, *adj2;

    /* Standard window-creating stuff */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (window), "destroy",
                      G_CALLBACK (gtk_main_quit),
                      NULL);
    gtk_window_set_title (GTK_WINDOW (window), "range controls");

    box1 = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (window), box1);
    gtk_widget_show (box1);

    box2 = gtk_hbox_new (FALSE, 10);
    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
    gtk_widget_show (box2);

    /* value, lower, upper, step_increment, page_increment, page_size */
    /* Note that the page_size value only makes a difference for
    * scrollbar widgets, and the highest value you'll get is actually
    * (upper - page_size). */
    adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
 
    vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));
    scale_set_default_values (GTK_SCALE (vscale));
    gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);
    gtk_widget_show (vscale);

    box3 = gtk_vbox_new (FALSE, 10);
    gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);
    gtk_widget_show (box3);

    /* Reuse the same adjustment */
    hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
    gtk_widget_set_size_request (GTK_WIDGET (hscale), 200, -1);
    scale_set_default_values (GTK_SCALE (hscale));
    gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
    gtk_widget_show (hscale);

    /* Reuse the same adjustment again */
    scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));
    /* Notice how this causes the scales to always be updated
    * continuously when the scrollbar is moved */
    gtk_range_set_update_policy (GTK_RANGE (scrollbar),
                                GTK_UPDATE_CONTINUOUS);
    gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);
    gtk_widget_show (scrollbar);

    box2 = gtk_hbox_new (FALSE, 10);
    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
    gtk_widget_show (box2);

    /* A checkbutton to control whether the value is displayed or not */
    button = gtk_check_button_new_with_label("Display value on scale widgets");
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
    g_signal_connect (G_OBJECT (button), "toggled",
                      G_CALLBACK (cb_draw_value), NULL);
    gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
    gtk_widget_show (button);
 
    box2 = gtk_hbox_new (FALSE, 10);
    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);

    /* An option menu to change the position of the value */
    label = gtk_label_new ("Scale Value Position:");
    gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
    gtk_widget_show (label);
 
    opt = gtk_option_menu_new ();
    menu = gtk_menu_new ();

    item = make_menu_item ("Top",
                          G_CALLBACK (cb_pos_menu_select),
                          GINT_TO_POINTER (GTK_POS_TOP));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
    item = make_menu_item ("Bottom", G_CALLBACK (cb_pos_menu_select),
                          GINT_TO_POINTER (GTK_POS_BOTTOM));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
    item = make_menu_item ("Left", G_CALLBACK (cb_pos_menu_select),
                          GINT_TO_POINTER (GTK_POS_LEFT));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
    item = make_menu_item ("Right", G_CALLBACK (cb_pos_menu_select),
                          GINT_TO_POINTER (GTK_POS_RIGHT));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
    gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
    gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
    gtk_widget_show (opt);

    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
    gtk_widget_show (box2);

    box2 = gtk_hbox_new (FALSE, 10);
    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);

    /* Yet another option menu, this time for the update policy of the
    * scale widgets */
    label = gtk_label_new ("Scale Update Policy:");
    gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
    gtk_widget_show (label);
 
    opt = gtk_option_menu_new ();
    menu = gtk_menu_new ();
 
    item = make_menu_item ("Continuous",
                          G_CALLBACK (cb_update_menu_select),
                          GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
    item = make_menu_item ("Discontinuous",
                          G_CALLBACK (cb_update_menu_select),
                          GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
    item = make_menu_item ("Delayed",
                          G_CALLBACK (cb_update_menu_select),
                          GINT_TO_POINTER (GTK_UPDATE_DELAYED));
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
    gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
    gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
    gtk_widget_show (opt);
 
    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
    gtk_widget_show (box2);

    box2 = gtk_hbox_new (FALSE, 10);
    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 
    /* An HScale widget for adjusting the number of digits on the
    * sample scales. */
    label = gtk_label_new ("Scale Digits:");
    gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
    gtk_widget_show (label);

    adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
    g_signal_connect (G_OBJECT (adj2), "value_changed",
                      G_CALLBACK (cb_digits_scale), NULL);
    scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
    gtk_scale_set_digits (GTK_SCALE (scale), 0);
    gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
    gtk_widget_show (scale);

    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
    gtk_widget_show (box2);
 
    box2 = gtk_hbox_new (FALSE, 10);
    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 
    /* And, one last HScale widget for adjusting the page size of the
    * scrollbar. */
    label = gtk_label_new ("Scrollbar Page Size:");
    gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
    gtk_widget_show (label);

    adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
    g_signal_connect (G_OBJECT (adj2), "value_changed",
                      G_CALLBACK (cb_page_size), (gpointer) adj1);
    scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
    gtk_scale_set_digits (GTK_SCALE (scale), 0);
    gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
    gtk_widget_show (scale);

    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
    gtk_widget_show (box2);

    separator = gtk_hseparator_new ();
    gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
    gtk_widget_show (separator);

    box2 = gtk_vbox_new (FALSE, 10);
    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
    gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
    gtk_widget_show (box2);

    button = gtk_button_new_with_label ("Quit");
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
                              G_CALLBACK (gtk_main_quit),
                              NULL);
    gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
    gtk_widget_grab_default (button);
    gtk_widget_show (button);

    gtk_widget_show (window);
}

int main( int  argc,
          char *argv[] )
{
    gtk_init (&argc, &argv);

    create_range_controls ();

    gtk_main ();

    return 0;
}

---

@pebi, wo gibt es die Linux Version ?

Gruß Sebastian

frag mal hier im forum nach :

http://rjpcomputing.com/v-web/bulletin/bb/index.php

oder hier :

http://www.rjpcomputing.com/?page_id=7

ich arbeite mit windows.

es ist alles komplett in source-code geschrieben (pelles-c, gibt sogar ein deutsches forum dafür). sogar einige visuelle-ide baukästchen wurde mit bcx to c geschrieben (ez-ide)

Nein, Pebi
warum soll ich da nachgucken, schau Dir mal den Topic hier an :
Titel : "Roboter Simulation für Linux"
Deswegen meine Frage.
Du kommst einfach nur mit Deiner Besserwissereinstellung an und laberst einfach was rum "Nimm das, das ist besser, meiner ist länger, dicker, schöner"
Zum eigentlichem Thema trägst Du nichts sinnvolles bei, aber das kennt schon jeder von Dir.

Gruß Sebastian

Linus mit dem schmusetuch.....

Software is like s e x: its better when its free...

dieses sollte der schwachmate torvald mal in deutsch schreiben.

Ährm, ich glaub so ganz langsam ist das hier mehr Offtopic als das um was es eigentlich geht und der Pepi braucht mal wieder ne Ausszeit...

Vielleicht spricht ja ein Mod oder Admin ein Machtwort.

Gruß
Lutz