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