Das entpackte Image schreiben Sie wie gewohnt per RPi Imager auf die SD-Karte (Abbildung 4). Der Schreibprozess dauert allerdings länger als bei einem PI-OS-Image. Nach dem Beschreiben der Karte stecken Sie diese in den Jetson und schalten die Spannungsversorgung ein. Das Board bootet in das Standard-Ubuntu-Setup, das die Entwickler um einige Screens erweiterten. Sie erlauben es beispielsweise, die CPU-Leistung zugunsten des Stromverbrauchs herunterzuregeln. Als Faustregel gilt: Passen Sie so wenig wie möglich an.
Nach Abschluss der Installation bootet der Jetson neu. Zunächst bringen Sie die Software auf den aktuellen Stand. Dazu öffnen Sie ein LX-Terminal und geben die Kommandos sudo apt update und sudo apt upgrade ein. Das Terminal finden Sie bei den Systemtools. Um die Änderungen zu übernehmen, leiten Sie mit sudo reboot einen Neustart des Systems ein.
Abbildung 4: Der RPi IMager erlaubt es, komfortabel Systemabbilder auf SD-Karten zu transferieren.
Jetson: GPIO
Um die GPIO des Jetson-Boards anzusteuern, verwenden Sie eine in der Standardinstallation bereits enthaltene Python-Bibliothek [7]. Interessanterweise fehlt der Nano-Editor, den Sie via sudo apt install nano problemlos nachinstallieren. Listing 1 zeigt ein einfaches Python-Programm, das die zwei LEDs auf dem Testaufbau blinken lässt und die Taster mithilfe von Interrupts abfragt. Zum Starten des GPIO-Testprogramms geben Sie im Terminal das Kommando python3 GPIOtest.py ein.
Listing 1
GPIOtest.py
import RPi.GPIO as GPIO
import time
LED_1_PIN = 18
LED_2_PIN = 23
BUTTON_1_PIN = 24
BUTTON_2_PIN = 25
def button_1_pressed(channel):
print ("Button 1 pressed")
def button_2_pressed(channel):
print ("Button 2 pressed")
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_1_PIN, GPIO.OUT)
GPIO.setup(LED_2_PIN, GPIO.OUT)
GPIO.setup(BUTTON_1_PIN, GPIO.IN)
GPIO.setup(BUTTON_2_PIN, GPIO.IN)
GPIO.add_event_detect(BUTTON_1_PIN, GPIO.FALLING, callback=button_1_pressed, bouncetime=10)
GPIO.add_event_detect(BUTTON_2_PIN, GPIO.FALLING, callback=button_2_pressed, bouncetime=10)
try:
while True:
GPIO.output(LED_1_PIN, GPIO.HIGH)
GPIO.output(LED_2_PIN, GPIO.LOW)
time.sleep(1)
GPIO.output(LED_1_PIN, GPIO.LOW)
GPIO.output(LED_2_PIN, GPIO.HIGH)
time.sleep(1)
finally:
GPIO.cleanup()
Die GPIO des Jetson ähnelt der des RasPi. Es gibt allerdings einige Unterschiede, die beim Blick auf das Pinout (Abbildung 5) direkt auffallen. Die GPIO-Nummern für die einzelnen Pins unterscheiden sich komplett von denen beim RasPi (Spalte Linux(BCM)). Die für das Beispielprogramm eingesetzte Bibliothek bietet allerdings die Möglichkeit, die bei Raspberry Pi üblichen BCM-Nummern zu verwenden. Weiterhin fällt auf, dass die Pins mit Sonderfunktionen gar keine GPIO-Nummern besitzen. Das bedeutet, dass sich diese Pins anders als beim Raspberry Pi nicht als normale GPIO-Anschlüsse verwenden lassen.
Abbildung 5: Das Pinout der Jetson-GPIO. Im Vergleich zum RasPi fallen die unterschiedlichen GPIO-Nummern auf. Quelle: Nvidia
Beim Experimentieren mit der Jetson-GPIO fiel dem Autor auf, dass die üblichen 10-kOhm-Pulldown-Widerstände, die beim RasPi immer funktionieren, für den Jetson scheinbar ein wenig zu groß ausfallen. Daher wichen sie im Testaufbau 1-kOhm-Widerständen. Ein weiterer Punkt, den Sie beachten sollten, betrifft die Sonderfunktionen der GPIO-Ports – hier liegt zumindest der RasPi 4 eindeutig vorn. Der Jetson lässt sich in seinem Funktionsumfang eher mit einem Raspberry Pi 3 vergleichen. Allerdings nutzen nur sehr wenige Projekte die erweiterte Funktionalität des RasPi 4 aus. Daher sollte man auf diesen Punkt nicht allzu viel Gewicht legen.
Jetson: I<+>2<+>C
Die I2C-Schnittstelle führt der Jetson wie der RasPi über die Pins 3 und 5 heraus. Um auf den I2C-Bus zuzugreifen, verwenden Sie wie gewohnt die I2C-Tools. Der einzige Unterschied: Das Kommando i2c-detect müssen Sie um die Option -r ergänzen, damit es die Geräte am I2C-Bus erkennt. Listing 2 zeigt die Ausgabe des Testaufbaus; den LM75 erkennt das Tool an der Adresse 0x48h.
Mit dem Kommando i2cget -y 0x01:*0x48:*0x00 lesen Sie das Temperaturregister des LM75 aus. Da es schwerfällt, Hexadezimalzahlen im Kopf in das dezimale Pendant umzurechnen, verwenden Sie das Kommando aus der letzten Zeile von Listing 2, um sich die Temperatur als ganzzahligen Wert ausgeben zu lassen. Dabei übernimmt bc mit den Parametern obase=10; ibase=16; das eigentliche Umrechnen. Das cut und tr formen die Ausgabe passend um.
Listing 2
I<+>2<+>C-Bus scannen (Jetson)
$ sudo i2cdetect -y -r 1 0 1 2 3 4 5 6 7 8 9 a b c d e f 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: -- -- -- -- -- -- -- -- $ watch 'echo "obase=10; ibase=16; $(i2cget -y 0x01:*0x48:*0x00 | cut -d 'x' -f2- | tr 'a-f' 'A-F')" | bc'
Jetson: SPI
Um die SPI-Funktionalität zu testen, verwenden Sie nicht die Python-Bibliothek, sondern die Möglichkeit, die GPIO via Sysfs anzusteuern. Dieser Weg bietet den Vorteil, dass er sich in jeder Programmiersprache nutzen lässt, die in der Lage ist, auf die Dateien zuzugreifen. Wenn wir das /sys Filesystem nutzen, gilt es, die mit Linux(BCM) gekennzeichneten GPIO-Nummern (Abbildung 5) zu verwenden.
Im Programm aus Listing 3 dient Java zum Ansteuern der SPI-Schnittstelle. Um es auf dem Jetson zu installieren, richten Sie mit dem Aufruf sudo apt install openjdk-11jdk das OpenJDK ein. Das Programm umfasst drei Methoden, die Grundfunktionen für den Zugriff auf die GPIO bereitstellen. Das Initialisieren der GPIOs (In/Out) übernimmt initGPIO() (ab Zeile 6). Für das Lesen und Schreiben von Werten sind readGPIO() (ab Zeile 12) und writeGPIO() (ab Zeile 23) zuständig.
Im Konstruktor der Klasse (ab Zeile 32) werden nur die IO-Ports gesetzt und die Pin-Nummern für die SPI-Schnittstelle übergeben. Der interessanteste Teil des Programms findet sich in der Methode readChannel() ab Zeile 42. Sie spricht den MCP3008 mit der Nummer des Kanals an und wertet die Antwort des Chips aus. Da der MCP3008 ein etwas eigenwilliges Verhalten an den Tag legt, fällt es tatsächlich leichter, ihn per Software-SPI anzusprechen. Die erste For-Schleife (ab Zeile 48) überträgt zunächst 5 Bit, um den MCP3008 zu initialisieren und ihm mitzuteilen, welchen Analogkanal das Programm auslesen möchte. Mit dem sechsten Taktzyklus beginnt der MCP3008 12-Bit-Daten zu senden, die die zweite For-Schleife empfängt und verarbeitet (ab Zeile 59).
Um das Testprogramm möglichst einfach zu halten, verzichtet es auf eine Fehlerbehandlung. Zum Bauen und Starten des Programms verwenden Sie die Kommandos javac MCP3008.java und java MCP3008.
