---

acm.h

Go to the documentation of this file.

#ifndef ACM_H
#define ACM_H
/*******************************************************************************
* E.S.O. - VLT project
*
* "@(#) $Id: acm.h,v 2.3 2002/03/27 17:24:05 vltsccm Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* ssandroc 2001-09-20 SPR 20010245 + 20010393 + 20010550.
* ssandroc 1999-05-05 added acmHW_WRITE_TORQUE acmHW_READ_SPEEDREF.
* ssandroc 1999-02-13 added acmHW_WRITE_TACHO for tacho signal output support.
* bgilli    05/04/98  added pathOptimisation flag in acmAXIS_SEND_POS_REFS proto.
* rkarban  11/08/97  add acmACTION_STAR_OFFS
* bgilli    16/04/97  added handling of UPDATE_POS_LIMS
* bgustafs  01/04/97  added acmHW_REF_MOVE
* mchiesa  22/12/96  added axisServoStateSpeedPos to acmAXIS_SERVO_STATE
* mchiesa  22/12/96  added calibration status to acmENC_INIT type
* mchiesa   24/10/96  added delay as IN parameter to acmHW_SET_TIMER_P
* awalland  17/10/96  include semLib.h (definition of SEM_ID)
* mchiesa   08/10/96  added tracking flag in acmENC_READ
* mchiesa   08/10/96  added acmHW_SET_TIMER_P to functions provided by HW
* mchiesa   08/10/96  added acmENC_CALC_OFFSETS_P function type from ikenc
* tphan     22/08/96  Compilation error !!!
*         acmHW_CYCLIC_VELERROR changed to acmHW_CYCLIC_VELERR
* bgustafs  20/05/96  modified signal name type
* nfiebig   05/05/95  created
* mchiesa   07/03/96  changed due to desing change of altaz
*/

/************************************************************************
 *
 *----------------------------------------------------------------------
 */

/************************************************************************
 * Contains the public global data and data type definitions of the
 * acm module.
 *----------------------------------------------------------------------
 */


/*
 *******************************************************************************
 * Header Files
 *******************************************************************************
 */
 
/* System Includes */

#include "semLib.h"

/* LCC Includes */

#include "ccs.h"
#include "err.h"
#include "io.h"

/* Local Includes */


/*
 ******************************************************************************
 * Constants and Literals
 ******************************************************************************
 */
 
#define acmMAX_FILE_NAME_LENGTH 256
#define acmMAX_NUM_SIGNALS 256

 /* acmSTATE */
#define   acmSTATE_UNDEFINED  0
#define   acmSTATE_IDLE       1
#define   acmSTATE_PRESETTING 2
#define   acmSTATE_TRACKING   3

    
 /* acmAXIS */
#define    acmAXIS_ALT_STR "altitude"
#define    acmAXIS_AZ_STR  "azimuth"
#define    acmAXIS_ROT_STR "rotator"
#define    acmAXIS_AD_STR  "adapter"

#define    acmAXIS_ALT  1
#define    acmAXIS_AZ   2
#define    acmAXIS_ROT  3
#define    acmAXIS_AD   4

 /* acmACTION */    
#define     acmACTION_NONE      1
#define     acmACTION_STAR      2 
#define     acmACTION_FIXED     3
#define     acmACTION_UPDATE    4
#define     acmACTION_STAR_OFFS 5
#define     acmACTION_AGC       6

#define     acmACTION_NONE_STR      "acmACTION_NONE"
#define     acmACTION_STAR_STR      "acmACTION_STAR"
#define     acmACTION_FIXED_STR     "acmACTION_FIXED"
#define     acmACTION_UPDATE_STR    "acmACTION_UPDATE"
#define     acmACTION_STAR_OFFS_STR "acmACTION_STAR_OFFS"
#define     acmACTION_AGC_STR       "acmACTION_AGC"

 

/*
 ******************************************************************************
 * Data Types
 ******************************************************************************
 */


/*
 ******************************************************************************
 * Interface for trk module (callable interface of ACM: ACM consists of all
 * three modules: AXIS + one HW + one ENC module
 ******************************************************************************
 */

/*
 * acmSEND_REFS
 */
