Raspberry Pi 4 und 5 im Browser: Basic-Modus und Linux-Modus, Schritt für Schritt

Ein Raspberry Pi in Velxio ist ein Board auf der Arbeitsfläche, das ein Python-Skript gegen die Schaltung ausführt, die du darum herum verdrahtest. Es gibt nichts zu kompilieren. Du schreibst das Skript, drückst Run, und eine von zwei Engines führt es aus:

• Basic-Modus führt das Skript auf einem Python-Interpreter in deinem Browser-Tab aus. Er startet in wenigen Sekunden und ist der Modus, den du die meiste Zeit verwenden wirst.
• Linux-Modus bootet einen echten Linux-Gast auf Velxios Servern und verbindet ihn mit derselben Schaltung. Du bekommst eine Shell, das Dateisystem und die eigenen Gerätedateien des Kernels für I2C, SPI, UART und GPIO. Der Bootvorgang dauert etwa eine Minute.

Dieser Artikel baut zwei Projekte, eines pro Modus, und zeigt jeden Klick auf dem Weg dorthin. Das erste ist eine Alarmstation aus Grove-Modulen auf einem Raspberry Pi 5: ein Bewegungssensor, ein Vibrationsschalter und ein DHT11 auf der Eingangsseite, ein Buzzer, zwei LEDs und ein Relais mit Lüfter auf der Ausgangsseite. Das zweite ist ein Sensoraufbau auf einem Raspberry Pi 4 mit drei I2C-Geräten. Beide Skripte verwenden die Bibliotheken, die mit Raspberry Pi OS ausgeliefert werden, sodass sie unverändert auf einem echten Board laufen.

Bevor du beginnst, zwei Dinge zum Zugang. Jeder kann einen Raspberry Pi auf der Arbeitsfläche platzieren und eine Schaltung darum herum verdrahten. Zum Ausführen braucht man ein angemeldetes Konto: Jedes kostenlose Konto erhält drei Testsitzungen von 15 Minuten auf der Raspberry-Pi-Familie, in beiden Modi, und jeder kostenpflichtige Tarif hebt das Limit auf. Die Details stehen im Abschnitt Was es kostet gegen Ende.

Zwei Wege, dasselbe Skript auszuführen

Die Engine wird für dich ausgewählt. Ein Skript, das etwas verlangt, das nur Linux kann, wie etwa subprocess, wird in den Linux-Modus geschickt, und ein Chip in der Symbolleiste sagt dir, warum. Du kannst den Linux-Modus auch selbst erzwingen, was das zweite Projekt tut.

Projekt 1: eine Grove-Alarmstation auf einem Raspberry Pi 5

Grove-Module sind der schnellste Weg, Sensoren an einen Pi zu bringen: Jedes Modul hat denselben vierpoligen Anschluss, und in Velxio wird jedes mit drei Drähten an den Header angeschlossen — SIG, VCC und GND. Diese Station überwacht einen Raum mit einem PIR-Bewegungssensor und einem Vibrationsschalter, liest die Luft mit einem DHT11 und antwortet über einen Buzzer, eine grüne LED für „alles ruhig”, eine blaue LED für „Alarm” und ein Relais, das einen Lüfter betreibt, wenn der Raum warm wird.

Schritt 1: ein Projekt auf dem Raspberry Pi 5 starten

Öffne velxio.dev/editor. Der Dialog Start a new project öffnet sich von selbst. Scrolle zum Abschnitt Raspberry Pi und klicke auf die Karte Raspberry Pi 5. Die Karte Raspberry Pi 4B funktioniert genauso: Die beiden Boards teilen den 40-Pin-Header und dieselben Bibliotheken, sodass alles Folgende für beide gilt.

Schritt 2: die Bauteile hinzufügen

Klicke auf die blaue Schaltfläche Add am rechten Ende der Symbolleiste. Sie öffnet den Bauteilkatalog.

Gib einen Namen in das Suchfeld ein und klicke auf die Karte, um das Bauteil auf die Arbeitsfläche zu setzen. Die Grove-Module sind alle unter ihren Seeed-Namen aufgeführt, sodass „Grove PIR” oder „Grove relay” sie findet. Füge diese acht Bauteile nacheinander hinzu:

