std.hardware.gpio

Nativer GPIO-Stack für Linux/ARM64 (Raspberry Pi 4 / BCM2711): von ARM64-Memory-Barriers und rohen Syscall-Wrappern über zwei komplementäre Zugriffsmodi (MMIO-Direktzugriff ohne Kontextwechsel und Linux GPIO-v2 ioctl) bis zu typsicheren Pin-Wrappern, Edge-Detection und Software-PWM. Alle acht Units arbeiten ohne externe Bibliotheken — nur POSIX-Syscalls und direkte Registerzugriffe.

Zwei Zugriffsmodi:

• Variante A — MMIO (gpio_mmio): Kein Kernel-Kontextwechsel nach GpioInit. Ideal für zeitkritische Anwendungen: Software-PWM, Bit-Bang-Protokolle (I²C, SPI), Frequenzen bis ~1 MHz. Erfordert /dev/gpiomem (ohne Root) oder /dev/mem (mit Root).
• Variante B — ioctl (gpio_ioctl): Linux GPIO Character Device API v2 (Kernel ≥ 5.10). Unterstützt atomare Multi-Pin-Operationen, Edge-Detection-Events und Consumer-Labels. Zugriff über /dev/gpiochipX.

→ std.hardware · std.hardware.bluetooth · std.hardware.usb

Übersicht der internen Schichten und Abhängigkeiten:

┌─────────────────────────────────────────────────────┐
│  Typsichere Pin-Wrapper                              │
│  gpio_pin  (OutputPin / InputPin)                   │
├─────────────────────────────────────────────────────┤
│  Erweiterungen                                       │
│  gpio_ext  (AltMode · Edge-Detection · SoftPWM)     │
├──────────────────────────┬──────────────────────────┤
│  Variante A: MMIO        │  Variante B: ioctl        │
│  gpio_mmio               │  gpio_ioctl               │
│  (kein Syscall im Loop)  │  (Linux GPIO-v2 API)      │
├──────────────────────────┴──────────────────────────┤
│  Hilfsfunktionen                                     │
│  gpio_util  (StringCopy · DelayMicroseconds)        │
├─────────────────────────────────────────────────────┤
│  Plattform-Konstanten (nur Konstanten)               │
│  rpi4  (BCM2711 Register-Offsets · Pin-Modi)        │
├─────────────────────────────────────────────────────┤
│  Grundschicht                                        │
│  gpio_syscalls · gpio_barriers                      │
└─────────────────────────────────────────────────────┘

ARM64 Memory- und Instruction-Barrier-Intrinsics. Pflichtbestandteil für korrekte MMIO-Zugriffe auf dem Cortex-A72 (BCM2711): Der Out-of-Order-Prozessor kann Schreibzugriffe umordnen — ohne Barrieren sieht der GPIO-Controller keine definierte Reihenfolge.

Faustregel: Nach jedem Schreibzugriff auf ein GPIO-Register GpioMemBarrier() aufrufen. Lesezugriffe (GPLEV) benötigen keine Barriere.

Unterste Schicht: direkte POSIX-Syscall-Wrapper für GPIO-Gerätedateien (/dev/gpiomem, /dev/gpiochipX). Wird von gpio_mmio und gpio_ioctl importiert; selten direkt verwendet.

Zwei plattformunabhängige Hilfsfunktionen, die von gpio_ioctl (String-Kopie für Consumer-Label) und gpio_ext (Busy-Wait für SoftPWM) benötigt werden.

BCM2711-Hardware-Konstanten für den Raspberry Pi 4. Enthält ausschließlich con-Definitionen — keine Funktionen. Wird von gpio_mmio importiert.

3 Bits pro Pin, 10 Pins pro 32-Bit-Register:

MMIO-Direktzugriff auf BCM2711-GPIO-Register (Variante A). Öffnet /dev/gpiomem und legt ein mmap-Mapping über die Register an. Nach dem einmaligen GpioInit-Aufruf sind alle weiteren Pin-Operationen reine Speicherzugriffe ohne Syscall — ideal für zeitkritische Bit-Bang-Protokolle und Software-PWM.

import std.hardware.gpio_mmio;
import std.alloc;
import std.io;

fn BlinkLed(pin: int64, times: int64): void {
    var ctx := GpioCtxAlloc();
    GpioInit(ctx);
    GpioSetPinMode(ctx, pin, GPIO_PIN_OUTPUT);

    var i: int64 := 0;
    while (i < times) {
        GpioWritePin(ctx, pin, GPIO_PIN_HIGH);
        GpioDelayMicroseconds(500000);   // 500 ms
        GpioWritePin(ctx, pin, GPIO_PIN_LOW);
        GpioDelayMicroseconds(500000);
        i := i + 1;
    }

    GpioClose(ctx);
    GpioCtxFree(ctx);
}

