FSGLab

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== Hexapode: Lynxmotion Roboter ======
//
Ein Hexapode (BH3-R von Lynxmotion) soll mit Hilfe eines Raspberry Pi und Java gesteuert werden. Der Hexapode besitzt einen SSC-32U Servocontroller mit einer seriellen Schnittstelle, über die alle 18 Motoren des Hexapoden kontrolliert werden können. Um mit Java die serielle Schnittstelle benutzen zu können, wird die Pi4J-Bibliothek verwendet. Ziel ist es, eine (kleine) Java-API für den Roboter zu entwickeln, so dass zukünftige Gruppen sich mit algorithmischen Aufgaben (Laufen Lernen, künstliche Intelligenz usw.) beschäftigen können.// 
|{{:hexapode_02.jpg?200|}}|
|BH3-R Hexapode von Lynxmotion mit SSC-32 Controller. |

=====Übersicht=====
=====Hardware=====
====Prinzip-Schaltbild====

|{{ :hexapode_01.png?400 |}}|
|{{:hexapode_aufbau.png?400 |}}|


Der Servocontroller und der Raspberry Pi bezeihen beide Strom seperat von Stromquellen. Diese sind noch Netzteile. Später sollen diese durch Batterien ersetzt werden, welche den Hexapoden mehr Bewegungsfreiheit geben werden. Da der Raspberry Pi mit 3.3 Volt läuft und der Servocontroller mit 5 Volt ist ein Levelshifter nötig damit die beiden Kommunizieren können. Der Raspberry Pi sendet Befehle an den Servocontroller der diese dann durchführt und die Motoren ansteuert. Diese Kommunikation wird geschieht durch die Pi4j Library die ein Senden von seriellen Befehlen ermöglicht. Der Servocontroller versorgt auch alle Motoren mit Strom. 
====Detail-Schaltbild====
  * Raspberry
          * Stromversorgung: Netzteil
          * GND, 3.3 Volt, TX und RX zum Levelshifter
                  * GND von Pin 6
                  * 3.3 Volt von Pin 1
                  * TX von Pin 8
                  * RX von Pin 10

{{:raspberry-pi_gpio_layout.png?400|}}
{{:hexapode_levelshifter_anschluss.png?400|}}
{{:hexapode_steckplatte.jpg?400|}}

Levelshifter findet in der Mitte von diesem Board platz

  * Levelshifter (4-channel I2C-safe Bi-directional Logic Level Converter - BSS138)
      * https://www.adafruit.com/product/757
      * GND, 3,3 Volt, TX und RX vom Raspberry zur Niedrigspannungsseite(LV)
      * GND, 5 Volt, TX und RX vom SCO32 Controller zur Hochspannungsseite(HV) 


  * Lynxmotion SSC-32U USB Servo-Controller
          * http://www.robotshop.com/en/lynxmotion-ssc-32u-usb-servo-controller.html
          * Stromversorgung: Netzteil 5V bei Benutzung von 5V Motoren (beim vorgesehenen Kabel wurden Blau-Rot und Braun-Schwarz zusammengelötet)
          * GND, 5 Volt, TX und RX zum Levelshifter
                  * GND,RX und TX zu dne RX,TX,GND Pins in der Mitte des Servocontrollers
                  * 5 Volt von einem der Mittleren Pins A-H
          * VL-VS Jumper nicht gesetzt!
          * VS1-VS2 Jumper gesetzt (d.h. alle Motoren sind mit Strom versorgt)

=====Software=====
====Grafische Oberfläche zum debuggen====

