06. Kombination (Inverse3 + kabelloser VerseGrip)

Anleitung für zwei Geräte: Richten Sie den Griff in eine bestimmte Richtung aus und halten Sie die Taste gedrückt, um den Cursor von „ Inverse3 “ in diese Richtung zu bewegen. Der Cursor ist auf einen kugelförmigen Arbeitsbereich beschränkt.

Du wirst Folgendes lernen:

• Lesen von zwei Gerätetypen im selben Status-Frame (inverse3 und wireless_verse_grip)
• Vom Griff aus Quaternionen(lokal) +Y (Achse) Richtung extrahieren
• Verwendung set_cursor_position Den Cursor an die berechnete Zielposition bewegen
• Das Ziel auf einen sicheren kugelförmigen Arbeitsbereich beschränken – der von „Minverse “ verwendete Radius ist kleiner als Inverse3
• Einstellungen Arbeitsbereichsvoreinstellungen(arm_front_centered), sodass der Ursprung im Zentrum des erreichbaren Bereichs liegt

Arbeitsablauf

1. Es wurden zwei Geräte gefunden:
   • Beim Start,C++ die verschiedenen Varianten über HTTP-Abfragen GET /devices, anschließend wird eine Kalibrierungsaufforderung ausgegeben, und Sie warten, bis die ENTER-Taste gedrückt wird.
   • Python liest die IDs der beiden Geräte aus dem ersten WebSocket-Status-Frame aus.
2. Registrieren Sie sich in der ersten Nachricht Sitzungsprofil, und legen Sie Folgendes fest: configure.preset: arm_front_centered(Einmaliger Händedruck).
3. In jedem Zyklus: Auslesen des Griffs orientation sowie buttons.{a, b} Status.
4. Wenn man die Bewegungstaste gedrückt hält, wird die Ausrichtung des Griffs im Weltkoordinatensystem berechnet (R(q) · ĵ(d. h. die Einheit nach der Drehung um die +Y-Achse) und drücke SPEED Nach dem Zoomen an der Zielposition überlagern.
5. Das Ziel auf den Arbeitsraum-Kugelraum beschränken und durch set_cursor_position Senden.
6. (nur Python) Je nach Gerät config.type Anpassung des Kugelradius –minverse beträgt 0,04 m, bei allen anderen Typen 0,10 m.

Parameter

Bezeichnung	Standardwert	Verwendungszweck
SPEED	0.01 m/Zyklus	Bewegungsweg pro Schritt bei gedrückter Taste
RADIUS_INVERSE3	0.10 m	Inverse3 / Der Arbeitsbereich von Inverse3x ist auf einen bestimmten Radius begrenzt
RADIUS_MINVERSE	0.04 m	Minverse Arbeitsbereichsbegrenzung (gilt nur für Python – in C++ ist dies fest codiert als 0.10)
PRINT_EVERY_MS	200	Intervall der Telemetrie-Ausgabe
Name des Sitzungsprofils	co.haply.inverse.tutorials:combined	Diese Simulation im „ Haply Hub“ kennzeichnen

Vor dem Betrieb kalibrieren

• Lassen Sie den Inverse3 sich selbst kalibrieren (oder legen Sie den Griff auf die Tintenpatrone und warten Sie, bis die LED dauerhaft leuchtet).
• Nehmen Sie den Griff von der Tintenpatrone 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 Statusfelder

Aus den Status-Frames jedes Zyklus auslesen:

• 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} — Boolesche Werte
• (Python, nur das erste Bild)data.inverse3[0].config.type —— Radius zur Auswahl von „ Inverse3 “ oder „ Minverse “
• (Python, nur das erste Bild)data.inverse3[0].status.calibrated —— Ist der Wert „false“, wird der Benutzer darauf hingewiesen.

Senden / Empfangen

Berechnung der Richtung aus einer Quaternion (mit R(q) Drehen +Y) sowie die Kugelbeschränkungen sind klassische Operationen der linearen Algebra; Einzelheiten finden Sie in der Quelldatei. Der Abschnitt „Inverse API“ umfasst den Handshake-Prozess sowie für jeden Zyklus set_cursor_position Aufrufstruktur.

Python

Einzelne asynchrone Schleife. Python liest die IDs der beiden Geräte aus dem ersten Status-Frame aus; der Handshake-Vorgang überträgt die Konfigurationsdatei + configure.preset: arm_front_centered Zur ersten Version hinzufügen set_cursor_position Wird aufgerufen.

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++ wird beim Start über GET /devices Ermittle die IDs (HTTP) der beiden Geräte und öffne anschließend den WebSocket.onmessage Läuft auf dem E/A-Thread von libhv; der Hauptthread wird blockiert und wartet auf das Drücken der ENTER-Taste.

// 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)

Genau wie beim Callback-Modell von libhv. Die Status-Frames und die gesendeten Befehle werden mithilfe stark typisierter Strukturen modelliert –devices_message zwei davon std::vector<> sodass ein einzelner glz::read So können beide Gerätetypen gleichzeitig analysiert werden.

// 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 Lieferumfang des SDK-Installationsprogramms enthalten

Das Tutorial 06 wird ebenfalls zusammen mit dem SDK lokal installiert – bitte im Installationsverzeichnis des Dienstes unter tutorials/06-haply-inverse-combined/ dort suchen.

Quellcode: Python · C++ · C++ Glaze

Verwandte Themen: Steuerbefehle (set_cursor_position) · Typ (Quaternion, vec3) · Installation und Arbeitsbereich (Voreinstellungen) · Tutorial 03 (Wireless VG) · Tutorial 05 (Positionssteuerung)