1. Grove - PIR Motion Sensor
2. Grove - Vibration Sensor (SW-420)
3. Grove - Temperature & Humidity Sensor (DHT11)
4. Grove - Piezo Buzzer
5. Grove - Green LED
6. Grove - Blue LED
7. Grove - Relay
8. DC Motor / Fan

Bauteile können überall auf der Arbeitsfläche verschoben werden. Den Pi unten und die Module über seinem Header zu lassen, hält die Drähte kurz.

Schritt 3: verkabeln

Um einen Draht zu ziehen, klicke auf einen Pin und dann auf den Pin am anderen Ende. Die Pin-Namen erscheinen, wenn du mit der Maus über ein Bauteil fährst. Jedes Grove-Modul nimmt dieselben drei Drähte: SIG an einen GPIO, VCC an 3V3, GND an GND. Das Relais ist die Ausnahme auf der Versorgungsseite — seine Spule möchte 5 V.

Der Lüfter hat keinen eigenen Signaldraht. Er sitzt an den geschalteten Kontakten des Relais, so wie eine Last auf einem Labortisch: Die Versorgung geht in COM und kommt nur aus NO heraus, solange die Spule erregt ist.

Schritt 4: das Skript

Der Datei-Explorer auf der linken Seite enthält bereits eine Datei namens script.py mit einem kurzen Blink-Skript. Behalte diesen Namen. Der Basic-Modus führt die erste .py-Datei aus, die er findet, aber der Linux-Modus führt speziell script.py aus, sodass ein Projekt, dessen Hauptdatei diesen Namen behält, in beiden funktioniert.

Ersetze ihren Inhalt durch dieses Skript:

"""Grove alarm station on a Raspberry Pi 5.

A PIR sensor and a vibration switch watch the room, a DHT11 reads the air,
and the actuators answer: a buzzer and a blue LED for the alarm, a green LED
while all is quiet, and a relay that runs a fan when the room gets warm.
Every module hangs off the header with a Grove cable, one signal pin each.

Wiring, BCM numbers (VCC and GND of each module to 3V3 and GND):
    PIR motion sensor   SIG GPIO17   HIGH while motion is seen
    vibration SW-420    SIG GPIO27   LOW while shaking, HIGH at rest
    DHT11               SIG GPIO4
    buzzer              SIG GPIO24
    green LED GPIO5, blue LED GPIO6
    relay               SIG GPIO23, VCC on 5V; the contacts switch the fan:
                        5V to COM, NO to the fan's +, the fan's - to GND
"""
import time

import adafruit_dht
import board
from gpiozero import LED, Button, Buzzer, MotionSensor

FAN_ON_AT = 28   # degrees C
HOLD = 2.5       # seconds the alarm light stays on after the beeps

pir = MotionSensor(17)
shaker = Button(27, pull_up=True)   # the SW-420 pulls SIG low while it vibrates
dht = adafruit_dht.DHT11(board.D4, use_pulseio=False)
buzzer = Buzzer(24)
quiet_led = LED(5)
alarm_led = LED(6)
fan = LED(23)                        # the relay coil: on() closes COM to NO


def alarm(reason, beeps, beep_time):
    print(f"ALARM: {reason}")
    quiet_led.off()
    alarm_led.on()
    buzzer.beep(on_time=beep_time, off_time=0.1, n=beeps, background=False)
    time.sleep(HOLD)
    alarm_led.off()
    quiet_led.on()


quiet_led.on()
motion_seen = False
shaking = False
next_reading = 0
print("Station armed")

while True:
    if pir.motion_detected and not motion_seen:
        alarm("motion in the room", beeps=3, beep_time=0.15)
    motion_seen = pir.motion_detected

    if shaker.is_pressed and not shaking:
        alarm("vibration on the door", beeps=1, beep_time=0.6)
    shaking = shaker.is_pressed

    if time.monotonic() >= next_reading:
        next_reading = time.monotonic() + 2
        try:
            temperature, humidity = dht.temperature, dht.humidity
        except RuntimeError as err:   # a DHT11 misses a reading now and then
            print(f"DHT11: {err}")
        else:
            fan.value = temperature >= FAN_ON_AT
            print(f"{temperature:.0f} C  {humidity:.0f} %RH  fan {'on' if fan.value else 'off'}")

    time.sleep(0.1)

Drei Dinge darin sind einen Blick wert, weil sie auf echter Hardware genauso sind:

