KinovaTypes.h

Go to the documentation of this file.

#pragma once

#define JOYSTICK_BUTTON_COUNT 16

#define NB_ADVANCE_RETRACT_POSITION             20

#define ERROR_DATA_COUNT_MAX    50

#define ERROR_LAYER_COUNT 7

#define LEGACY_CONFIG_NB_ZONES_MAX              10

#define LEGACY_CONFIG_NB_POINTS_COUNT   8

#define CONTROL_MAPPING_COUNT 6

#define MODE_MAP_COUNT 6

#define STICK_EVENT_COUNT 6

#define BUTTON_EVENT_COUNT 26

#define STRING_LENGTH 20

#define JACO_FINGERS_COUNT 3

#define ERROR_UNKNOWFILE 5001

#define ERROR_MEMORY 5002

#define ERROR_FILEREADING 5003

const unsigned short PAGE_SIZE = 2048;

const int ADDRESS_PAGE_SIZE = 4;

const unsigned short PACKET_PER_PAGE_QTY = 40;

const int PAGEPACKET_SIZE = 52;

const int USB_HEADER_SIZE = 8;

const int USB_DATA_SIZE = 56;

enum POSITION_TYPE
{

  NOMOVEMENT_POSITION = 0, 
  CARTESIAN_POSITION = 1, 
  ANGULAR_POSITION = 2, 
  CARTESIAN_VELOCITY = 7, 
  ANGULAR_VELOCITY = 8, 
  ANY_TRAJECTORY = 11, 
  TIME_DELAY = 12, 
};

enum PERIPHERAL_TYPE
{
  PERIPHERAL_TYPE_NONE = 0, 
  PERIPHERAL_TYPE_ANY = 1, 
  PERIPHERAL_TYPE_ACTUATORK01 = 100, 
  PERIPHERAL_TYPE_FINGERK01 = 200, 
  PERIPHERAL_TYPE_JOYSTICK = 300, 
  PERIPHERAL_TYPE_VIRTUAL_JOYSTICK = 301, 
  PERIPHERAL_TYPE_CAN_INTERFACE = 400, 
};

enum HAND_MODE
{
  HAND_NOMOVEMENT, 
  POSITION_MODE, 
  VELOCITY_MODE, 
};

enum ArmLaterality
{
  RIGHTHAND, 
  LEFTHAND, 
};

enum Controller
{
  THREE_AXIS_JOYSTICK = 0, 
  TWO_AXIS_JOYSTICK = 1, 
  API = 2, 
  EASY_RIDER = 3, 
  UNIVERSAL_INTERFACE = 4, 
  EXTERNAL_CUSTOMINTERFACE = 5, 
  NONE = 6, 
  OLED_DISPLAY = 7 
};

enum CONTROL_TYPE
{
  CONTROL_TYPE_CARTESIAN = 0, 
  CONTROL_TYPE_ANGULAR = 1 
};

enum CONTROL_MODULE
{
  CONTROL_MODULE_NONE,

  CONTROL_MODULE_ANGULAR_VELOCITY,

  CONTROL_MODULE_ANGULAR_POSITION,

  CONTROL_MODULE_CARTESIAN_VELOCITY,

  CONTROL_MODULE_CARTESIAN_POSITION,

  CONTROL_MODULE_RETRACT,

  CONTROL_MODULE_TRAJECTORY,

  CONTROL_MODULE_PREDEFINED,

  CONTROL_MODULE_TIMEDELAY,
};

enum RETRACT_TYPE
{
  RETRACT_TYPE_NORMAL_TO_READY = 0,

  RETRACT_TYPE_READY_STANDBY = 1,

  RETRACT_TYPE_READY_TO_RETRACT = 2,

  RETRACT_TYPE_RETRACT_STANDBY = 3,

  RETRACT_TYPE_RETRACT_TO_READY = 4,

  RETRACT_TYPE_NORMAL_STANDBY = 5,

  RETRACT_TYPE_NOT_INITIALIZED = 6
};

struct AngularInfo
{
  float Actuator1;

  float Actuator2;

  float Actuator3;

  float Actuator4;

  float Actuator5;

  float Actuator6;

