Échantillon de mesures

Cet exemple montre comment utiliser l'interface CPP HaplyHardwareAPI pour utiliser l'Inverse3 comme un simple périphérique d'entrée. Un exemple complet se trouve à la fin du fichier, mais les principales étapes sont les suivantes :

Inclure les en-têtes nécessaires

#include "HardwareAPI.h"

Trouver l'appareil et ouvrir la connexion

std::vector ports =
            Haply::HardwareAPI::Devices::DeviceDetection::DetectInverse3s(); // List all the available devices
Haply::HardwareAPI::IO::SerialStream serial_stream(ports[0].c_str()); // Open the connection to the first device found
Haply::HardwareAPI::Devices::Inverse3 inverse3(&serial_stream; // Create the device object
Haply::HardwareAPI::Devices::Inverse3::DeviceInfoResponse response_to_wake = inverse3.DeviceWakeup(); // Get the device info

Obtenir la mesure de la position

Il y a deux façons d'obtenir la mesure de la position à partir de l'Inverse3. La première consiste à utiliser la cinématique intégrée à l'appareil et la seconde à utiliser la cinématique résolue sur l'ordinateur.

Utilisation de la cinématique intégrée de l'appareil

L'utilisation de la cinématique intégrée à l'appareil est le moyen le plus simple d'obtenir la mesure de la position. Elle ajuste automatiquement l'orientation de la base et renvoie la position de l'effecteur.

// In a loop
while(True) {
        Haply::HardwareAPI::Devices::Inverse3::EndEffectorStateResponse
            response = inverse3.GetEndEffectorPosition();
        printf("Position: %f %f %f\n", response.position[0],
               response.position[1], response.position[2]);
}

Utilisation de la cinématique résolue sur l'ordinateur

Comme nous utilisons un IMU pour obtenir l'orientation de la base, pour des applications très précises, il pourrait introduire des variations dans la mesure de la position. Pour éviter cela, la cinématique peut être résolue sur l'ordinateur et les angles de la base peuvent être réglés manuellement pour correspondre à la configuration physique.

// Set the angles of the base, default position is upright
// Inverse3.AdjustAngles([angle0, angle1, angle2]);

// In a loop
while(True) {
        Haply::HardwareAPI::Devices::Inverse3::EndEffectorStateResponse
            response = inverse3.GetEndEffectorPosition(false);
        printf("Position: %f %f %f\n", response.position[0],
               response.position[1], response.position[2]);
}

Exemple complet

#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::vector ports =
            Haply::HardwareAPI::Devices::DeviceDetection::DetectInverse3s();
        std::string portNames[256];
        int nbport = ports.size();
#if defined _DEBUG
        printf("Found %d ports: \n", nbport);
#endif
        if (nbport > 0)
        {
            int index = nbport - 1;
#if defined(_WIN32) || defined(_WIN64)
            portName = _strdup(ports[index].c_str());
#endif
#if defined(__linux__) || defined(__APPLE__)
            portName = strdup(ports[index].c_str());
#endif
        }
        else
        {
#if defined _DEBUG
            std::cout << "No Inverse3 found" << std::endl;
#endif
            return -1;
        }
    }
    else
    {
#if defined(_WIN32) || defined(_WIN64)
        portName = _strdup(argv[1]);  // argv1;
#endif
#if defined(__linux__)
        portName = strdup(argv[1]);  // argv1;
#endif
    }

#if defined _DEBUG
    printf("Using port %s\n", portName);
#endif
    Haply::HardwareAPI::IO::SerialStream serial_stream(portName);
    if (serial_stream.OpenDevice() < 0)
        printf("unable to open serial stream for '%s'", portName);
    Haply::HardwareAPI::Devices::Inverse3 inverse3(&serial_stream);
    Haply::HardwareAPI::Devices::Inverse3::DeviceInfoResponse response_to_wake =
        inverse3.DeviceWakeup();
#if defined _DEBUG
    std::cout << std::endl << "Press ENTER to continue . . .";
    std::cin.get();
#endif
    while (true)
    {
        // This is the fast update loop
        // To Use the Inverse3 as a pure measurement device, use the following
        // functions Inverse3.GetEndEffectorPosition(); // for standard
        // Kinematics For added precision, the kinematics can be resolved on the
        // computer with the following functions
        // Inverse3.GetEndEffectorPosition(false); for on-computer Kinematics
        // When using the on-computer Kinematics, the angles of the base can be
        // adjusted with the following function to match the physical setup:
        // Inverse3.AdjustAngles([angle0, angle1, angle2]);
        Haply::HardwareAPI::Devices::Inverse3::EndEffectorStateResponse
            response = inverse3.GetEndEffectorPosition(false);
        printf("Position: %f %f %f\n", response.position[0],
               response.position[1], response.position[2]);

        std::this_thread::sleep_for(std::chrono::microseconds(100));
    }
}