hebi.h

Go to the documentation of this file.

#pragma once

#include <math.h>
#include <stdbool.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


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

typedef enum HebiArQuality {
  HebiArQualityNotAvailable, 
  HebiArQualityLimitedUnknown, 
  HebiArQualityLimitedInitializing, 
  HebiArQualityLimitedRelocalizing, 
  HebiArQualityLimitedExcessiveMotion, 
  HebiArQualityLimitedInsufficientFeatures, 
  HebiArQualityNormal 
} HebiArQuality;

typedef enum HebiIoBankPinResidentType {
  HebiIoBankPinResidentTypeNone, // Io pin should be interpreted empty
  HebiIoBankPinResidentTypeInteger, // Io pin should be interpreted as an integer (`int64_t`)
  HebiIoBankPinResidentTypeFloat // Io pin should be interpreted as a float (`float`)
} HebiIoBankPinResidentType;


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, 
  HebiCommandFloatVelocityLimitMin, 
  HebiCommandFloatVelocityLimitMax, 
  HebiCommandFloatEffortLimitMin,   
  HebiCommandFloatEffortLimitMax,   
} HebiCommandFloatField;

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

typedef enum HebiCommandNumberedFloatField {
  HebiCommandNumberedFloatDebug, 
} HebiCommandNumberedFloatField;

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

typedef enum HebiCommandStringField {
  HebiCommandStringName,   
  HebiCommandStringFamily, 
  HebiCommandStringAppendLog, 
} HebiCommandStringField;

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

typedef enum HebiCommandEnumField {
  HebiCommandEnumControlStrategy, 
  HebiCommandEnumMstopStrategy,            
  HebiCommandEnumMinPositionLimitStrategy, 
  HebiCommandEnumMaxPositionLimitStrategy, 
} HebiCommandEnumField;

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

typedef enum HebiCommandLedField {
  HebiCommandLedLed, 
} HebiCommandLedField;


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

typedef enum HebiFeedbackHighResAngleField {
  HebiFeedbackHighResAnglePosition,        
  HebiFeedbackHighResAnglePositionCommand, 
  HebiFeedbackHighResAngleMotorPosition,   
} HebiFeedbackHighResAngleField;

typedef enum HebiFeedbackNumberedFloatField {
  HebiFeedbackNumberedFloatDebug, 
} HebiFeedbackNumberedFloatField;

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

typedef enum HebiFeedbackVector3fField {
  HebiFeedbackVector3fAccelerometer, 
  HebiFeedbackVector3fGyro,          
  HebiFeedbackVector3fArPosition, 
} HebiFeedbackVector3fField;

typedef enum HebiFeedbackQuaternionfField {
  HebiFeedbackQuaternionfOrientation, 
  HebiFeedbackQuaternionfArOrientation, 
} HebiFeedbackQuaternionfField;

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

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

typedef enum HebiFeedbackLedField {
  HebiFeedbackLedLed, 
} HebiFeedbackLedField;


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,      
  HebiInfoFloatVelocityLimitMin,    
  HebiInfoFloatVelocityLimitMax,    
  HebiInfoFloatEffortLimitMin,      
  HebiInfoFloatEffortLimitMax,      
} HebiInfoFloatField;

typedef enum HebiInfoHighResAngleField {
  HebiInfoHighResAnglePositionLimitMin, 
  HebiInfoHighResAnglePositionLimitMax, 
} HebiInfoHighResAngleField;

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

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

typedef enum HebiInfoFlagField {
  HebiInfoFlagSaveCurrentSettings, 
} HebiInfoFlagField;

typedef enum HebiInfoEnumField {
  HebiInfoEnumControlStrategy, 
  HebiInfoEnumCalibrationState,         
  HebiInfoEnumMstopStrategy,            
  HebiInfoEnumMinPositionLimitStrategy, 
  HebiInfoEnumMaxPositionLimitStrategy, 
} HebiInfoEnumField;

typedef enum HebiInfoLedField {
  HebiInfoLedLed, 
} HebiInfoLedField;


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

typedef enum HebiRobotModelElementType {
  HebiRobotModelElementTypeOther,
  HebiRobotModelElementTypeActuator,
  HebiRobotModelElementTypeBracket,
  HebiRobotModelElementTypeJoint,
  HebiRobotModelElementTypeLink,
  HebiRobotModelElementTypeRigidBody,
  HebiRobotModelElementTypeEndEffector
} HebiRobotModelElementType;

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

