03. Afficher les données du Wireless VerseGrip

Même principe que le tutoriel n° 2, mais pour un VerseGrip sans fil : ajoute les boutons (A/B/C) et le niveau de batterie à l'affichage en continu.

Ce que vous allez apprendre :

• Lire les champs d'état spécifiques à la version sans fil : buttons.{a,b,c}, battery_level, hall
• Utiliser probe_orientation comme message de maintien de connexion pour un observateur autonome
• Même principe de « handshake » (poignée de main), limité au premier message, que dans le tutoriel 02

Déroulement

1. Établissez une connexion WebSocket vers ws://localhost:10001 et attendez la première trame d'état.
2. Récupérez le device_id du premier Wireless VerseGrip présenté dans le tableau wireless_verse_grip.
3. Construisez une requête avec le profil de session et un keepalive probe_orientation par appareil.
4. Envoyez la requête, puis supprimez le champ session — c'est une poignée de main ponctuelle.
5. À chaque trame suivante, convertissez le quaternion en angles d'Euler et affichez les données de télémétrie à fréquence limitée, y compris l'état des boutons et le niveau de la batterie. Renvoyez le keepalive à chaque itération.

Paramètres

Nom	Valeur par défaut	Rôle
URI	ws://localhost:10001	URL du canal de simulation WebSocket
PRINT_EVERY_MS	100	Limitation de la fréquence d'affichage de la console
Nom du profil de session	co.haply.inverse.tutorials:print-wireless-verse-grip	Identifiez cette simulation dans le Hub 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 — cette fonction suit une convention différente et donnera ici des valeurs erronées. Les trois variantes de langage mettent en œuvre les mêmes calculs ; consultez le code source pour connaître la formule.

Quand probe_orientation est-ce vraiment nécessaire ?

probe_orientation n'est utile que lorsque votre session n'envoie aucune commande à un Inverse3. Dès que vous commandez un Inverse3 (force, position, couple…), le service diffuse automatiquement l'orientation du VerseGrip associé dans chaque trame d'état — aucune sonde n'est nécessaire. Utilisez probe_orientation uniquement pour les outils autonomes de surveillance de la poignée, comme dans ce tutoriel.

Champs d'État lus

À partir de data.wireless_verse_grip[0].state :

• orientation — quaternion (w, x, y, z)
• hall — lecture complète du capteur à effet 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 appareil qui ne fournit que l'orientation 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}. Indiquez une valeur par défaut lors de la lecture. Activez serialization/explicit_fields pour continuer à le recevoir.

Envoi / réception

Même structure que le tutoriel 02, avec simplement le tableau des appareils wireless_verse_grip. La boucle WebSocket reçoit une trame d'état et renvoie la poignée de main ainsi que le keepalive probe_orientation; le premier message sortant contient le profil de session, et chaque trame suivante ne contient que le keepalive.

Python

Une seule boucle asynchrone.

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. Notez que button_state est explicitement désigné (et non buttons) afin de ne pas masquer le champ buttons de wvg_state — Glaze associe les champs en fonction de leur nom ; le nom du type de structure n'a donc aucune importance.

// 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 options que le tutoriel 01:

• --full — affiche la charge utile brute au format JSON, au lieu du résumé sur une seule ligne.
• --query-config — réinjecte session.force_render_full_state à chaque tick sortant, de sorte que chaque trame contienne le bloc config au lieu du seul delta d'état.

--query-config est particulièrement utile pour le VerseGrip sans fil, car le bloc config contient le champ sub_type propre à la WVG (stylus / prototype / ruko / kingfisher, ajouté dans la version 3.5), en plus des champs de configuration habituels. L'exécution de python 03-haply-inverse-print-wireless-verse-grip.py --full --query-config permet de voir config.sub_type se mettre à jour en temps réel, en même temps que les autres paramètres de configuration.

Les variantes C++ ne proposent pas ces options.

Fourni avec le programme d'installation du SDK

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

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

Liens connexes : Tutoriel 02 (VG filaire) · Types (quaternion) · Commandes de contrôle (probe_orientation) · Protocole WebSocket