Démarrage rapide : Stylet VerseGrip

Les VerseGrips ajoutent des capacités de suivi de l'orientation au Inverse3. Cet article décrit la procédure d'installation du VerseGrip Stylus et ses caractéristiques.

Le stylet VerseGrip

Le VerseGrip Stylus Inverse3 applique une technologie de communication sans fil à grande vitesse de pointe et exclusive pour fournir une orientation et des entrées/sorties dans la main. Réimaginer ce qui est possible dans cet espace pour une polyvalence inégalée.

Quelques-unes des caractéristiques incroyables que nous avons créées pour vous :

• 2 boutons d'entrée utilisateur,
• 1 bouton d'étalonnage,
• 1 bouton d'alimentation/veille, et
• 2 voyants LED RVB
• Autonomie de 10 à 12 heures
• Connexion USB-c pour le chargement
• Vitesse de communication sans fil jusqu'à 1 KHz
• Jusqu'à 8 VerseGrip Stylus peuvent être couplés à un dongle sur une même bande.

Le VerseGrip Stylus présente sept caractéristiques principales à l'extérieur : (1) le connecteur à bille qui s'insère dans le gimbal Inverse3 , (2) et (3) les boutons d'entrée, (4) le port de charge USB-C, (5) le bouton d'étalonnage, (6) les LED d'état, et (7) un bouton d'alimentation.

Soutien à la clientèle

Si vous avez des questions ou des inquiétudes concernant votre appareil et son utilisation, n'hésitez pas à nous contacter, nous serons heureux de vous aider à répondre à vos questions. Le stylet VerseGrip est un appareil fonctionnel doté d'une technologie sans fil complexe et exclusive. Toute tentative d'ouverture de l'appareil annulera non seulement votre garantie, mais rendra rapidement l'appareil inutilisable. Afin d'éviter de longues procédures d'expédition et de réparation coûteuses, N'ESSAYEZ PAS D'OUVRIR L'APPAREIL.

Installation et étalonnage du stylet VerseGrip

Cette section décrit les étapes de branchement du dongle, de mise sous tension de votre VerseGrip Stylus et d'étalonnage.

Mise en place

• Branchez le dongle sur une prise USB de votre ordinateur.
• Placez la poignée sur une surface plane où elle ne bougera pas, les boutons tournés vers le haut et le connecteur à bille orienté vers l'écran.

Mise sous tension et étalonnage

• Appuyez une fois sur le bouton d'alimentation. Le voyant d'état devient rouge, puis bleu. Le bleu indique que l'IMU de l'appareil est en cours d'auto-calibrage.
• Après l'auto-calibrage, le voyant d'état clignote en rouge une fois toutes les 0,5 secondes. Il s'agit du mode veille.
• Appuyez sur n'importe quel bouton pour sortir l'appareil du mode veille. Vous verrez le voyant d'état clignoter en vert pendant qu'il se réveille, puis devenir vert fixe. Il transmet maintenant des données au réseau sans fil.
• Lorsque la batterie est faible, le stylet VerseGrip s'éteint toutes les 2 minutes, veuillez le recharger immédiatement.

Recalibrage

• Pour recalibrer, appuyez sur le bouton de calibrage et maintenez-le enfoncé pendant trois secondes, ou jusqu'à ce que vous constatiez que l'orientation s'est déplacée dans votre simulation.

Mise en veille et mise hors tension

• Appuyez à nouveau sur le bouton d'alimentation pour revenir en mode veille. Le voyant d'état devient rouge, clignote toutes les 2 secondes et la transmission des données s'arrête.
• Pour éteindre le stylet VerseGrip, maintenez le bouton d'alimentation enfoncé pendant 5 secondes et relâchez-le. Lorsque vous relâchez le bouton, le voyant d'état doit s'éteindre et il n'y a plus d'indications. Il cessera de transmettre des données.

Chargement

• Branchez le stylet VerseGrip sur le secteur via la prise de charge USB-C.
• Le voyant de charge est bleu lorsqu'il est branché sur le secteur, et lorsqu'il est complètement chargé, il clignote rapidement en bleu. Lorsque vous branchez l'appareil sur le secteur, il démarre et se met en veille.