  void InitStruct()
  {
    Actuator1 = 0.0f;
    Actuator2 = 0.0f;
    Actuator3 = 0.0f;
    Actuator4 = 0.0f;
    Actuator5 = 0.0f;
    Actuator6 = 0.0f;
  }
};

struct CartesianInfo
{
  float X;

  float Y;

  float Z;

  float ThetaX;

  float ThetaY;

  float ThetaZ;

  void InitStruct()
  {
    X = 0.0f;
    Y = 0.0f;
    Z = 0.0f;
    ThetaX = 0.0f;
    ThetaY = 0.0f;
    ThetaZ = 0.0f;
  }
};

struct SensorsInfo
{
  float Voltage;

  float Current;

  float AccelerationX;

  float AccelerationY;

  float AccelerationZ;

  float ActuatorTemp1;

  float ActuatorTemp2;

  float ActuatorTemp3;

  float ActuatorTemp4;

  float ActuatorTemp5;

  float ActuatorTemp6;

  float FingerTemp1;

  float FingerTemp2;

  float FingerTemp3;

  void InitStruct()
  {
    Voltage = 0.0f;
    Current = 0.0f;
    AccelerationX = 0.0f;
    AccelerationY = 0.0f;
    AccelerationZ = 0.0f;
    ActuatorTemp1 = 0.0f;
    ActuatorTemp2 = 0.0f;
    ActuatorTemp3 = 0.0f;
    ActuatorTemp4 = 0.0f;
    ActuatorTemp5 = 0.0f;
    ActuatorTemp6 = 0.0f;
    FingerTemp1 = 0.0f;
    FingerTemp2 = 0.0f;
    FingerTemp3 = 0.0f;
  }

};

struct FingersPosition
{
  float Finger1;

  float Finger2;

  float Finger3;

  void InitStruct()
  {
    Finger1 = 0.0f;
    Finger2 = 0.0f;
    Finger3 = 0.0f;
  }
};

struct CartesianPosition
{
  CartesianInfo Coordinates;

  FingersPosition Fingers;

  void InitStruct()
  {
    Coordinates.InitStruct();
    Fingers.InitStruct();
  }
};

struct AngularPosition
{
  AngularInfo Actuators;

  FingersPosition Fingers;
};

struct Limitation
{
  float speedParameter1;

  float speedParameter2;
  float speedParameter3; 
  float forceParameter1; 
  float forceParameter2; 
  float forceParameter3; 
  float accelerationParameter1; 
  float accelerationParameter2; 
  float accelerationParameter3; 
  void InitStruct()
  {
    speedParameter1 = 0.0f;
    speedParameter2 = 0.0f;
    speedParameter3 = 0.0f;
    forceParameter1 = 0.0f;
    forceParameter2 = 0.0f;
    forceParameter3 = 0.0f;
    accelerationParameter1 = 0.0f;
    accelerationParameter2 = 0.0f;
    accelerationParameter3 = 0.0f;
  }
};

struct UserPosition
{
  POSITION_TYPE Type;

  float Delay;

  CartesianInfo CartesianPosition;

  AngularInfo Actuators;

  HAND_MODE HandMode;

  FingersPosition Fingers;

  void InitStruct()
  {
    Type = CARTESIAN_POSITION;
    Delay = 0.0f;
    CartesianPosition.InitStruct();
    Actuators.InitStruct();
    HandMode = POSITION_MODE;
    Fingers.InitStruct();
  }
};

struct TrajectoryPoint
{
  UserPosition Position;

  int LimitationsActive;

  Limitation Limitations;

  void InitStruct()
  {
    Position.InitStruct();
    LimitationsActive = 0;
    Limitations.InitStruct();
  }
};

struct TrajectoryFIFO
{
  unsigned int TrajectoryCount;

  float UsedPercentage;

  unsigned int MaxSize;
};

struct SingularityVector
{
  int TranslationSingularityCount;
  int OrientationSingularityCount;
  float TranslationSingularityDistance;
  float OrientationSingularityDistance;
  CartesianInfo RepulsionVector;
};

struct JoystickCommand
{
  short ButtonValue[JOYSTICK_BUTTON_COUNT];

  float InclineLeftRight;

  float InclineForwardBackward;

  float Rotate;

  float MoveLeftRight;

  float MoveForwardBackward;

  float PushPull;

