Measurement Sample

This example shows how to use the CPP HaplyHardwareAPI use the Inverse3 as a pure input device. A full example can be found in the end of the file, but the main steps are:

Include the necessary headers

#include "HardwareAPI.h"

Find the device and open the connection

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

Get the position measurement

There is two ways to get the position measurement from the Inverse3. The first one is with the device builtin kinematics, and the second one is with the kinematics resolved on the computer.

Using the device builtin kinematics

Using the device builtin kinematics is the simplest way to get the position measurement, it will adjust orientation of the base automatically and return the position of the end effector.

// 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]);
}

Using the kinematics resolved on the computer

As we are using an IMU to get the orientation of the base, for very precise applications it could introduce variations in the position measurement. To avoid this, the kinematics can be resolved on the computer and the angles of the base can be set manually to match the physical setup.

// 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]);
}

Full example

#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));
    }
}