Linux GPIO-v2 ioctl-Interface (Variante B, Kernel ≥ 5.10). Öffnet /dev/gpiochipX und verwendet die standardisierte gpio_v2_*-Kernel-API. Unterstützt atomare Multi-Pin-Operationen (bis 64 Pins gleichzeitig), Consumer-Labels und Edge-Detection über Line-Fds.

import std.hardware.gpio_ioctl;
import std.alloc;
import std.io;

fn IoctlBlinkLed(pin: int64): void {
    // Chip-Info abfragen
    var info := GpioGetChipInfo("/dev/gpiochip0");
    PrintLn("Lines: " + IntToStr(GpioChipInfoLines(info)));
    GpioChipInfoFree(info);

    // Pin als Ausgang anfordern
    var pins: int64 := alloc(4);
    poke32(pins, pin);   // Pin-Nummer als int32 eintragen

    var lineFd := GpioRequestLines("/dev/gpiochip0", pins, 1,
                                    GPIO_V2_LINE_FLAG_OUTPUT, "blink");
    free(pins, 4);

    // 5× blinken
    var i: int64 := 0;
    while (i < 5) {
        GpioSetLineValues(lineFd, 1, 1);  // mask=1 (Line 0), bits=1 (HIGH)
        GpioDelayMicroseconds(500000);
        GpioSetLineValues(lineFd, 1, 0);  // bits=0 (LOW)
        GpioDelayMicroseconds(500000);
        i := i + 1;
    }

    GpioReleaseLine(lineFd);
}

Typsichere Pin-Wrapper (Variante für MMIO). Implementiert ein Konventions-basiertes Typsystem: GpioOutputPin*-Funktionen existieren nur für Schreibzugriffe, GpioInputPin*-Funktionen nur für Lesezugriffe. Ein Aufruf der jeweils falschen Seite (z. B. GpioOutputPinRead) schlägt mit „unknown function“ beim Compilieren fehl.

import std.hardware.gpio_mmio;
import std.hardware.gpio_pin;
import std.alloc;
import std.io;

fn ButtonControlsLed(ledPin: int64, btnPin: int64): void {
    var ctx := GpioCtxAlloc();
    GpioInit(ctx);

    var led := GpioOutputPinAlloc(ctx, ledPin);
    GpioOutputPinInit(led, GPIO_PULL_NONE);

    var btn := GpioInputPinAlloc(ctx, btnPin);
    GpioInputPinInit(btn, GPIO_PULL_UP);   // Taster gegen GND mit Pullup

    var i: int64 := 0;
    while (i < 1000) {
        var pressed := GpioInputPinRead(btn);
        // Taster mit Pullup: gedrückt = LOW (0), losgelassen = HIGH (1)
        GpioOutputPinWrite(led, 1 - pressed);
        GpioDelayMicroseconds(5000);   // 5 ms Entprellzeit
        i := i + 1;
    }

    GpioOutputPinFree(led);
    GpioInputPinFree(btn);
    GpioClose(ctx);
    GpioCtxFree(ctx);
}

Erweiterungen für Alternativfunktionen, Edge-Detection und Software-PWM. Baut auf gpio_mmio und gpio_ioctl auf.

Die Bit-Codes sind nicht linear (BCM2711 GPFSEL 3-Bit):

import std.hardware.gpio_mmio;
import std.hardware.gpio_ext;
import std.hardware.gpio_ioctl;
import std.alloc;

fn FadeLed(pin: int64): void {
    var ctx := GpioCtxAlloc();
    GpioInit(ctx);
    GpioSetPinMode(ctx, pin, GPIO_PIN_OUTPUT);

    // Fade-In: 0 % → 100 % Helligkeit
    var duty: int64 := 0;
    while (duty <= 100) {
        GpioSoftPWM(ctx, pin, 1000, duty, 20);  // 1 kHz, 20 ms pro Schritt
        duty := duty + 5;
    }

    GpioClose(ctx);
    GpioCtxFree(ctx);
}

fn WaitForButton(lineFd: int64): void {
    // Wartet auf fallende Flanke (Tasterdruck) — max. 10 Sekunden
    var r := GpioWaitForEdge(lineFd, 10000);
    if (r == 1) { Print("Taster gedrückt!\n"); }
    if (r == 0) { Print("Timeout.\n"); }
}

Entscheidungshilfe für die Wahl des Zugriffsmodus:

• std.hardware.usb — USB-Stack (HID, CDC, Bulk, Gadget)
• std.hardware.bluetooth — Bluetooth-Stack (BLE/Classic)
• std.thread — Threads für parallele Pin-Überwachung
• std.signals — Signalbehandlung für sauberes Shutdown (GpioClose)
• std.time — Zeitstempel und Timer-Funktionen

Letzte Aktualisierung: 2026-06-07