• Der SW-420 ist so verdrahtet, wie es sein Datenblatt beschreibt: SIG ist HIGH, während das Modul stillsteht, und geht auf LOW, während es wackelt. Ein gpiozero-Button mit Pull-up liest das während eines Wackelns als „gedrückt”, weshalb das Skript keine Invertierungslogik benötigt.
• Das Relais wird als LED angesteuert. gpiozero hat keine Relais-Klasse; ein Ausgabegerät, das ein- oder ausgeschaltet ist, ist alles, was eine Relaisspule braucht.
• adafruit_dht wirft einen RuntimeError, wenn ein Lesevorgang fehlschlägt, und ein DHT11 lässt tatsächlich hin und wieder einen Lesevorgang ausfallen. Der try-Block ist keine defensive Verzierung, sondern die Art und Weise, wie die Bibliothek verwendet werden soll.

Schritt 5: ausführen

Klicke in der Symbolleiste auf das grüne Dreieck, um das Projekt auszuführen. Der Serial Monitor öffnet sich unten und berichtet, was die Engine tut: Er lädt die Python-Laufzeitumgebung, installiert die GPIO-Bibliothek und gibt eine Zeile wie [Velxio] ready in 6068 ms aus, gefolgt vom Namen des Skripts, das er ausführt. Von da an landet jedes print() im Skript dort.

Das Skript gibt Station armed aus, dann alle zwei Sekunden eine Temperatur- und Feuchtigkeitszeile. Der DHT11 auf der Arbeitsfläche startet bei 31 C, also schließt das Relais sofort und der Lüfter dreht hoch: Der Motor zeigt einen Richtungspfeil und seine Drehzahl in U/min, und die eigene Anzeige des Relais leuchtet. Interagiere nun mit den Sensoren:

• Klicke auf die Kuppel des PIR oder drücke Motion in seinem Sensorpanel. SIG geht für fünf Sekunden auf HIGH, das Skript gibt ALARM: motion in the room aus, die blaue LED leuchtet auf und der Buzzer piept dreimal.
• Klicke auf den Vibrationssensor oder schalte Vibration in seinem Panel um. Ein langer Piepton und ALARM: vibration on the door.
• Ziehe den Temperaturregler des DHT11 unter 28 C. Beim nächsten Lesevorgang öffnet das Relais und der Lüfter läuft aus.

Das rote Quadrat neben der Run-Schaltfläche stoppt das Skript. Das ist der Basic-Modus in Gänze: Das Skript läuft in deinem Tab, die Pins erreichen die Arbeitsfläche direkt, und die ganze Schleife von Run bis zu einer reagierenden Schaltung dauert Sekunden.

Projekt 2: ein I2C-Sensoraufbau auf einem Raspberry Pi 4, dann der Linux-Modus

Das zweite Projekt setzt drei I2C-Geräte auf den Header-Bus und verwendet das echte smbus2, um mit ihnen zu kommunizieren: einen Grove ADS1115 Analog-Digital-Wandler mit zwei Potentiometern, einen Grove SHT31 Temperatur- und Feuchtigkeitssensor und ein SSD1306 OLED. Ein Button und eine LED an einfachen GPIO-Anschlüssen vervollständigen es. Dieselbe Schaltung funktioniert auf einem Raspberry Pi 5, ohne ein Kabel oder eine Zeile zu ändern: Der Header ist derselbe.

Der ADS1115 ist aus einem Grund dabei, der viele überrascht: Ein Raspberry Pi hat keinen analogen Eingang. Ein Potentiometer, das direkt an einen GPIO angeschlossen wird, liest immer nur high oder low, sowohl auf der echten Platine als auch in Velxio, deshalb gehen die Drehknöpfe durch den ADC.

Die Schaltung

Starte ein neues Projekt auf der Raspberry Pi 4B-Karte und füge diese Teile aus dem Katalog hinzu:

• Grove - 4 Channel 16-bit ADC (ADS1115)
• Potentiometer, zweimal
• Grove - Temperature&Humidity Sensor (SHT31)
• SSD1306 OLED (I2C, 4-pin)
• LED, Resistor 220 Ω und Pushbutton

Dann verkable sie. Alle drei I2C-Geräte teilen sich GPIO2 (SDA) und GPIO3 (SCL):

Das Skript