  void InitStruct()
  {
    for (int i = 0; i < JOYSTICK_BUTTON_COUNT; i++)
    {
      ButtonValue[i] = 0;
    }

    InclineLeftRight = 0.0f;
    InclineForwardBackward = 0.0f;
    Rotate = 0.0f;
    MoveLeftRight = 0.0f;
    MoveForwardBackward = 0.0f;
    PushPull = 0.0f;
  }
};

struct ClientConfigurations
{
  char ClientID[STRING_LENGTH];

  char ClientName[STRING_LENGTH];

  char Organization[STRING_LENGTH];

  char Serial[STRING_LENGTH];

  char Model[STRING_LENGTH];

  ArmLaterality Laterality;

  float MaxTranslationVelocity;

  float MaxOrientationVelocity;

  float MaxTranslationAcceleration;

  float MaxOrientationAcceleration;

  float MaxForce;

  float Sensibility;

  float DrinkingHeight;

  int ComplexRetractActive;

  float RetractedPositionAngle;

  int RetractedPositionCount;
  UserPosition RetractPositions[NB_ADVANCE_RETRACT_POSITION];

  float DrinkingDistance;

  int Fingers2and3Inverted;

  float DrinkingLenght;

  int DeletePreProgrammedPositionsAtRetract;

  int EnableFlashErrorLog;

  int EnableFlashPositionLog;

  int Expansion[198];
};

enum ControlFunctionalityTypeEnum
{
  CF_NoFunctionality = 0,

  CF_Disable_EnableJoystick = 1,

  CF_Retract_ReadyToUse = 2,

  CF_Change_TwoAxis_ThreeAxis = 3,

  CF_Change_DrinkingMode = 4,

  CF_Cycle_ModeA_list = 5,

  CF_Cycle_ModeB_list = 6,

  CF_DecreaseSpeed = 7,

  CF_IncreaseSpeed = 8,

  CF_Goto_Position1 = 9,

  CF_Goto_Position2 = 10,

  CF_Goto_Position3 = 11,

  CF_Goto_Position4 = 12,

  CF_Goto_Position5 = 13,

  CF_RecordPosition1 = 14,

  CF_RecordPosition2 = 15,

  CF_RecordPosition3 = 16,

  CF_RecordPosition4 = 17,

  CF_RecordPosition5 = 18,

  CF_X_Positive = 19,

  CF_X_Negative = 20,

  CF_Y_Positive = 21,

  CF_Y_Negative = 22,

  CF_Z_Positive = 23,

  CF_Z_Negative = 24,

  CF_R_Positive = 25,

  CF_R_Negative = 26,

  CF_U_Positive = 27,

  CF_U_Negative = 28,

  CF_V_Positive = 29,

  CF_V_Negative = 30,

  CF_OpenHandOneFingers = 31,

  CF_CloseHandOneFingers = 32,

  CF_OpenHandTwoFingers = 33,

  CF_CloseHandTwoFingers = 34,

  CF_OpenHandThreeFingers = 35,

  CF_CloseHandThreeFingers = 36,

  CF_ForceAngularVelocity = 37,

  CF_ForceControlStatus = 38,

  CF_Trajectory = 39,

  CF_AutomaticOrientationXPlus = 40,

  CF_AutomaticOrientationXMinus = 41,

  CF_AutomaticOrientationYPlus = 42,

  CF_AutomaticOrientationYMinus = 43,

  CF_AutomaticOrientationZPlus = 44,

  CF_AutomaticOrientationZMinus = 45,

  CF_AdvanceGOTO_1 = 46,

  CF_AdvanceGOTO_Clear_1 = 47,

  CF_AdvanceGOTO_Add_1 = 48,
};

struct StickEvents
{
  unsigned char Minus;

  unsigned char Plus;
};

struct ButtonEvents
{
  unsigned char OneClick;

  unsigned char TwoClick;

  unsigned char HoldOneSec;

  unsigned char HoldTwoSec;

  unsigned char HoldThreeSec;

  unsigned char HoldFourSec;

  unsigned char HoldDown;
};

enum ControlMappingMode
{
  OneAxis,

  TwoAxis,

  ThreeAxis,

  SixAxis
};

struct ControlsModeMap
{
  int DiagonalsLocked;

