---

extppmcmot.c

Go to the documentation of this file.

/***************************************************************************
                          extppmcmot.c  -  description
                             -------------------
    begin                : Mon Oct 23 2000
    copyright            : (C) 2000 by Eric Keller
    email                : eek105
 ***************************************************************************/

/*
  extppmcmot.c

  Dispatcher of external motion functions for PPMC boards.
  
  Modification history:

  2 oct 2000 eek.  Did a search&replace for stg replace with ppmc
  3 oct 2000 eek. split out the various functions to board level
  .c files as follows:
  ppmc_internal does init and low level functions
  ppmc_dac              dac board functions
  ppmc_dio              digital io board functions
  ppmc_encoder  encoder board 


  */

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

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

static char __attribute__((unused))  ident[] = "$Id: extppmcmot.c,v 1.2 2001/10/23 18:07:31 wshackle Exp $";
//the following functions and all internal
// low level functions are contained in
// ppmc_internal.c

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

int extMotQuit()
{
  return ppmcMotQuit();
}
//the following functions are implemented in
//ppmc_dac.c
int extDacNum()
{
  return ppmcDacNum();
}

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

int extDacWriteAll(int max, double * volts)
{
  return ppmcDacWriteAll(max, volts);
}
//the following functions are implemented
//in ppmc_encoder.c
int extEncoderSetIndexModel(unsigned int model)
{
  return ppmcEncoderSetIndexModel(model);
}

int extEncoderNum()
{
  return ppmcEncoderNum();
}

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

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

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

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

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

//the following functions are implemented 
//in ppmc_dio.c
int extMaxLimitSwitchRead(int axis, int * flag)
{
#ifdef NO_LIMIT_SWITCH
  *flag = 0;
  return 0;
#else
  return ppmcMaxLimitSwitchRead(axis, flag);
#endif
}

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

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

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

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

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

int extDioQuit()
{
  return ppmcDioQuit();
}

int extDioMaxInputs()
{
  return ppmcDioMaxInputs();
}

int extDioMaxOutputs()
{
  return ppmcDioMaxOutputs();
}

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

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

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

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

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

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

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

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

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

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

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

int extDioWordCheck(int index, unsigned int *word)
{
  return ppmcDioWordCheck(index, word);
}
//functions implemented in ppmc_aio.c
int extAioInit(const char * stuff)
{
  return ppmcAioInit(stuff);
}

int extAioQuit()
{
  return ppmcAioQuit();
}

int extAioMaxInputs()
{
  return ppmcAioMaxInputs();
}

int extAioMaxOutputs()
{
  return ppmcAioMaxOutputs();
}

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

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

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

---