typedef struct
    {
    vltDOUBLE  posAlt;  /* position altitude */
    vltDOUBLE  posAz; /* position azimuth */
    vltDOUBLE  posRot;  /* position rotator */
    vltDOUBLE  posAdap; /* position adapter */
    vltDOUBLE  parallacticAngle;
    vltDOUBLE  vffAlt;  /* velocity feed-forward altitude */
    vltDOUBLE  vffAz; /* velocity feed-forward azimuth */
    vltDOUBLE  vffRot;  /* velocity feed-forward rotator */
    vltDOUBLE  agcAlt;  /* auto-guiding correction altitude */
    vltDOUBLE  agcAz; /* auto-guiding correction azimuth */
    vltDOUBLE  agcRot;  /* auto-guiding correction rotator */
    } acmSEND_REFS_SET_POINTS;
 

typedef ccsCOMPL_STAT  (acmSEND_REFS) (vltINT32   action,    /* acmACTION */
               ccsTIMEVAL timeStamp,
               acmSEND_REFS_SET_POINTS
                          setPoints,
               vltINT32  *state,     /* acmSTATE  */
               ccsERROR  *error);


typedef acmSEND_REFS *acmSEND_REFS_P;

acmSEND_REFS acmSendRefs;


/*
 * acmREAD_POS
 */
typedef struct
{
    vltDOUBLE  posAlt;  /* encoder position altitude */
    vltDOUBLE  posAz; /* encoder position azimuth */
    vltDOUBLE  posRot;  /* encoder position rotator */
} acmREAD_POS_DATA;

typedef ccsCOMPL_STAT (acmREAD_POS) (acmREAD_POS_DATA *acmReadPosData,
             ccsERROR  *error);

typedef acmREAD_POS *acmREAD_POS_P;


/*
 * acmREM_TRACK_F
 */

typedef vltDOUBLE (acmREM_TRACK_F) (
                vltDOUBLE  ra,
                vltDOUBLE  decl,
                vltDOUBLE  limLow,
                vltDOUBLE  limHigh,
                vltDOUBLE  siderealTime,
                vltDOUBLE  lat,
                vltDOUBLE *remTime,
                ccsERROR  *error);

typedef acmREM_TRACK_F *acmREM_TRACK_F_P;
    



/*
 ******************************************************************************
 * Interface for AXIS module
 ******************************************************************************
 */

typedef struct
    {
    vltINT32   action;    /* acmACTION */
    ccsTIMEVAL timeStamp; /* absolute time */
    vltDOUBLE  pos;   /* position */
    vltDOUBLE  vff;   /* velocity feed-forward */
    vltDOUBLE  agc;   /* auto-guiding correction */
    } acmAXIS_REF;

typedef ccsCOMPL_STAT (acmAXIS_SEND_POS_REFS) 
      (acmAXIS_REF ref,
       vltLOGICAL pathOptimisation,
       char   *axisName,  /* only required if multiple instances of
         * axis, must match with axisName passed
         * axisInitAll(). If not required NULL.
         */
       vltINT32   *state, /*acmSTATE*/
       ccsERROR   *error);

typedef acmAXIS_SEND_POS_REFS *acmAXIS_SEND_POS_REFS_P;


typedef enum 
    {
    axisServoStateUndef,
    axisServoStateStartup,
    axisServoStateHwOff,
    axisServoStateHwSwitchingOn,
    axisServoStateSpeedNoMoveWithEnc,
    axisServoStateSpeedNoMoveNoEnc,
    axisServoStateDeceleratingWithEnc,
    axisServoStateDeceleratingNoEnc,
    axisServoStateSpeedWithEnc,
    axisServoStateSpeedNoEnc,
    axisServoStatePos,
    axisServoStatePosPreset,
    axisServoStatePosFixed,
    axisServoStatePosExtrapol,
    axisServoStateSpeedPos
    } acmAXIS_SERVO_STATE;

typedef ccsCOMPL_STAT (acmAXIS_CHECK_STOP_COND)
    (
    void       *encData,
    vltLOGICAL *stop,
    vltINT32   delayTimeInMicroSec,
    ccsERROR   *error
    );
typedef acmAXIS_CHECK_STOP_COND *acmAXIS_CHECK_STOP_COND_P;


