Ich habe mir inzwischen ein Arduino Motor-Shield besorgt, um bei der späteren Hardware die Motoren treiben zu können. Um den Treiber zu testen, habe ich einen kleinen Teststand aufgebaut auf dem ich einen Motor mit einer Luftschraube betreiben kann. Die Kratzer auf dem Aluminium sind meinem handwerklichen Geschick zu schulden, aber seit heute kann ich immerhin sagen: "Ja, ich habe schon einmal mit einem Proxxon frei Hand gefräst." Für den Gesellenbrief genügt es vermutlich nicht, aber glücklicherweise bietet das Ergebnis dennoch ausreichend Halt…



Hier betreibe ich den Motor selbst bereits direkt mit der Batteriespannung. Das Galileo-Board würde ich auch gerne an dem gleichen Batteriepack betreiben. Dafür fehlt mir aber noch ein einfacher DCDC-Spannungswandler (Teile kommen hoffentlich nächste Woche)…

Ich habe erstmalig auch meinen Speed-Blitz testen können. Und in der Tat ist er recht schnell, möchte ich mal behaupten, wenn man sich den quasi stehenden Rotor anschaut.





Die Motoransteuerung selbst war leichter als ich erwartet hatte. Das Arduino-Shield lässt sich leicht über GPIOs und die PWM Ausgänge kontrollieren. Da ich ja ein eigenes Linux aufgespielt habe, kann ich z.Zt. leider keine Sketches aufspielen. Die einzelnen Ausgänge können jedoch direkt als Dateien in dem Linux-Dateisystem angesprochen werden.

Auch hier hat Sergey Kiselev wieder eine schöne (Englische) Einführung geschrieben:

http://www.malinov.com/Home/sergey-s-blog/intelgalileo-programminggpiofromlinux

Um den Motor an Ausgang B des Shields zu steuern muss ich nun PWM Channel 4 an Pin 11, sowie die GPIOS 13 (Drehrichtung) und 8 (Bremse) programmieren. Unter Linux muss ich dazu einmal die Multiplexer an Linux GPIO ID 43 sowie 55 auf 1 programmieren. Die Linux GPIOs für 13 und 8 sind 39 und 26 respektive.

Die jeweiligen Sequenzen habe ich mir in Shell-Skripte gepackt:

PWM Sequenz

echo -n "4" > /sys/class/pwm/pwmchip0/export
echo -n "1" > /sys/class/pwm/pwmchip0/pwm4/enable
echo -n "1000000" > /sys/class/pwm/pwmchip0/pwm4/period 
echo -n "500000" > /sys/class/pwm/pwmchip0/pwm4/duty_cycle 
echo -n "4" > /sys/class/pwm/pwmchip0/unexport

Brake Sequenz

echo -n "26" > /sys/class/gpio/export
echo -n "out" > /sys/class/gpio/gpio26/direction
echo -n "$1" > /sys/class/gpio/gpio26/value
echo -n "26" > /sys/class/gpio/unexport

Direction Sequenz

echo -n "39" > /sys/class/gpio/export
echo -n "out" > /sys/class/gpio/gpio39/direction
echo -n "$1" > /sys/class/gpio/gpio39/value
echo -n "39" > /sys/class/gpio/unexport

Das Einschalten kann dann z.B. einfach über die Eingabe

./engineB_setBrake.sh 0

durchgeführt werden.

Als Kandidat für die Crawlee Hardware schaue ich mir das neue Intel Galileo Board etwas genauer an. Es handelt sich dabei um einen 400MHz x86 Prozessor auf einem Arduino kompatiblen Board, was eine einfache Inbetriebnahme verspricht.



Gesagt getan tut sich zunächst einmal nichts. Ursache war am Ende meine falsche Annahme, dass der USB-Treiber in dem drivers Verzeichnis liegt. Da liegt aber nur ein FTDI Treiber mit dem wir nichts anfangen können. Am Ende war es am einfachsten,
wenn man bei dem manuellen Treiberupdate das Hauptinstallationsverzeichnis von arduino auswählt.

Von da an hatte es aus der Arduino IDE heraus keine Probleme mehr gegeben. Für Crawlee benötige ich aber gar nicht die Arduino Funktionen, sondern das darunter liegende Linux. Ohne SD Karte genügt der Flash Speicher nur für ein Minimal-Linux, was insbesondere kein WiFi und die ROS Ungebung nicht unterstützt, weswegen ich auf die SD gestützte Variante umsteigen muss.

Interessant ist das Galileo Board, weil es einen x86 Kern in kleinstem Formfaktor bietet. Am Ende sollte es möglich sein beliebige Standart-Komponenten einzubinden, da ja die x86 Treiber verwendet werden können. Von der Leistungsfähigkeit ist es deutlich stärker als der Atmega gestützte Arduino, aber gleichzeitig nicht so leistungsfähig, wie der höher getaktete Raspberry Pi. Für Bildverarbeitung könnte es am Ende nicht reichen, aber ich bin guter Dinge, dass die übrigen ROS-Komponenten funktionieren sollten.

Um Crawlee #0 mobil zu machen, muss der EeePC sich zusammen mit dem RP6 bewegen. Dementsprechend fertige ich einen entsprechenden Aufbau an. Zunächst habe ich mir eine Gewindestange besorgt, die ich auf 4 Stangen gleicher Höhe abgelängt habe. Diese habe ich dann mit Muttern versehen und an die RP6 Platine angebracht.



Die Muttern, die hier sichtbar sind, habe ich als Auflage mit Sekundenkleber fixiert, und anschließend an der Platine festgeschraubt.



Als Laptoptisch soll eine dünne Spanplatte dienen, die ich in der Restekiste im Baumarkt gefunden habe. Ich habe diese mit Löchern versehen, und die USB-zu-Seriell Platine, die zusammen mit dem RP6 geliefert wurde, montiert.





Diesen Tisch habe ich lose (in der Tat ist das ganze Konstrukt nicht sehr lose, weil auf Grund meiner unpräzisen Arbeitsweise alles auf leichter Spannung gehalten wird…) aufgelegt, und durchgebohrte Schrauben und Gewindestangen mit dem Multitool gekürzt.





Damit der EeePC nicht auf die Dauer von diesem Tisch herunterwackelt, gab es noch eine einfache Halterungen aus ein paar Winkeln, die ich ebenfalls im Baumarkt erstanden habe.



Et voilà :-)

Heute gibt es ein paar Fotos von meinem neuen RP6 im Urzustand.

Man findet den Roboter gut verpackt in der Modellbau- und Spielwarenabteilung in jeder gut sortierten Conrad Filiale.




Nachdem er aus seinem anti-statischen Schutzbeutel befreit wurde …



… habe ich erst einmal die Platine inspiziert.



Der RP6 ist an zentraler Stelle mit dem Atmega32 ausgestattet. Man erkennt aber auch im hinteren Bereich die Motortreiber Sektion und im vorderen Bereich die Infrarotsensoren und LEDs zur Statusanzeige. Ansonsten zeichnet sich die RP6 Platine vor allem durch zahlreiche Erweiterungsstecker aus.

Und hier ist nun mein neues Arbeitstier: Der Arexx RP6 V2!



Eine schöne detaillierte Erklärung der RP6 Hardware habe ich im Roboternetz gefunden: http://www.rn-wissen.de/index.php/RP6