  int Expansion;

  StickEvents ControlSticks[STICK_EVENT_COUNT];

  ButtonEvents ControlButtons[BUTTON_EVENT_COUNT];
};

struct ControlMapping
{
  int NumOfModesA;

  int NumOfModesB;

  int ActualModeA;

  int ActualModeB;

  ControlMappingMode Mode;

  ControlsModeMap ModeControlsA[MODE_MAP_COUNT];

  ControlsModeMap ModeControlsB[MODE_MAP_COUNT];
};

struct ControlMappingCharts
{
  int NumOfConfiguredMapping;

  int ActualControlMapping;

  ControlMapping Mapping[CONTROL_MAPPING_COUNT];
};

enum errorLoggerType
{
  ERROR_NOTINITIALIZED,

  keos_err1,

  keos_err2,

  keos_err3,

  User_err_start_marker,

  errorlog_Actuator_Temperature,

  errorlog_Actuator_TemperatureOK,

  errorlog_Finger_Temperature,

  errorlog_Finger_TemperatureOK,

  errorlog_voltage,

  errorlog_voltageOK,

  errorlog_current_FingersClosing,

  errorlog_current_FingersOpening,

  errorlog_current_FingersOK,

  errorlog_current_Actuators,

  errorlog_current_ActuatorsOK,

  errorLog_RobotStatus_Build_Incomplete,

  errorLogger_END
};

struct SystemError
{
  unsigned int ErrorHeader;

  errorLoggerType ErrorType;

  int FirmwareVersion;

  int KeosVersion;

  unsigned int SystemTime;

  bool LayerErrorStatus[ERROR_LAYER_COUNT];

  int LifeTime;

  int DataCount;

  unsigned int Data[ERROR_DATA_COUNT_MAX];

};

struct ZoneLimitation
{
  float speedParameter1;

  float speedParameter2;

  float speedParameter3;

  float forceParameter1;

  float forceParameter2;

  float forceParameter3;

  float accelerationParameter1;

  float accelerationParameter2;

  float accelerationParameter3;
};

enum ShapeType
{
  PrismSquareBase_X = 0,

  PrismSquareBase_Y = 1,

  PrismSquareBase_Z = 2,

  PrismTriangularBase_X = 3,

  PrismTriangularBase_Y = 4,

  PrismTriangularBase_Z = 5,

  Pyramid = 6
};

struct ForcesInfo
{
  float Actuator1;

  float Actuator2;

  float Actuator3;

  float Actuator4;

  float Actuator5;

  float Actuator6;

  float X;

  float Y;

  float Z;

  float ThetaX;

  float ThetaY;

  float ThetaZ;
};

struct QuickStatus
{
  unsigned char Finger1Status;

  unsigned char Finger2Status;

  unsigned char Finger3Status;

  unsigned char RetractType;

  unsigned char RetractComplexity;

  unsigned char ControlEnableStatus;

  unsigned char ControlActiveModule;

  unsigned char ControlFrameType;

  unsigned char CartesianFaultState;

  unsigned char ForceControlStatus;

  unsigned char CurrentLimitationStatus;

  unsigned char RobotType;

  unsigned char RobotEdition;

  unsigned char TorqueSensorsStatus;
};

struct Finger
{
  char ID[STRING_LENGTH];

  float ActualCommand;

  float ActualSpeed;

  float ActualForce;

  float ActualAcceleration;

  float ActualCurrent;

  float ActualPosition;

  float ActualAverageCurrent;

  float ActualTemperature;

  int CommunicationErrors;

  int OscillatorTuningValue;

  float CycleCount;

  float RunTime;

  float PeakMaxTemp;

  float PeakMinTemp;

  float PeakCurrent;

  float MaxSpeed;

  float MaxForce;

  float MaxAcceleration;

  float MaxCurrent;

  float MaxAngle;

  float MinAngle;

  unsigned int DeviceID;

  unsigned int CodeVersion;

  unsigned short IsFingerInit;

  unsigned short Index;

  unsigned short FingerAddress;

  unsigned short IsFingerConnected;
};

struct Gripper
{
  char Model[STRING_LENGTH];

  Finger Fingers[JACO_FINGERS_COUNT];
};

struct ZoneShape
{
  ShapeType shapeType;