typedef void (acmTIMER_IR)
    (
    SEM_ID   *timerSem,
    vltINT32  dummy
    );
typedef acmTIMER_IR *acmTIMER_IR_P;


typedef ccsCOMPL_STAT (acmAXIS_UPDATE_VEL_REF)
    (
    void       *encData,
    vltDOUBLE  *velocity,    
    vltINT32   delayTimeInMicroSec,
    ccsERROR   *error
    );
typedef acmAXIS_UPDATE_VEL_REF *acmAXIS_UPDATE_VEL_REF_P;

typedef ccsCOMPL_STAT (acmAXIS_PRESET_POS) 
    (vltDOUBLE       pos,
     vltUINT32       timeoutInMilliSec, /* max time till 
                 * stopFunction returns
                 * with stop == TRUE */
     acmAXIS_CHECK_STOP_COND_P   stopFunction,
     acmAXIS_SERVO_STATE  *axisState,
     ccsERROR     *error);

typedef acmAXIS_PRESET_POS *acmAXIS_PRESET_POS_P;

typedef ccsCOMPL_STAT (acmAXIS_SEND_VEL_REF) 
    (vltDOUBLE       velocity,
     vltUINT32       timeoutInMilliSec, /* max time till 
                 * stopFunction returns
                 * with stop == TRUE */
     acmAXIS_CHECK_STOP_COND_P   stopFunction,
     acmAXIS_UPDATE_VEL_REF_P    updateVelRefFunction,
     acmAXIS_SERVO_STATE  *axisState,
     ccsERROR     *error);

typedef acmAXIS_SEND_VEL_REF *acmAXIS_SEND_VEL_REF_P;

typedef ccsCOMPL_STAT (acmAXIS_GET_STATE) 
    (acmAXIS_SERVO_STATE  *axisState,
     ccsERROR     *error);

typedef acmAXIS_GET_STATE *acmAXIS_GET_STATE_P;

typedef ccsCOMPL_STAT (acmAXIS_UPDATE_POS_LIMS) 
     (vltDOUBLE                 posLimits[],
     ccsERROR     *error);

typedef acmAXIS_UPDATE_POS_LIMS *acmAXIS_UPDATE_POS_LIMS_P;

typedef struct
    {
    char         acmAxisDigitalFileName[acmMAX_FILE_NAME_LENGTH];
    char         acmAxisAnalogFileName[acmMAX_FILE_NAME_LENGTH];
    ioDIRADDRESS *acmAxisSignal; /* signal direct address array*/
    vltINT32     acmAxisSignalNumber;    /* number of signals */
    vltBYTES32   acmAxisSignalNames[acmMAX_NUM_SIGNALS]; /* name of signals */
    }acmAXIS_SIGNAL_CONF;

typedef acmAXIS_SIGNAL_CONF *acmAXIS_SIGNAL_CONF_P;


/*
 ******************************************************************************
 * Interface for HW dependant module
 * (vlt)altaz, nttaltaz, nttrot, (vlt)rot [(vlt)ad]
 ******************************************************************************
 */



typedef ccsCOMPL_STAT (acmHW_HW_ON) 
    (
    void       *hwData,
    ccsERROR   *error
    );

typedef acmHW_HW_ON *acmHW_HW_ON_P; 

typedef ccsCOMPL_STAT (acmHW_HW_OFF)
    (
    void      *hwData,
    ccsERROR  *error
    );
typedef acmHW_HW_OFF *acmHW_HW_OFF_P;

typedef ccsCOMPL_STAT (acmHW_READ_SPEEDREF)
    (
    void       *hwData,
    vltLOGICAL *enable,
    vltDOUBLE  *speed,
    ccsERROR   *error
    );
typedef acmHW_READ_SPEEDREF *acmHW_READ_SPEEDREF_P;

typedef ccsCOMPL_STAT (acmHW_WRITE_SPEED)
    (
    void      *hwData,
    vltDOUBLE speed,
    vltDOUBLE *voltageWritten,
    ccsERROR  *error
    );

typedef acmHW_WRITE_SPEED *acmHW_WRITE_SPEED_P;