typedef enum HebiActuatorType {
  HebiActuatorTypeX5_1,
  HebiActuatorTypeX5_4,
  HebiActuatorTypeX5_9,
  HebiActuatorTypeX8_3,
  HebiActuatorTypeX8_9,
  HebiActuatorTypeX8_16,
  HebiActuatorTypeR8_3,
  HebiActuatorTypeR8_9,
  HebiActuatorTypeR8_16
} HebiActuatorType;

typedef enum HebiLinkType {
  HebiLinkTypeX5,
  HebiLinkTypeR8,
} HebiLinkType;

typedef enum HebiLinkInputType {
  HebiLinkInputTypeRightAngle,
  HebiLinkInputTypeInline
} HebiLinkInputType;

typedef enum HebiLinkOutputType {
  HebiLinkOutputTypeRightAngle,
  HebiLinkOutputTypeInline
} HebiLinkOutputType;

typedef enum HebiBracketType {
  HebiBracketTypeX5LightLeft,
  HebiBracketTypeX5LightRight,
  HebiBracketTypeX5HeavyLeftInside,
  HebiBracketTypeX5HeavyLeftOutside,
  HebiBracketTypeX5HeavyRightInside,
  HebiBracketTypeX5HeavyRightOutside,
  HebiBracketTypeR8LightLeft,
  HebiBracketTypeR8LightRight,
  HebiBracketTypeR8HeavyLeftInside,
  HebiBracketTypeR8HeavyLeftOutside,
  HebiBracketTypeR8HeavyRightInside,
  HebiBracketTypeR8HeavyRightOutside
} HebiBracketType;

typedef enum HebiEndEffectorType {
  HebiEndEffectorTypeCustom,
  HebiEndEffectorTypeX5Parallel,
  HebiEndEffectorTypeR8Parallel
} HebiEndEffectorType;

typedef enum HebiMatrixOrdering {
  HebiMatrixOrderingRowMajor,
  HebiMatrixOrderingColumnMajor
} HebiMatrixOrdering;


typedef struct HebiCommand_* HebiCommandPtr;

typedef struct HebiFeedback_* HebiFeedbackPtr;

typedef struct HebiInfo_* HebiInfoPtr;

typedef struct HebiGroupCommand_* HebiGroupCommandPtr;

typedef struct HebiGroupFeedback_* HebiGroupFeedbackPtr;

typedef struct HebiGroupInfo_* HebiGroupInfoPtr;

typedef struct HebiGroup_* HebiGroupPtr;

typedef struct HebiLookup_* HebiLookupPtr;

typedef struct HebiLookupEntryList_* HebiLookupEntryListPtr;

typedef struct HebiLogFile_* HebiLogFilePtr;

typedef struct HebiString_* HebiStringPtr;

typedef struct HebiRobotModel_* HebiRobotModelPtr;

typedef struct HebiRobotModelElement_* HebiRobotModelElementPtr;

typedef struct HebiIK_* HebiIKPtr;

typedef struct HebiTrajectory_* HebiTrajectoryPtr;

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


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;

typedef struct HebiRobotModelElementMetadata_ {
  uint32_t struct_size_;
  HebiRobotModelElementType element_type_;
  union {
    struct /*Actuator Type */ {
      HebiActuatorType actuator_type_;
    };
    struct /*Bracket Type */ {
      HebiBracketType bracket_type_;
    };
    struct /*Joint Type */ {
      HebiJointType joint_type_;
    };
    struct /*Link Type*/ {
      HebiLinkType link_type_;
      HebiLinkInputType input_type_;
      HebiLinkOutputType output_type_;
      float extension_;
      float twist_;
    };
    struct /*End effector Type*/ {
      HebiEndEffectorType end_effector_type_;
    };
  };
} HebiRobotModelElementMetadata;

typedef struct HebiRobotModelElementTopology_ {
  int32_t element_index_;
  int32_t parent_index_;
  int32_t parent_output_;
  int32_t dof_location_;
  int32_t com_index_;
  int32_t output_index_;
  int32_t end_effector_index_;
} HebiRobotModelElementTopology;

