ecmcMotion.h

Go to the documentation of this file.

/*************************************************************************\
* Copyright (c) 2019 European Spallation Source ERIC
* ecmc is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*
*  ecmcMotion.h
*
*  Created on: Jan 10, 2019
*      Author: anderssandstrom
*
\*************************************************************************/
 
#ifndef ECMC_MOTION_H_
#define ECMC_MOTION_H_
 
# ifdef __cplusplus
extern "C" {
# endif  // ifdef __cplusplus
 
 
#define CHECK_AXIS_RETURN_IF_ERROR(axisIndex)\
        {\
          if (axisIndex >= ECMC_MAX_AXES || axisIndex <= 0) {\
            LOGERR("ERROR: Axis index out of range.\n");\
            return ERROR_MAIN_AXIS_INDEX_OUT_OF_RANGE;\
          }\
          if (axes[axisIndex] == NULL) {\
            LOGERR("ERROR: Axis object NULL\n");\
            return ERROR_MAIN_AXIS_OBJECT_NULL;\
          }\
        }\
 
#define CHECK_AXIS_RETURN_IF_ERROR_AND_BLOCK_COM(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->getBlockExtCom()) {\
            LOGERR("ERROR: External Commands Disabled\n");\
            return ERROR_MAIN_AXIS_EXTERNAL_COM_DISABLED;\
          }\
        }\
 
#define CHECK_AXIS_ENCODER_RETURN_IF_ERROR(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->\
              getEnc() == NULL) {\
            LOGERR("ERROR: Encoder object NULL.\n");\
            return ERROR_MAIN_ENCODER_OBJECT_NULL;\
          }\
        }\
 
#define CHECK_AXIS_ENCODER_CFG_RETURN_IF_ERROR(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->\
              getConfigEnc() == NULL) {\
            LOGERR("ERROR: Encoder object NULL.\n");\
            return ERROR_MAIN_ENCODER_OBJECT_NULL;\
          }\
        }\
 
#define CHECK_AXIS_CONTROLLER_RETURN_IF_ERROR(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->getCntrl() == NULL) {\
            LOGERR("ERROR: Controller object NULL.\n");\
            return ERROR_MAIN_CONTROLLER_OBJECT_NULL;\
          }\
        }\
 
#define CHECK_AXIS_DRIVE_RETURN_IF_ERROR(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->getDrv() == NULL) {\
            LOGERR("ERROR: Drive object NULL.\n");\
            return ERROR_MAIN_DRIVE_OBJECT_NULL;\
          }\
        }\
 
#define CHECK_AXIS_TRAJ_RETURN_IF_ERROR(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->getTraj() == NULL) {\
            LOGERR("ERROR: Trajectory object NULL.\n");\
            return ERROR_MAIN_TRAJECTORY_OBJECT_NULL;\
          }\
        }\
 
#define CHECK_AXIS_SEQ_RETURN_IF_ERROR(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->getSeq() == NULL) {\
            LOGERR("ERROR: Sequence object NULL.\n");\
            return ERROR_MAIN_SEQUENCE_OBJECT_NULL;\
          }\
        }\
 
#define CHECK_AXIS_MON_RETURN_IF_ERROR(axisIndex)\
        {\
          CHECK_AXIS_RETURN_IF_ERROR(axisIndex);\
          if (axes[axisIndex]->getMon() == NULL) {\
            LOGERR("ERROR: Monitor object NULL.\n");\
            return ERROR_MAIN_MONITOR_OBJECT_NULL;\
          }\
        }\
 
 
int moveAbsolutePosition(
  int    axisIndex,
  double positionSet,
  double velocitySet,
  double accelerationSet,
  double decelerationSet);
 
int moveRelativePosition(
  int    axisIndex,
  double positionSet,
  double velocitySet,
  double accelerationSet,
  double decelerationSet);
 
int moveVelocity(int    axisIndex,
                 double velocitySet,
                 double accelerationSet,
                 double decelerationSet);
 
int stopMotion(int axisIndex,
               int killAmplifier);
 
int moveHome(int    axisIndex,
             int    nCmdData,
             double homePositionSet,
             double velocityTowardsCamSet,
             double velocityOffCamSet,
             double accelerationSet,
             double decelerationSet);
 
