std.hardware.bluetooth

Nativer Bluetooth-Stack für Linux: von rohen AF_BLUETOOTH-Sockets über BlueZ-D-Bus-Steuerung bis zu vollständigen GATT-Client-/Server-Implementierungen für Bluetooth Low Energy (BLE) und Classic Bluetooth (RFCOMM). Alle neun Units implementieren das Protokoll direkt in Lyx — keine externen Bluetooth-Bibliotheken. Verbindungen werden als Dateideskriptoren (int64) verwaltet; jede Funktion nimmt einen fd entgegen.

→ Standard Library · std.android

Übersicht der internen Schichten und Abhängigkeiten:

┌─────────────────────────────────────────────────────┐
│  AI / Profile-Typen                                  │
│  bluetooth_ai                                        │
├─────────────────────────────────────────────────────┤
│  BLE: GATT-Schicht                                   │
│  bluetooth_gattc · bluetooth_gatts                   │
├──────────────────────────┬──────────────────────────┤
│  BLE: L2CAP / ATT        │  Classic: RFCOMM          │
│  bluetooth_l2cap         │  bluetooth_rfcomm         │
├──────────────────────────┴──────────────────────────┤
│  Erweiterungen (BLE Scanner, Advertising, Mesh)      │
│  bluetooth_ext                                       │
├─────────────────────────────────────────────────────┤
│  Steuerungsebene (BlueZ D-Bus)                       │
│  bluetooth_dbus                                      │
├─────────────────────────────────────────────────────┤
│  Typen & Low-Level Syscalls                          │
│  bluetooth_types · bluetooth                         │
└─────────────────────────────────────────────────────┘

Unterste Schicht: direkte AF_BLUETOOTH-Socket-Syscalls. Wird in der Regel nicht direkt verwendet — bluetooth_rfcomm und bluetooth_l2cap bauen darauf auf.

Adress-Typen und Hilfsfunktionen. Alle Bluetooth-Adressen sind heap-allozierte 6-Byte-Puffer (int64 als Zeiger).

import std.hardware.bluetooth_types;
import std.alloc;

var addr := BTStrToAddr("AA:BB:CC:DD:EE:FF");
var outBuf: int64 := alloc(18);
BTAddrToStr(addr, outBuf);  // → "AA:BB:CC:DD:EE:FF"

Steuerungsebene über das BlueZ-D-Bus-Interface. Ermöglicht Gerätesuche, Pairing und Verbindungsaufbau ohne direkten HCI-Zugriff. Erfordert einen laufenden BlueZ-Daemon (bluetoothd).

import std.hardware.bluetooth_dbus;
import std.hardware.bluetooth_types;
import std.alloc;
import std.io;

fn ScanDevices(): void {
    var fd := BlueZOpenConnection();
    var adapterPath: pchar := "/org/bluez/hci0";
    var pathLen: int64 := 16;

    BlueZStartDiscovery(fd, adapterPath, pathLen);
    Sleep(5000);
    BlueZStopDiscovery(fd, adapterPath, pathLen);

    var buf: int64 := alloc(4096);
    BlueZGetManagedObjects(fd, buf, 4096);

    var addrBuf: int64 := alloc(18);
    BlueZFindDeviceAddress(buf, 4096, addrBuf);
    Print(addrBuf);

    BlueZClose(fd);
    free(buf, 4096);
    free(addrBuf, 18);
}

RFCOMM emuliert einen seriellen Port über Bluetooth Classic (BR/EDR). Typische Anwendungen: Verbindung zu Mikrocontrollern (HC-05, HC-06), Barcode-Scannern und Legacy-Geräten.

import std.hardware.bluetooth_rfcomm;
import std.hardware.bluetooth_types;
import std.alloc;
import std.io;

fn ConnectArduino(): void {
    var addr := BTStrToAddr("98:D3:31:F5:AB:CD");
    var fd := RFCommConnect(addr, 1);

    var msg: pchar := "LED:ON\n";
    RFCommSendAll(fd, msg, 7);

    var buf: int64 := alloc(64);
    var n := RFCommRecv(fd, buf, 63);
    Print(buf);

    RFCommClose(fd);
    free(buf, 64);
}

L2CAP ist die Transportschicht für BLE-Verbindungen. Diese Unit enthält zusätzlich eine vollständige ATT-Implementierung (Attribute Protocol) — die Grundlage für GATT.

GATT-Client baut auf einem L2CAP/ATT-fd auf. Der fd wird vorher via L2CapConnect erzeugt. Servicelisten und Characteristic-Listen werden in heap-allokierten Puffern gehalten; Accessor-Funktionen lesen einzelne Felder heraus.

Direktzugriff auf den internen Puffer:

import std.hardware.bluetooth_l2cap;
import std.hardware.bluetooth_gattc;
import std.hardware.bluetooth_types;
import std.alloc;
import std.io;