AVERTISSEMENT : Ne laissez pas la batterie se vider ! Elle ne pourra pas conserver sa charge si c'est le cas. Si cela se produit, le stylet VerseGrip fonctionnera tant qu'il restera branché.

États et indicateurs lumineux

Couleur et comportement des voyants d'état	État
Rouge, solide	En attente d'initialisation des composants
Bleu, solide	L'IMU de la poignée est en cours d'auto-calibrage
Rouge, clignotant toutes les 2 secondes	Mode veille. Pas de transmission de données.
Vert, clignotant toutes les 2 secondes	Mode normal, transmission automatique des données au réseau sans fil.
Pas de lumière, pas d'indication	Le courant est coupé.

Couleur du voyant de charge	État
Bleu, solide	Chargement
Bleu, clignotant rapidement	Cela indique que l'appareil est complètement chargé.
Pas de lumière, pas d'indication	L'appareil ne se recharge pas

Exemple de code

Voici un exemple simple d'utilisation du stylet Versegrip avec C++.

DevKit Inverse

#include <external/libhv.h>

#include <nlohmann/json.hpp>

#include <chrono>
#include <cstdio>
#include <string>

using namespace hv;
using json = nlohmann::json;

// Procedure to get the first detected and available Wired VerseGrip Stylus device id
std::string get_first_verse_grip_device_id(const json &data) {
    const auto& vgs = data["wireless_verse_grip"];

    if (vgs.empty()) {
        return "";
    }

    return vgs.items().begin().key();
}

int main() {
    const auto print_delay = std::chrono::milliseconds(100);
    auto current           = std::chrono::high_resolution_clock::now();
    bool first_message     = true;
    std::string device_id;

    WebSocketClient ws;

    ws.onmessage = [&](const std::string &msg) {
        json data = json::parse(msg);

        if (first_message) {
            first_message              = false;
            const std::string first_id = get_first_verse_grip_device_id(data);

            if (first_id.empty()) {
                printf("no Wireless VerseGrip found.\n");
                ws.close();
                return;
            }

            device_id = first_id;
        }

        if (device_id.empty() || !data["wireless_verse_grip"].contains(device_id)) {
            return;
        }

        const auto now = std::chrono::high_resolution_clock::now();

        if (std::chrono::high_resolution_clock::now() > current + print_delay) {
            current          = now;
            const json state = data["wireless_verse_grip"][device_id];

            printf("Rotation : { x:%f, y:%f, z:%f, w:%f }, Hall:%i, Button : [%d, %d, %d], Battery: {%f}\n",
                state["orientation"]["x"].get<float>(),
                state["orientation"]["y"].get<float>(),
                state["orientation"]["z"].get<float>(),
                state["orientation"]["w"].get<float>(),
                state["hall"].get<int8_t>(),
                state["buttons"]["a"].get<bool>(),
                state["buttons"]["b"].get<bool>(),
                state["buttons"]["c"].get<bool>(),
                state["battery_level"].get<float>());
        }
    };

    ws.open("ws://localhost:10000");

    printf("Press ENTER to stop...\n\n");
    while (std::cin.get() != '\n') {
    }

    if (ws.isConnected()) {
        ws.close();
    }

    return 0;
}

HardwareAPI

#include <string.h>

#include <chrono>
#include <iostream>
#include <iterator>
#include <string>
#include <thread>

#include "HardwareAPI.h"

int main(int argc, char* argv[])
{
    char* portName;

    if (argc < 2)
    {
        std::printf("Usage: %s <port>\n", argv[0]);
    }
    else
    {
#if defined(_WIN32) || defined(_WIN64)
        portName = _strdup(argv[1]);  // argv1;
#endif
#if defined(__linux__)
        portName = strdup(argv[1]);  // argv1;
#endif
    }

    Haply::HardwareAPI::IO::SerialStream serial_stream(portName);

    Haply::HardwareAPI::Devices::Handle handle(&serial_stream);

    while (true)
    {
        Haply::HardwareAPI::Devices::Handle::VersegripStatusResponse data;
        data = handle.GetVersegripStatus();
        std::printf(
            "device_id: %d battery_level: %f quaternion: %f %f %f %f buttons: "
            "%d error_flags: %d\n",
            data.device_id, data.battery_level, data.quaternion[0],
            data.quaternion[1], data.quaternion[2], data.quaternion[3],
            data.buttons, data.error_flag);

    }
}