06. Ensemble (Inverse3 + VerseGrip sans fil)

Tutoriel pour deux périphériques : orientez la poignée dans une direction donnée et maintenez le bouton enfoncé pour déplacer le curseur de Inverse3 dans cette direction. Le curseur est confiné à un espace de travail sphérique.

Vous apprendrez :

• Lire deux types d'appareils dans la même trame d'état (inverse3 et wireless_verse_grip)
• À partir de la poignée quaternions(local) +Y Extraction de la direction d'orientation dans l'axe)
• Utilisation set_cursor_position Déplacer le curseur vers la position calculée
• Limiter la cible à un espace de travail sphérique sécurisé — le rayon utilisé parMinverse est inférieur à Inverse3
• Paramètres Préréglages d'espace de travail(arm_front_centered), de manière à ce que l'origine se trouve au centre de la zone accessible

Processus de travail

1. Deux appareils ont été détectés :
   • Au démarrage,C++ les différentes variantes via une requête HTTP GET /devices, puis imprimez les instructions de calibrage et attendez que la touche ENTER soit enfoncée.
   • Python lit les identifiants des deux appareils à partir de la première trame d'état WebSocket.
2. S'inscrire dès le premier message Fichier de configuration de session, puis configurer configure.preset: arm_front_centered(Poignée de main unique).
3. À chaque cycle : lecture de la poignée orientation ainsi que buttons.{a, b} État.
4. Si l'on maintient le bouton « Mouvement » enfoncé, l'orientation de la poignée dans le système de coordonnées mondial est calculée (R(q) · ĵ, c'est-à-dire l'unité après rotation autour de l'axe +Y), puis en appuyant sur SPEED Après mise à l'échelle, superposer à l'emplacement cible.
5. Limiter la cible à l'intérieur de la sphère de l'espace de travail, et à l'aide de set_cursor_position Envoyer.
6. (Python uniquement) En fonction de l'appareil config.type Réglage du rayon de la sphère ——minverse est de 0,04 m, tandis que pour tous les autres types, elle est de 0,10 m.

Paramètres

Nom	Valeur par défaut	Utilisation
SPEED	0.01 m/cycle	Distance parcourue à chaque pas lorsque le bouton est maintenu enfoncé
RADIUS_INVERSE3	0.10 m	Inverse3 / Rayon limite de l'espace de travail d'Inverse3x
RADIUS_MINVERSE	0.04 m	Minverse Rayon de limitation de l'espace de travail (applicable uniquement à Python — en C++, il est codé en dur à 0.10)
PRINT_EVERY_MS	200	Intervalle de régulation de la sortie de télémesure
Nom du profil de session	co.haply.inverse.tutorials:combined	Identifier cette simulation dans Haply Hub

Effectuer un étalonnage avant la mise en service

• Laissez le Inverse3 se calibrer automatiquement (ou placez le stylo sur la cartouche d'encre et attendez que la LED reste allumée en continu).
• Retirez le manche de la cartouche d'encre.
• Maintenez la touche A ou B enfoncée et tournez la poignée : le curseur se déplacera dans la direction indiquée par la poignée.

Champs d'état lus

Lecture à 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} — Valeurs booléennes
• (Python, première image uniquement)data.inverse3[0].config.type —— Rayon utilisé pour choisir entre Inverse3 et Minverse
• (Python, première image uniquement)data.inverse3[0].status.calibrated —— Si la valeur est « false », afficher un message à l'utilisateur

Envoyer / Recevoir

Calcul de la direction à partir d'un quaternion (à l'aide de R(q) Rotation +Y) ainsi que les contraintes sphériques constituent toutes des opérations classiques d'algèbre linéaire ; pour plus de détails, voir le fichier source. La partie « API inverse » comprend la procédure de poignée de main ainsi que, pour chaque cycle, set_cursor_position Composition des appels.

Python

Boucle asynchrone unique. Python lit les identifiants des deux appareils à partir de la première trame d'état ; la procédure de négociation établit le profil de configuration + configure.preset: arm_front_centered Ajouté à la première fois set_cursor_position Appel en cours.

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)

Le C++, lors de son lancement, via GET /devices Identifiez les identifiants (HTTP) des deux appareils, puis ouvrez une connexion WebSocket.onmessage Il s'exécute sur le thread d'E/S de libhv ; le thread principal est quant à lui bloqué, dans l'attente d'une pression sur la touche 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)

Le modèle de rappel est identique à celui de libhv. On utilise des structures fortement typées pour modéliser les trames d'état et les commandes émises —devices_message les deux parmi std::vector<> ce qui permet, en une seule fois, glz::read Il est ainsi possible d'analyser simultanément 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

Fourni avec le programme d'installation du SDK

Le tutoriel 06 sera également installé localement avec le SDK — veuillez vous rendre dans le répertoire d'installation du service, sous tutorials/06-haply-inverse-combined/ Rechercher dans.

Code source : Python · C++ · C++ Glaze

Contenu associé : Commandes de contrôle (set_cursor_position) · Type (quaternion, vec3) · Installation et espace de travail (paramètres par défaut) · Tutoriel 03 (VG sans fil) · Tutoriel 05 (Contrôle de position)