06. Kombiniert (Inverse3 + Wireless VerseGrip)

Tutorial mit zwei Geräten: Richten Sie den Griff aus und halten Sie eine Taste gedrückt, um den Cursor von Inverse3 in diese Richtung zu bewegen. Der Cursor wird innerhalb eines kugelförmigen Arbeitsraums begrenzt.

Was Sie lernen:

• Auslesen von zwei Gerätetypen aus demselben Zustandsrahmen (inverse3 und wireless_verse_grip)
• Ermitteln der Zeigerichtung des Griffs aus seinem Quaternion (lokale +Y-Achse)
• Verwenden von set_cursor_position, um den Cursor zu einem berechneten Ziel zu bewegen
• Begrenzen des Zielpunkts auf eine sichere Arbeitsraumkugel – Minverse verwendet einen kleineren Radius als Inverse3
• Festlegen eines Arbeitsraum-Presets (arm_front_centered), damit der Ursprung in der Mitte der Reichweite liegt

Ablauf

1. Beide Geräte erkennen:
   • C++-Varianten fragen beim Start über HTTP GET /devices ab, geben dann eine Kalibrierungsaufforderung aus und warten auf ENTER.
   • Python liest beide Geräte-IDs aus dem ersten Zustandsrahmen von WebSocket.
2. Registrieren Sie das Sitzungsprofil und setzen Sie in der ersten Nachricht configure.preset: arm_front_centered (einmaliger Handshake).
3. Bei jedem Zyklus: Lesen Sie die orientation des Griffs und den Zustand von buttons.{a, b}.
4. Wird eine Bewegungstaste gehalten, berechnen Sie die Richtung des Griffs im Weltkoordinatensystem (R(q) · ĵ – die gedrehte Einheitsachse +Y) und addieren Sie diese, skaliert mit SPEED, zur Zielposition.
5. Begrenzen Sie den Zielpunkt innerhalb der Arbeitsraumkugel und senden Sie ihn über set_cursor_position.
6. (nur Python) Passen Sie den Kugelradius anhand von config.type des Geräts an – minverse = 0.04 m, alle anderen = 0.10 m.

Parameter

Name	Standardwert	Zweck
SPEED	0.01 m/tick	Schrittweite, solange eine Taste gehalten wird
RADIUS_INVERSE3	0.10 m	Begrenzungsradius des Arbeitsraums für Inverse3 / Inverse3x
RADIUS_MINVERSE	0.04 m	Begrenzungsradius des Arbeitsraums für Minverse (nur Python – C++ ist fest auf 0.10 codiert)
PRINT_EVERY_MS	200	Drosselung der Telemetrie
Name des Sitzungsprofils	co.haply.inverse.tutorials:combined	Kennzeichnet diese Simulation in Haply Hub

Vor dem Start kalibrieren

• Lassen Sie Inverse3 sich selbst kalibrieren (oder legen Sie den Griff auf das Inkwell und warten Sie, bis die LED dauerhaft leuchtet).
• Nehmen Sie den Griff vom Inkwell ab.
• Halten Sie A oder B gedrückt und drehen Sie den Griff – der Cursor bewegt sich in die Richtung, in die der Griff zeigt.

Gelesene Zustandsfelder

Aus dem Zustandsrahmen jedes Zyklus:

• data.inverse3[0].state.cursor_position — vec3
• data.wireless_verse_grip[0].state.orientation — quaternion
• data.wireless_verse_grip[0].state.buttons.{a, b, c} — Booleans
• (Python, nur im ersten Rahmen) data.inverse3[0].config.type — wählt den Radius für Inverse3 oder Minverse
• (Python, nur im ersten Rahmen) data.inverse3[0].status.calibrated — fordert den Benutzer auf, wenn der Wert false ist

Senden / Empfangen

Die Berechnung der Richtung aus dem Quaternion (Drehung von +Y mit R(q)) und die Begrenzung auf die Kugel sind klassische lineare Algebra – siehe die Quelldateien. Die Inverse-API-Seite besteht aus dem Handshake und dem pro Zyklus gesendeten set_cursor_position.

Python