fn ReadBattery(addrStr: pchar): int64 {
    var addr := BTStrToAddr(addrStr);
    var fd   := L2CapConnect(addr, BT_PSM_ATT, BDADDR_LE_PUBLIC);

    AttExchangeMtu(fd, 512);

    var svcBuf: int64 := alloc(GATT_SVC_RECORD_SIZE * 16);
    var svcCount := GattDiscoverServices(fd, svcBuf, 16);

    var idx := GattFindServiceByUUID(svcBuf, svcCount, GATT_SVC_BATTERY);
    var charBuf: int64 := alloc(GATT_CHAR_RECORD_SIZE * 8);
    GattDiscoverChars(fd, GattSvcStart(svcBuf, idx), GattSvcEnd(svcBuf, idx),
                      charBuf, 8);

    var cidx := GattFindCharByUUID(charBuf, 8, GATT_UUID_BATTERY_LEVEL);
    var valBuf: int64 := alloc(4);
    GattReadChar(fd, GattCharValue(charBuf, cidx), valBuf, 4);
    var level: int64 := peek8(valBuf);

    L2CapClose(fd);
    free(svcBuf, GATT_SVC_RECORD_SIZE * 16);
    free(charBuf, GATT_CHAR_RECORD_SIZE * 8);
    free(valBuf, 4);
    return level;
}

fn MonitorHeartRate(addrStr: pchar): void {
    var addr := BTStrToAddr(addrStr);
    var fd   := L2CapConnect(addr, BT_PSM_ATT, BDADDR_LE_PUBLIC);
    AttExchangeMtu(fd, 512);

    var svcBuf: int64 := alloc(GATT_SVC_RECORD_SIZE * 16);
    var svcCount := GattDiscoverServices(fd, svcBuf, 16);
    var idx := GattFindServiceByUUID(svcBuf, svcCount, GATT_SVC_HEART_RATE);

    var charBuf: int64 := alloc(GATT_CHAR_RECORD_SIZE * 8);
    GattDiscoverChars(fd, GattSvcStart(svcBuf, idx), GattSvcEnd(svcBuf, idx), charBuf, 8);
    var cidx := GattFindCharByUUID(charBuf, 8, GATT_UUID_HR_MEASUREMENT);

    GattEnableNotification(fd, GattCharValue(charBuf, cidx) + 1);  // CCCD handle

    var ntfBuf: int64 := alloc(32);
    var handleOut: int64 := alloc(8);
    var i: int64 := 0;
    while (i < 10) {
        GattPoll(fd, 5000);
        GattRecvNotification(fd, handleOut, ntfBuf, 32);
        Print("BPM: ");
        PrintLn(IntToStr(peek8(ntfBuf + 1)));  // Byte 0 = Flags, Byte 1 = BPM
        i := i + 1;
    }

    L2CapClose(fd);
}

GATT-Server registriert Services über D-Bus und macht das Gerät zum BLE-Peripheral. Erfordert eine aktive BlueZOpenConnection.

Direktzugriff auf den internen Puffer:

Ergänzungen für aktives BLE-Scanning, Advertising-Pakete und Bluetooth-Mesh.

import std.hardware.bluetooth_ext;
import std.hardware.bluetooth_dbus;
import std.hardware.bluetooth_types;
import std.alloc;
import std.io;

fn ScanAndPrint(): void {
    var fd := BlueZOpenConnection();
    var path: pchar := "/org/bluez/hci0";

    var resultBuf: int64 := alloc(BLE_SCAN_RESULT_SIZE * 32);
    var count := BleScan(fd, path, 16, resultBuf, 32);

    var i: int64 := 0;
    while (i < count) {
        if (BleScanResultIsConnectable(resultBuf, i) != 0) {
            var nameBuf: int64 := alloc(64);
            var nameLen := BleScanResultNameLen(resultBuf, i);
            // Name-Bytes kopieren …
            PrintLn("RSSI: " + IntToStr(BleScanResultRSSI(resultBuf, i)) + " dBm");
            free(nameBuf, 64);
        }
        i := i + 1;
    }

    BlueZClose(fd);
    free(resultBuf, BLE_SCAN_RESULT_SIZE * 32);
}

KI-native Bluetooth-Profile: Definiert Standard-BLE-Profile als typsichere Compiler-Typen, sodass manuelle UUID-Verwaltung und Buffer-Arithmetik entfallen. Wrapper-Schicht über bluetooth_gattc.

import std.hardware.bluetooth_ai;
import std.hardware.bluetooth_types;

var addr := BTStrToAddr("AA:BB:CC:DD:EE:FF");

// Typsichere Profile — Compiler kennt die Semantik
var sensor: BleSensor<HeartRate>;
sensor.Connect(addr);
var bpm: HeartRateValue := sensor.Read();
PrintLn(IntToStr(bpm.value) + " bpm");

var batt: BleSensor<Battery>;
batt.Connect(addr);
PrintLn(IntToStr(batt.Read().percent) + " %");

• std.thread — Threads für parallele Sensor-Verbindungen
• std.signals — Signalbehandlung für sauberes Herunterfahren
• std.net.socket — TCP/UDP-Netzwerkkommunikation
• std.android.ioctl — ioctl-Nummern für Android-Bluetooth-Treiber

Letzte Aktualisierung: 2026-06-05