03. Sortie VerseGrip sans fil

Il s'agit du même modèle que le tutoriel n° 2, mais destiné au VerseGrip sans fil — il permet d'afficher l'état de diffusion ainsi que les boutons (A/B/C) et le niveau de batterie.

Contenu pédagogique :

• Lecture du champ d'état « Exclusivement sans fil » : buttons.{a,b,c}, battery_level, hall
• Comme « keepalive » pour un observateur indépendant probe_orientation Utilisation
• Modèle de « handshake » effectué uniquement lors du premier message, comme dans le tutoriel 02

Flux de travail

1. ws://localhost:10001Ouvre une connexion WebSocket et attend la première trame d'état.
2. wireless_verse_grip Le premier VerseGrip sans fil de la gamme device_idrécupère.
3. Profil de sessionpar appareil probe_orientation Configurez les requêtes, y compris les requêtes « keepalive ».
4. Après avoir envoyé la demande session Supprime ce champ — car il s'agit d'une poignée de main ponctuelle.
5. Par la suite, à chaque image, les quaternionssont convertis en angles d'Euler, et les données de télémétrie, notamment l'état des boutons et le niveau de batterie, sont transmises à une fréquence limitée. À chaque tick, un message « keepalive » est renvoyé.

Paramètres

Nom	Valeur par défaut	Utilisation
URI	ws://localhost:10001	URL WebSocket du canal de simulation
PRINT_EVERY_MS	100	Intervalle de limitation de l'affichage sur la console
Nom du profil de session	co.haply.inverse.tutorials:print-wireless-verse-grip	Haply Identifier cette simulation dans Hub

Convention relative à l'angle d'Euler

La transformation s'effectue dans le système de coordonnées de l'application +X right, +Y forward, +Z upIl suit l'ordre intrinsèque Z-X-Y (lacet → tangage → roulis). glm::eulerAnglesNe l'utilisez pas — Cette fonction suit une autre convention ; elle lit donc ici une valeur erronée. Les trois variantes linguistiques implémentent toutes la même formule ; pour la formule exacte, veuillez vous reporter au code source.

probe_orientationSi cela s'avère réellement nécessaire

probe_orientationCette session n'est utile que lorsque aucune commande n'est envoyée à Inverse3. Dès qu'une commande (force, position, couple, etc.) est envoyée à Inverse3, le service diffuse automatiquement les valeurs d'orientation de VerseGrip associées à chaque trame d'état ; la sonde n'est donc pas nécessaire. probe_orientationVeuillez l'utiliser uniquement avec un outil de surveillance de la prise en main autonome, comme dans ce tutoriel.

Champ « État de lecture »

data.wireless_verse_grip[0].stateValeur lue à :

• orientation — quaternion (w, x, y, z)
• hall — Valeur du capteur Hall de type entier
• buttons.a, buttons.b, buttons.c — Boole
• battery_level — Type réel (0,0 – 1,0)
• transform.rotation — Rotation de l'espace de travail (quaternion). Les éléments de direction ne sont pas affectés par la position ni l'échelle ; ils ne sont donc pas transférés du tout.

Comportement des mises à jour partielles

transform.rotation valeur du quaternion identique {w:1,x:0,y:0,z:0}Dans ce cas, il est omis. Veuillez indiquer une valeur par défaut lors de la lecture. Pour le recevoir systématiquement, serialization/explicit_fieldsVeuillez l'activer.

Émission / Réception

Tutoriel 02C'est la même structure, seule la disposition des composants change wireless_verse_gripdevient. La boucle WebSocket reçoit une trame d'état et effectue la négociation de connexion avec probe_orientation Un message « keepalive » est renvoyé. Le premier message envoyé contient le profil de session, tandis que toutes les trames suivantes ne contiennent que le message « keepalive ».

Python

Il s'agit d'une 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)

On utilise une structure de type spécifié. À titre d'information, wvg_statede buttons de manière à ne pas masquer les champs button_statea explicitement utilisé ce nom (buttons (ou non). Glaze effectuant le mappage des champs par leur nom, vous pouvez choisir librement le nom des types de structures.

// 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 prend en charge les deux indicateurs présentés dans le tutoriel 01:

• --full — Au lieu d'afficher un résumé en une ligne, il affiche le contenu JSON brut de manière claire et lisible.
• --query-config — À chaque tick d'envoi session.force_render_full_stateen réinjectant, de sorte que chaque trame ne contienne que les modifications d'état, au lieu de config Veillez à inclure le bloc.

--query-configest config En plus des champs de configuration généraux, ce bloc est réservé à WVG sub_type Champ (stylus / prototype / ruko / kingfisher(ajouté dans la version 3.5), ce qui le rend particulièrement utile pour le VerseGrip sans fil. python 03-haply-inverse-print-wireless-verse-grip.py --full --query-configLorsqu'on l'exécute, avec d'autres paramètres de configuration, config.sub_type Vous pouvez constater que les valeurs sont mises à jour en temps réel.

La variante C++ ne rend pas ce drapeau visible.

Inclus dans le programme d'installation du SDK

Le tutoriel 03 est également installé localement avec le SDK. Dans le répertoire d'installation du service, sous tutorials/03-haply-inverse-print-wireless-verse-grip/ Vérifiez le dossier.

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

Documents connexes : Tutoriel n° 2 (VG filaire) · Type (quaternion) · Commandes de contrôle (probe_orientation) · Protocole WebSocket