06. Ensemble (Inverse3 + Wireless VerseGrip)

Tutoriel à deux appareils : pointez la poignée et maintenez un bouton enfoncé pour déplacer le curseur Inverse3 dans cette direction. Le curseur est confiné à l'intérieur d'un espace de travail sphérique.

Ce que vous apprendrez :

• Lire deux types d'appareils dans la même trame d'état (inverse3 et wireless_verse_grip)
• Retirer la pièce de guidage de la poignée de son emplacement quaternion (axe local +Y)
• Utiliser set_cursor_position pour déplacer le curseur vers une cible calculée
• Limiter la cible à une sphère de l'espace de travail sécurisé — Minverse utilise un rayon plus petit que Inverse3
• Définir un préréglage de l'espace de travail (arm_front_centered) afin que l'origine soit située au centre de la portée

Déroulement

1. Détecter les deux appareils :
   • Les variantes C++ interrogeant GET /devices via HTTP au démarrage, puis affichent une invite de calibrage et attendent que l'utilisateur appuie sur la touche Entrée.
   • Python lit les identifiants des deux appareils à partir de la première trame d'état de WebSocket.
2. Enregistrez le profil de session et définissez configure.preset: arm_front_centered dans le premier message (prise de contact unique).
3. À chaque cycle, lisez l'orientation de la poignée et l'état de buttons.{a, b}.
4. Si un bouton de déplacement est enfoncé, calculez la direction de la poignée dans l'espace du monde (R(q) · ĵ — l'axe unitaire +Y pivoté), multipliez-la par SPEED puis ajoutez-la à la position cible.
5. Limitez la cible à l'intérieur de la sphère de l'espace de travail et envoyez-la via set_cursor_position.
6. (Python uniquement) Adaptez le rayon de la sphère en fonction du config.type de l'appareil — minverse = 0,04 m, tout le reste = 0,10 m.

Paramètres

Nom	Valeur par défaut	Rôle
SPEED	0.01 m/cycle	Aucun déplacement tant qu'un bouton est enfoncé
RADIUS_INVERSE3	0.10 m	Rayon de contrainte de l'espace de travail pour Inverse3 / Inverse3x
RADIUS_MINVERSE	0.04 m	Rayon de contrainte de l'espace de travail pour Minverse (Python uniquement — C++ corrigé) 0.10 (en dur)
PRINT_EVERY_MS	200	Limitation du débit de télémétrie
Nom du profil de session	co.haply.inverse.tutorials:combined	Identifiez cette simulation dans le Hub Haply

Calibrer avant l'exécution

• Laissez- Inverse3 -se calibrer automatiquement (ou posez la poignée sur l'encrier et attendez que la LED reste allumée en continu).
• Retirez la poignée de l'encrier.
• Maintenez la touche A ou B enfoncée et faites pivoter la poignée : le curseur se déplace dans la direction vers laquelle pointe la poignée.

Champs d'État lus

À partir de la trame d'état de chaque cycle :

• 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} — booléens
• (Python, première trame uniquement) data.inverse3[0].config.type — sélectionne le rayon de Inverse3 ou celui de Minverse
• (Python, première trame uniquement) data.inverse3[0].status.calibrated — invite l'utilisateur à effectuer un étalonnage si la valeur est erronée

Envoi et réception

Le calcul de la direction à partir du quaternion (rotation de +Y par R(q)) et la contrainte à la sphère relèvent de l'algèbre linéaire classique — consultez les fichiers source. Du côté de l'API Inverse, il s'agit de la prise de contact initiale et de set_cursor_position à chaque cycle.

Python

Boucle asynchrone unique. Python lit les identifiants des deux appareils à partir de la première trame d'état ; la prise de contact joint le profil et configure.preset: arm_front_centered au premier set_cursor_position.

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++ détecte les identifiants des deux appareils via GET /devices au démarrage (HTTP), puis ouvre un WebSocket. onmessage s'exécute sur le thread d'E/S de libhv ; le thread principal reste bloqué en attente d'une entrée.

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

Même modèle de rappel libhv. Des structures typées modélisent à la fois les trames d'état et la commande sortante — deux std::vector<> dans devices_message permettent à une seule glz::read de fabriquer ces deux types d'appareils.

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

Inclus avec le programme d'installation du SDK

Le tutoriel n° 6 est également installé localement avec le SDK — consultez tutorials/06-haply-inverse-combined/ dans le répertoire d'installation du service.

Source : Python · C++ · C++ Glaze

Voir aussi : Commandes de contrôle (set_cursor_position) · Types (quaternion, vec3) · Montage et espace de travail (préréglages) · Tutoriel n° 3 (VG sans fil) · Tutoriel 05 (contrôle de position)