Bauen eines Linux-gesteuerten, laufenden Roboters

ArticleCategory: [Es gibt verschiedene Artikel Kategorien]

AuthorImage:[Ein Bild von Dir]

TranslationInfo:[Autor und Übersetzer]

original in en Katja und Guido Socher 

en to de Katja Socher

AboutTheAuthor:[Eine kleine Biographie über den Autor]

Katja ist die deutsche Redakteurin von LinuxFocus. Sie mag Tux, Film & Fotografie und das Meer. Ihre Homepage findet sich hier.

Guido ist ein langj�hriger Linuxfan und er mag Linux, weil es von ehrlichen und offenen Leuten entwickelt wurde. Dies ist einer der Gr�nde, warum wir es Open Source nennen. Seine Homepage ist auf linuxfocus.org/~guido.

Abstract:[Hier sollte eine kleine Zusammenfassung stehen]

ArticleIllustration:[Das Titelbild des Artikels]

ArticleBody:[Der eigentliche Artikel. Überschriften innerhalb des Artikels sollten h2 oder h3 sein.]

Einf�hrung

Roboter haben uns schon immer fasziniert, so da� wir beide begeistert waren, als wir vor einiger Zeit ein Buch �ber Roboter entdeckten, das schon gleich den Roboterbausatz enthielt, um einen kleinen, insektenartigen Roboter namens Stiquito zu bauen. Stiquito ist ein etwas besonderer Roboter, da er keinen Motor hat, sondern dadurch l�uft, da� seine Beine mit Nitinol verdrahtet sind. Auf diese Weise l�uft er v�llig leise, fast wie ein echtes Insekt. Aber als wir ihn gebaut hatten, stellten wir fest, da� seine tats�chliche Bewegung sehr sehr langsam ist, weil er nur sehr wenig Reibung mit der Oberfl�che hat, auf der er l�uft. Gl�cklicherweise enthielt das Buch noch einige weitere Beschreibungen von anderen Roboterdesigns, die uns schlie�lich dazu inspirierten, den Roboter, �ber den du hier lesen kannst, zu bauen.

Nitinol

Bauen des Roboters

Um den Roboter zu bauen, haben wir die folgenden Teile benutzt:

• Platine mit runden �sen auf beiden Seiten. Die �sen sollten durchkontaktiert sein. Es mu� eine Epoxidhartzplatine sein, weil sie sonst nicht stark genug ist. Siehe das Bild rechts.

  Abb. 1: Platine

  • 15 x 15 mm, 6 x 6 L�cher (f�r den K�rper)
  • zwei 18 x 16 mm, 7 x 6 L�cher (f�r den K�rper)
  • 18 x 6 mm, 7 x 2 L�cher (f�r den Aufbau auf dem K�rper)
• Messingr�hrchen
  • 4cm Messingr�hrchen: 2mm Au�en-, 1mm Innendurchmesser
  • 0.5m Messingr�hrchen: 1mm Au�endurchmesser, ca. 0.6 mm Innendurchmesser. Wir benutzen es, um Crimps f�r den Nitinoldraht zu machen.
• 1m Nitinoldraht, .004" Diameter (Durchmesser)
• 0.5m Stahldraht, 1 mm Durchmesser
• 5m von 0.1mm lackiertem Kupferdraht (sehr d�nner, isolierter Draht, wie er in Transformatoren benutzt wird. Du kannst ihn entweder kaufen oder einen alten Transformator auseinandernehmen).
• feines 600 k�rniges Schmiergelpapier
• L�tkolben, L�tzinn
• scharfes K�chenmesser
• Seitenschneider
• Spitzzange
• Einen m�nnlichen 25 Pin Stecker f�r den Parallelport und die Teile f�r die Elektronik, die unten im Schaltbild aufgelistet sind .

Abb. 2: Spitzzange

F�r den K�rper braucht man zuerst drei der Platinenteile, die mit 6x6 L�chern und die zwei mit 6x7 L�chern sowie das 4cm lange Messingr�hrchen mit 2 mm Durchmesser zusammen mit 3.7 cm Stahldraht.


Abb. 4: R�ckgrat und Powerbus