int setPosition(int    axisIndex,
                double homePositionSet);
 
int getAxisError(int axisIndex);
 
int getAxisErrorID(int axisIndex);
 
int getAxisCycleCounter(int  axisIndex,
                        int *counter);
 
int getAxisDebugInfoData(int   axisIndex,
                         char *buffer,
                         int   bufferByteSize);
 
int getAxisStatusStructV2(int   axisIndex,
                          char *buffer,
                          int   bufferByteSize);
 
int getAxisExecute(int  axisIndex,
                   int *value);
 
int getAxisCommand(int  axisIndex,
                   int *value);
 
int getAxisCmdData(int  axisIndex,
                   int *value);
 
int getAxisReset(int  axisIndex,
                 int *value);
 
int getAxisEnabled(int  axisIndex,
                   int *value);
 
int getAxisEnable(int  axisIndex,
                  int *value);
 
int getAxisBlockCom(int  axisIndex,
                    int *block);
 
int getAxisBusy(int  axisIndex,
                int *value);
 
int getAxisEncVelo(int     axisIndex,
                   double *velo);
 
int getAxisTrajVelo(int     axisIndex,
                    double *velo);
 
int getAxisID(int  axisIndex,
              int *value);
 
int getAxisEnableAlarmAtHardLimits(int  axisIndex,
                                   int *value);
 
int getAxisSoftLimitPosBwd(int     axisIndex,
                           double *value);
 
int getAxisSoftLimitPosFwd(int     axisIndex,
                           double *value);
 
int getAxisEnableSoftLimitBwd(int  axisIndex,
                              int *value);
 
int getAxisEnableSoftLimitFwd(int  axisIndex,
                              int *value);
 
int getAxisAcceleration(int     axisIndex,
                        double *value);
 
int getAxisDeceleration(int     axisIndex,
                        double *value);
 
int getAxisTargetPos(int     axisIndex,
                     double *value);
 
int getAxisTargetVel(int     axisIndex,
                     double *value);
 
int getAxisDone(int  axisIndex,
                int *value);
 
int getAxisAtHardFwd(int  axisIndex,
                     int *value);
 
int getAxisLimitSwitchFwd(int  axisIndex,
                          int *value);
 
int getAxisAtHardBwd(int  axisIndex,
                     int *value);
 
int getAxisLimitSwitchBwd(int  axisIndex,
                          int *value);
 
int getAxisEncHomed(int  axisIndex,
                    int *value);
 
int getAxisEncPosAct(int     axisIndex,
                     double *value);
 
int getAxisEncVelAct(int     axisIndex,
                     double *value);
 
int getAxisAtHome(int  axisIndex,
                  int *value);
 
int getAxisCntrlError(int     axisIndex,
                      double *value);
 
int getAxisHomeVelOffCam(int     axisIndex,
                         double *value);
 
int getAxisHomeVelTowardsCam(int     axisIndex,
                             double *value);
 
int getAxisEncScaleNum(int     axisIndex,
                       double *value);
 
int getAxisEncScaleDenom(int     axisIndex,
                         double *value);
 
int getAxisEncPosRaw(int      axisIndex,
                     int64_t *value);
 
int getAxisCntrlOutPpart(int     axisIndex,
                         double *value);
 
int getAxisCntrlOutIpart(int     axisIndex,
                         double *value);
 
int getAxisCntrlOutDpart(int     axisIndex,
                         double *value);
 
int getAxisCntrlOutFFpart(int     axisIndex,
                          double *value);
 
int getAxisCntrlOutput(int     axisIndex,
                       double *value);
 
// int getAxisCntrlVelSet(int axisIndex,double *value);
// int getAxisCntrlRate(int axisIndex,double *value);
 
int getAxisDrvScale(int     axisIndex,
                    double *value);
 
int getAxisDrvEnable(int  axisIndex,
                     int *value);
 
int getAxisMonAtTarget(int  axisIndex,
                       int *value);
 
int getAxisType(int  axisIndex,
                int *value);
 
const char* getAxisTrajTransExpr(int  axisIndex,
                                 int *error);
 
const char* getAxisEncTransExpr(int  axisIndex,
                                int *error);
 
const char* getAxisPLCExpr(int  axisIndex,
                           int *error);
 