Eine einzige asynchrone Schleife. Python liest beide Geräte-IDs aus dem ersten Zustandsrahmen; der Handshake hängt Profil und configure.preset: arm_front_centered an den ersten set_cursor_position-Aufruf an.

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

        if first_message:
            first_message = False
            inverse3_id = data["inverse3"][0]["device_id"]
            grip_id     = data["wireless_verse_grip"][0]["device_id"]
            radius      = get_workspace_radius(data["inverse3"][0].get("config", {}))

            # Handshake: profile + preset + first position command
            request_msg = {
                "session": {"configure": {"profile": {"name": SLUG}}},
                "inverse3": [{
                    "device_id": inverse3_id,
                    "configure": {"preset": {"preset": "arm_front_centered"}},
                    "commands": {"set_cursor_position": {"position": position}},
                }],
            }
        else:
            # Per tick: update position from grip pointing direction (classic math, not shown), send
            request_msg = {
                "inverse3": [{
                    "device_id": inverse3_id,
                    "commands": {"set_cursor_position": {"position": position}},
                }],
            }

        await websocket.send(json.dumps(request_msg))

C++ (nlohmann)

C++ ermittelt beim Start beide Geräte-IDs über GET /devices (HTTP) und öffnet dann WebSocket. onmessage läuft im I/O-Thread von libhv; der Hauptthread blockiert, bis ENTER gedrückt wird.

// Startup (synchronous):
const std::string inv3_device_id = get_first_device_id("inverse3");
const std::string grip_device_id = get_first_device_id("wireless_verse_grip");

// Per tick:
ws.onmessage = [&](const std::string &msg) {
    json data = json::parse(msg);
    // ... classic math (not shown): update local Inverse3State + WirelessVerseGripState,
    //     compute new position from grip orientation, clamp to sphere ...

    json command;
    command["inverse3"] = json::array();
    command["inverse3"].push_back({
        {"device_id", inv3_device_id},
        {"commands", {{"set_cursor_position",
            {{"position", {{"x", pos.x}, {"y", pos.y}, {"z", pos.z}}}}}}}
    });

    if (first_message) {
        first_message = false;
        command["session"] = {{"configure", {{"profile",
            {{"name", "co.haply.inverse.tutorials:combined"}}}}}};
        command["inverse3"][0]["configure"] = {
            {"preset", {{"preset", "arm_front_centered"}}}};
    }

    ws.send(command.dump());
};
ws.open("ws://localhost:10001");
while (std::cin.get() != '\n') {}  // block main thread

C++ (Glaze)

Dasselbe Callback-Modell wie bei libhv. Typisierte Structs bilden sowohl die Zustandsrahmen als auch den ausgehenden Befehl ab – zwei std::vector<> in devices_message ermöglichen es, mit einem einzigen glz::read beide Gerätetypen zu lesen.

// 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{}; };
struct wvg_device { std::string device_id; wvg_state state; };

struct inverse_state { vec3 cursor_position{}, cursor_velocity{}; };
struct inverse_device { std::string device_id; inverse_state state; };

struct devices_message {
    std::vector<inverse_device> inverse3;
    std::vector<wvg_device> wireless_verse_grip;
};

struct set_cursor_position_cmd { vec3 position; };
struct commands_message {
    std::optional<session_cmd> session;
    std::vector<device_commands> inverse3;
};

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

    const auto &wvg = data.wireless_verse_grip[0].state;
    cursor_pos = data.inverse3[0].state.cursor_position;
    // ... classic math (not shown): if (wvg.buttons.a || wvg.buttons.b)
    //     move in pointing dir; clamp to sphere ...

    commands_message out_cmds{};
    device_commands dc{ .device_id = inv3_device_id };
    dc.commands.set_cursor_position = set_cursor_position_cmd{cursor_pos};

    if (first_message) {
        first_message = false;
        out_cmds.session = session_cmd{ /* profile = combined */ };
        dc.configure = device_configure{ .preset = preset_cfg{"arm_front_centered"} };
    }
    out_cmds.inverse3.push_back(std::move(dc));

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

Im SDK-Installer enthalten

Tutorial 06 wird zusätzlich lokal mit dem SDK installiert – suchen Sie in tutorials/06-haply-inverse-combined/ im Installationsverzeichnis des Dienstes.

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

Siehe auch: Steuerbefehle (set_cursor_position) · Typen (quaternion, vec3) · Montage & Arbeitsraum (Presets) · Tutorial 03 (Wireless VG) · Tutorial 05 (Positionsregelung)