Schneide das Messingr�hrchen in St�cke von 8, 17.5 und 8mm wie im Bild gezeigt. Man kann das durch Hin- und Herrollen des R�hrchens unter dem scharfen K�chenmesser und durch Biegen erreichen. Die R�hrchen brechen dort, wo du die Kerben mit dem Messer gemacht hast. Es ist wichtig, da� das mittlere R�hrchen etwas l�nger ist als die 6x6 L�cher Platine. Schneide ca. 3.7cm Stahldraht ab. Die endg�ltige L�nge mu� ca. 3mm l�nger sein als die drei R�hrchen zusammen. Stecke den Stahldraht durch die drei R�hrchen.
Das R�hrchen in der Mitte mu� in der Lage sein, zu rotieren, w�hrend die anderen beiden an den Stahldraht angel�tet werden.


Abb. 5: L�te die Platinen an das R�ckgrat

Das mittlere R�hrchen wird jetzt an die 6x6 L�cher Platine gel�tet. Pa� auf, da� sie rotieren k�nnen. Die anderen beiden R�hrchen werden an die anderen beiden Platinen gel�tet.
Jetzt nimm die vierte, die kleine 2x7 L�cher Platine. Sie soll hochkant auf dem mittleren Messingr�hrchen stehen. Die Platine mu� mit einer kleinen Feile oder dem Seitenschneider eingekerbt werden. L�te sie, wie im Bild gezeigt, an das mittlere Messingr�hrchen und die mittlere Platine an:

Abb. 6: Hinzuf�gen der kleinen Platine

Schmiergel das Messingr�hrchen mit 1mm Durchmesser und schneide einige 4mm lange St�cke aus dem R�hrchen. Rolle das Rohr unter dem K�chenmesser und bieg es dann. Du brauchst 16 von diesen Crimps, aber mach lieber ein paar mehr.

Da jetzt eine ganze Menge Crimpen gebraucht wird, probierst du es besser mit einem kleinen St�ck Nitinol aus, bevor du richtig loslegst: Stecke das Ende des Nitinoldrahtes in das sehr d�nne Messingr�hrchen (1mm Au�endurchmesser) und dr�cke dann das Messingr�hrchen fest mit der Spitzzange. Dies nennt man Crimpen. Pa� auf, da� du eine gute Spitzzange verwendest, da die Kraft zum Zusammendr�cken der Messingr�hrchen sehr hoch ist. Du kannst die Enden des Nitinols auch durch feines 600k�rniges Schmiergelpapier gleiten lassen, um gute elektrische Verbindungen zu bekommen.

Jetzt verdrahten wir das Nitinol, das ben�tigt wird, um die Beine hoch und runter zu bewegen.


Abb. 7: "die Br�cke"

Man spannt den Nitinoldraht so, als wollte man eine Br�cke bauen. Man f�ngt auf einer Seite an. Dort zieht man den Nitinoldraht durch das letzte Loch, das auf der linken und geraden Seite m�glich ist. Man macht einen Knoten in das Nitinol (um eine bessere Verbindung sicherzustellen) und setzt eine Crimp (ein ca. 4mm langes Messingr�hrchen) dar�ber und crimpt es fest, so da� es fest sitzt und der Nitinoldraht durch das zweite Loch von oben auf der linken Seite und dann durch das letzte m�gliche Loch auf der linken und geraden Seite gezogen werden kann (sieh Abb. 7). Der Nitinoldraht mu� fest sein, aber nicht zu fest. Wenn du mit dem Finger das Nitinol ber�hrst, sollte es sich 2-4mm bewegen. Wenn es nicht fest genug ist oder zu fest sitzt, wird sich der Roboter sp�ter nicht ordentlich bewegen. L�te die Crimpen an die Platine.
Mach dasselbe auf der rechten Seite.
Bevor du weitermachst, probier aus, ob es funktioniert. Benutze eine 1.5 V Batterie und verbinde sie mit dem Nitinoldraht. Wenn der Draht sich zusammenzieht, mu� der mittlere K�rpterteil um 10-20 Grad rotieren. Pa� auf, da� du die Batterie nicht l�nger als eine Sekunde anschlie�t. Du besch�digst sonst den Draht, wenn du ihn �berhitzt.

