hebi.h

Go to the documentation of this file.

#pragma once

#include <math.h>
#include <stddef.h>
#include <stdint.h>

#ifdef __cplusplus /* Use C linkage when compiling this C library header from C++ */
extern "C" {
#endif

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

// Enum Types

typedef enum HebiStatusCode {
  HebiStatusSuccess = 0, 
  HebiStatusInvalidArgument = 1, 
  HebiStatusBufferTooSmall = 2, 
  HebiStatusValueNotSet = 3, 
  HebiStatusFailure = 4, 
  HebiStatusArgumentOutOfRange = 5 
} HebiStatusCode;

// Command Enums

typedef enum HebiCommandFloatField {
  HebiCommandFloatVelocity, 
  HebiCommandFloatEffort, 
  HebiCommandFloatPositionKp, 
  HebiCommandFloatPositionKi, 
  HebiCommandFloatPositionKd, 
  HebiCommandFloatPositionFeedForward, 
  HebiCommandFloatPositionDeadZone, 
  HebiCommandFloatPositionIClamp, 
  HebiCommandFloatPositionPunch, 
  HebiCommandFloatPositionMinTarget, 
  HebiCommandFloatPositionMaxTarget, 
  HebiCommandFloatPositionTargetLowpass, 
  HebiCommandFloatPositionMinOutput, 
  HebiCommandFloatPositionMaxOutput, 
  HebiCommandFloatPositionOutputLowpass, 
  HebiCommandFloatVelocityKp, 
  HebiCommandFloatVelocityKi, 
  HebiCommandFloatVelocityKd, 
  HebiCommandFloatVelocityFeedForward, 
  HebiCommandFloatVelocityDeadZone, 
  HebiCommandFloatVelocityIClamp, 
  HebiCommandFloatVelocityPunch, 
  HebiCommandFloatVelocityMinTarget, 
  HebiCommandFloatVelocityMaxTarget, 
  HebiCommandFloatVelocityTargetLowpass, 
  HebiCommandFloatVelocityMinOutput, 
  HebiCommandFloatVelocityMaxOutput, 
  HebiCommandFloatVelocityOutputLowpass, 
  HebiCommandFloatEffortKp, 
  HebiCommandFloatEffortKi, 
  HebiCommandFloatEffortKd, 
  HebiCommandFloatEffortFeedForward, 
  HebiCommandFloatEffortDeadZone, 
  HebiCommandFloatEffortIClamp, 
  HebiCommandFloatEffortPunch, 
  HebiCommandFloatEffortMinTarget, 
  HebiCommandFloatEffortMaxTarget, 
  HebiCommandFloatEffortTargetLowpass, 
  HebiCommandFloatEffortMinOutput, 
  HebiCommandFloatEffortMaxOutput, 
  HebiCommandFloatEffortOutputLowpass, 
  HebiCommandFloatSpringConstant, 
  HebiCommandFloatReferencePosition, 
  HebiCommandFloatReferenceEffort, 
} HebiCommandFloatField;

typedef enum HebiCommandHighResAngleField {
  HebiCommandHighResAnglePosition, 
  HebiCommandHighResAnglePositionLimitMin, 
  HebiCommandHighResAnglePositionLimitMax, 
} HebiCommandHighResAngleField;

typedef enum HebiCommandNumberedFloatField {
  HebiCommandNumberedFloatDebug, 
} HebiCommandNumberedFloatField;

typedef enum HebiCommandBoolField {
  HebiCommandBoolPositionDOnError, 
  HebiCommandBoolVelocityDOnError, 
  HebiCommandBoolEffortDOnError, 
} HebiCommandBoolField;

typedef enum HebiCommandStringField {
  HebiCommandStringName, 
  HebiCommandStringFamily, 
} HebiCommandStringField;

typedef enum HebiCommandFlagField {
  HebiCommandFlagSaveCurrentSettings, 
  HebiCommandFlagReset, 
  HebiCommandFlagBoot, 
  HebiCommandFlagStopBoot, 
} HebiCommandFlagField;

typedef enum HebiCommandEnumField {
  HebiCommandEnumControlStrategy, 
} HebiCommandEnumField;

typedef enum HebiCommandIoPinBank {
  HebiCommandIoBankA, 
  HebiCommandIoBankB, 
  HebiCommandIoBankC, 
  HebiCommandIoBankD, 
  HebiCommandIoBankE, 
  HebiCommandIoBankF, 
} HebiCommandIoPinBank;

typedef enum HebiCommandLedField {
  HebiCommandLedLed, 
} HebiCommandLedField;

// Feedback Enums

typedef enum HebiFeedbackFloatField {
  HebiFeedbackFloatBoardTemperature, 
  HebiFeedbackFloatProcessorTemperature, 
  HebiFeedbackFloatVoltage, 
  HebiFeedbackFloatVelocity, 
  HebiFeedbackFloatEffort, 
  HebiFeedbackFloatVelocityCommand, 
  HebiFeedbackFloatEffortCommand, 
  HebiFeedbackFloatDeflection, 
  HebiFeedbackFloatDeflectionVelocity, 
  HebiFeedbackFloatMotorVelocity, 
  HebiFeedbackFloatMotorCurrent, 
  HebiFeedbackFloatMotorSensorTemperature, 
  HebiFeedbackFloatMotorWindingCurrent, 
  HebiFeedbackFloatMotorWindingTemperature, 
  HebiFeedbackFloatMotorHousingTemperature, 
} HebiFeedbackFloatField;

typedef enum HebiFeedbackHighResAngleField {
  HebiFeedbackHighResAnglePosition, 
  HebiFeedbackHighResAnglePositionCommand, 
} HebiFeedbackHighResAngleField;

typedef enum HebiFeedbackNumberedFloatField {
  HebiFeedbackNumberedFloatDebug, 
} HebiFeedbackNumberedFloatField;

typedef enum HebiFeedbackUInt64Field {
  HebiFeedbackUInt64SequenceNumber, 
  HebiFeedbackUInt64ReceiveTime, 
  HebiFeedbackUInt64TransmitTime, 
  HebiFeedbackUInt64HardwareReceiveTime, 
  HebiFeedbackUInt64HardwareTransmitTime, 
  HebiFeedbackUInt64SenderId, 
} HebiFeedbackUInt64Field;

typedef enum HebiFeedbackVector3fField {
  HebiFeedbackVector3fAccelerometer, 
  HebiFeedbackVector3fGyro, 
} HebiFeedbackVector3fField;

typedef enum HebiFeedbackQuaternionfField {
  HebiFeedbackQuaternionfOrientation, 
} HebiFeedbackQuaternionfField;

typedef enum HebiFeedbackEnumField {
  HebiFeedbackEnumTemperatureState, 
  HebiFeedbackEnumMstopState, 
  HebiFeedbackEnumPositionLimitState, 
  HebiFeedbackEnumVelocityLimitState, 
  HebiFeedbackEnumEffortLimitState, 
  HebiFeedbackEnumCommandLifetimeState, 
} HebiFeedbackEnumField;

typedef enum HebiFeedbackIoPinBank {
  HebiFeedbackIoBankA, 
  HebiFeedbackIoBankB, 
  HebiFeedbackIoBankC, 
  HebiFeedbackIoBankD, 
  HebiFeedbackIoBankE, 
  HebiFeedbackIoBankF, 
} HebiFeedbackIoPinBank;

typedef enum HebiFeedbackLedField {
  HebiFeedbackLedLed, 
} HebiFeedbackLedField;

// Info Enums

typedef enum HebiInfoFloatField {
  HebiInfoFloatPositionKp, 
  HebiInfoFloatPositionKi, 
  HebiInfoFloatPositionKd, 
  HebiInfoFloatPositionFeedForward, 
  HebiInfoFloatPositionDeadZone, 
  HebiInfoFloatPositionIClamp, 
  HebiInfoFloatPositionPunch, 
  HebiInfoFloatPositionMinTarget, 
  HebiInfoFloatPositionMaxTarget, 
  HebiInfoFloatPositionTargetLowpass, 
  HebiInfoFloatPositionMinOutput, 
  HebiInfoFloatPositionMaxOutput, 
  HebiInfoFloatPositionOutputLowpass, 
  HebiInfoFloatVelocityKp, 
  HebiInfoFloatVelocityKi, 
  HebiInfoFloatVelocityKd, 
  HebiInfoFloatVelocityFeedForward, 
  HebiInfoFloatVelocityDeadZone, 
  HebiInfoFloatVelocityIClamp, 
  HebiInfoFloatVelocityPunch, 
  HebiInfoFloatVelocityMinTarget, 
  HebiInfoFloatVelocityMaxTarget, 
  HebiInfoFloatVelocityTargetLowpass, 
  HebiInfoFloatVelocityMinOutput, 
  HebiInfoFloatVelocityMaxOutput, 
  HebiInfoFloatVelocityOutputLowpass, 
  HebiInfoFloatEffortKp, 
  HebiInfoFloatEffortKi, 
  HebiInfoFloatEffortKd, 
  HebiInfoFloatEffortFeedForward, 
  HebiInfoFloatEffortDeadZone, 
  HebiInfoFloatEffortIClamp, 
  HebiInfoFloatEffortPunch, 
  HebiInfoFloatEffortMinTarget, 
  HebiInfoFloatEffortMaxTarget, 
  HebiInfoFloatEffortTargetLowpass, 
  HebiInfoFloatEffortMinOutput, 
  HebiInfoFloatEffortMaxOutput, 
  HebiInfoFloatEffortOutputLowpass, 
  HebiInfoFloatSpringConstant, 
} HebiInfoFloatField;

typedef enum HebiInfoHighResAngleField {
  HebiInfoHighResAnglePositionLimitMin, 
  HebiInfoHighResAnglePositionLimitMax, 
} HebiInfoHighResAngleField;

typedef enum HebiInfoBoolField {
  HebiInfoBoolPositionDOnError, 
  HebiInfoBoolVelocityDOnError, 
  HebiInfoBoolEffortDOnError, 
} HebiInfoBoolField;

typedef enum HebiInfoStringField {
  HebiInfoStringName, 
  HebiInfoStringFamily, 
  HebiInfoStringSerial, 
} HebiInfoStringField;

typedef enum HebiInfoFlagField {
  HebiInfoFlagSaveCurrentSettings, 
} HebiInfoFlagField;

typedef enum HebiInfoEnumField {
  HebiInfoEnumControlStrategy, 
  HebiInfoEnumCalibrationState, 
} HebiInfoEnumField;

typedef enum HebiInfoLedField {
  HebiInfoLedLed, 
} HebiInfoLedField;

// RobotModel Enums

typedef enum HebiFrameType {
  HebiFrameTypeCenterOfMass,
  HebiFrameTypeOutput,
  HebiFrameTypeEndEffector
} HebiFrameType;

typedef enum HebiJointType {
  HebiJointTypeRotationX,
  HebiJointTypeRotationY,
  HebiJointTypeRotationZ,
  HebiJointTypeTranslationX,
  HebiJointTypeTranslationY,
  HebiJointTypeTranslationZ
} HebiJointType;

// Typedefs

typedef struct _HebiString* HebiStringPtr;

typedef struct _HebiCommand* HebiCommandPtr;

typedef struct _HebiFeedback* HebiFeedbackPtr;

typedef struct _HebiGroup* HebiGroupPtr;

typedef struct _HebiGroupCommand* HebiGroupCommandPtr;

typedef struct _HebiGroupFeedback* HebiGroupFeedbackPtr;

typedef struct _HebiGroupInfo* HebiGroupInfoPtr;

typedef struct _HebiInfo* HebiInfoPtr;

typedef struct _HebiIK* HebiIKPtr;

typedef struct _HebiRobotModel* HebiRobotModelPtr;

typedef struct _HebiRobotModelElement* HebiRobotModelElementPtr;

typedef struct _HebiLogFile* HebiLogFilePtr;

typedef struct _HebiLookup* HebiLookupPtr;

typedef struct _HebiLookupEntryList* HebiLookupEntryListPtr;

typedef struct _HebiTrajectory* HebiTrajectoryPtr;

typedef void (*GroupFeedbackHandlerFunction)(HebiGroupFeedbackPtr fbk, void* user_data);

// Structures

typedef struct _HebiMacAddress { uint8_t bytes_[6]; } HebiMacAddress;

typedef struct _HebiVector3f {
  float x;
  float y;
  float z;
} HebiVector3f;

typedef struct _HebiQuaternionf {
  float w;
  float x;
  float y;
  float z;
} HebiQuaternionf;

// Lookup API

HebiLookupPtr hebiLookupCreate(void);

void hebiLookupRelease(HebiLookupPtr lookup);

HebiLookupEntryListPtr hebiCreateLookupEntryList(HebiLookupPtr lookup);

size_t hebiLookupEntryListGetSize(HebiLookupEntryListPtr lookup_list);

HebiStatusCode hebiLookupEntryListGetName(HebiLookupEntryListPtr lookup_list, size_t index, char* buffer,
                                          size_t* length);

HebiStatusCode hebiLookupEntryListGetFamily(HebiLookupEntryListPtr lookup_list, size_t index, char* buffer,
                                            size_t* length);

HebiStatusCode hebiLookupEntryListGetMacAddress(HebiLookupEntryListPtr lookup_list, size_t index,
                                                HebiMacAddress* mac_address);

void hebiLookupEntryListRelease(HebiLookupEntryListPtr lookup_list);

// Group API

HebiGroupPtr hebiGroupCreateImitation(size_t size);

HebiGroupPtr hebiGroupCreateFromMacs(HebiLookupPtr lookup, const HebiMacAddress* const* addresses,
                                     size_t num_addresses, int32_t timeout_ms);

HebiGroupPtr hebiGroupCreateFromNames(HebiLookupPtr lookup, const char* const* families, size_t num_families,
                                      const char* const* names, size_t num_names, int32_t timeout_ms);

HebiGroupPtr hebiGroupCreateFromFamily(HebiLookupPtr lookup, const char* family, int32_t timeout_ms);

HebiGroupPtr hebiGroupCreateConnectedFromMac(HebiLookupPtr lookup, const HebiMacAddress* address,
                                             int32_t timeout_ms);

HebiGroupPtr hebiGroupCreateConnectedFromName(HebiLookupPtr lookup, const char* family, const char* name,
                                              int32_t timeout_ms);

size_t hebiGroupGetSize(HebiGroupPtr group);

HebiStatusCode hebiGroupSendCommandWithAcknowledgement(HebiGroupPtr group, HebiGroupCommandPtr command,
                                                       int32_t timeout_ms);

HebiStatusCode hebiGroupSendCommand(HebiGroupPtr group, HebiGroupCommandPtr command);

HebiStatusCode hebiGroupSetCommandLifetime(HebiGroupPtr group, int32_t lifetime_ms);

int32_t hebiGroupGetCommandLifetime(HebiGroupPtr group);

HebiStatusCode hebiGroupSetFeedbackFrequencyHz(HebiGroupPtr group, float frequency);

float hebiGroupGetFeedbackFrequencyHz(HebiGroupPtr group);

HebiStatusCode hebiGroupRegisterFeedbackHandler(HebiGroupPtr group, GroupFeedbackHandlerFunction handler,
                                                void* user_data);

void hebiGroupClearFeedbackHandlers(HebiGroupPtr group);

HebiStatusCode hebiGroupSendFeedbackRequest(HebiGroupPtr group);

HebiStatusCode hebiGroupGetNextFeedback(HebiGroupPtr group, HebiGroupFeedbackPtr feedback,
                                        int32_t timeout_ms);

HebiStatusCode hebiGroupRequestInfo(HebiGroupPtr group, HebiGroupInfoPtr info, int32_t timeout_ms);

HebiStatusCode hebiGroupStartLog(HebiGroupPtr group, const char* dir, const char* file, HebiStringPtr* ret);

HebiLogFilePtr hebiGroupStopLog(HebiGroupPtr group);

void hebiGroupRelease(HebiGroupPtr group);

HebiGroupCommandPtr hebiGroupCommandCreate(size_t size);

size_t hebiGroupCommandGetSize(HebiGroupCommandPtr cmd);

HebiStatusCode hebiGroupCommandReadGains(HebiGroupCommandPtr cmd, const char* file);

HebiStatusCode hebiGroupCommandWriteGains(HebiGroupCommandPtr cmd, const char* file);

HebiCommandPtr hebiGroupCommandGetModuleCommand(HebiGroupCommandPtr cmd, size_t module_index);

HebiStatusCode hebiGroupCommandCopy(HebiGroupCommandPtr dest, HebiGroupCommandPtr src);

void hebiGroupCommandClear(HebiGroupCommandPtr cmd);

void hebiGroupCommandRelease(HebiGroupCommandPtr cmd);

HebiGroupFeedbackPtr hebiGroupFeedbackCreate(size_t size);

size_t hebiGroupFeedbackGetSize(HebiGroupFeedbackPtr fbk);

HebiFeedbackPtr hebiGroupFeedbackGetModuleFeedback(HebiGroupFeedbackPtr fbk, size_t module_index);

HebiStatusCode hebiGroupFeedbackCopy(HebiGroupFeedbackPtr dest, HebiGroupFeedbackPtr src);

void hebiGroupFeedbackClear(HebiGroupFeedbackPtr fbk);

void hebiGroupFeedbackRelease(HebiGroupFeedbackPtr fbk);

HebiGroupInfoPtr hebiGroupInfoCreate(size_t size);

size_t hebiGroupInfoGetSize(HebiGroupInfoPtr info);

HebiStatusCode hebiGroupInfoWriteGains(HebiGroupInfoPtr info, const char* file);

HebiInfoPtr hebiGroupInfoGetModuleInfo(HebiGroupInfoPtr info, size_t module_index);

HebiStatusCode hebiGroupInfoCopy(HebiGroupInfoPtr dest, HebiGroupInfoPtr src);

void hebiGroupInfoClear(HebiGroupInfoPtr info);

void hebiGroupInfoRelease(HebiGroupInfoPtr info);

// Command API

HebiStatusCode hebiCommandGetFloat(HebiCommandPtr cmd, HebiCommandFloatField field, float* value);

void hebiCommandSetFloat(HebiCommandPtr cmd, HebiCommandFloatField field, const float* value);

HebiStatusCode hebiCommandGetHighResAngle(HebiCommandPtr cmd, HebiCommandHighResAngleField field,
                                          int64_t* int_part, float* dec_part);

void hebiCommandSetHighResAngle(HebiCommandPtr cmd, HebiCommandHighResAngleField field,
                                const int64_t* int_part, const float* dec_part);

HebiStatusCode hebiCommandGetNumberedFloat(HebiCommandPtr cmd, HebiCommandNumberedFloatField field,
                                           size_t number, float* value);

void hebiCommandSetNumberedFloat(HebiCommandPtr cmd, HebiCommandNumberedFloatField field, size_t number,
                                 const float* value);

HebiStatusCode hebiCommandGetBool(HebiCommandPtr cmd, HebiCommandBoolField field, int32_t* value);

void hebiCommandSetBool(HebiCommandPtr cmd, HebiCommandBoolField field, const int32_t* value);

HebiStatusCode hebiCommandGetString(HebiCommandPtr cmd, HebiCommandStringField field, char* buffer,
                                    size_t* length);

void hebiCommandSetString(HebiCommandPtr cmd, HebiCommandStringField field, const char* buffer,
                          const size_t* length);

int32_t hebiCommandGetFlag(HebiCommandPtr cmd, HebiCommandFlagField field);

void hebiCommandSetFlag(HebiCommandPtr cmd, HebiCommandFlagField field, int32_t value);

HebiStatusCode hebiCommandGetEnum(HebiCommandPtr cmd, HebiCommandEnumField field, int32_t* value);

void hebiCommandSetEnum(HebiCommandPtr cmd, HebiCommandEnumField field, const int32_t* value);

HebiStatusCode hebiCommandGetIoPinInt(HebiCommandPtr cmd, HebiCommandIoPinBank field, size_t pin_number,
                                      int64_t* value);

HebiStatusCode hebiCommandGetIoPinFloat(HebiCommandPtr cmd, HebiCommandIoPinBank field, size_t pin_number,
                                        float* value);

void hebiCommandSetIoPinInt(HebiCommandPtr cmd, HebiCommandIoPinBank field, size_t pin_number,
                            const int64_t* value);

void hebiCommandSetIoPinFloat(HebiCommandPtr cmd, HebiCommandIoPinBank field, size_t pin_number,
                              const float* value);

HebiStatusCode hebiCommandGetLedColor(HebiCommandPtr cmd, HebiCommandLedField field, uint8_t* r, uint8_t* g,
                                      uint8_t* b);

int32_t hebiCommandHasLedModuleControl(HebiCommandPtr cmd, HebiCommandLedField field);

void hebiCommandSetLedOverrideColor(HebiCommandPtr cmd, HebiCommandLedField field, uint8_t r, uint8_t g,
                                    uint8_t b);

void hebiCommandSetLedModuleControl(HebiCommandPtr cmd, HebiCommandLedField field);

void hebiCommandClearLed(HebiCommandPtr cmd, HebiCommandLedField field);

// Feedback API

HebiStatusCode hebiFeedbackGetFloat(HebiFeedbackPtr fbk, HebiFeedbackFloatField field, float* value);

HebiStatusCode hebiFeedbackGetHighResAngle(HebiFeedbackPtr fbk, HebiFeedbackHighResAngleField field,
                                           int64_t* int_part, float* dec_part);

HebiStatusCode hebiFeedbackGetNumberedFloat(HebiFeedbackPtr fbk, HebiFeedbackNumberedFloatField field,
                                            size_t number, float* value);

HebiStatusCode hebiFeedbackGetUInt64(HebiFeedbackPtr fbk, HebiFeedbackUInt64Field field, uint64_t* value);

HebiStatusCode hebiFeedbackGetEnum(HebiFeedbackPtr, HebiFeedbackEnumField, int32_t*);

HebiStatusCode hebiFeedbackGetVector3f(HebiFeedbackPtr fbk, HebiFeedbackVector3fField field,
                                       HebiVector3f* value);

HebiStatusCode hebiFeedbackGetQuaternionf(HebiFeedbackPtr fbk,
                                          HebiFeedbackQuaternionfField field,
                                          HebiQuaternionf* value);

HebiStatusCode hebiFeedbackGetIoPinInt(HebiFeedbackPtr fbk, HebiFeedbackIoPinBank field, size_t pin_number,
                                       int64_t* value);

HebiStatusCode hebiFeedbackGetIoPinFloat(HebiFeedbackPtr fbk, HebiFeedbackIoPinBank field, size_t pin_number,
                                         float* value);

HebiStatusCode hebiFeedbackGetLedColor(HebiFeedbackPtr fbk, HebiFeedbackLedField field, uint8_t* r,
                                       uint8_t* g, uint8_t* b);

// Info API

HebiStatusCode hebiInfoGetFloat(HebiInfoPtr info, HebiInfoFloatField field, float* value);

HebiStatusCode hebiInfoGetHighResAngle(HebiInfoPtr, HebiInfoHighResAngleField,
                                       int64_t* int_part, float* dec_part);

HebiStatusCode hebiInfoGetBool(HebiInfoPtr info, HebiInfoBoolField field, int32_t* value);

HebiStatusCode hebiInfoGetString(HebiInfoPtr info, HebiInfoStringField field, char* buffer, size_t* length);

int32_t hebiInfoGetFlag(HebiInfoPtr info, HebiInfoFlagField field);

HebiStatusCode hebiInfoGetEnum(HebiInfoPtr info, HebiInfoEnumField field, int32_t* value);

HebiStatusCode hebiInfoGetLedColor(HebiInfoPtr info, HebiInfoLedField field, uint8_t* r, uint8_t* g,
                                   uint8_t* b);

// RobotModel API

HebiRobotModelElementPtr hebiRobotModelElementCreateJoint(HebiJointType joint_type);

HebiRobotModelElementPtr hebiRobotModelElementCreateRigidBody(const double* com, const double* inertia,
                                                              double mass, size_t num_outputs,
                                                              const double* outputs);

void hebiRobotModelElementRelease(HebiRobotModelElementPtr element);

HebiRobotModelPtr hebiRobotModelCreate(void);

HebiStatusCode hebiRobotModelSetBaseFrame(HebiRobotModelPtr robot_model, const double* transform);

HebiStatusCode hebiRobotModelGetBaseFrame(HebiRobotModelPtr robot_model, double* transform);

size_t hebiRobotModelGetNumberOfFrames(HebiRobotModelPtr robot_model, HebiFrameType frame_type);

size_t hebiRobotModelGetNumberOfDoFs(HebiRobotModelPtr robot_model);

HebiStatusCode hebiRobotModelAdd(HebiRobotModelPtr robot_model, HebiRobotModelElementPtr existing_element,
                                 size_t output_index, HebiRobotModelElementPtr new_element, int32_t combine);

HebiStatusCode hebiRobotModelGetForwardKinematics(HebiRobotModelPtr robot_model, HebiFrameType frame_type,
                                                  const double* positions, double* frames);

HebiStatusCode hebiRobotModelGetJacobians(HebiRobotModelPtr robot_model, HebiFrameType frame_type,
                                          const double* positions, double* jacobians);

HebiStatusCode hebiRobotModelGetMasses(HebiRobotModelPtr robot_model, double* masses);

void hebiRobotModelRelease(HebiRobotModelPtr robot_model);

// Inverse Kinematics API

HebiIKPtr hebiIKCreate(void);

HebiStatusCode hebiIKAddObjectiveEndEffectorPosition(HebiIKPtr ik, float weight, size_t end_effector_index,
                                                     double x, double y, double z);

HebiStatusCode hebiIKAddObjectiveEndEffectorSO3(HebiIKPtr ik, double weight, size_t end_effector_index,
                                                const double* matrix);

HebiStatusCode hebiIKAddObjectiveEndEffectorTipAxis(HebiIKPtr ik, double weight, size_t end_effector_index,
                                                    double x, double y, double z);

HebiStatusCode hebiIKAddConstraintJointAngles(HebiIKPtr ik, double weight, size_t num_joints,
                                              const double* min_positions, const double* max_positions);


HebiStatusCode hebiIKAddObjectiveCustom(HebiIKPtr ik, double weight,
                                        size_t num_errors,
                                        void(*err_fnc)(void* user_data,
                                                       size_t num_positions,
                                                       const double* positions,
                                                       double* errors),
                                        void* user_data);

void hebiIKClearAll(HebiIKPtr ik);

HebiStatusCode hebiIKSolve(HebiIKPtr ik, HebiRobotModelPtr model, const double* initial_positions,
                           double* ik_solution, void* result_info);

void hebiIKRelease(HebiIKPtr ik);

// Trajectory API

HebiTrajectoryPtr hebiTrajectoryCreateUnconstrainedQp(size_t num_waypoints, const double* positions,
                                                      const double* velocities, const double* accelerations,
                                                      const double* time_vector);

void hebiTrajectoryRelease(HebiTrajectoryPtr trajectory);

double hebiTrajectoryGetDuration(HebiTrajectoryPtr trajectory);

HebiStatusCode hebiTrajectoryGetState(HebiTrajectoryPtr trajectory, double time, double* position,
                                      double* velocity, double* acceleration);

// Logging API

void hebiLogFileRelease(HebiLogFilePtr log_file);

HebiStatusCode hebiLogFileGetFileName(HebiLogFilePtr log_file, char* buffer, size_t* length);

HebiLogFilePtr hebiLogFileOpen(const char* file);

size_t hebiLogFileGetNumberOfModules(HebiLogFilePtr log_file);

HebiStatusCode hebiLogFileGetNextFeedback(HebiLogFilePtr log_file, HebiGroupFeedbackPtr field);

// String Functions

HebiStatusCode hebiStringGetString(HebiStringPtr str, char* buffer, size_t* length);

void hebiStringRelease(HebiStringPtr str);

// Misc Functions

HebiStatusCode hebiGetLibraryVersion(int32_t* major, int32_t* minor, int32_t* revision);

void hebiCleanup(void);

#ifdef __cplusplus
} // extern "C"
#endif