Diese Seite ist ein Tutorial zum NXT, das sich mit der Programmierung von Software mit NXC unter Linux beschäftigt.
Ein NXT ist die neuste Version der Lego Mindstorms Roboterreihe. Diese Roboter kann man selber zusammenbauen und anschließend nach den eigenen Wünschen programmieren. Standardmäßig liefert Lego eine grafische Oberfläche zum erstellen der Programme. Diese ist einfach zu verstehen und ist daher von jedem ohne Probleme nutzbar. Diese Oberfläche wird jedoch hier nicht behandelt. Beim Kauf enthalten ist der programmierbare Stein, 3 Motoren (mit eingebauten Drehsensoren), ein Lichtsensor (Helligkeit), ein Geräuschsensor, ein Tastsensor und ein Infratorsensor (Abstand). Außerdem enthalten sind alle nötigen Kabel, sowie viele Teile zum bauen der Roboter (Teile ähnlich wie Lego Technik).
NXC ist eine weitere Möglichkeit die Roboter zu programmieren. NXC steht für "Not eXactly C". Es handelt sich um eine Programmiersprache die sich an C orientiert. NXC wird als Plain Text programmiert. Das bedeutet man sieht beim Programmieren erstmal nur Text. Dadurch erhält man mehr Möglichkeiten der Programmierung. NXC benötigt keine andere Firmware (es gibt momentan auch noch keine). NXC-Dateien kann man in jedem Editor erstellen. Anschließend werden sie dann kompiliert und auf den Roboter transferiert. Näheres dazu später.
Ja. Die grafische Oberfläche ist zwar nur unter Windows und OSX möglich, aber NXC kann durchaus auch unter Linux programmiert werden, das es mit jedem Editor funktioniert und es den Compiler auch für Linux gibt.
Um mit dieser Anleitung etwas anfangen zu können, müssen grundlegende Kenntnisse von Programmiersprachen gegeben sein. Ich werde keine Dinge wie Schleifen usw. erklären sondern nur beschreiben wie man die Sensoren, Motoren usw. anspricht.
Dieses Abschnitt des Tutorials wurde unter Ubuntu/Kubuntu getestet.
Die Software wird nun im gewählten Editor geschrieben. Es empfiehlt sich das Synthaxhighlighting von C zu benutzen, da NXC ja sehr ähnlich ist. Wenn man damit fertig ist speichert man die Datei einfach mit der Endung ".nxc".
Zum Kompilieren benötigt man das Programm NBC. Dies lädt man auf der oben verlinkten Seite runter und extrahiert es in ein beliebiger Verzeichnis (z.B.: ~/NXT/nbc). Hat man das getan, empfiehlt es sich mit folgendem Befehl eine Verknüpfung zu erstellen um das Programm einfacher zu erreichen:
sudo ln -s ~/NXT/nbc/nbc /usr/bin/nbc
Nun lässt sich das Programm einfacher erreichen.
Zum Kompilieren benutzt man nun Folgenden Befehl:
nbc -T=NXT -O=file.rxe file.nxc
"file" ist dabei der Dateiname.
Wenn keine Fehlermeldung erscheint wurde die Software für den NXT richtig programmiert und umgewandelt.
Wenn man einen Bluetoothstick hat kann man mein selbstgeschreibenes Programm namens "NXT-Manager" nehmen um Dateien auf den NXT zu übertragen und noch einiges mehr zu tun. Hier findet ihr eine Anleitung und den Download.
Nun müssen wir das die USB Schnittstelle für linxt verfügbar machen.
Zuerst installieren wir die Pakete "libusb-dev" und "libusb-0.1-4" mit folgendem Befehl:
sudo apt-get install libusb-dev libusb-0.1-4
Wenn dies erfolgreich abgeschlossen ist starten wir cpan:
sudo cpan
Sollte man nun mit Fragen bombardiert werden bestätigt man einfach immer mit Enter bis nur noch "cpan" dasteht und man etwas eingeben kann. Nun führt man die 2 folgenden Befehle aus:
install Inline
install Device::USB
Zum Transferieren der Programme auf den NXT benötigt man das Programm linxt. Dies lädt man auch runter und extrahiert es in ein beliebiges Verzeichnis (z.B.: ~/NXT/linxt). Nun empfiehlt sich es sich weiter eine Verknüpfung zu erstellen:
sudo ln -s ~NXT/linxt/linxt /usr/bin/linxt
Wenn man auch das erfolgreich absolviert hat ist man zum Transferieren auf den NXT bereit.
Jetzt kann man anfangen zu Transferieren. Dies geht mit folgendem Befehl:
sudo linxt -u file.rxe
Nun sind folgende Punkte zu Beachten:
Beachtet man diese Punkte sollte man keine Probleme haben.
Nun sollten die Programme auf dem NXT unter Software zu finden sein.
Sind sowohl Bricxcc sowie die Windowsversion von NBC runter geladen kann die Installation beginnen.
Zuerst muss man Bricxcc einfach ganz normal installieren.
Ist man damit fertig muss man das NBC Paket in das Installationsverzeichnis, indem sich auch die Bricxcc.exe befindet, extrahieren.
Nun ist man auch schon fertig mit der Installation und kann zum erstellen eines Programms Bricxcc starten.
Beim Start von Bricxcc muss man einige Angaben machen. Man muss die Felder folgendermaßen ausfüllen:
Die Software erstellt man nun im Bricxcc und speichert sie anschließend als NXC File (*.nxc).
Um die Software zu Kompilieren klickt man einfach auf die beiden Zahnräder in der Symbolleiste oder drückt F5.
Das Transferieren auf den NXT:
Hierfür klickt man einfach auf das blaue Dreieck in der Symbolleiste oder drückt F6.
Dieser Teil des Tutorials wird immer erneuert, da ich immer neue Funktionen entdecke werde und NXC auch noch in der Betaphase steckt.
Ganz oben in jeder Datei musst erstmal die Definitions Datei der APIs eingebunden werden. Das geht mit folgendem Befehl:
#include "NXCDefs.h"
Wichtig: Ab der Version "NBC 1.0.1.b29 beta" muss/darf man diesen Include nicht mehr machen.
Jedes Programm durchläuft, wenn es zu nichts anderes Aufgefordert wird nur den Maintask. Dieser muss in jedem Programm enthalten sein und sieht wie folgt aus:
task main() {
// Hier müssen die Befehle rein
}
Außerdem ist es möglich Unteranwendungen zu erstellen die mit einem kurzen Befehl ausgeführt werden können. Diese erstellt man folgendermaßen:
sub name() {
// Hier müssen die Befehle rein
}
Das "name" lässt sich dabei frei wählen. Diese Unteranwendung bindet man dann einfach mit
name();
in der Main oder einer weiteren Unteranwendung ein.
Um eine While-Schleife zu erstellen die solange läuft bis man das Programm auf dem NXT beendet, kann man folgenden Befehl benutzen:
while(true) {
// Hier müssen die Befehle rein
}
Um neue Variablen des Typ int anzulegen benutzt man folgenden Befehl:
int name;
Diese Variable ist jetzt mit "name" abrufbar.
Arrays anzulegen gestaltet sich schon etwas komplizierter:
int name[] = {};
Nun muss man noch die Reihen und den Anfangswert erstellen:
ArrayInit(name, 0, 100); // Erstellt 100 Reihen mit dem Wert 0 für das Array name
Jetzt kann man das Array einfach wie eine Variable mit name[x] (x in diesem Fall 0 - 99) abrufen, wobei zu beachten ist, dass ein Array immer bei 0 anfängt zu zählen.
Die Ausgänge(OUT) werden mit A, B und C durchnummeriert. Diese Ausgänge werden nur für Motoren und deren integrierte Drehsensoren verwendet.
Die Ausgänge können auch miteinander kombiniert werden:
Auf diese Art ist es möglich mehrere Motoren mit der selben Funktion in nur einem Befehl anzusprechen.
Die Eingänge(IN) werden mit 1, 2, 3, 4 durchnummeriert. Diese Eingänge werden für die Sensoren (Licht, Geräusch, Tast, Infrarot) verwendet.
Eine Kombination dieser Eingänge macht keinen Sinn und ist deshalb auch nicht möglich.
Die Motoren des NXT kann man den Roboter vorwärts und rückwärts fahren lassen, sowie stehen bleiben oder drehen. Der NXT nimmt hierbei Geschwindigkeiten in Prozent (zwischen 0 und 100) an.
Um einfach vorwärts zu Fahren benutzt man folgende Funktionen:
OnFwd(OUT_A, 75); // Dreht Motor A mit 75
OnFwd(OUT_B, 50); // Dreht Motor B mit 50
OnFwd(OUT_BC, 100); // Dreht Motor B und Motor C mit 100
Das Rückwärtsfahren funktioniert fast genau so:
OnRev(OUT_C, 60); // Dreht Motor C mit 60 rückwärts
Um den Motor anzuhalten benutzt man folgenden Befehl:
Off(OUT_ABC); // Schaltet die Motoren A, B und C aus
Um den Roboter drehen zu lassen muss man nur einen Motor rückwärts und den anderen vorwärts drehen lassen oder den einen langsamer als den anderen drehen lassen.
Um ein 100% gerades Fahren zu ermöglichen gibt es eine Funktion, die die Motoren beim Drehen aufeinander warten lässt: (hier muss man natürlich mindestens 2 Ausgänge angeben)
OnFwdReg(OUT_AB, 30, 1); // Lässt die Motoren A und B mit 30 synchron fahren
OnFwdReg(OUT_ABC, -50, 1); // Lässt die Motoren A, B und C mit 50 synchron rückwärts fahren
Außerdem kann man einen Motor um einen bestimmten Drehwinkel drehen lassen:
RotateMotor(OUT_A, 30, 90); // Dreht Motor A mit 30 um 90°
Dies lässt sich auch auf 2 Motoren synchron anwenden:
RotateMotorEx(OUT_AB, 20, 360, 0, true, false); // Vorwärts mit 20 um 360°
RotateMotorEx(OUT_AB, -20, 360, 0, true, false); // Rückwärts mit -20 um 360°
RotateMotorEx(OUT_AB, 20, 360, 100, true, false); // Motor A rückwärts und B vorwärts
RotateMotorEx(OUT_AB, 20, 360, -100, true, false); // Motor A vorwärts und B rückwärts
Zuerst einmal ist es wichtig zu wissen, dass man die Drehsensoren nicht, wie beim alten RCX, zusätzlich einbauen muss, sondern dass sie in den Motor integriert sind.
Eine Umdrehung des Motors hat 360°. Um die Umdrehungen eines Motors auszulesen kann man folgenden Befehl verwenden:
Umdrehungen_a = MotorRotationCount(OUT_A); // liest die Umdrehungen vom Motor A aus
Die Variable Umdrehungen_a muss natürlich zuerst erstellt werden.
Außerdem ist darauf zu achten, dass der RotationCounter natürlich auch negative Werte haben kann, wenn der Motor zuvor rückwärts gedreht wurde.
Um die Werte des Umdrehungssensors zurück zu setzen benutzt man folgenden Befehl:
ResetRoatationCount(OUT_A); // Motor A wird zurück gesetzt
Der Lichtsensor des NXT erkennt die Helligkeit des Untergrunds. Dadurch sind auch Farben erkennbar. Er misst die Helligkeit im Bereich von 0 bis 100.
Um den Lichtsensor verwenden zu können müssen wir ihn erstmal als solchen erkennen:
SetSensorLight(IN_1); // Setzt IN_1 als Lichtsensor
Nun können wir die Werte des Sensors mit folgendem Befehl auslesen:
light = Sensor(IN_1); // liest den Helligkeitswert von IN_1 aus
Die Variable light ist vorher zu erstellen.
Der Soundsensor ist dem Lichtsensor in der Handhabung sehr ähnlich. Auch er misst die Werte zwischen 0 und 100.
Der Soundsensor kann also nur hören wie laut etwas nicht und keine Befehle in Form von Worten verstehen. Allerdings ist ein erkennen von Klatschen oft hilfreich.
Um ihn als solchen zu definieren benutzt man folgenden Befehl:
SetSensorSound(IN_4); // Setzt IN_4 als Soundsensor
Um die werte des Sensors abzurufen geht man folgendermaßen vor:
sound = Sensor(IN_4); // liest den Soundwert von IN_4 aus
Wie immer ist die Variable sound vorher zu erstellen.
Der Tastsensor des NXT erkennt nur zwischen 2 Zuständen.
Auch diesen Sensor müssen wir wieder zuerst erkennbar machen:
SetSensorTouch(IN_2); // Setzt IN_2 als Tastsensor
Zum Auslesen verwenden wir wieder folgenden Befehl:
tast = Sensor(IN_2); // liest den Wert des Sensors IN_2 aus
Die Variable tast ist natürlich wie immer zu erstellen.
Der Ultraschallsensor des NXT kann Abstände zu einem Gegenstand messen. Er misst diese in inch.
Bei der Benutzung sind folgende Dinge zu beachten:
Beachtet man diese Punkte kann man den Ultraschallsensor problemlos benutzen.
Um ihn als solchen zu erkennen benutzt man folgende Funktion:
SetSensorLowspeed(IN_3); // Setzt IN_3 als Ultraschallsensor
Der Befehl zum Auslesen sieht diesmal etwas anders aus:
ultra = SensorUS(IN_3); // liest den Wert des Ultraschallsensors in Port 3 aus.
Auch hier ist die Variable ultra vorher zu erstellen.
Der NXT hat ein schwarz-weißes Display mit der Auflösung 100*64. Dieses kann man vor allem sehr gut zum debuggen oder wenn man einfach mal eine Ausgabe sehen will verwenden.
Den Standort der Ausgaben gibt man mit x und y Koordinaten an (x von links, y von unten). Für die Y Koordinaten kann man auch folgendes benutzen LCD_LINE1, LCD_LINE2, ...
Außerdem gibt es immer die Option "true" oder "false". True bedeutet das immer die ganze Ausgabe gelöscht und wieder neu angelegt wird (erzeugt mitunter Flackern). False bedeutet das nur die geänderten Stellen verändert werden.
Die einfache Textausgabe funktioniert folgendermaßen:
TextOut(0,50,"Hallo"); // Gibt bei x=0 y=50 den Text Hallo aus
TextOut(20,LCD_LINE3,"Test"); // Gibt bei x=20 in der 3.Zeile von oben Test aus
Um eine vorher erstellte Variable oder eine Funktion auszugeben benutzt man folgenden Befehl:
NumOut(0,50,a); // Gibt bei x=0 y=50 die Variable a aus
NumOut(20,LCD_LINE3,Sensor(IN_2)); // Gibt bei x=20 in der 3. Zeile den Sensorwert von IN_2 aus
Um Linien zu erstellen, die man zum Beispiel als Trennnlinien verwenden kann, geht man folgendermaßen vor:
LineOut(10, 100, 50); // Zeichnet eine Linie von x1=0 y1=10 zu x2=100 y2=50
Um einen Kreis zu zeichnen benutzt man folgenden Befehl:
CircleOut(20, LCD_LINE6, 15); // Zeichnet einen Kreis um x=20 in der 6.Zeile mit dem Radius 15
| Follow the Line | 13.01.2007 |
|
Mein erstes Programm. Der Roboter verfolgt eine schwarze Linie mit Hilfe eines Lichtsensors. [mehr] |
|
| Find the Ball | 25.02.2007 |
|
Der Roboter findet Bälle im Umkreis von ca. 50cm, sammelt diese ein und erkennt ihre Farbe. [mehr] |
|
Ohne diese 2 Programme wäre es für mich unmöglich den NXT per Plaintext zu programmieren. Deshalb vielen dank dann die Entwicklung dieser 2 Programme.
Da ich der erste und alleine bin der sich an einem NXC-Tutorial versucht, kann ich natürlich nicht alle Funktionen des NXT auf einmal heraussuchen und in diesem Tutorial erklären. Deshalb brauche ich eure Hilfe. Solltet ihr Fehler im Tutorial finden, oder neue Funktionen finden, würde ich mich sehr darüber freuen wenn ihr mir diese mit teilt, damit ich sie zum Tutorial hinzufügen kann.
Außerdem würde ich mich natürlich freuen wenn ihr dieses Tutorial etwas verbreitet. Damit meine ich, dass ihr Werbung dafür machen könnt, aber bitte kopiert nicht einfach den Text von dieser Seite und gebt ihn als euren aus. Wenn ihr ihn irgendwo einfügen wollt, dann meldet euch bei mir und fragt nach.
Lukas Probst
Rebmannsweg 36c
79539 Lörrach
Email: lukas@internet-freaks.net
ICQ: 216328456
Jabber: aqualuk@gmail.com
24.718 Besucher| project of if | designed and coded by lukas probst | Impressum