Abb. 8: Biegen des Drahts

F�r die Beine schneidest du drei 10cm lange Teile aus dem Stahldraht. Jedes Teil wird auf beiden Seiten um 1.5cm gebogen. Dann werden sie an die drei K�rperteile des Roboters gel�tet. Sie sollten parallel zueinander sein.




Abb. 9, 10: die Roboterbeine

Jetzt mu�t du das Nitinol mit den sechs Beinen verdrahten.


Abb. 11: Hinzuf�gen des Antriebs

Ziehe Nitinol von oben durch eine Crimpe und durch ein Loch in der Platine. Der Abstand zum Stahldraht betr�gt drei L�cher. Crimp es fest (sieh die Bilder oben).
Dann zieh eine Crimp �ber den Stahldraht bis du das Kniegelenk erreichst. Zieh den Nitinoldraht hindurch und crimp es fest. Jetzt kommt der schwierigste Teil. Halte den Roboter mit einem kleinen Schraubstock, fixiere ihn und spann die Beine mit Klebeband oder extra Kupferdraht an, um spannungsfrei l�ten zu k�nnen. Der Stahldraht wirkt als Gegenkraft zum Nitinol. Damit dies funktioniert, darf das Nitniol �berhaupt nicht lose sein. Der Stahldraht mu� ein Platinenloch zum Nitinol gezogen werden und dann mu� die Crimp an das Bein festgel�tet werden.

Abb. 12: Nitinol und Stahldraht auf derselben Ebene


Stell sicher, da� der Stahldraht und das Nitinol auf derselben Ebene sind. Die Beine d�rfen sich nicht nach oben oder unten bewegen, wenn sich das Nitinol zusammenzieht, sondern sie m�ssen sich nach hinten bewegen.

Mach dasselbe mit den anderen f�nf Beinen.
Die Beine und der Stahldraht mit den Messingr�hrchen in der Mitte des Roboters fungieren als Powerbus und deshalb mu� eine elektrische Verbindung zwischen allen von ihnen bestehen. Da jedoch der mittlere K�rperteil mehr Freiheit hat, da er rotieren kann und daher keine gute Verbindung besteht, haben wir dies dadurch verbessert, da� wir 3cm des 0.1mm lackierten Kupferdrahtes genommen haben und ihn um ein �briggebliebenes Messingr�hrchen gewickelt haben, um eine kleine Spule zu bekommen. Nimm das Messingr�hrchen heraus und l�te die Spule so, da� die inneren Beinpaare mit den �u�eren Beinpaare verbunden sind. Die Wicklungsform des Drahtes stellt die maximale Flexibilit�t sicher.

Wenn der Roboter fertig ist, kannst du 0.5m lange St�cke (oder l�nger, wenn du willst) aus 0.1mm lackiertem Kupferdraht an die Crimps auf der Platine l�ten. L�te dann die K�rpercrimps selbst an die Platine. Wir brauchen neun Dr�hte, sechs f�r die Beine, zwei f�r hoch/runter und eins f�r den allgemeinen Powerbus. Du kannst die anderen Enden des Drahtes an einen kleinen Stecker l�ten, den du dann in die entsprechende kleine Buchse der Treiberschaltung stecken kannst.

Der Gang

Unser Insekt wurde f�r einen Dreifu�gang (tripod) entwickelt. Ein Dreifu�gang meint, da� drei Beine am Boden sind (zwei F��e auf der einen und ein Fu� auf der anderen Seite), w�hrend die anderen drei in der Luft sind. Wenn der Roboter geht, dann bewegen sich die drei Beine am Boden in die eine Richtung, w�hrend sich die Beine in der Luft in die entgegengesetzte Richtung bewegen.

Abb. 13: Der Gang

Steuern des Roboters mit unserem Linuxcomputer

Die Treiberschaltung