typedef ccsCOMPL_STAT (acmHW_READ_TACHO)
    (
    void       *hwData,
    vltDOUBLE  *voltage,
    ccsERROR   *error
    );

typedef acmHW_READ_TACHO *acmHW_READ_TACHO_P;

typedef ccsCOMPL_STAT (acmHW_WRITE_TACHO)
    (
    void      *hwData,
    vltLOGICAL valid,
    vltDOUBLE speed,
    vltDOUBLE *voltageWritten,
    ccsERROR  *error
    );

typedef acmHW_WRITE_TACHO *acmHW_WRITE_TACHO_P;

typedef ccsCOMPL_STAT (acmHW_WRITE_TORQUE)
    (
    void      *hwData,
    vltDOUBLE position,
    vltDOUBLE velocity,
    vltDOUBLE torque,
    vltDOUBLE *voltageWritten,
    ccsERROR  *error
    );

typedef acmHW_WRITE_TORQUE *acmHW_WRITE_TORQUE_P;

typedef ccsCOMPL_STAT (acmHW_CHECK_INTERLOCK)
    (
    void       *hwData,
    vltLOGICAL *active,    
    ccsERROR   *error
    );
typedef acmHW_CHECK_INTERLOCK *acmHW_CHECK_INTERLOCK_P;

typedef ccsCOMPL_STAT (acmHW_CHECK_VICINITY_LIMIT)
    (
    void       *hwData,
    vltLOGICAL *upActive,    
    vltLOGICAL *lowActive,    
    ccsERROR   *error
    );

typedef acmHW_CHECK_VICINITY_LIMIT *acmHW_CHECK_VICINITY_LIMIT_P;

typedef struct
    {
    vltLOGICAL  valid;
    vltDOUBLE   velError;
    } acmHW_CYCLIC_VELERR;

typedef ccsCOMPL_STAT (acmHW_CYCLIC)
    (
    void      *hwData,
    vltINT32   delayInMicroSecs,  /* delay time in microseconds */
    vltLOGICAL posAvailable,    /* position is valid */
    vltDOUBLE  pos,     /* position in rad */
    acmHW_CYCLIC_VELERR *velErr,        /* velocity error */
    ccsERROR  *error
    );

typedef acmHW_CYCLIC *acmHW_CYCLIC_P;



typedef ccsCOMPL_STAT (acmHW_SET_TIMER)
    (
    void    *hwData,
    acmTIMER_IR_P IrRoutine,
    SEM_ID    *timerSem,
    vltUINT32   delay,  /* delay in microsec */
    ccsERROR    *error
    );

typedef acmHW_SET_TIMER *acmHW_SET_TIMER_P;


typedef ccsCOMPL_STAT (acmHW_INIT)
    (
    void       *hwData,
    ccsERROR   *error
    );

typedef acmHW_INIT *acmHW_INIT_P;

typedef ccsCOMPL_STAT (acmHW_EXIT)
    (
    void       *hwData,
    ccsERROR   *error
    );

typedef acmHW_EXIT *acmHW_EXIT_P;

typedef ccsCOMPL_STAT (acmHW_OFF)
    (
    void       *hwData,
    ccsERROR   *error
    );

typedef acmHW_OFF *acmHW_OFF_P;

typedef ccsCOMPL_STAT (acmHW_REF_MOVE)
    (
    void       *hwData,
    acmAXIS_SEND_VEL_REF_P cbAxisSendVelRefP,
    acmAXIS_GET_STATE_P    cbAxisGetStateP,
    ccsERROR   *error
    );

typedef acmHW_REF_MOVE *acmHW_REF_MOVE_P;

typedef ccsCOMPL_STAT (acmHW_VERSION)
    (
    char      *buffer,
    ccsERROR  *error
    );

typedef acmHW_VERSION *acmHW_VERSION_P;

typedef ccsCOMPL_STAT (acmHW_UPDATE)
    (
    void      *hwData,
    ccsERROR  *error
    );

typedef acmHW_UPDATE *acmHW_UPDATE_P;