Speichere dies als script.py. Es fragt zuerst jede der drei Adressen, ob jemand antwortet, und läuft dann in einer Schleife: zwei ADC-Kanäle, Temperatur und Feuchtigkeit, der Button-Zustand auf der LED und die Messwerte auf dem OLED über luma.oled.

"""Sensor rig check for a Raspberry Pi 4.

Probes the three I2C devices, then loops: two knobs through the ADS1115,
temperature and humidity from the SHT31, the readings on the OLED, and a
button that lights the LED. Everything here is what Raspberry Pi OS ships:
smbus2 for the bus, gpiozero for the LED and the button, luma.oled for
the display.

Wiring, on the 40-pin header:
    I2C   : ADS1115, SHT31 and OLED on GPIO2 (SDA) and GPIO3 (SCL), 3V3, GND
    ADC   : one potentiometer on ADS1115 A0, another on A1
    GPIO  : LED through 220 ohm on GPIO27, button between GPIO22 and GND
"""
import time

import smbus2
from gpiozero import LED, Button
from luma.core.interface.serial import i2c
from luma.core.render import canvas
from luma.oled.device import ssd1306

ADS1115, SHT31, OLED = 0x48, 0x44, 0x3C
NAMES = {ADS1115: "ADS1115", SHT31: "SHT31", OLED: "SSD1306 OLED"}

# ADS1115 config register, field by field (datasheet, table 8)
ADS_START = 0x8000       # OS: begin one conversion
ADS_MUX_SINGLE = 0x4000  # AINx against GND; the channel goes in bits 12 and 13
ADS_PGA_4V = 0x0200      # +/-4.096 V full scale
ADS_ONE_SHOT = 0x0100    # power down between conversions
ADS_128_SPS = 0x0080     # 128 samples per second
ADS_NO_COMP = 0x0003     # comparator off
ADS_LSB_VOLTS = 4.096 / 32768

bus = smbus2.SMBus(1)
led = LED(27)
button = Button(22, pull_up=True)


def present(address):
    """True when a device acknowledges its address on bus 1."""
    try:
        bus.write_quick(address)
        return True
    except OSError:
        return False


def read_ads1115(channel):
    """One single-shot conversion on AIN0..AIN3, returned in volts."""
    config = (ADS_START | ADS_MUX_SINGLE | (channel << 12)
              | ADS_PGA_4V | ADS_ONE_SHOT | ADS_128_SPS | ADS_NO_COMP)
    bus.write_i2c_block_data(ADS1115, 0x01, [config >> 8, config & 0xFF])
    time.sleep(0.01)
    hi, lo = bus.read_i2c_block_data(ADS1115, 0x00, 2)
    raw = (hi << 8) | lo
    if raw & 0x8000:
        raw -= 0x10000
    return raw * ADS_LSB_VOLTS


def read_sht31():
    """Single shot, high repeatability, no clock stretching (command 0x2400)."""
    bus.i2c_rdwr(smbus2.i2c_msg.write(SHT31, [0x24, 0x00]))
    time.sleep(0.02)
    reply = smbus2.i2c_msg.read(SHT31, 6)
    bus.i2c_rdwr(reply)
    d = list(reply)
    temperature = -45 + 175 * ((d[0] << 8) | d[1]) / 65535
    humidity = 100 * ((d[3] << 8) | d[4]) / 65535
    return temperature, humidity


print("I2C bus 1:")
for address, name in NAMES.items():
    print(f"  0x{address:02X}  {name}: {'found' if present(address) else 'missing'}")
print()

oled = ssd1306(i2c(port=1, address=OLED))

while True:
    knob_a = read_ads1115(0)
    knob_b = read_ads1115(1)
    temperature, humidity = read_sht31()
    pressed = button.is_pressed
    led.value = pressed
    print(f"A0 {knob_a:5.3f} V   A1 {knob_b:5.3f} V   {temperature:4.1f} C  {humidity:3.0f} %RH"
          + ("   button pressed" if pressed else ""))
    with canvas(oled) as draw:
        draw.text((0, 0), "Pi 4 sensor rig", fill="white")
        draw.text((0, 16), f"A0 {knob_a:.2f}V  A1 {knob_b:.2f}V", fill="white")
        draw.text((0, 32), f"{temperature:.1f} C   {humidity:.0f} %RH", fill="white")
        draw.text((0, 48), "button " + ("down" if pressed else "up"), fill="white")
    time.sleep(2)

