03. Commander un VerseGrip sans fil

Même modèle que le tutoriel n° 2, mais pour un VerseGrip sans fil — avec en plus les boutons (A/B/C) et l'indicateur de niveau de batterie en mode streaming.

Ce que vous apprendrez :

• Lecture des champs d'état spécifiques au réseau sans fil : buttons.{a,b,c}, battery_level, hall
• Utilisation de probe_orientation als Keepalive pour un observateur indépendant
• Le même modèle de « handshake » que dans le tutoriel 02, où seul le premier message contient la configuration de la session

Déroulement

1. Établissez une connexion via WebSocket vers ws://localhost:10001 et attendez le premier message d'état.
2. Sélectionnez la device_id le premier VerseGrip sans fil de la gamme Array wireless_verse_grip.
3. Créez une demande à l'aide du Fiche de séance et un keepalive spécifique à l'appareil via probe_orientation.
4. Envoyez la demande, puis désélectionnez la case session — C'est une poignée de main unique en son genre.
5. À chaque image suivante, convertissez le quaternion en angles d'Euler et transmettez les données de télémétrie réduites, y compris l'état des boutons et le niveau de la batterie. Renvoyez le message « keepalive » à chaque cycle d'horloge.

Paramètres

Nom	Standard	Objet
URI	ws://localhost:10001	URL du canal de simulation WebSocket
PRINT_EVERY_MS	100	Limitation de la puissance de sortie de la console
Nom du profil de session	co.haply.inverse.tutorials:print-wireless-verse-grip	Cette simulation est répertoriée sur la plateforme « Haply Hub »

Convention d'Euler

La conversion s'effectue intrinsèquement dans l'ordre Z-X-Y (lacet → tangage → roulis) dans le système de coordonnées de l'application. +X right, +Y forward, +Z up. N'utilisez pas glm::eulerAngles — suit une autre convention et fournit ici des valeurs erronées. Les trois variantes linguistiques mettent en œuvre les mêmes calculs mathématiques ; vous trouverez la formule dans les codes sources.

Quand probe_orientation qui est réellement nécessaire

probe_orientation n'a de sens que si votre session aucun Envoyez la commande à Inverse3 . Dès que vous accédez à Inverse3 (puissance, position, couple…), le service transmet automatiquement l’orientation du VerseGrip couplé dans chaque trame d’état — un « keepalive » n’est alors pas nécessaire. Utilisez probe_orientation uniquement pour les outils autonomes de surveillance de la prise, comme celui présenté dans ce tutoriel.

Champs d'état lus

Aus data.wireless_verse_grip[0].state:

• orientation — quaternion (w, x, y, z)
• hall — valeur de mesure entière du capteur à effet Hall
• buttons.a, buttons.b, buttons.c — Valeurs booléennes
• battery_level — Nombre à virgule flottante (0,0 – 1,0)
• transform.rotation — Rotation de l'espace de travail (quaternion); La position et la mise à l'échelle ne sont pas prises en compte pour un appareil qui ne fournit que l'orientation, et ne sont jamais transmises

Sémantique dans le cadre des mises à jour partielles

transform.rotation est omis s'il correspond au quaternion d'identité {w:1,x:0,y:0,z:0} correspond à. Définissez une valeur par défaut lors de la lecture. Activez serialization/explicit_fields, afin de le conserver pour toujours.

Envoyer / Recevoir

Même structure que dans Tutoriel n° 2, uniquement avec le réseau de capteurs wireless_verse_grip. La boucle WebSocket reçoit une trame d'état et envoie la poignée de main ainsi que le keep-alive via probe_orientation Retour ; le premier message sortant contient le profil de session, chaque trame suivante ne contient que le Keepalive.

Python

Une boucle asynchrone isolée.

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. button_state est expressément mentionné (et non buttons), afin d'éviter que le champ ne soit masqué buttons dans wvg_state à éviter. Glaze attribue les champs en fonction de leur nom ; le nom du type de structure peut donc être choisi librement.

// 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 JSON brute mise en forme, au lieu du résumé sur une seule ligne.
• --query-config — ajoute à chaque tick sortant session.force_render_full_state à nouveau, de sorte que chaque image contienne le config- qui contient un bloc au lieu d'un simple changement d'état.

--query-config est particulièrement utile dans la version sans fil de VerseGrip, car le config- En plus des champs de configuration habituels, bloquez le champ spécifique à la WVG sub_type (stylus / prototype / ruko / kingfisher, ajouté à partir de la version 3.5) contient. Si vous python 03-haply-inverse-print-wireless-verse-grip.py --full --query-config En l'exécutant, vous pouvez suivre en direct comment config.sub_type mise à jour avec les autres paramètres de configuration.

Les versions C++ ne proposent pas ces indicateurs.

Fourni avec le programme d'installation du SDK

Le tutoriel 03 est également installé localement avec le SDK ; vous le trouverez à l'emplacement suivant : tutorials/03-haply-inverse-print-wireless-verse-grip/ dans le répertoire d'installation du service.

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

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