typedef struct HebiHighResAngleStruct_ {
  int64_t revolutions_;
  float offset_;
} HebiHighResAngleStruct;

typedef struct HebiIoBankPinStruct_ {
  union {
    int64_t int_value_;
    float float_value_;    
  };
  HebiIoBankPinResidentType stored_type_;
} HebiIoBankPinStruct;

typedef struct HebiCommandRef_ {
  int32_t* message_bitfield_;
  float* float_fields_;
  HebiHighResAngleStruct* high_res_angle_fields_;
  HebiVector3f* vector3f_fields_;
  HebiQuaternionf* quaternionf_fields_;
  uint64_t* uint64_fields_;
  int32_t* enum_fields_;
  bool* bool_fields_;
  float* numbered_float_fields_;
  HebiIoBankPinStruct* io_fields_;
  uint32_t* led_fields_;
  void* reserved_;
} HebiCommandRef;

typedef struct HebiCommandMetadata_ {
  // Total number of fields for each field type
  uint32_t float_field_count_;
  uint32_t high_res_angle_field_count_;
  uint32_t vector3f_field_count_;
  uint32_t quaternionf_field_count_;
  uint32_t uint64_field_count_;
  uint32_t enum_field_count_;
  uint32_t bool_field_count_;
  uint32_t numbered_float_field_count_;
  uint32_t io_field_count_;
  uint32_t led_field_count_;
  uint32_t string_field_count_;
  uint32_t flag_field_count_;
  // Field offsets into `message_bitfield_`
  uint32_t float_field_bitfield_offset_;
  uint32_t high_res_angle_field_bitfield_offset_;
  uint32_t vector3f_field_bitfield_offset_;
  uint32_t quaternionf_field_bitfield_offset_;
  uint32_t uint64_field_bitfield_offset_;
  uint32_t enum_field_bitfield_offset_;
  uint32_t bool_field_bitfield_offset_;
  uint32_t numbered_float_field_bitfield_offset_;
  uint32_t io_field_bitfield_offset_;
  uint32_t led_field_bitfield_offset_;
  uint32_t string_field_bitfield_offset_;
  uint32_t flag_field_bitfield_offset_;
  // Corresponds to the relative offset within the relevant block of `HebiCommandRef::message_bitfield_` for individual numbered float fields.
  const uint32_t* numbered_float_relative_offsets_;
  const uint32_t* numbered_float_field_sizes_;
  // Corresponds to the relative offset within the relevant block of `HebiCommandRef::message_bitfield_` for individual io bank pins.
  const uint32_t* io_relative_offsets_;
  const uint32_t* io_field_sizes_;
  // Total number of bits in `message_bitfield_`
  uint32_t message_bitfield_count_;
} HebiCommandMetadata;

typedef struct HebiFeedbackRef_ {
  const int32_t* message_bitfield_;
  const float* float_fields_;
  const HebiHighResAngleStruct* high_res_angle_fields_;
  const HebiVector3f* vector3f_fields_;
  const HebiQuaternionf* quaternionf_fields_;
  const uint64_t* uint64_fields_;
  const int32_t* enum_fields_;
  const bool* bool_fields_;
  const float* numbered_float_fields_;
  const HebiIoBankPinStruct* io_fields_;
  const uint32_t* led_fields_;
  void* reserved_;
} HebiFeedbackRef;