Drei Details sind einen Blick wert. Der ADS1115 wird Feld für Feld konfiguriert, so wie sein Datenblatt das Konfigurationsregister aufbaut, sodass jede Konstante gegen Tabelle 8 dieses Dokuments geprüft werden kann. Der SHT31 wird mit i2c_rdwr gelesen, weil sein Messbefehl zwei Bytes ohne Registeradresse ist, was einfache SMBus-Aufrufe nicht ausdrücken können. Und luma.oled ist dieselbe Display-Bibliothek, die Raspberry-Pi-Tutorials mit pip installieren; hier ist sie vorinstalliert, genau wie smbus2 und gpiozero.

Zuerst im Basic-Modus ausführen

Drücke Run. Die Prüfung findet die drei Chips, die Schleife gibt die Messwerte aus und das OLED zeigt sie an. Drehe an einem Potentiometer und die A0- oder A1-Spannung folgt; klicke auf den SHT31 und du kannst die Temperatur und Feuchtigkeit einstellen, die er meldet; halte den Pushbutton gedrückt und die LED leuchtet.

Bisher lief alles im Browser. Die nächsten Schritte führen dasselbe Projekt auf einer Linux-Maschine aus.

Zum Linux-Modus wechseln

1. Wenn der Serial Monitor nicht geöffnet ist, klicke auf Serial in der Symbolleiste.
2. Klicke in der Titelleiste des Serial Monitors rechts auf Linux terminal.

3. Ein Dialog namens Advanced Linux mode erklärt, was gleich passieren wird: Das Projekt startet neu, der Bootvorgang dauert etwa eine Minute und alles läuft langsamer als im Browser. Klicke auf Start Linux mode.

Der Gast bootet im Serial Monitor, der zu einem echten Terminal geworden ist. Während des Bootens zeigt der Chip neben der Board-Auswahl in der Symbolleiste Linux an, und sein Tooltip besagt, dass der Linux-Modus für dieses Projekt aktiv ist.

Wenn die Eingabeaufforderung erscheint, kopiert Velxio script.py in das Home-Verzeichnis des Gasts und startet es. Auf einem ruhigen Server erscheint die Eingabeaufforderung nach etwa 20 Sekunden und die ersten Messwerte etwa eine Minute, nachdem du auf den Button geklickt hast. Die Ausgabe ist dieselbe wie zuvor, und das OLED wird durch denselben luma.oled-Aufruf angesteuert, jetzt von innerhalb des Gasts über das /dev/i2c-1 des Kernels.

Die Shell verwenden

Dafür ist der Linux-Modus da. Klicke in das Terminal, drücke Strg+C, um das Skript zu stoppen, und du bist an einer Root-Eingabeaufforderung auf einem Alpine-Linux-System. Ein paar Zeilen zum Ausprobieren:

cat /etc/os-release | head -2
ls /dev/i2c* /dev/spidev* /dev/gpiochip*
gpioset gpiochip0 27=1
ls -la /home/pi

Die zweite Zeile listet die Header-Busse als Geräteknoten auf: /dev/i2c-0, /dev/i2c-1, /dev/spidev0.0, /dev/spidev0.1 und /dev/gpiochip0. Sie beantworten dieselben Systemaufrufe wie auf einem Raspberry Pi, sodass eine Bibliothek, die sie selbst öffnet, ein C-Programm oder dein eigener ioctl-Code mit den Teilen auf der Zeichenfläche kommuniziert.

Die dritte Zeile ist die moderne Art, einen Pin von der Shell aus anzusteuern, mit den libgpiod-Werkzeugen, die Raspberry Pi OS Bookworm mitbringt. In dem Moment, in dem du Enter drückst, leuchtet die LED an GPIO27 auf der Zeichenfläche. Der Gast hat libgpiod Version 1, daher ist der Chip ein positionelles Argument, wie oben geschrieben, und die Schreibweise von Version 2 mit --chip wird nicht verstanden.

Um das Skript erneut von Hand auszuführen, tippe python3 script.py ein. Um zur Browser-Engine zurückzukehren, klicke in derselben Titelleiste auf Exit Linux terminal. Die Wahl wird nicht mit dem Projekt gespeichert: Öffne es morgen erneut, und Run geht zurück in den Basic-Modus.

Was in jedem Modus funktioniert

Die folgende Tabelle ist die Kurzfassung der Raspberry-Pi-Seite in der Dokumentation, die Bauteil für Bauteil gegen das Live-Produkt geprüft wurde.