Diese Platine erlaubt es uns, unseren PC zum Steuern des Antriebs unseres Roboters zu benutzen und wird in den Parallelport gesteckt.
Als wir unser Computerprogramm entwickelt haben, haben wir es zuerst mit LEDs getestet und die Robotersteuerungsdr�hte erst in den Sockel der Platine gesteckt, als es korrekt funktioniert hat und die LEDs einen korrekten Laufgang anzeigten. Du solltest dasselbe tun, wenn du mit dem Programm experimentierst.
Der Roboter ist recht hungrig. Du mu�t zwischen 200 und 250 mA Strom durch den Nitinoldraht schicken, damit er sich zusammenzieht. Die 3cm langen Nitinoldr�hte an den Beinen haben ungef�hr 7 Ohm. Starte immer zuerst die Software, bevor du den Strom an die Treiberschaltung anschlie�t, weil alle Datenpins von der Software zuerst auf "aus" gesetzt werden, um ein Besch�digen des Nitinoldrahtes zu verhindern. Das Bios des Computers setzt die Datenpins des Parallelports auf Zufallswerte. Einige davon k�nnten deshalb dann im Zustand "an" sein. Das Nitinol kann besch�digt werden, wenn du einen Strom viel l�nger als eine Sekunde hindurchschickst. Die Zeit f�r das Nitinol, um abzuk�hlen, sollte 1.5mal so lang sein, wie die Zeit, die du es erhitzt hast.

Das Schaltbild:

Abb. 14: Schaltbild

Wie du im obigen Schaltbild sehen kannst, benutzen wir eine elektronisch stabilisierte Stromquelle, um einen guten und sicheren Strom sicherzustellen und um den Parallelport zu sch�tzen. Als externe Stromquelle kannst du jede DC Stromquelle zwischen 6 und 24V anschlie�en. Der 7805 ist ein Standardspannungsregler. Das einzige, was du hier beachten mu�t, ist, da� die zwei Kondensatoren (470uF und 0.1uF) sich nahe zum 7805 Spannungsregler befinden, weil es ansonsten passieren k�nnte, da� der 7805 Chip anf�ngt, zu oszillieren, was den 7805 zerst�ren k�nnte.

Der tats�chliche Treiber mu� achtmal gebaut werden. Eins f�r jedes Bein und zwei f�r das Drehen des Roboters (Hoch und Runter der Beine). Wir benutzen einen kleinen NPN Darlingtontransistor, weil unser Roboter eine Menge Strom verbraucht. Der BC875 oder BC618 k�nnen ungef�hr 500mA schalten. Die 47K bei der Eingabe stellen sicher, da� ein offener Stromkreis (z.B. der Computer ist nicht angeschlossen) immer mit "aus" �quivalent ist. Das Spannungsniveau des Parallelports liegt �ber 4V f�r "an" und unter 1V f�r den Zustand "aus". Der Transistor arbeitet nur als Schalter. Die 15 Ohm Widerst�nde begrenzen den Strom und sch�tzen sowohl die Beine des Roboters als auch den Transistor. Die LEDs zeigen den Zustand an (ein oder aus).

Unten siehst du Bilder des Schaltkreises. Die roten LEDs (die, die parallel zu den Roboterantrieben sind), sind schwierig zu sehen, weil wir transparente rote LEDs benutzt haben. Wir haben die 15 Ohm Widerst�nde aus Konstantandrahtwicklungen gebaut, aber dies war nur der Fall, weil wir sehr viel von diesem Draht zur Verf�gung hatten. Es ist billiger, fertige 2W Widerst�nde zu kaufen.

Abb 15: der Schaltkreis

Der Parallelport

Der Parallelport wurde entwickelt, um als Ausgangsport von einem Computer zu dienen und an einen Drucker angeschlossen zu werden. Einige Parallelports erlauben sowohl Ein- als auch Ausgang. Hier benutzen wir nur den Ausgangsport. In einem sp�teren Artikel werden wir Sensoren an unseren Roboter anschlie�en und dann auch den Eingangsport benutzen. Obwohl der Parallelport 25 Pins hat, benutzen wir nur neun. Acht werden als Datenausgangsverbindungen benutzt und einer dient als Erdung.
Die Pinbelegung f�r den Parallelport sieht wie folgt aus:

