03. Wireless VerseGrip drucken

Das gleiche Schema wie in Tutorial 02, jedoch für einen kabellosen VerseGrip – fügt dem gestreamten Status die Tasten (A/B/C) und den Akkustand hinzu.

Was Sie lernen werden:

• Auslesen von drahtlos-spezifischen Statusfeldern: buttons.{a,b,c}, battery_level, hall
• Verwendung von probe_orientation als eigenständiger Keepalive-Beobachter
• Das gleiche Handshake-Muster, bei dem nur die erste Nachricht gesendet wird, wie in Tutorial 02

Arbeitsablauf

1. Öffne einen WebSocket zu ws://localhost:10001 und auf den ersten Status-Frame warten.
2. Entscheiden Sie sich für den ersten kabellosen VerseGrip device_id aus dem wireless_verse_grip Array.
3. Erstellen Sie eine Anfrage mit dem Sitzungsprofil und pro Gerät probe_orientation Keepalive.
4. Sende die Anfrage und entferne anschließend das session Feld – es handelt sich um einen einmaligen Handshake.
5. Wandle in jedem nachfolgenden Frame das Quaternion in Euler-Winkel um und gib die gedrosselte Telemetriedaten aus, einschließlich der Tastenstatus und des Akkustands. Sende das Keepalive bei jedem Tick erneut.

Parameter

Name	Standard	Zweck
URI	ws://localhost:10001	WebSocket-URL des Simulationskanals
PRINT_EVERY_MS	100	Drosselung der Konsolenausgabe
Name des Sitzungsprofils	co.haply.inverse.tutorials:print-wireless-verse-grip	Identifiziert diese Simulation im Haply

Euler-Konvention

Die Umrechnung erfolgt im Anwendungsbezugssystem nach dem intrinsischen Z-X-Y-Schema (Gieren → Nicken → Rollen) +X right, +Y forward, +Z up. Nicht Verwendung glm::eulerAngles — Es folgt einer anderen Konvention und wird hier falsch angezeigt. Alle drei Sprachvarianten verwenden dieselbe mathematische Formel; die Formel findest du im Quellcode.

Wenn probe_orientation tatsächlich benötigt wird

probe_orientation ist nur dann sinnvoll, wenn deine Sitzung nicht Senden Sie einen beliebigen Befehl an einen Inverse3. Sobald Sie einen Befehl an einen Inverse3 senden Inverse3 Kraft, Position, Drehmoment ...), überträgt der Dienst automatisch die Ausrichtung des gekoppelten VerseGrip in jedem Zustandsframe – ganz ohne Sensor. Verwenden Sie probe_orientation nur für eigenständige Tools zur Griffüberwachung wie in diesem Tutorial.

Statusfelder gelesen

Von data.wireless_verse_grip[0].state:

• orientation — quaternion (w, x, y, z)
• hall — Ganzzahliger Messwert des Hall-Sensors
• buttons.a, buttons.b, buttons.c — Boolesche Werte
• battery_level — float (0,0 – 1,0)
• transform.rotation — Drehung des Arbeitsbereichs (quaternion); Position und Skalierung sind bei einem Gerät, das ausschließlich die Ausrichtung erfasst, nicht relevant und werden niemals ausgegeben

Semantik der Teilaktualisierung

transform.rotation wird weggelassen, wenn es dem Identitätsquaternion entspricht {w:1,x:0,y:0,z:0}. Beim Einlesen einen Standardwert angeben. Aktivieren serialization/explicit_fields um es immer zu erhalten.

Senden / Empfangen

Gleiche Form wie Tutorial 02, nur mit dem wireless_verse_grip Gerätearray. Die WebSocket-Schleife empfängt einen Status-Frame und sendet den Handshake zurück + probe_orientation Keepalive; die erste ausgehende Nachricht enthält das Sitzungsprofil, alle nachfolgenden Frames enthalten nur das Keepalive.

Python

Einzelne asynchrone Schleife.

async with websockets.connect(URI) as websocket:
    while True:
        msg  = await websocket.recv()
        data = json.loads(msg)

        if first_message:
            first_message = False
            device_id = data["wireless_verse_grip"][0]["device_id"]
            request_msg = {
                "session": {"configure": {"profile": {
                    "name": "co.haply.inverse.tutorials:print-wireless-verse-grip"}}},
                "wireless_verse_grip": [{
                    "device_id": device_id,
                    "commands": {"probe_orientation": {}}  # empty — keepalive
                }]
            }

        await websocket.send(json.dumps(request_msg))
        request_msg.pop("session", None)  # one-shot handshake