typedef struct HebiFeedbackMetadata_ {
  // Total number of fields for each field type
  uint32_t float_field_count_;
  uint32_t high_res_angle_field_count_;
  uint32_t vector3f_field_count_;
  uint32_t quaternionf_field_count_;
  uint32_t uint64_field_count_;
  uint32_t enum_field_count_;
  uint32_t bool_field_count_;
  uint32_t numbered_float_field_count_;
  uint32_t io_field_count_;
  uint32_t led_field_count_;
  uint32_t string_field_count_;
  uint32_t flag_field_count_;
  // Field offsets into `message_bitfield_`
  uint32_t float_field_bitfield_offset_;
  uint32_t high_res_angle_field_bitfield_offset_;
  uint32_t vector3f_field_bitfield_offset_;
  uint32_t quaternionf_field_bitfield_offset_;
  uint32_t uint64_field_bitfield_offset_;
  uint32_t enum_field_bitfield_offset_;
  uint32_t bool_field_bitfield_offset_;
  uint32_t numbered_float_field_bitfield_offset_;
  uint32_t io_field_bitfield_offset_;
  uint32_t led_field_bitfield_offset_;
  uint32_t string_field_bitfield_offset_;
  uint32_t flag_field_bitfield_offset_;
  // Corresponds to the relative offset within the relevant block of `HebiFeedbackRef::message_bitfield_` for individual numbered float fields.
  const uint32_t* numbered_float_relative_offsets_;
  const uint32_t* numbered_float_field_sizes_;
  // Corresponds to the relative offset within the relevant block of `HebiFeedbackRef::message_bitfield_` for individual io bank pins.
  const uint32_t* io_relative_offsets_;
  const uint32_t* io_field_sizes_;
  // Total number of bits in `message_bitfield_`
  uint32_t message_bitfield_count_;
} HebiFeedbackMetadata;

typedef struct HebiInfoRef_ {
  const int32_t* message_bitfield_;
  const float* float_fields_;
  const HebiHighResAngleStruct* high_res_angle_fields_;
  const HebiVector3f* vector3f_fields_;
  const HebiQuaternionf* quaternionf_fields_;
  const uint64_t* uint64_fields_;
  const int32_t* enum_fields_;
  const bool* bool_fields_;
  const float* numbered_float_fields_;
  const HebiIoBankPinStruct* io_fields_;
  const uint32_t* led_fields_;
  void* reserved_;
} HebiInfoRef;

typedef struct HebiInfoMetadata_ {
  // Total number of fields for each field type
  uint32_t float_field_count_;
  uint32_t high_res_angle_field_count_;
  uint32_t vector3f_field_count_;
  uint32_t quaternionf_field_count_;
  uint32_t uint64_field_count_;
  uint32_t enum_field_count_;
  uint32_t bool_field_count_;
  uint32_t numbered_float_field_count_;
  uint32_t io_field_count_;
  uint32_t led_field_count_;
  uint32_t string_field_count_;
  uint32_t flag_field_count_;
  // Field offsets into `message_bitfield_`
  uint32_t float_field_bitfield_offset_;
  uint32_t high_res_angle_field_bitfield_offset_;
  uint32_t vector3f_field_bitfield_offset_;
  uint32_t quaternionf_field_bitfield_offset_;
  uint32_t uint64_field_bitfield_offset_;
  uint32_t enum_field_bitfield_offset_;
  uint32_t bool_field_bitfield_offset_;
  uint32_t numbered_float_field_bitfield_offset_;
  uint32_t io_field_bitfield_offset_;
  uint32_t led_field_bitfield_offset_;
  uint32_t string_field_bitfield_offset_;
  uint32_t flag_field_bitfield_offset_;
  // Corresponds to the relative offset within the relevant block of `HebiInfoRef::message_bitfield_` for individual numbered float fields.
  const uint32_t* numbered_float_relative_offsets_;
  const uint32_t* numbered_float_field_sizes_;
  // Corresponds to the relative offset within the relevant block of `HebiInfoRef::message_bitfield_` for individual io bank pins.
  const uint32_t* io_relative_offsets_;
  const uint32_t* io_field_sizes_;
  // Total number of bits in `message_bitfield_`
  uint32_t message_bitfield_count_;
} HebiInfoMetadata;


HebiLookupPtr hebiLookupCreate(const char* const* ifaces, size_t ifaces_length);

void hebiLookupRelease(HebiLookupPtr lookup);

HebiStatusCode hebiLookupSetLookupFrequencyHz(HebiLookupPtr lookup, double frequency);

double hebiLookupGetLookupFrequencyHz(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);


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 command);

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

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

HebiStatusCode hebiGroupCommandReadSafetyParameters(HebiGroupCommandPtr command, const char* file);

HebiStatusCode hebiGroupCommandWriteSafetyParameters(HebiGroupCommandPtr command, const char* file);

HebiCommandPtr hebiGroupCommandGetModuleCommand(HebiGroupCommandPtr command, size_t module_index);

HebiStatusCode hebiGroupCommandCopy(HebiGroupCommandPtr dest, HebiGroupCommandPtr src);