25 PIN D-SUB FEMALE at the PC.

 Pin  Name   Dir   Description
 1  STROBE  [-->] Strobe
 2  D0      [-->] Data Bit 0
 3  D1      [-->] Data Bit 1
 4  D2      [-->] Data Bit 2
 5  D3      [-->] Data Bit 3
 6  D4      [-->] Data Bit 4
 7  D5      [-->] Data Bit 5
 8  D6      [-->] Data Bit 6
 9  D7      [-->] Data Bit 7
 10 ACK     [<--] Acknowledge
 11 BUSY    [<--] Busy
 12 PE      [<--] Paper End
 13 SEL     [<--] Select
 14 AUTOFD  [-->] Autofeed
 15 ERROR   [<--] Error
 16 INIT    [-->] Initialize
 17 SELIN   [-->] Select In
 18 GND     [---] Signal Ground
 19 GND     [---] Signal Ground
 20 GND     [---] Signal Ground
 21 GND     [---] Signal Ground
 22 GND     [---] Signal Ground
 23 GND     [---] Signal Ground
 24 GND     [---] Signal Ground
 25 GND     [---] Signal Ground

Die Software

==== pprobi.c =====
/* vim: set sw=8 ts=8 si : */
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License.
 * See http://www.gnu.org/copyleft/ for details.
 *
 * Written by Katja Socher <[email protected]> 
 *         and Guido Socher <[email protected]>
 *         
 */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <signal.h>
  
#include "robi.h"

/* ----------- */
static int opt_r=0;
static int fd=0;
/* ----------- */
/* ----------- */
void help()
{
    printf("pprobi -- control software for a walking robot\n\
USAGE: pprobi [-h] [parport-device]\n\
\n\
OPTIONS:\n\
         -h this help\n\
         -r reset the parallel port data pins (all zero) and exit\n\
     \n\
The default device is /dev/parport0 \n\
");
#ifdef VERINFO
    puts(VERINFO);
#endif   
exit(0); 
}
/* Signal handler: all off then exit */
void offandexit(int code)
{
    robi_setdata(fd,0);
    set_terminal(0);
    exit(0);
}

/* ----------- */
int main(int argc, char **argv)
{
    int state,bpat,alternate;
    char *dev;
    /* The following things are used for getopt: */
    int ch;
        extern char *optarg;
        extern int optind;
        extern int opterr;

    opterr = 0;
    while ((ch = (char)getopt(argc, argv, "hr")) != -1) {
        switch (ch) {
        case 'h':
            help(); /*no break, help does not return */
        case 'r':
            opt_r=1;
            break;
        case '?':
            fprintf(stderr, "serialtemp ERROR: No such option. -h for help.\n");
            exit(1);
        /*no default action for case */
        }
    }
    if (argc-optind < 1){
        /* less than one argument */
        dev="/dev/parport0";
    }else{
        /* the user has provided one argument */
        dev=argv[optind];
    }
    fd=robi_claim(dev); /* robi_claim has its own error checking */
    /* catch signals INT and TERM and switch off all data lines before
     * terminating */
    signal(SIGINT, offandexit);
    signal(SIGTERM, offandexit);

    /* initialize parpprt data lines to zero: */
    robi_setdata(fd,0);
    set_terminal(1); /* set_terminal has its own error handling */ 
    state=0;
    alternate=0;
    if (opt_r){
        offandexit(1);
    }
        while(1){
        ch=getchoice();
        if (ch!=0) state=ch;
        if (ch == ' '){
            printf("Stop\n");
            robi_setdata(fd,0);
            usleep(500*1000);
        }
        if (ch == 'q'|| ch == 'x'){
            printf("Quit\n");
            break;
        }

        if (state=='l'){
            /*right */
            printf("walking right\n");
            walkright(fd);
        }
        if (state=='h'){
            /*left */
            printf("walking left\n");
            walkleft(fd);
        }
        if (state=='j'){
            printf("walking back\n");
            walkback(fd);
        }
        if (state=='k'){
            if (alternate){
                printf("walking straight on a\n");
                walkstraight_a(fd);
            }else{
                printf("walking straight on b\n");
                walkstraight_b(fd);
            }
            alternate=(alternate +1) %2;
        }

    }
    /* we get here if q was typed */
    set_terminal(0);
    return (0);
}