int getAxisTrajSource(int  axisIndex,
                      int *value);
 
int getAxisEncSource(int  axisIndex,
                     int *value);
 
int getAxisAllowCommandsFromPLC(int  axisIndex,
                                int *value);
 
int getAxisPLCEnable(int  axisIndex,
                     int *value);
 
int setAxisExecute(int axisIndex,
                   int value);
 
int setAxisCommand(int axisIndex,
                   int value);
 
int setAxisCmdData(int axisIndex,
                   int value);
 
int setAxisEnable(int axisIndex,
                  int value);
 
int setAxisEnableMotionFunctions(int axisIndex,
                                 int enablePos,
                                 int enableConstVel,
                                 int enableHome);
 
int setAxisEnableAlarmAtHardLimits(int axisIndex,
                                   int value);
 
int setAxisBlockCom(int axisIndex,
                    int block);
 
int setAxisEnableSoftLimitBwd(int axisIndex,
                              int value);
 
int setAxisEnableSoftLimitFwd(int axisIndex,
                              int value);
 
int setAxisSoftLimitPosBwd(int    axisIndex,
                           double value);
 
int setAxisSoftLimitPosFwd(int    axisIndex,
                           double value);
 
int setAxisEnableAlarmAtSoftLimit(int axisIndex,
                                  int value);
 
int setAxisAcceleration(int    axisIndex,
                        double value);
 
int setAxisDeceleration(int    axisIndex,
                        double value);
 
int setAxisEmergDeceleration(int    axisIndex,
                             double value);
 
int setAxisJerk(int    axisIndex,
                double value);
 
int setAxisTargetPos(int    axisIndex,
                     double value);
 
int setAxisTargetVel(int    axisIndex,
                     double value);
 
int setAxisJogVel(int    axisIndex,
                  double value);
 
 
int setAxisExtSetPos(int    axisIndex,
                     double value);
 
int setAxisEncScaleDenom(int    axisIndex,
                         double value);
 
int setAxisEncScaleNum(int    axisIndex,
                       double value);
 
int setAxisEncInvHwReady(int axisIndex,
                         int invert);
 
int setAxisHomePos(int    axisIndex,
                   double value);
 
int setAxisErrorId(int axisIndex,
                   int errorId);
 
int setAxisEncHomeLatchCountOffset(int axisIndex,
                                   int count);
 
int setAxisHomeVelTowardsCam(int    axisIndex,
                             double dVel);
 
int setAxisHomeVelOffCam(int    axisIndex,
                         double dVel);
 
/*int setAxisGearRatio(int    axisIndex,
                     double ratioNum,
                     double ratioDenom);*/
 
int axisErrorReset(int axisIndex,
                   int value);
 
int setAxisPLCTrajVelFilterEnable(int axisIndex,
                                  int enable);
 
int setAxisPLCTrajVelFilterSize(int axisIndex,
                                int size);
 
int setAxisPLCEncVelFilterEnable(int axisIndex,
                                 int enable);
 
int setAxisPLCEncVelFilterSize(int axisIndex,
                               int size);
 
int setAxisEncVelFilterSize(int axisIndex,
                            int size);
 
 
int setAxisEncPosFilterSize(int axisIndex,
                            int size);
 
int setAxisEncPosFilterEnable(int axisIndex,
                              int enable);
 
int setAxisTrajSource(int axisIndex,
                      int value);
 
int setAxisEncSource(int axisIndex,
                     int value);
 
int setAxisTrajStartPos(int    axisIndex,
                        double value);
 
int setAxisEncOffset(int    axisIndex,
                     double value);
 
int setAxisEncType(int axisIndex,
                   int value);
 
int setAxisEncBits(int axisIndex,
                   int bits);
 
int setAxisEncAbsBits(int axisIndex,
                      int bits);
 
int setAxisEncRawMask(int      axisIndex,
                      uint64_t rawMask);
 
int addAxisEnc(int axisIndex);
 
int selectAxisEncPrimary(int axisIndex,
                         int index);
 
int selectAxisEncConfig(int axisIndex,
                        int index);
 
int setAxisEncEnableRefAtHome(int axisIndex,
                              int enable);
 