void hebiGroupCommandClear(HebiGroupCommandPtr command);

void hebiGroupCommandRelease(HebiGroupCommandPtr command);

HebiGroupFeedbackPtr hebiGroupFeedbackCreate(size_t size);

size_t hebiGroupFeedbackGetSize(HebiGroupFeedbackPtr feedback);

HebiFeedbackPtr hebiGroupFeedbackGetModuleFeedback(HebiGroupFeedbackPtr feedback, size_t module_index);

HebiStatusCode hebiGroupFeedbackCopy(HebiGroupFeedbackPtr dest, HebiGroupFeedbackPtr src);

void hebiGroupFeedbackClear(HebiGroupFeedbackPtr feedback);

void hebiGroupFeedbackRelease(HebiGroupFeedbackPtr feedback);

HebiGroupInfoPtr hebiGroupInfoCreate(size_t size);

size_t hebiGroupInfoGetSize(HebiGroupInfoPtr info);

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

HebiStatusCode hebiGroupInfoWriteSafetyParameters(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);


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

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

void hebiCommandGetReference(HebiCommandPtr command, HebiCommandRef* ref);

void hebiCommandGetMetadata(HebiCommandMetadata* metadata);



void hebiFeedbackGetReference(HebiFeedbackPtr feedback, HebiFeedbackRef* ref);

void hebiFeedbackGetMetadata(HebiFeedbackMetadata* metadata);


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

void hebiInfoGetReference(HebiInfoPtr info, HebiInfoRef* ref);

void hebiInfoGetMetadata(HebiInfoMetadata* metadata);


HebiRobotModelElementPtr hebiRobotModelElementCreateJoint(HebiJointType joint_type);

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

HebiRobotModelElementPtr hebiRobotModelElementCreateEndEffector(HebiEndEffectorType end_effector_type,
                                                                const double* com, const double* inertia,
                                                                double mass, const double* output_frame,
                                                                HebiMatrixOrdering ordering);

HebiRobotModelElementPtr hebiRobotModelElementCreateActuator(HebiActuatorType actuator_type);

HebiRobotModelElementPtr hebiRobotModelElementCreateBracket(HebiBracketType bracket_type);

HebiRobotModelElementPtr hebiRobotModelElementCreateLink(HebiLinkType link_type, HebiLinkInputType input_type,
                                                         HebiLinkOutputType output_type, double extension,
                                                         double twist);

void hebiRobotModelElementRelease(HebiRobotModelElementPtr element);

HebiRobotModelPtr hebiRobotModelImport(const char* file);

HebiRobotModelPtr hebiRobotModelImportBuffer(const char* buffer, size_t buffer_size);

const char* hebiRobotModelGetImportError();

size_t hebiRobotModelGetImportWarningCount();

const char* hebiRobotModelGetImportWarning(size_t warning_index);

HebiRobotModelPtr hebiRobotModelCreate(void);

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

HebiStatusCode hebiRobotModelGetBaseFrame(HebiRobotModelPtr robot_model, double* transform,
                                          HebiMatrixOrdering ordering);

size_t hebiRobotModelGetNumberOfFrames(HebiRobotModelPtr robot_model, HebiFrameType frame_type);

size_t hebiRobotModelGetNumberOfDoFs(HebiRobotModelPtr robot_model);

size_t hebiRobotModelGetNumberOfElements(HebiRobotModelPtr robot_model);

HebiStatusCode hebiRobotModelGetElementMetadata(HebiRobotModelPtr model, size_t index, HebiRobotModelElementMetadata* output);

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

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

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

HebiStatusCode hebiRobotModelGetMasses(HebiRobotModelPtr robot_model, double* masses);


HebiStatusCode hebiRobotModelGetTreeTopology(HebiRobotModelPtr robot_model, HebiFrameType frame_type, HebiRobotModelElementTopology* table);


void hebiRobotModelRelease(HebiRobotModelPtr robot_model);


HebiIKPtr hebiIKCreate(void);

HebiStatusCode hebiIKAddObjectiveEndEffectorPosition(HebiIKPtr ik, double 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, HebiMatrixOrdering ordering);

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


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


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


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

void hebiStringRelease(HebiStringPtr str);


const char* hebiSafetyParametersGetLastError(void);

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

void hebiCleanup(void);

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