---

extstgmot.c

Go to the documentation of this file.

/*
  extstgmot.c

  Dispatcher of external motion functions for Servo To Go board.

  Modification history:

  20-Mar-2000 WPS added unused attribute to ident to avoid 'defined but not used' compiler warning.
  24-Jun-1999  FMP created from extshvmot.c and extmmmot.c, which were
  so similar that I decided to combine them and make them obsolete. Also
  added NO_LIMIT_SWITCH.
  */

#include "extintf.h"            /* these decls */
#include "stg.h"                /* decls for stg implementation */

/* ident tag */
#ifndef __GNUC__
#ifndef __attribute__
#define __attribute__(x)
#endif
#endif

static char __attribute__((unused))  ident[] = "$Id: extstgmot.c,v 1.3 2001/08/02 21:02:40 proctor Exp $";

/* Uncomment any of the following declarations to inhibit
   the use of home switches or index pulses when homing, or to
   ignore limit switches if you don't have them. */

/* Uncomment NO_HOME_SWITCH if you want homing sequence to
   ignore the home switch, and only use the index pulse for homing.
   This has the effect of making the home switches always appear tripped. */
/* #define NO_HOME_SWITCH */

/* Uncomment NO_INDEX_PULSE if you want homing sequence to
   ignore the index pulse, and only use the home switch for homing.
   This has the effect of making the index pulse always appear present. */
/* #define NO_INDEX_PULSE */

/* Uncomment NO_LIMIT_SWITCH if you don't have limit switches.
   This has the effect of making the positive and negative travel
   limit switches never appear tripped. */
/* #define NO_LIMIT_SWITCH */

int extMotInit(const char * stuff)
{
  return stgMotInit(stuff);
}

int extMotQuit(void)
{
  return stgMotQuit();
}

int extDacNum(void)
{
  return stgDacNum();
}

int extDacWrite(int dac, double volts)
{
  return stgDacWrite(dac, volts);
}

int extDacWriteAll(int max, double * volts)
{
  return stgDacWriteAll(max, volts);
}

int extEncoderSetIndexModel(unsigned int model)
{
  return stgEncoderSetIndexModel(model);
}

int extEncoderNum(void)
{
  return stgEncoderNum();
}

int extEncoderRead(int encoder, double * counts)
{
  return stgEncoderRead(encoder, counts);
}

int extEncoderReadAll(int max, double * counts)
{
  return stgEncoderReadAll(max, counts);
}

int extEncoderResetIndex(int encoder)
{
  return stgEncoderResetIndex(encoder);
}

int extEncoderReadLatch(int encoder, int * flag)
{
#ifdef NO_INDEX_PULSE
  *flag = 1;
  return 0;
#else
  return stgEncoderReadLatch(encoder, flag);
#endif
}

int extEncoderReadLevel(int encoder, int * flag)
{
  return stgEncoderReadLevel(encoder, flag);
}

int extMaxLimitSwitchRead(int axis, int * flag)
{
#ifdef NO_LIMIT_SWITCH
  *flag = 0;
  return 0;
#else
  return stgMaxLimitSwitchRead(axis, flag);
#endif
}

int extMinLimitSwitchRead(int axis, int * flag)
{
#ifdef NO_LIMIT_SWITCH
  *flag = 0;
  return 0;
#else
  return stgMinLimitSwitchRead(axis, flag);
#endif
}

int extHomeSwitchRead(int axis, int * flag)
{
#ifdef NO_HOME_SWITCH
  *flag = 1;
  return 0;
#else
  return stgHomeSwitchRead(axis, flag);
#endif
}

int extAmpEnable(int axis, int enable)
{
  return stgAmpEnable(axis, enable);
}

int extAmpFault(int axis, int * fault)
{
  return stgAmpFault(axis, fault);
}

int extDioInit(const char * stuff)
{
  return stgDioInit(stuff);
}

int extDioQuit(void)
{
  return stgDioQuit();
}

int extDioMaxInputs(void)
{
  return stgDioMaxInputs();
}

int extDioMaxOutputs(void)
{
  return stgDioMaxOutputs();
}

int extDioRead(int index, int *value)
{
  return stgDioRead(index, value);
}

int extDioWrite(int index, int value)
{
  return stgDioWrite(index, value);
}

int extDioCheck(int index, int *value)
{
  return stgDioCheck(index, value);
}

int extDioByteRead(int index, unsigned char *byte)
{
  return stgDioByteRead(index, byte);
}

int extDioShortRead(int index, unsigned short *sh)
{
  return stgDioShortRead(index, sh);
}

int extDioWordRead(int index, unsigned int *word)
{
  return stgDioWordRead(index, word);
}

int extDioByteWrite(int index, unsigned char byte)
{
  return stgDioByteWrite(index, byte);
}

int extDioShortWrite(int index, unsigned short sh)
{
  return stgDioShortWrite(index, sh);
}

int extDioWordWrite(int index, unsigned int word)
{
  return stgDioWordWrite(index, word);
}

int extDioByteCheck(int index, unsigned char *byte)
{
  return stgDioByteCheck(index, byte);
}

int extDioShortCheck(int index, unsigned short *sh)
{
  return stgDioShortCheck(index, sh);
}

int extDioWordCheck(int index, unsigned int *word)
{
  return stgDioWordCheck(index, word);
}

int extAioInit(const char * stuff)
{
  return stgAioInit(stuff);
}

int extAioQuit(void)
{
  return stgAioQuit();
}

int extAioMaxInputs(void)
{
  return stgAioMaxInputs();
}

int extAioMaxOutputs(void)
{
  return stgAioMaxOutputs();
}

int extAioStart(int index)
{
  return stgAioStart(index);
}

void extAioWait(void)
{
  stgAioWait();
}

int extAioRead(int index, double *volts)
{
  return stgAioRead(index, volts);
}

int extAioWrite(int index, double volts)
{
  return stgAioWrite(index, volts);
}

int extAioCheck(int index, double *volts)
{
  return stgAioCheck(index, volts);
}

---