03. Afficher les données du Wireless VerseGrip

Même principe que le tutoriel 02, mais pour un Wireless VerseGrip — ajoute les boutons (A/B/C) et le niveau de batterie à l'état diffusé en continu.

Ce que vous allez apprendre :

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

Déroulement

Ouvrez une connexion WebSocket vers ws://localhost:10001 et attendez la première trame d'état.
Récupérez le device_id du premier Wireless VerseGrip à partir du tableau wireless_verse_grip.
Construisez une requête avec le profil de session et un keepalive probe_orientation par appareil.
Envoyez la requête, puis retirez le champ session — c'est une poignée de main ponctuelle.
À chaque trame suivante, convertissez le quaternion en angles d'Euler et affichez la télémétrie à fréquence limitée, incluant l'état des boutons et le niveau de 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 console
Nom du profil de session	`co.haply.inverse.tutorials:print-wireless-verse-grip`	Identifie cette simulation dans Haply Hub

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 des valeurs erronées ici. Les trois variantes de langage implémentent les mêmes calculs; consultez le code source pour la formule.

Quand probe_orientation est réellement 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 jumelé 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 ce tutoriel.

Champs d'état lus

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

orientation — quaternion (w, x, y, z)
hall — lecture entière du capteur à effet Hall
buttons.a, buttons.b, buttons.c — booléens
battery_level — flottant (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 émises

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}. Fournissez une valeur par défaut lors de la lecture. Activez serialization/explicit_fields pour toujours le recevoir.

Envoi / réception

Même structure que le tutoriel 02, avec simplement le tableau d'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
C++ (nlohmann)
C++ (Glaze)

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

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

Structures typées. Notez que button_state est nommé explicitement (et non buttons) afin d'éviter de masquer le champ buttons de wvg_state — Glaze associe les champs par leur nom, le nom du type de structure n'a donc pas d'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 JSON mise en forme, 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 au WVG (stylus / prototype / ruko / kingfisher, ajouté en 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 direct, en même temps que les autres valeurs de configuration.

Les variantes C++ n'offrent pas ces options.

Fourni avec le programme d'installation du SDK

Le tutoriel 03 est aussi 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

Déroulement​

Paramètres​

Champs d'état lus​

Envoi / réception​

Options de ligne de commande (Python)​

Déroulement

Paramètres

Champs d'état lus

Envoi / réception

Options de ligne de commande (Python)