==== robi.c  =====
/* vim: set sw=8 ts=8 si : */
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License.
 * See http://www.gnu.org/copyleft/ for details.
 *
 * Written by Katja Socher <[email protected]>
 *        and Guido Socher <[email protected]> 
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h> 
#include <sys/types.h>
#include <sys/time.h> 
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <linux/ppdev.h>
#include <sys/ioctl.h>
#include <termios.h>
#include "robi.h"


/* like printf but exit the program */
static int die(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vprintf(fmt, ap);
    va_end(ap);
    exit(1);
}
/* get one character from stdin 
 * Returns non zero if char was read otherwise zero
 * The arrow keys are mapped as follows:
 * <- = h
 * -> = l
 * v = j
 * ^ = k
 */
int getchoice()
{
    int c;
    char s[20];
    
    if (fgets(s,20,stdin)){
        c=s[0];
        switch (c){
            case 0x1b: /* ESC */
                if (s[1] == 0x5b){
                    /* arrow keys are pressed */
                    switch (s[2]){
                        case 0x41: /*up arrow*/
                            c='k';
                            break;
                        case 0x42: /*down arrow*/
                            c='j';
                            break;
                        case 0x44: /*l arrow*/
                            c='h';
                            break;
                        case 0x43: /*r arrow*/
                            c='l';
                            break;
                        default:
                            c=0;
                    }
                }else{
                    c=0;
                }
                break;
            case ' ':
            case 'h':
            case 'j':
            case 'k':
            case 'l':
            case 'q':
            case 'x':
                break;
            default:
                c=0;
        }
        return(c);
    }
    return(0);
}
    
/* Set the Terminal to Non Canonical mode with echo off
 * or reset the terminal.
 * USAGE: set_terminal(1) for canonical
 */
int set_terminal(int canonical)
{
    static struct termios originalsettings;
    struct termios newsettings;
    static int origok=0; /* set if originalsettings valid */
    if (canonical){
        /* save original settings and set canonical mode*/
        tcgetattr(fileno(stdin),&originalsettings);
        newsettings=originalsettings;
        newsettings.c_lflag &= ~ICANON;
        newsettings.c_lflag &= ~ECHO;
        newsettings.c_cc[VMIN]=0; /* do not block */
        newsettings.c_cc[VTIME]=1; /* 100 ms */
        if (tcsetattr(fileno(stdin),TCSANOW,&newsettings) !=0){
            die("ERROR: could not set terminal attributes on stdin\n");
        }
        origok=1;
    }else{
        if (origok){
            /* restore settings */
            tcsetattr(fileno(stdin),TCSANOW,&originalsettings);
        }
    }
    return(0);
}

/* open /dev/parportX device and claim it.
 * USAGE: fd=robi_claim("/dev/parport0");
 * The return value is a file descriptor used by other
 * functions such as robi_setdata */
int robi_claim(char *dev)
{
    int fd,i;

    fd = open(dev, O_RDWR );
        if (fd < 0) {
                die("ERROR: cannot open device %s\n",dev);
        }
    i=0;
    /* we need exclusive rights as we do not set the control lines*/
    /*ioctl(fd, PPEXCL, &i)&&die("ERROR: request for exclusive 
    rights failed\n");*/
    ioctl(fd, PPCLAIM, &i)&&die("ERROR: could not claim parport\n");
    return(fd);

}
/* Walk left
 */
int walkleft(int fd)
{
    /* first B legs to ground */
    robi_setdata(fd,LEGBD);
    usleep(400 *1000);
    /* all A legs 1 step */
    robi_setdata(fd, LEGB1 | LEGB3 );
    usleep(1100 *1000);

    /* first A legs to ground, cool B*/
    robi_setdata(fd,LEGAD);
    usleep(400 *1000);
    robi_setdata(fd,0);
    usleep(1000 *1000);
    return(0);
}
/* Walk right
 */
int walkright(int fd)
{
    
    /* first A legs to ground */
    robi_setdata(fd,LEGAD);
    usleep(500 *1000);
    robi_setdata(fd,  LEGA3 | LEGAD);
    usleep(300 *1000);
    /* all A legs 1 step */
    robi_setdata(fd, LEGA1 | LEGA3 );
    usleep(1100 *1000);

    /* first B legs to ground, cool A*/
    robi_setdata(fd,LEGBD);
    usleep(400 *1000);
    robi_setdata(fd,0);
    usleep(1000 *1000);
    return(0);
}
/* Walk with all 3 legs 1 step forward
 */