Was keiner der beiden Modi kann, damit du dafür keine Testsitzung verbrauchst:

• Analogeingang an einem GPIO. Der Pi hat keinen ADC. Setze einen ADS1115 oder einen MCP3008 zwischen den Sensor und das Board, wie im zweiten Projekt.
• pigpio. Es mappt die Peripherieregister über /dev/gpiomem, und nichts hier stellt dieses Mapping bereit. Verwende RPi.GPIO, gpiozero oder, im Linux-Modus, libgpiod.
• apt, raspi-config, einen Desktop. Der Gast ist Alpine Linux, nicht Raspberry Pi OS. Python 3 und pip sind vorhanden; der Paketmanager und die Pi-Firmware-Werkzeuge nicht.
• Netzwerk von innerhalb des Gasts. Nichts im Gast kann das Internet oder PyPI erreichen. Pakete, die in requirements.txt aufgeführt sind, werden vor dem Boot aufgelöst und sind an der Eingabeaufforderung importierbar.
• Große Machine-Learning-Stacks. PyTorch und TensorFlow werden mit einer Erklärung abgelehnt.

Zwei Gewohnheiten sparen Zeit. Benenne die Hauptdatei script.py, damit beide Modi dieselbe Datei ausführen. Und lege Drittanbieter-Pakete in eine requirements.txt daneben: Wenn ein Skript ein Paket importiert, das fehlt, bietet die Ausführungskonsole die Zeile an, und ein Button schreibt sie für dich.

Was es kostet

Jeder kann eine Raspberry-Pi-Schaltung ohne Konto verdrahten. Das Ausführen ist beschränkt:

• Ein kostenloses Konto erhält drei Testsitzungen von 15 Minuten auf der Raspberry-Pi-Familie. Eine Sitzung öffnet sich, wenn du auf Run drückst, in beiden Modi, und jede Ausführung bis zu ihrem Ende ist kostenlos. Abgemeldet zeigt die Toolbar einen Chip, der dich vor der ersten Ausführung zum Anmelden einlädt.
• Jeder kostenpflichtige Plan hebt das Limit auf. Der günstigste, No AI, kostet 4 USD pro Monat oder 36 USD pro Jahr und enthält die Raspberry-Pi- und STM32-Boards mit unbegrenzter Laufzeit; Maker und Pro enthalten sie ebenfalls. Aktuelle Preise stehen auf der Preisseite.

Testsitzungen sind auf beiden Engines gleich, also sollte ein Skript, das nur den Basic-Modus braucht, dort bleiben: Es startet in Sekunden statt in einer Minute, und der Linux-Gast ist für das da, was nur Linux kann.

Wie es weitergeht

• Galerie-Beispiele für den Pi: ein Button und eine LED auf einem Pi 4, ein PIR-Bewegungsalarm auf einem Pi 5, ein MPU6050 über smbus2 und alle Busse gleichzeitig auf einem Pi 4.
• Der Grove-Katalog: Der Grove-Module-Artikel zeigt, wie ein Modul auf der Leinwand aussieht und wie es emuliert wird.
• Die Dokumentation: die Seite der Raspberry-Pi-Familie mit den vollständigen Kompatibilitätstabellen und die Pinbelegungen des Raspberry Pi 4 und des Raspberry Pi 5.

Zusammenfassung

Zwei Projekte, zwei Engines. Die Grove-Alarmstation lief im Basic-Modus auf einem Raspberry Pi 5, von einer leeren Leinwand zu einer reagierenden Schaltung in wenigen Minuten, mit dem gpiozero- und Adafruit-DHT-Code, den ein Raspberry-Pi-Tutorial verwenden würde. Der Sensoraufbau lief zuerst im Basic-Modus auf einem Raspberry Pi 4, dann im Linux-Modus, wo dasselbe Skript über das /dev/i2c-1 des Kernels mit dem ADS1115, dem SHT31 und dem OLED sprach, und ein an der Eingabeaufforderung eingegebener gpioset-Befehl eine LED auf der Leinwand zum Leuchten brachte. Der Basic-Modus deckt das meiste ab, was ein Raspberry-Pi-Tutorial verlangt; der Linux-Modus ist für das Terminal, die Dateien und die Systemwerkzeuge da, zum Preis einer Minute Bootzeit.