int getAxisEncPrimaryIndex(int  axisIndex,
                           int *index);
 
int getAxisEncConfigIndex(int  axisIndex,
                          int *index);
 
int setAxisEncRefToOtherEncAtStartup(int axisIndex,
                                     int encRef);
 
int setAxisEncMaxDiffToPrimEnc(int    axisIndex,
                               double value);
 
int setAxisCntrlKp(int    axisIndex,
                   double value);
 
int setAxisCntrlKi(int    axisIndex,
                   double value);
 
int setAxisCntrlKd(int    axisIndex,
                   double value);
 
int setAxisCntrlKff(int    axisIndex,
                    double value);
 
int setAxisCntrlDeadband(int    axisIndex,
                         double value);
 
int setAxisCntrlDeadbandTime(int axisIndex,
                             int value);
 
int setAxisCntrlInnerParams(int    axisIndex,
                            double kp,
                            double ki,
                            double kd,
                            double tol);
 
int setAxisCntrlOutHL(int    axisIndex,
                      double value);
 
int setAxisCntrlOutLL(int    axisIndex,
                      double value);
 
int setAxisCntrlIpartLL(int    axisIndex,
                        double value);
 
int setAxisCntrlIpartHL(int    axisIndex,
                        double value);
 
int getAxisDrvScaleNum(int     axisIndex,
                       double *value);
 
int setAxisDrvScaleNum(int    axisIndex,
                       double value);
 
int setAxisDrvScaleDenom(int    axisIndex,
                         double value);
 
 
int setAxisDrvVelSetOffsetRaw(int    axisIndex,
                              double value);
 
int setAxisDrvBrakeEnable(int axisIndex,
                          int enable);
 
int setAxisDrvBrakeOpenDelayTime(int axisIndex,
                                 int delayTime);
 
int setAxisDrvBrakeCloseAheadTime(int axisIndex,
                                  int aheadTime);
 
int setAxisDrvStateMachineTimeout(int    axisIndex,
                                  double seconds);
 
int setAxisDrvReduceTorqueEnable(int axisIndex,
                                 int enable);
 
/*int setAxisDrvType(int axisIndex,
                   int type);*/
 
int getAxisMonAtTargetTol(int     axisIndex,
                          double *value);
 
int setAxisMonAtTargetTol(int    axisIndex,
                          double value);
 
int setAxisEnableCheckEncsDiff(int axisIndex,
                               int enable);
 
int getAxisMonAtTargetTime(int  axisIndex,
                           int *value);
 
int setAxisMonAtTargetTime(int axisIndex,
                           int value);
 
int getAxisMonEnableAtTargetMon(int  axisIndex,
                                int *value);
 
int setAxisMonEnableAtTargetMon(int axisIndex,
                                int value);
 
int getAxisMonPosLagTol(int     axisIndex,
                        double *value);
 
int setAxisMonPosLagTol(int    axisIndex,
                        double value);
 
int getAxisMonPosLagTime(int  axisIndex,
                         int *value);
 
int setAxisMonPosLagTime(int axisIndex,
                         int value);
 
int getAxisMonEnableLagMon(int  axisIndex,
                           int *value);
 
int setAxisMonEnableLagMon(int axisIndex,
                           int value);
 
int getAxisMonMaxVel(int     axisIndex,
                     double *value);
 
int setAxisMonMaxVel(int    axisIndex,
                     double value);
 
int setAxisMonEnableMaxVel(int axisIndex,
                           int value);
 
int getAxisMonEnableMaxVel(int  axisIndex,
                           int *value);
 
int setAxisMonMaxVelDriveILDelay(int axisIndex,
                                 int value);
 
int setAxisMonMaxVelTrajILDelay(int axisIndex,
                                int value);
 
int getAxisMonLatchLimit(int  axisIndex,
                         int *value);
 
int setAxisMonLatchLimit(int axisIndex,
                         int value);
 
int setAxisSeqTimeout(int axisIndex,
                      int value);
 
int setAxisHomeSeqId(int axisIndex,
                     int value);
 
int setAxisHomeAcc(int    axisIndex,
                   double acc);
 
int setAxisHomeDec(int    axisIndex,
                   double acc);
 
int setAxisHomePostMoveEnable(int axisIndex,
                              int enable);
 
