03. Imprimer le VerseGrip sans fil

Même schéma que dans le tutoriel 02, mais pour un VerseGrip sans fil — ajoute les boutons (A/B/C) et le niveau de batterie à l'affichage en temps réel.

Ce que vous apprendrez :

• Lecture des champs d'état spécifiques à la communication sans fil : buttons.{a,b,c}, battery_level, hall
• Utilisation de probe_orientation en tant que mécanisme de maintien de connexion autonome
• Même modèle de négociation de connexion par « premier message uniquement » que dans le tutoriel 02

Flux de travail

1. Ouvrir un WebSocket vers ws://localhost:10001 et attendre la première trame d'état.
2. Choisissez les premiers VerseGrip sans fil device_id à partir de wireless_verse_grip tableau.
3. Construisez une requête avec le profil de session et par appareil probe_orientation keepalive.
4. Envoyez la requête, puis supprimez le session champ — il s'agit d'une poignée de main unique.
5. À chaque image suivante, convertissez le quaternion en angles d'Euler et affichez les données de télémétrie (avec un débit limité), y compris l'état des boutons et le niveau de la batterie. Renvoyez le message de maintien de connexion à chaque tick.

Paramètres

Nom	Par défaut	Objectif
URI	ws://localhost:10001	URL WebSocket du canal de simulation
PRINT_EVERY_MS	100	Régulateur de débit via la console
Nom du profil de session	co.haply.inverse.tutorials:print-wireless-verse-grip	Identifie cette simulation dans Haply

convention d'Euler

La conversion est intrinsèque Z-X-Y (lacet → tangage → roulis) dans le repère de l'application +X right, +Y forward, +Z up. Ne pas utiliser glm::eulerAngles — elle suit une convention différente et ne s'affichera pas correctement ici. Ces trois variantes de langage utilisent le même calcul ; consultez les sources pour voir la formule.

Quand probe_orientation est en fait nécessaire

probe_orientation n'est utile que lorsque votre session pas envoyer n'importe quelle commande à un Inverse3. Dès que vous envoyez une commande à un Inverse3 force, position, couple...), le service transmet automatiquement l'orientation du VerseGrip appairé à chaque trame d'état — aucune sonde n'est nécessaire. Utilisez probe_orientation uniquement pour les outils autonomes de surveillance de la prise en main, comme dans ce tutoriel.

Champs d'état lus

De data.wireless_verse_grip[0].state:

• orientation — quaternion (w, x, y, z)
• hall — valeur entière de la lecture du capteur Hall
• buttons.a, buttons.b, buttons.c — booléens
• battery_level — nombre à virgule flottante (0,0 – 1,0)
• transform.rotation — rotation de l'espace de travail (quaternion); la position et l'échelle ne s'appliquent pas à un périphérique à orientation unique et ne sont jamais transmises

Sémantique des mises à jour partielles

transform.rotation est omis lorsqu'il est égal au quaternion identité {w:1,x:0,y:0,z:0}. Fournir une valeur par défaut lors de la lecture. Activer serialization/explicit_fields pour toujours le recevoir.

Envoyer / recevoir

De la même forme que Tutoriel 02, simplement avec le wireless_verse_grip tableau de périphériques. La boucle WebSocket reçoit une trame d'état et renvoie la poignée de main + probe_orientation keepalive ; le premier message sortant contient le profil de session, chaque trame suivante ne contient que le keepalive.

Python

Boucle asynchrone unique.

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)

Structures typées. Remarque button_state est explicitement nommé (et non buttons) pour éviter de faire de l'ombre à buttons champ sur wvg_state — Glaze mappe les champs par leur nom, de sorte que le nom du type de structure est libre.

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

Options de ligne de commande (Python)

La variante Python accepte les deux mêmes indicateurs que le tutoriel 01:

• --full — affiche le contenu JSON brut sous une forme lisible, au lieu du résumé sur une seule ligne.
• --query-config — réinjecte session.force_render_full_state à chaque impulsion sortante, de sorte que chaque trame transporte le config le bloc plutôt que simplement le delta d'état.

--query-config est particulièrement utile pour le VerseGrip sans fil car le config Ce bloc contient les éléments spécifiques à WVG sub_type champ (stylus / prototype / ruko / kingfisher, ajouté dans la version 3.5) en plus des champs de configuration habituels. Exécution de python 03-haply-inverse-print-wireless-verse-grip.py --full --query-config vous permet de regarder config.sub_type se mettre à jour en temps réel, parallèlement aux autres valeurs de configuration.

Les variantes C++ ne mettent pas ces indicateurs à disposition.

Fourni avec le programme d'installation du SDK

Le didacticiel 03 est également installé localement avec le SDK — regardez dans tutorials/03-haply-inverse-print-wireless-verse-grip/ dans le répertoire d'installation du service.

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

À lire également : Tutoriel 02 (Wired VG) · Types (quaternion) · Commandes de contrôle (probe_orientation) · Protocole WebSocket