C++ (nlohmann)

ws.onmessage = [&](const std::string &msg) {
    const json data = json::parse(msg);

    if (first_message) {
        first_message = false;
        device_id = data["wireless_verse_grip"][0].at("device_id").get<std::string>();
        request_msg = {
            {"session", {{"configure", {{"profile",
                {{"name", "co.haply.inverse.tutorials:print-wireless-verse-grip"}}}}}}},
            {"wireless_verse_grip", json::array({
                {{"device_id", device_id},
                 {"commands", {{"probe_orientation", json::object()}}}},
            })},
        };
    }

    ws.send(request_msg.dump());
    request_msg.erase("session");  // one-shot handshake
};
ws.open("ws://localhost:10001");
while (std::cin.get() != '\n') {}  // block main thread

C++ (Glaze)

Typisierte Strukturen. Hinweis button_state wird explizit genannt (nicht buttons), um zu vermeiden, dass der buttons Feld aktivieren wvg_state — Glaze ordnet Felder anhand ihres Namens zu, sodass der Name des Strukturtyps frei gewählt werden kann.

// Struct models
struct quat { float w{1.0f}, x{}, y{}, z{}; };
struct button_state { bool a{}, b{}, c{}; };
struct wvg_state {
    quat orientation{};
    uint8_t hall{};
    button_state buttons{};
    float battery_level{};
};
struct wvg_device { std::string device_id; wvg_state state; };
struct devices_message { std::vector<wvg_device> wireless_verse_grip; };

struct probe_orientation_cmd {};  // empty object on the wire
struct commands_message {
    std::optional<session_cmd> session;  // one-shot — omitted when unset
    std::vector<device_commands> wireless_verse_grip;
};

// Send / receive
ws.onmessage = [&](const std::string &msg) {
    devices_message data{};
    if (glz::read<glz_settings>(data, msg)) return;

    if (first_message) {
        first_message = false;
        request_msg.session = session_cmd{ /* profile = print-wireless-verse-grip */ };
        device_commands dc{ .device_id = data.wireless_verse_grip[0].device_id };
        dc.commands.probe_orientation = probe_orientation_cmd{};
        request_msg.wireless_verse_grip.push_back(std::move(dc));
    }

    std::string out_json;
    (void)glz::write_json(request_msg, out_json);
    ws.send(out_json);
    request_msg.session.reset();  // one-shot handshake
};
ws.open("ws://localhost:10001");
while (std::cin.get() != '\n') {}  // block main thread

Befehlszeilenoptionen (Python)

Die Python-Variante akzeptiert dieselben beiden Flags wie Tutorial 01:

• --full — gibt die JSON-Nutzdaten in lesbarer Form aus, anstatt nur die einzeilige Zusammenfassung.
• --query-config — wieder einspritzt session.force_render_full_state bei jedem ausgehenden Takt, sodass jeder Frame die config Block statt nur des Zustandsdeltas.

--query-config ist besonders nützlich für den Wireless VerseGrip, da der config Der Block enthält die WVG-spezifischen sub_type Feld (stylus / prototype / ruko / kingfisher(in Version 3.5 hinzugefügt) zusätzlich zu den regulären Konfigurationsfeldern. Ausführen von python 03-haply-inverse-print-wireless-verse-grip.py --full --query-config ermöglicht es dir, zu schauen config.sub_type live aktualisiert, zusammen mit den anderen Konfigurationswerten.

Die C++-Varianten stellen diese Flags nicht zur Verfügung.

Im Lieferumfang des SDK-Installationsprogramms enthalten

Tutorial 03 wird ebenfalls lokal mit dem SDK installiert – schau mal unter tutorials/03-haply-inverse-print-wireless-verse-grip/ im Installationsverzeichnis des Dienstes.

Quelle: Python · C++ · C++ Glaze

Siehe auch: Anleitung 02 (Wired VG) · Typen (Quaternionen) · Steuerbefehle (probe_orientation) · WebSocket-Protokoll