typedef struct
    {
    void      *hwData;
    /* 
     * called by servo task, these functions are not allowed to have
     * calls to taskDelays
     */
    acmHW_HW_OFF_P     hwHwOffP;       
    acmHW_READ_SPEEDREF_P  hwReadSpeedrefP;
    acmHW_READ_TACHO_P     hwReadTachoP;
    acmHW_WRITE_SPEED_P    hwWriteSpeedP;
    acmHW_WRITE_TACHO_P    hwWriteTachoP;
    acmHW_WRITE_TORQUE_P   hwWriteTorqueP;
    acmHW_CHECK_INTERLOCK_P      hwCheckInterlockP;
    acmHW_CHECK_VICINITY_LIMIT_P hwCheckVicinityLimitP; 
    acmHW_CYCLIC_P     hwCyclicP;   /* optional (NULL) */
    acmHW_SET_TIMER_P            hwSetTimerP; /* optional (NULL) */
  /* if not NULL axisServoTask 
   * uses this function to hook
   * to a time. In this case either
   * the IR routine or the sem must
   * be given every 2 ms
   */
    /* 
     * called by std commands: these funtions may include taskDelays
     */
    acmHW_VERSION_P    hwVersionP;
    acmHW_HW_ON_P    hwHwOnP;
    acmHW_INIT_P     hwInitP;
    acmHW_EXIT_P     hwExitP;
    acmHW_OFF_P      hwOffP;
    acmHW_REF_MOVE_P             hwRefMoveP;
    acmHW_UPDATE_P     hwUpdateP;
    }acmHW;

typedef acmHW *acmHW_P;


/* Entry point */
typedef ccsCOMPL_STAT (acmHW_INIT_ALL)
    (
    char         *dbRoot,
    acmAXIS_SEND_POS_REFS_P   cbAxisSendRefsP,
    acmHW_P                  acmHw,
    acmAXIS_SIGNAL_CONF_P    acmHwSignalConf,
    ccsERROR                 *error
    );

typedef acmHW_INIT_ALL *acmHW_INIT_ALL_P;

/*
 ******************************************************************************
 * Interface for ENC dependant module
 * IKEnc, ODEnc
 ******************************************************************************
 */
typedef ccsCOMPL_STAT (acmENC_VERSION)
    (
    char      *buffer,
    ccsERROR  *error
    );

typedef acmENC_VERSION *acmENC_VERSION_P; 

typedef ccsCOMPL_STAT (acmENC_READ)
    (
    void      *encData,
    vltDOUBLE *positionInRad,
    vltLOGICAL tracking,  /* writes ccsTRUE if servo is in tracking
         * else ccsFALSE
         */
    ccsERROR  *error
    );

typedef acmENC_READ *acmENC_READ_P; 


/* NTT modes */
#define acmENC_CALIB_STD "STANDARD"
#define acmENC_CALIB_MECH_ALIGN "MECHALIGN"
#define acmENC_CALIB_VER_EXT "VERIFYEXT"
#define acmENC_CALIB_MIRRORS "MIRRORS"
#define acmENC_CALIB_ABSREF "ABSREF"
#define acmENC_CALIB_HEAD_1 "HEAD_1"
#define acmENC_CALIB_HEAD_2 "HEAD_2"
#define acmENC_CALIB_HEAD_3 "HEAD_3"
#define acmENC_CALIB_HEAD_4 "HEAD_4"

/* VLT modes */
#define acmENC_CALIB_MODE_2a "2a"
#define acmENC_CALIB_MODE_2b "2b"
#define acmENC_CALIB_MODE_2c "2c"
#define acmENC_CALIB_MODE_2d "2d"
#define acmENC_CALIB_MODE_4a "4a"
#define acmENC_CALIB_MODE_4b "4b"

typedef enum
    {
    /* NTT modes */
    acmEncCalibModeStandard,
    acmEncCalibModeMechAlign,
    acmEncCalibModeVerifyExt,
    acmEncCalibModeMirrors,
    acmEncCalibModeAbsRef,
    acmEncCalibModeHead1,
    acmEncCalibModeHead2,
    acmEncCalibModeHead3,
    acmEncCalibModeHead4,

    /* VLT modes */
    acmEncCalibMode2a,
    acmEncCalibMode2b,
    acmEncCalibMode2c,
    acmEncCalibMode2d,
    acmEncCalibMode4a,
    acmEncCalibMode4b

    }acmENC_CALIB_MODE;