int setAxisHomePostMoveTargetPosition(int    axisIndex,
                                      double targetPosition);
 
int setAxisMonEnableCntrlOutHLMon(int axisIndex,
                                  int value);
 
int setAxisMonCntrlOutHL(int    axisIndex,
                         double value);
 
int setAxisMonEnableVelocityDiff(int axisIndex,
                                 int value);
 
int setAxisMonVelDiffTrajILDelay(int axisIndex,
                                 int value);
 
int setAxisMonVelDiffDriveILDelay(int axisIndex,
                                  int value);
 
int setAxisMonVelDiffTol(int    axisIndex,
                         double value);
 
int setAxisMonEnableExternalInterlock(int axisIndex,
                                      int value);
 
int setAxisMonEnableAnalogInterlock(int axisIndex,
                                    int value);
 
int setAxisMonExtHWInterlockPolarity(int axisIndex,
                                     int value);
 
int setAxisMonAnalogInterlockPolarity(int axisIndex,
                                      int value);
 
int setAxisMonAnalogInterlockRawLimit(int    axisIndex,
                                      double value);
 
int getAxisMonExtHWInterlockPolarity(int  axisIndex,
                                     int *pol);
 
int setAxisMonLimitBwdPolarity(int axisIndex,
                               int value);
 
int getAxisMonLimitBwdPolarity(int  axisIndex,
                               int *pol);
 
int setAxisMonLimitFwdPolarity(int axisIndex,
                               int value);
 
int getAxisMonLimitFwdPolarity(int  axisIndex,
                               int *pol);
 
int setAxisMonHomeSwitchPolarity(int axisIndex,
                                 int value);
 
int getAxisMonHomeSwitchPolarity(int  axisIndex,
                                 int *pol);
 
int setAxisAllowCommandsFromPLC(int axisIndex,
                                int value);
 
int setAxisPLCEnable(int axisIndex,
                     int value);
 
int appendAxisPLCExpr(int   axisIndex,
                      char *expr);
 
int compileAxisPLCExpr(int axisIndex);
 
int createAxis(int axisIndex,
               int axisType,
               int drvType,
               int trajType);
 
int linkEcEntryToAxisEnc(int   slaveBusPosition,
                         char *entryIdString,
                         int   axisIndex,
                         int   encoderEntryIndex,
                         int   entryBitIndex);
 
int linkEcEntryToAxisDrv(int   slaveBusPosition,
                         char *entryIdString,
                         int   axisIndex,
                         int   driveEntryIndex,
                         int   entryBitIndex);
 
int linkEcEntryToAxisMon(int   slaveBusPosition,
                         char *entryIdString,
                         int   axisIndex,
                         int   monitorEntryIndex,
                         int   entryBitIndex);
 
int linkEcEntryToAxisStatusOutput(int   slaveIndex,
                                  char *entryIDString,
                                  int   axisIndex);
 
int linkEcEntryToAxisSeqAutoModeSet(int   slaveIndex,
                                    char *entryIDString,
                                    int   axisIndex);
 
int linkEcEntryToAxisSeqAutoModeAct(int   slaveIndex,
                                    char *entryIDString,
                                    int   axisIndex);
 
int setAxisAutoModeCmdHoming(int axisIndex,
                             int cmd);
 
 
int setAxisAutoModeCmdMotion(int axisIndex,
                             int cmd);
 
int setDiagAxisIndex(int axisIndex);
 
int setDiagAxisFreq(int freq);
 
int setDiagAxisEnable(int enable);
 
int getAxisModRange(int     axisIndex,
                    double *range);
 
int setAxisModRange(int    axisIndex,
                    double range);
 
int setAxisModType(int axisIndex,
                   int type);
 
int getAxisModType(int  axisIndex,
                   int *value);
 
int setAxisDisableAtErrorReset(int axisIndex,
                               int disable);
 
int setAxisAllowSourceChangeWhenEnabled(int axisIndex,
                                        int allow);
 
int getAxisValid(int axisIndex);
 
int setAxisEmergencyStopInterlock(int axisIndex,
                                  int stop);
 
# ifdef __cplusplus
}
# endif  // ifdef __cplusplus
 
#endif  /* ECMC_MOTION_H_ */