  int Expansion1;

  CartesianInfo Points[LEGACY_CONFIG_NB_POINTS_COUNT];
};

struct Zone
{
  int ID;

  int Expansion1;

  ZoneShape zoneShape;

  ZoneLimitation zoneLimitation;

  int Expansion2;
};

struct ZoneList
{
  int NbZones;

  int Expansion1;

  Zone Zones[LEGACY_CONFIG_NB_ZONES_MAX];

};

struct SystemStatus
{
  unsigned int JoystickActive;

  unsigned int RetractStatus;

  unsigned int DrinkingMode;

  unsigned int ArmLaterality;

  unsigned int TranslationActive;

  unsigned int RotationActive;

  unsigned int FingersActive;

  unsigned int WarningOverchargeForce;

  unsigned int WarningOverchargeFingers;

  unsigned int WarningLowVoltage;

  unsigned int MajorErrorOccured;
};

struct GeneralInformations
{
  double TimeAbsolute;

  double TimeFromStartup;

  unsigned int IndexStartup;

  int ExpansionLong1;

  float TimeStampSavings;

  float ExpansionFloat;

  float SupplyVoltage;

  float TotalCurrent;

  float Power;

  float AveragePower;

  float AccelerationX;

  float AccelerationY;

  float AccelerationZ;

  float SensorExpansion1;

  float SensorExpansion2;

  float SensorExpansion3;

  unsigned int CodeVersion;

  unsigned int CodeRevision;

  unsigned short Status;

  unsigned short Controller;

  unsigned short ControlMode;

  unsigned short HandMode;

  unsigned short ConnectedActuatorCount;

  unsigned short PositionType;

  unsigned short ErrorsSpiExpansion1;

  unsigned short ErrorsSpiExpansion2;

  unsigned short ErrorsMainSPICount;

  unsigned short ErrorsExternalSPICount;

  unsigned short ErrorsMainCANCount;

  unsigned short ErrorsExternalCANCount;

  SystemStatus ActualSystemStatus;

  UserPosition Position;

  UserPosition Command;

  UserPosition Current;

  UserPosition Force;

  ZoneLimitation ActualLimitations;

  float ControlIncrement[6];

  float FingerControlIncrement[3];

  JoystickCommand ActualJoystickCommand;

  unsigned int PeripheralsConnected[4];

  unsigned int PeripheralsDeviceID[4];

  float ActuatorsTemperatures[6];

  float FingersTemperatures[3];

  float FutureTemperatures[3];

  int ActuatorsCommErrors[6];

  int FingersCommErrors[3];

  int ExpansionLong2;

  double ControlTimeAbsolute;

  double ControlTimeFromStartup;

  unsigned char ExpansionsBytes[192];
};

struct AngularAcceleration
{
  float Actuator1_X;

  float Actuator1_Y;

  float Actuator1_Z;

  float Actuator2_X;

  float Actuator2_Y;

  float Actuator2_Z;

  float Actuator3_X;

  float Actuator3_Y;

  float Actuator3_Z;

  float Actuator4_X;

  float Actuator4_Y;

  float Actuator4_Z;

  float Actuator5_X;

  float Actuator5_Y;

  float Actuator5_Z;

  float Actuator6_X;

  float Actuator6_Y;

  float Actuator6_Z;

  void InitStruct()
  {
    Actuator1_X = 0.0f;
    Actuator1_Y = 0.0f;
    Actuator1_Z = 0.0f;
    Actuator2_X = 0.0f;
    Actuator2_Y = 0.0f;
    Actuator2_Z = 0.0f;
    Actuator3_X = 0.0f;
    Actuator3_Y = 0.0f;
    Actuator3_Z = 0.0f;
    Actuator4_X = 0.0f;
    Actuator4_Y = 0.0f;
    Actuator4_Z = 0.0f;
    Actuator5_X = 0.0f;
    Actuator5_Y = 0.0f;
    Actuator5_Z = 0.0f;
    Actuator6_X = 0.0f;
    Actuator6_Y = 0.0f;
    Actuator6_Z = 0.0f;
  }
};

struct PeripheralInfo
{
  unsigned int Handle;

  unsigned int Type;

  unsigned int Port;

  unsigned int Address;

  unsigned int CodeVersion;
};