int walkstraight_a(int fd)
{
    
    /* first A legs to ground */
    robi_setdata(fd,LEGAD);
    usleep(800 *1000);
    /* all A legs 1 step */
    robi_setdata(fd, LEGA1 | LEGA2 | LEGA3 );
    usleep(1000 *1000);

    /* first B legs to ground, cool A*/
    robi_setdata(fd,LEGBD);
    usleep(500 *1000);
    robi_setdata(fd,0);
    usleep(1200 *1000);
    return(0);
}
/* Walk with all 3 legs 1 step forward
 */
int walkstraight_b(int fd)
{
    /* first B legs to ground */
    robi_setdata(fd,LEGBD);
    usleep(400 *1000);
    /* all B legs 1 step */
    robi_setdata(fd,LEGB1 | LEGB2 | LEGB3);
    usleep(1000 *1000);
    /* A down and cool */
    robi_setdata(fd,LEGAD);
    usleep(800 *1000);
    robi_setdata(fd,0);
    usleep(1200 *1000);
    return(0);
}
/* Walk with all 6 legs 1 step back
 */
int walkback(int fd)
{
    
    /* first A legs to ground */
    robi_setdata(fd,LEGAD);
    usleep(800 *1000);
    /* all B legs 1 step in the air*/
    robi_setdata(fd, LEGB1 | LEGB2 | LEGB3 );
    usleep(500 *1000);

    /* first B legs to ground, cool A*/
    robi_setdata(fd,LEGBD);
    usleep(500 *1000);
    /* all A legs 1 step in the air*/
    robi_setdata(fd,LEGA1 | LEGA2 | LEGA3);
    usleep(500 *1000);
    /* A down and cool */
    robi_setdata(fd,LEGAD);
    usleep(800 *1000);
    robi_setdata(fd,0);
    usleep(1000 *1000);
    return(0);
}
/*---------*/
/* Write a bit pattern to the data lines
 * USAGE: rc=robi_setdata(fd,bitpat);
 * The return value is 0 on success.
 */
int robi_setdata(int fd,unsigned char bitpat)
{
    int rc;

    rc=ioctl(fd, PPWDATA, &bitpat);
    return(rc);
}

==== robi.h =====
/* vim: set sw=8 ts=8 si et: */
#ifndef H_ROBI
#define H_ROBI 1
#define VERINFO "version 0.2"


/* the first thing you need to do: */
extern int robi_claim(char *dev);

/* write a bit pattern to the data lines of the parallel port: */
extern int robi_setdata(int fd,unsigned char bitpat);

/* input and terminal functions */
extern int set_terminal(int canonical);
extern int getchoice();
extern int walkstraight_a(int fd);
extern int walkstraight_b(int fd);
extern int walkback(int fd);
extern int walkleft(int fd);
extern int walkright(int fd);

/* data pins to legs: 
 * A1------=------B1
 *         =      
 *         =      
 * B2------=------A2
 *         =      
 *         =      
 * A3------=------B3
 *
 *
 * Pin to set A-legs to ground= AD
 * Pin to set B-legs to ground= BD
 *
 * parallel port    leg name
 * -------------------------
 * data 0           A1
 * data 1           A2
 * data 2           A3
 * data 3           AD
 * data 4           B1
 * data 5           B2
 * data 6           B3
 * data 7           BD
 */
#define LEGA1 1
#define LEGA2 2
#define LEGA3 4
#define LEGAD 8
#define LEGB1 16
#define LEGB2 32
#define LEGB3 64
#define LEGBD 128

#endif