Zum Herumspielen mit den Befehlen des Boards und Testen der Hardware eignet sich das Programm [[ http://cutecom.sourceforge.net/ | CuteCom]]. Dieses muss auf dem Raspberry-PI installiert sein und man kann es über ssh öffnen, indem man sich via

<code>ssh -X username@hostname</code>

am Raspberry anmeldet.

**Installation via apt**

<code>sudo apt install cutecom</code>

Um CuteCom (TODO)

====Setup====
===Auf Raspberry Pi einloggen===
Hiernach können sie sich mit Hilfe von SSH auf dem Raspberry Pi einloggen:

<code>ssh <user>@<Adresse></code>

Oder sie benutzen ein Remote Desktop programm wie z.B. VNC Viewer. Diese haben den Vorteil, dass es ihnen eine Benutzeroberfläche bietet. 
===Serielle Schnittstelle aktivieren===

Um mit Java auf die serielle Schnittstelle zugreifen zu können, muss diese zuerst aktiviert werden, denn standardmäßig wird sie vom Kernel für Systemnachrichten benutzt.

Folgende Punkte sind dabei zu beachten. Diese Punkte werden anschließend ausführlich besprochen.

  * Der Benutzer muss der Gruppe dialout angehören.
  * Die serielle Schnittstelle muss mit raspi-config freigeschaltet werden.
  * In der Datei /boot/config.txt muss eine Zeile geändert werden.

**Gruppenzugehörigkeit dialout überprüfen**

Der //user// (in der Regel pi) der //ttyAMA0// benutzen will, muss der Gruppe //dialout// angehören.

Auf der Konsole kann mit //id// (zeigt alle Gruppen des aktiven Benutzers an) geprüft werden, ob der Benutzer bereits der Gruppe //dialout// angehört.

Wenn nicht, wird durch die folgende Zeile die Gruppe //dialout// dem Benutzer //pi// hinzugefügt. 
<code>sudo usermod -a -G dialout pi</code>
Jetzt sind noch zwei Schritte abzuarbeiten: 

**Step 1: Schnittstelle in raspi-config aktivieren**

  * sudo raspi-config
      * Select Interfacing Options
      * Select Serial
          * "Would you like a login shell to be accessible over serial?" Select <No>
          * "Would you like the serial port hardware to be enabled?" <Yes>
          * "The serial login shell is disabled The serial interface is enabled" <Ok>
          *  Select <Finish> and select <Yes> when asked "Would you like to reboot now"

**Step 2: /boot/config.txt editieren**

Nach dem Neustart muss noch die Datei /boot/config.txt editiert werden:

Hier ist die Zeile enable_uart = 0 auf 
<code>enable_uart = 1</code>
abzuändern. 

Nach einem Neustart sollte dann das Gerät (die serielle Schnittstelle) unter /dev/ttyAMA0 sichtbar sein. 

===Pi4J===
Die Pi4J-Bibliothek muss installiert werden. Anschließend werden zwei Programme übersetzt (kompiliert), um die korrekte Installation und Funktionsweise der Bibliothek zu überprüfen. Wenn diese Beispiele laufen, steht der Entwicklung einer eigenen API mit Hilfe der pi4J-Bibliothek (siehe nächsten Abschnitt) nichts mehr im Wege.

Mit der folgenden Zeile wird Pi4J auf dem RaspberryPi installiert.

<code>curl -s get.pi4j.com | sudo bash</code>

Nach der Installation können auch gleich die mitgelieferten Beispiele übersetzt werden. Hierfür lautet der Befehl

<code>sudo /opt/pi4j/examples/build</code>

==Pi4J Testen==
Pi4J liefert eine Reihe von Beispielprogrammen mit. Zwei dieser Programme probieren wir aus.


Die mitgelieferten Beispiele befinden sich alle im Verzeichnis

<code>/opt/pi4j/examples</code>

In dieses Verzeichnis ist zu wechseln.

**Wichtig:** Beim Übersetzen (javac) und Ausführen (java) ist der classpath der pi4j-Bibliothek mit anzugeben! 
==TEST: SystemInfoExample==
TEST: SystemInfoExample

Wir übersetzen das SystemInfoExample

<code>javac -classpath .:classes:/opt/pi4j/lib/'*' -d . SystemInfoExample.java</code>

Mit der folgenden Zeile wird das Programm ausgeführt

<code>sudo java -classpath .:classes:/opt/pi4j/lib/'*' SystemInfoExample</code>

Die Ausgabe (kleiner Auszug) sollte in etwa so aussehen: 
<code>
----------------------------------------------------
PLATFORM INFO
----------------------------------------------------
Platform Name     :  Raspberry Pi
Platform ID       :  raspberrypi
----------------------------------------------------
HARDWARE INFO
----------------------------------------------------
Serial Number     :  00000000092a697c
CPU Revision      :  7
CPU Architecture  :  7
CPU Part          :  0xb76
CPU Temperature   :  41.7
CPU Core Voltage  :  1.35
CPU Model Name    :  ARMv6-compatible processor rev 7 (v6l)
Processor         :  0
</code>
==TEST: SerialExample==
Wir übersetzen das SerialExample

<code>sudo javac -classpath .:classes:/opt/pi4j/lib/'*' -d . SerialExample.java</code>

Wir testen, ob das Beispiel SerialExample gestartet werden kann (da wir nichts angeschlossen haben, sollte das Programm nach dem Start wieder beendet werden).

<code>sudo java -classpath .:classes:/opt/pi4j/lib/* SerialExample</code>

==Java API für den Hexapoden ==

<code>I
// NFO Java Carriage Return java = \r 
Serial gui = cutecom (sudo apt-get install cutecom) //INFO
 </code>

Tutorial : http://fablab-wiki.fsg-preetz.de/index.php?title=Hexapod_Api_Tutorials 
Quellen

Source code : https://github.com/Creepler13/Hexapode-Lynxmotion-Roboter-Java-Api

JavaDoc : https://creepler13.github.io/Hexapode-Lynxmotion-Roboter-Java-Api/

(Api by Lukas.D und Denis.S) 

====Ansprechen des Hexapoden ohne API====
Es ist natürlich auch möglich den Hexapoden ohne die kleine Java API anzusprechen. Hierbei ist es aber wichtig die Funktionsweise des Lynxmotion SSC32U Servo Controllers zu verstehen. Hierzu können sie sich den [[https://fablab-wiki.fsg-preetz.de/images/8/86/Lynxmotion_ssc-32u_user_guide.pdf  | User Guide]] durchlesen. Um den Servo Controller und damit die Motoren anzusprechen, muss über die Serielle Schnittstelle ein Befehl gesendet werden mit folgendem Aufbau:

<code># <ch> P <pos> S <sg> T <zeit> <cr></code>

  * <ch> Pin/Kanal von 1 bis 31
  * <pos> Position zu der der Servo sich bewegen soll
  * <sg> Servo geschwindigkeit in Microsekunden pro Sekunde (1000≈90°/s)
  * <zeit> Zeit in Millisekunden um zum neuen Ort zu gelangen.
  * <cr> carriage return (ASCII 13)


Ein Beispiel für einen Befehl wäre zum Beispiel:

<code>#3 P1600 T1000 <cr></code>

Hier wird der Servo 3 in einer Sekunde zur Position 1600 bewegt. Es ist aber auch möglich mehrere Motoren gleichzeitig zu bewegen:

<code>#5 P1600 #10 P750 T2500 <cr></code>

Hier wird der Servo 5 zu Position 1600 bewegt und der Servo 10 zu Position 750. Beide haben für diese Bewegung 2,5 sekunden zeit.


Um dies in PI4J umzusetzten muss erst einmal die Serielle Schnittstelle wie im Serial Example eröffnet werden. Danach können die Befehle einfach per

<code>Serial.write("<befehl>");</code>

gesendet werden. 

====Programm ausführen====
Wenn sie ein Programm geschreiben haben, dass entweder die Java APi benutzt oder welches sie händisch programmiert haben, dann müssen sie dieses erst einmal auf den Raspberrypi verschieben. 
===Dateien mit SCP verschieben===
Datein können sie mit SCP verschieben. Hierzu gehen sie in das Verzeichniss in dem Ihr Projekt liegt und führen sie folgenden Befehl aus:

<code>scp ./<Projektordner> <user>@<Adresse>:~/<Zeilort></code>

===Projekte mit Git kopieren===
Wenn sie Git benutzen stellen sie sicher,dass Git auf ihrem Raspberry Pi installiert ist. Wenn nicht, dann installieren sie es mit:

<code>sudo apt-get install git</code>

Programme mit den Befehlen auf den Raspberry Pi laden:

Kopiert die Git Reposetory ins momentane Verzeichnis:

<code>git clone <Adresse></code>

Aktualisiert (lädt Änderungen) die Git Reposetory im momentane Verzeichnis:

<code>git pull <Adresse></code>

===Programm starten===
Nun müssen sie folgenden Befehl auf der Konsole ausführen um das Programm zu compilieren:

<code>javac -classpath .:classes:/opt/pi4j/lib/'*' -d . <Dateiname>.java</code>

Und im Anschluss das kompilierte Programm starten:

<code>sudo java -classpath .:classes:/opt/pi4j/lib/* <Dateiname></code>

Nun sollte das Programm laufen. Wenn dies nicht der Fall ist, testen sie die Beispiele der Pi4j Library. 

===Quellen===
Die wichtigste Quelle für dieses Projekt ist der SSC-32U User Guide. Er enthält u.a. das Protokoll für die serielle Kommunikation. 
  * [[https://fablab-wiki.fsg-preetz.de/images/8/86/Lynxmotion_ssc-32u_user_guide.pdf |SSC-32U Servo Controller]]

Weitere Quellen zum SCC-32 Servo-Controller:
  * http://www.lynxmotion.com/images/html/build185.htm
  * http://www.lynxmotion.com/s-4-electronics-guides.aspx
  * http://www.robotshop.com/en/lynxmotion-ssc-32u-usb-servo-controller.html#Useful-Links

Die Pi4J Bibliothek wird benötigt, um mit Java die serielle Schnittstelle des Raspberry ansprechen zu können.
  * http://pi4j.com/

Api
  * https://github.com/Creepler13/Hexapode-Lynxmotion-Roboter-Java-Api

===History===
  * bis Juni 2019 Hannes. H
  * ab Juni 2019 bis Februar 2021 Denis. S & Lukas. D