typedef ccsCOMPL_STAT (acmENC_CALIB)
    (
    void              *encData,
    acmENC_CALIB_MODE  calibMode,
    ccsERROR          *error
    );

typedef acmENC_CALIB *acmENC_CALIB_P; 


typedef ccsCOMPL_STAT (acmENC_STATUS)
    (
    void      *encData,
    char      *buffer,
    vltINT32  reportLevel,
    ccsERROR  *error
    );

typedef acmENC_STATUS *acmENC_STATUS_P; 


typedef ccsCOMPL_STAT (acmENC_INIT)
    (
    void       *encData,
    vltLOGICAL *calibrated,
    ccsERROR   *error
    );

typedef acmENC_INIT *acmENC_INIT_P;

typedef ccsCOMPL_STAT (acmENC_EXIT)
    (
    void       *encData,
    ccsERROR   *error
    );

typedef acmENC_EXIT *acmENC_EXIT_P;

typedef ccsCOMPL_STAT (acmENC_OFF)
    (
    void       *encData,
    ccsERROR   *error
    );

typedef acmENC_OFF *acmENC_OFF_P;

typedef ccsCOMPL_STAT (acmENC_UPDATE)
    (
    void       *encData,
    ccsERROR   *error
    );

typedef acmENC_UPDATE *acmENC_UPDATE_P;

typedef struct
    {
    void      *encData;
    /* 
     * called by servo task, these functions are not allowed to have
     * calls to taskDelays
     */
    acmENC_READ_P                encReadP;
    /* 
     * called by std commands: these funtions may include taskDelays
     */
    acmENC_VERSION_P             encVersionP;
    acmENC_CALIB_P     encCalibP;
    acmENC_STATUS_P    encStatusP;
    acmENC_INIT_P    encInitP; 
    acmENC_EXIT_P    encExitP; 
    acmENC_OFF_P     encOffP;
    acmENC_UPDATE_P    encUpdateP;
    }acmENC;

typedef acmENC *acmENC_P;

/* Entry point */
typedef ccsCOMPL_STAT (acmENC_INIT_ALL)
    (
    char         *dbRoot,
    acmAXIS_PRESET_POS_P      cbAxisPresetPosP,
    acmAXIS_SEND_VEL_REF_P    cbAxisSendVelRefP,
    acmAXIS_GET_STATE_P       cbAxisGetStateP,
    acmAXIS_UPDATE_POS_LIMS_P cbAxisUpdatePosLims,
    acmAXIS_SIGNAL_CONF_P     acmEncSignalConf,
    acmENC_P                  acmEnc,
    ccsERROR                 *error
    );

typedef acmENC_INIT_ALL *acmENC_INIT_ALL_P;
/*
 ******************************************************************************
 * Optional Interface between ENC and HW dependant module
 * lookup in symbol table with INIT command to ENC in database
 * the function can be provided by HW module 
 ******************************************************************************
 */

typedef ccsCOMPL_STAT (acmENC_CALC_OFFSETS)
    (void /* ikencDATA */ *ikencData,
     vltINT32 refMark,
     vltDOUBLE  b1h1Pos,
     vltDOUBLE  b1h2Pos,
     vltDOUBLE  b2h1Pos,
     vltDOUBLE  b2h2Pos,
     vltINT32 *b1h1Offset,
     vltINT32 *b1h2Offset,
     vltINT32 *b2h1Offset,
     vltINT32 *b2h2Offset,
     ccsERROR *error);
typedef acmENC_CALC_OFFSETS *acmENC_CALC_OFFSETS_P;

/*
 ******************************************************************************
 * callable interface for BOOT file of ACM module 
 * (ACM consists of all three modules: AXIS + one HW + one ENC module)
 ******************************************************************************
 */

/*
defined in AXIS module !

typedef ccsCOMPL_STAT  (axisINIT_ALL) (
  char      *dbRoot,
  char      *axisName,
  acmHW_INIT_ALL_P      acmHwInitModuleP,
  acmENC_INIT_ALL_P     acmEncInitModuleP);

axisINIT_ALL axisInitAll;
*/

#endif 

---