Die Software benutzt die ppdev Programmierschnittstelle des 2.4.x Kernels (du brauchst einen 2.3.x oder 2.4.x Kernel. Es funktioniert nicht mit einem �lteren Kernel). Dies ist eine saubere und angenehme Schnittstelle zum Schreiben von user space parallel port Ger�tetreibern. In �lteren Kerneln h�tten wir ein Kernelmodul schreiben oder eine h��liche Methode benutzen m�ssen, die es nur dem Benutzer root erlaubt h�tte, das Programm laufen zu lassen. Die ppdev Schnittstelle benutzt die Ger�tedatei und durch Anpassen des Eigent�mers und der Rechte der Datei kannst du festlegen, wem es erlaubt ist, diese Parallelportschnittstellle zu benutzen.

Um das ppdev als ein Modul in deinen Kernel zu kompilieren, mu�t du das PARPORT Modul zusammen mit dem PPDEV device kompilieren. Dies sollte dann wie folgt in der .config Datei aussehen:

#
# Parallel port support
#
CONFIG_PARPORT=m
CONFIG_PARPORT_PC=m
CONFIG_PARPORT_PC_FIFO=y
# CONFIG_PARPORT_PC_SUPERIO is not set
# CONFIG_PARPORT_AMIGA is not set
# CONFIG_PARPORT_MFC3 is not set
# CONFIG_PARPORT_ATARI is not set
# CONFIG_PARPORT_SUNBPP is not set
CONFIG_PARPORT_OTHER=y
CONFIG_PARPORT_1284=y
#
# Character devices
#
CONFIG_PPDEV=m
#

Das Programm beansprucht (initialisiert) zuerst den Parallelport mit dem ioctl Befehl PPCLAIM. Dann setzt es das Terminal in non canonical mode. Dies wird gemacht, um die Eingabe direkt von der Tastatur zu erhalten, ohne da� der Benutzer nach jeder Eingabe Return dr�cken mu�. Als n�chstes geht es in eine Schleife, wo zuerst �berpr�ft wird, ob es irgendeine Benutzereingabe gab und dann der Roboter entsprechend dem Befehl laufen gelassen wird. Wenn du nichts machst, macht das Programm mit dem letzten Befehl weiter (z.B. f�hrt es fort, den Roboter geradeaus laufen zu lassen).
Der Befehl ioctl(fd, PPWDATA, &bitpat); wird benutzt, um die Datenverbindung auf ein gegebenes Bitmuster zu setzen.

Die Pins deines Roboters m�ssen mit den Ausgabeverbindungen der Treiberschaltung wie folgt verbunden sein:

Legs:
  A1------=------B1
          =      
          =      
  B2------=------A2
          =      
          =      
  A3------=------B3
 
 
  Pin to set A-legs to ground= AD
  Pin to set B-legs to ground= BD

Corresponding output lines of the driver circuit:
  data 0           A1
  data 1           A2
  data 2           A3
  data 3           AD
  data 4           B1
  data 5           B2
  data 6           B3
  data 7           BD

Hier ist er, der laufende Roboter:

Er bewegt sich in diesem animierten gif etwas zu schnell. In Wirklichkeit ist er wegen der Abk�hlungsphasen, die er braucht, damit das Nitinol in seine Ausgangsl�nge zur�ckgeht, etwas langsamer.

Wir hoffen, da� du beim Bauen des Roboters viel Spa� hattest. La� uns von deinem Roboter wissen, besonders dann, wenn deiner mit einem anderen Design gebaut wurde!

Referenzen

• Conrad, J.M., and J.W. Mills: Stiquito: Advanced Experiments with a simple and inexpensive robot. Los Alamitos, Calif.: IEEE Computer Society Press
• Conrad, J.M., and J.W. Mills: Stiquito for beginners. Los Alamitos, Calif.: IEEE Computer Society Press
  Die beiden B�cher inspirierten uns, unseren Roboter zu bauen und wir haben durch sie Nitinol kennengelernt.
• http://www.dynalloy.com
  Hier kannst du den Nitinoldraht bestellen, der zum Bauen des Roboters gebraucht wird. Sie akzeptieren Kreditkarten. Die anderen Teile sollten in deinem Elektronik- oder Hobbyladen vor Ort erh�ltlich sein.
• http://www.howstuffworks.com/parallel-port.htm : how parallel ports work
  Ein allgemeiner Artikel �ber Parallelports
• The Linux 2.4 Parallel Port Subsystem Chapter 7 User-level device drivers