---

pmac.cc

Go to the documentation of this file.

static char sccsid[] = "@(#) pmac.c 1.32@(#)";

/*
  Utility functions for reading and writing PMAC dual-ported RAM.
  This code is intended for use with 386/486 PC's and a POSIX OS,
  such as Lynx.  The code assumes 4-byte integers in Intel format.

  Modification history:

   6-Nov-1996 WPS edited to shorten startup time on Windows NT.
  27-Sep-1996  FMP added write_pmac_uint32 (it was left out)
  20-Jun-1996  Fred Proctor changed return val in pmac_writemsg debug
  from 0 to PMAC_ACK.
  14-Nov-1995  Fred Proctor added probing code
  13-Nov-1995  Fred Proctor reworked for 8 axes with better DPRAM mapping
  6-Oct-1995  Fred Proctor added TBUF transformation initialization
  to pmac_program().
  28-Jul-1995  Fred Proctor took out val = -val, for pmac_spindle_speed()
  20-Jul-1995  Fred Proctor added pmac_target_pos()
  18-Jul-1995  Fred Proctor added pmac_reset()
  24-Mar-1995 Sandor Szabo added pmac.c specific macros from pmac.h
  into pmac.c.  This will minimize recompiles to *.cc files when low
  level changes made to pmac.c (e.g., changing PMAC_IO_ADDR).
  Added newer DP RAM messaging code.
  22-Mar-1995  Fred Proctor added $$$ to pmac_exit(), in order to clear
  out any lingering effects of the controller on the PMAC
  15-Mar-1995  Fred Proctor out pmac_enable,disable_spindle() in;
  upped rotary buffer size to 8192
  26-Feb-1995  Fred Proctor changed DEBUG to DEBUG_PMAC
  15-Feb-1995  Fred Proctor added pmac_print_error()
  10-Feb-1995  Fred Proctor 10x'ed TIMEOUT for pmac waits-- the
  time appeared to need increasing with the ICS backplane and CPU.
  26-Jan-1995  Fred Proctor ifdef DEBUG'ed out all pmac dpram calls,
  so that everything will compile in DEBUG mode. Checked 'pmac' ptr
  for non-NULL at every access, so that it will automatically init
  itself-- now calls to pmac_init() need not appear in user code.
  21-Dec-1994  Fred Proctor removed pcioInit() call
  23-Sep-1994  Fred Proctor moved utility functions for program running,
  etc. (pmac_sendstring() and all functions after that) into this file,
  from hme and servo. Added debug flag so that this code can now be
  used in non-Lynx programs (functions that require the PMAC hardware,
  e.g., pmac_read/write*, aren't provided for debug).
  */

#ifndef rtlinux
#include "rcs.hh"               /* WIN32, class PHYSMEM_HANDLE, rcs_print_error */
#else

#include "physmem.hh"


#endif





#include "pmac.h"

#ifdef lynxosPC
extern "C" {
#include "pcioDrv.h"            // inportb, outportb
}
#endif

#ifdef linux
#include <asm/io.h>             // inb, outb
#endif

/* #define PMAC_PROM_V1_13 1     uncomment to run old version pmac proms */

#ifndef PMAC_PROM_V1_13
#define PMAC_MSG_BASE 0x600     /* base location in dpram for ascii com */
#endif

static unsigned int PMAC_BASE_ADDR = 0xD0000;
static unsigned int PMAC_IO_ADDR = 0x210;

/* suggested parameters for single 8K dual-ported RAM in PC bus */

#define PMAC_NAME "pmac"
#define PMAC_DPRAM_SIZE ((long) 0x4000) /* 16K bytes = 8K 16-bit DP RAM */
#define PMAC_IO_SIZE    ((long) 0x8) /* 8 bytes of IO space. */
#define PMAC_RESERVED 0x800     /* 2K reserved for future use */

#define PMAC_IO_SPEED 9         /* speed factor for 486-66; see PMAC
                                   manual, v. 1.13, p. 3-189 */

#define PMAC_LAST_CHAR (PMAC_SIZE - PMAC_RESERVED - PMAC_MSG_LEN - 4 - 1)
#define PMAC_LAST_SHORT ((PMAC_SIZE - PMAC_RESERVED - PMAC_MSG_LEN - 4) / sizeof(short) - 1)
#define PMAC_LAST_INT ((PMAC_SIZE - PMAC_RESERVED - PMAC_MSG_LEN - 4) / sizeof(int) - 1)
#define PMAC_LAST_FLOAT ((PMAC_SIZE - PMAC_RESERVED - PMAC_MSG_LEN - 4) / sizeof(float) - 1)

#if !defined(lynxosPC) && !defined(WIN32)
#define DEBUG_PMAC                      /* all non-Lynx platforms must use
                                           debug version (no PMAC hardware) */
#endif

#ifdef DEBUG_PMAC

#include <stdio.h>
#include <errno.h>

#endif

PHYSMEM_HANDLE *pmac_dpram_handle=NULL;
PHYSMEM_HANDLE *pmac_io_handle=NULL;

#define TIMEOUT 100*PMAC_IO_SPEED*100 /* timeout for bus port wait-- see
                                       PMAC manual, v1.13, p. 3-191 */

static int sendchar(char c, int timeout);
static PMAC_RETURN_VAL getline(char *, int);
static PMAC_RETURN_VAL sendline(const char *line, int timeout);

#define ACK 6
#define BELL 7
#define LF 10
#define CR 13
#define CTRL_X 24

#define PMAC_DATA_BASE_OFFSET (0x800 + 4 + PMAC_MSG_LEN)


void pmac_outportb(unsigned long port, char byte)
{
#if defined(lynxosPC)
        outportb(port, byte);
#else
#if defined(linux)
       outb(byte, port);
#else
        if(NULL != pmac_io_handle)
        {
                pmac_io_handle->offset =  port - PMAC_IO_ADDR;
                pmac_io_handle->write(&byte, 1);
        }
#endif
#endif
}

char pmac_inportb(unsigned long port)
{
        char byte;
#if defined(lynxosPC)
        byte = inportb(port);
#else
#if defined(linux)
        byte = inb(port);
#else
        if(NULL != pmac_io_handle)
        {
                pmac_io_handle->offset =  port - PMAC_IO_ADDR;
                pmac_io_handle->read(&byte, 1);
        }
#endif
#endif
        return byte;
}

static int pmac_initialized = 0;

void pmac_init()
{
#ifndef DEBUG_PMAC
 char reply[PMAC_MSG_LEN];

 if(pmac_initialized)
 {
   return;
 }

 if(NULL == pmac_io_handle)
 {
  pmac_io_handle = new PHYSMEM_HANDLE(PMAC_IO_ADDR, NT_ISA_IO_ADDRESS, PMAC_IO_SIZE);
  if(NULL == pmac_io_handle)
  {
#ifndef rtlinux
    rcs_print_error( "can't get PMAC IO\n");
#endif
    return;
  }
  if(!pmac_io_handle->valid())
  {
#ifndef rtlinux
    rcs_print_error( "can't get PMAC IO\n");
#endif
    return;
  }
 }
  /* clear serial registers */
  pmac_outportb(PMAC_IO_ADDR+5, 0);
  pmac_outportb(PMAC_IO_ADDR+6, 0);

   /* read any chars from port-- ignore any timeout status since
     it will probably time out */
#ifndef WIN32
  getline(reply, TIMEOUT);
#else
 getline(reply, TIMEOUT/10);
#endif

  if(NULL == pmac_dpram_handle)
  {
        pmac_dpram_handle = new PHYSMEM_HANDLE(PMAC_BASE_ADDR, NT_ISA_MEM_ADDRESS, PMAC_DPRAM_SIZE);
        if(NULL == pmac_dpram_handle)
        {
#ifndef rtlinux
                rcs_print_error( "can't get PMAC DP RAM\n");
#endif
                return;
        }
        if(!pmac_dpram_handle->valid())
        {
#ifndef rtlinux
                rcs_print_error( "can't get PMAC DP RAM\n");
#endif
                return;
        }
  }

  /* put it in online mode */
  (void) pmac_online();
   pmac_initialized = 1;
#endif
}

void pmac_exit()
{
#ifndef DEBUG_PMAC
  pmac_initialized = 0;
 if(NULL != pmac_dpram_handle)
  {
         delete pmac_dpram_handle;
         pmac_dpram_handle = NULL;
  }
  if(NULL != pmac_io_handle)
  {
          delete pmac_io_handle;
          pmac_io_handle = NULL;
  }

#endif
}

static int pmac_dpram_error_message_sent = 0;

/*
  Read contents of dual-ported RAM as a character,
  8 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of characters up from base.

  Returns unsigned char found at indexed location.
  */
PMAC_UINT8 read_pmac_uint8(int index)
{
#ifdef DEBUG_PMAC
  return 0;
#else
  PMAC_UINT8 byte;
  if(NULL == pmac_dpram_handle)
  {
          pmac_init();
  }
  if(NULL == pmac_dpram_handle)
  {
          if(!pmac_dpram_error_message_sent)
          {
#ifndef rtlinux
                  rcs_print_error("Can't read from PMAC's dual-ported RAM.\n");
#endif
          }
          pmac_dpram_error_message_sent=1;
          return 0;
  }
  pmac_dpram_handle->offset = PMAC_DATA_BASE_OFFSET + index;
  pmac_dpram_handle->read(&byte, 1);
  return byte;
#endif
}

/*
  Write a character into dual-ported RAM,
  8 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of characters up from base.
  val is unsigned char to write at indexed location.
  */
void write_pmac_uint8(int index, PMAC_UINT8 val)
{
#ifdef DEBUG_PMAC
  return;
#else
 if(NULL == pmac_dpram_handle)
  {
          pmac_init();
  }
  if(NULL == pmac_dpram_handle)
  {
          if(!pmac_dpram_error_message_sent)
          {
#ifndef rtlinux
                  rcs_print_error("Can't write to PMAC's dual-ported RAM.\n");
#endif
          }
          pmac_dpram_error_message_sent=1;
          return;
  }
  pmac_dpram_handle->offset = PMAC_DATA_BASE_OFFSET + index;
  pmac_dpram_handle->write(&val, 1);
#endif
}

/*
  Read contents of dual-ported RAM as a short integer,
  16 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of short integers up from base.

  Returns unsigned short found at indexed location.
  */
PMAC_UINT16 read_pmac_uint16(int index)
{
#ifdef DEBUG_PMAC
  return 0;
#else
  PMAC_UINT16 retval;
 if(NULL == pmac_dpram_handle)
  {
          pmac_init();
  }
  if(NULL == pmac_dpram_handle)
  {
          if(!pmac_dpram_error_message_sent)
          {
#ifndef rtlinux
                  rcs_print_error("Can't read from PMAC's dual-ported RAM.\n");
#endif
          }
          pmac_dpram_error_message_sent=1;
          return 0;
  }
  pmac_dpram_handle->offset = PMAC_DATA_BASE_OFFSET + index*2;
  pmac_dpram_handle->read(&retval, 2);
  return retval;
#endif
}

/*
  Write a short integer into dual-ported RAM,
  16 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of short integers up from base.
  val is unsigned short integer to write at indexed location.
  */
void write_pmac_uint16(int index, PMAC_UINT16 val)
{
#ifdef DEBUG_PMAC
  return;
#else
 if(NULL == pmac_dpram_handle)
  {
          pmac_init();
  }
  if(NULL == pmac_dpram_handle)
  {
          if(!pmac_dpram_error_message_sent)
          {
#ifndef rtlinux
                  rcs_print_error("Can't write to PMAC's dual-ported RAM.\n");
#endif
          }
          pmac_dpram_error_message_sent=1;
          return;
  }
  pmac_dpram_handle->offset = PMAC_DATA_BASE_OFFSET + index*2;
  pmac_dpram_handle->write(&val, 2);
#endif
}

/*
  Read contents of dual-ported RAM as an integer,
  32 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of integers up from base.

  Returns unsigned integer found at indexed location.
  */
PMAC_UINT32 read_pmac_uint32(int index)
{
#ifdef DEBUG_PMAC
  return 0;
#else
  PMAC_UINT16 lo, hi;
  PMAC_UINT32 retval;

  lo = read_pmac_uint16(index*2);
  hi = read_pmac_uint16(index*2+1);
  retval = ((PMAC_UINT32)hi << 16) + lo;
  return retval;
#endif
}

/*
  Write an integer into dual-ported RAM,
  32 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of integers up from base.
  val is unsigned integer to write at indexed location.
  */
void pmac_writeint(int index, unsigned int val)
{
#ifdef DEBUG_PMAC
  return;
#else
  PMAC_UINT16 lo, hi;


  lo = (unsigned short) (val & 0x0000FFFF);
  hi = (unsigned short) ((val & 0xFFFF0000) >> 16);

  write_pmac_uint16( index*2,   lo);
  write_pmac_uint16( index*2+1, hi);
#endif
}

void write_pmac_uint32(int index, PMAC_UINT32 val)
{
  pmac_writeint(index, (unsigned int) val);
}

/*
  Read contents of dual-ported RAM as a float,
  32 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of floats up from base.

  Returns float found at indexed location.
  */
float pmac_readfloat(int index)
{
#ifdef DEBUG_PMAC
  return 0;
#else
  PMAC_UINT16 lo, hi;
  PMAC_UINT32 temp32;


  lo = read_pmac_uint16(2*index);
  hi = read_pmac_uint16(2*index+1);

  temp32 = (hi << 16) + lo;
  return *((float *) &temp32);
#endif
}

/*
  Write a float into dual-ported RAM,
  32 bits on LynxOS/386.

  base is a pointer, pmac_get() <= base < size;
  index is number of floats up from base.
  val is float to write at indexed location.
  */
void pmac_writefloat(int index, float val)
{
#ifdef DEBUG_PMAC
  return;
#else
  PMAC_UINT16 lo, hi;

  lo = (unsigned short) (*((unsigned int *) &val) & 0x0000FFFF);
  hi = (unsigned short) ((*((unsigned int *) &val) & 0xFFFF0000) >> 16);

  write_pmac_uint16(index*2,lo);
  write_pmac_uint16(index*2+1,hi);
#endif
}




static int write_ready()
{
#ifndef DEBUG_PMAC
  /* is bit 2 of addr+2 set? if so, return 1, else return 0 */
  return pmac_inportb(PMAC_IO_ADDR+2) & 2 ? 1 : 0;
#else
  return 1;
#endif
}

static int read_ready()
{
#ifndef DEBUG_PMAC
  /* is bit 1 of addr+2 set? if so, return 1, else return 0 */
  return pmac_inportb(PMAC_IO_ADDR+2) & 1 ? 1 : 0;
#else
  return 1;
#endif
}

static int sendchar(char outchar, int timeout)
{
#ifndef DEBUG_PMAC
  int i = 0;

  while (i++ < timeout && !write_ready())
    ;
  if (i < timeout)
  {
    pmac_outportb(PMAC_IO_ADDR+7, outchar);
    return 0;
  }
  return -1;
#else
  return 0;
#endif
}

static PMAC_RETURN_VAL sendline(const char *line, int timeout)
{
#ifndef PMAC_DEBUG
  int i = 0;

  while (line[i] != 0)
  {
    if (-1 == sendchar(line[i++], timeout))
      return PMAC_WRITE_TIMEOUT;
  }
  if (-1 == sendchar(13, timeout))
    return PMAC_WRITE_TIMEOUT;

  return PMAC_ACK;
#else
  return PMAC_ACK;
#endif
}

/* set I3=2 for this to work. The default, I3=1, will result in the
   first char of replies being LF. The reply will be blank, and the
   return value of pmac_writemsg will be PMAC_INVALID_COMM_PARAMS.
   */
static PMAC_RETURN_VAL getline(char *linebuf, int timeout)
{
#ifdef DEBUG_PMAC
  return PMAC_ACK;
#else

  char ic;
  int timer, nc;
  PMAC_RETURN_VAL retval = PMAC_ACK;

  ic = nc = timer = 0;
  for (;;)
  {
    if (read_ready())
    {
      ic = pmac_inportb(PMAC_IO_ADDR+7);
      timer = 0;

      /* check for -1-- this is an error */
      if (ic == -1)
      {
        retval = PMAC_INVALID_COMM_PARAMS;
        break;
      }

      /* check for ACK-- break if found */
      if (ic == ACK)
      {
        /* if message overran, then retval was set to
           PMAC_BUF_TOO_SMALL. If it's a normal message
           termination, then retval will be PMAC_ACK, as it was
           initialized to. Just break in either case. */
        break;
      }

      /* check for LF-- PMAC is in an invalid comm setup if
         so (I3 is probably the default, 1) */
      if (ic == LF)
      {
        retval = PMAC_INVALID_COMM_PARAMS;
        break;
      }

      /* check for BELL error-- if so, reset message and wait for
         CR */
      if (ic == BELL)
      {
        /* now need to wait 'til following CR--  reset everything*/
        retval = PMAC_ERR;
        continue;               /* keep going for the CR */
      }

      /* check for CR-- this will normally just pass through and
         not stop us. When there's been an error, this is the
         final char */
      if (ic == CR && retval == PMAC_ERR)
      {
        /* error message done */
        break;
      }

      /* wrap around any message overrun */
      if (nc >= PMAC_MSG_LEN-1)
      {
        retval = PMAC_BUF_TOO_SMALL;
        continue;               /* so we get it all out */
      }

      /* got here-- it's a data char */
      linebuf[nc++] = ic;
      continue;
    }
    else
    {
      /* not ready for read */
      if (timer++ >= timeout)
      {
        retval = PMAC_TIMEOUT;
        break;
      }
    }
  }

  /* null-terminate response */
  linebuf[nc++] = 0;

  return retval;

#endif                          /* not DEBUG_PMAC */
}

static PMAC_RETURN_VAL pmac_writemsg_bus(const char *msg, char *reply, int len)
{
#ifndef DEBUG_PMAC

  int timeout = 10*700*PMAC_IO_SPEED;
  PMAC_RETURN_VAL retval;

  /* send this message */
  if ((retval = sendline(msg, timeout)) != PMAC_ACK)
    return retval;

  /* wait for reply */
  return getline(reply, timeout);
#else
  return PMAC_ACK;

#endif
}

/* select which version of comm you want:
   pmac_writemsg_v13
   pmac_writemsg_v15
   pmac_writemsg_bus
   */
PMAC_RETURN_VAL pmac_writemsg(const char *msg, char *reply, int len)
{
#ifdef DEBUG_PMAC
  printf("%s\n", msg);
  return PMAC_ACK;
#else
  return pmac_writemsg_bus(msg, reply, len);
#endif
}

/* resets the PMAC to EEPROM settings */
PMAC_RETURN_VAL pmac_reset()
{
  int timeout = 10*700*PMAC_IO_SPEED;

#if defined(lynxosPC) || defined(linux)
  if (NULL == pmac_io_handle)
    return PMAC_ERR;
#endif

  /* send $$$ */
  return sendline("$$$", timeout);
}

/* pmac_sendstring assumes that PMAC has been initialized elsewhere */
int pmac_sendstring(const char *string)
{
#ifdef DEBUG_PMAC
  printf("%s\n", string);
  return 0;
#else
  int dperr;
  char reply[PMAC_MSG_LEN];

#if defined(lynxosPC) || defined(linux)
  /* check for valid pmac address */
  if (NULL == pmac_io_handle)
  {
    /* PMAC not initialized-- init it */
    pmac_init();
  }
#endif

  /* send it out */
  if ((dperr =  pmac_writemsg(string, reply, PMAC_MSG_LEN)) != PMAC_ACK)
  {
    /* something went wrong with the write */
    pmac_print_error(dperr, reply);
#ifndef rtlinux
    rcs_print_error( "command is %s\n", string);
#endif
    return -1;
  }
  else
  {
    /* command went okay */
    return 0;
  }
#endif
}

#ifdef DEBUG_PMAC
/* current pmac state */
static int pmac_online_state;
#endif

/* put the PMAC in online mode */
int pmac_online()
{
  /* abort any programs */
  if (-1 == pmac_sendstring("A")) /* abort any prog */
    return -1;
  /* close any buffer */
  if (-1 == pmac_sendstring("CLOSE")) /* close any buffer */
    return -1;
  /* delete any rotary programs */
  if (-1 == pmac_sendstring("DELETE ROT")) /* delete any rot buffer */
    return -1;

  return 0;
}

/* put the PMAC in program mode */
int pmac_program()
{
  /* abort any programs */
  if (-1 == pmac_sendstring("A")) /* abort any prog */
    return -1;
  /* close any open buffers */
  if (-1 == pmac_sendstring("CLOSE"))
    return -1;
  /* delete any rotary buffers */
  if (-1 == pmac_sendstring("DELETE ROT"))
    return -1;
  /* define the transformation matrix */
  if (-1 == pmac_sendstring("DEFINE TBUF 1"))
    return -1;
  /* define a rotary buffer */
  if (-1 == pmac_sendstring("DEFINE ROT 8192"))
    return -1;
  /* start the rotary buffer */
  if (-1 == pmac_sendstring("B0")) /* position rot buff at beginning */
    return -1;
  if (-1 == pmac_sendstring("OPEN ROT")) /* open it up */
    return -1;
  if (-1 == pmac_sendstring("R")) /* start running any motions */
    return -1;
  /* select the transformation matrix */
  if (-1 == pmac_sendstring("TSEL 1"))
    return -1;
  /* initialize the transformation matrix */
  if (-1 == pmac_sendstring("TINIT"))
    return -1;
  if (-1 == pmac_sendstring("ADIS 1")) /* Q1, Q2, and Q3 */
    return -1;

  return 0;
}

/* Returns 1 if the axis is in position, 0 if it is not, or -1
   if there is an error (bad axis number) */
int pmac_in_position(int axis)
{
#ifdef DEBUG_PMAC
  return 1;                     /* always in position in simulation */
#else
  int ipos;

  /* set up the ipos index into DP RAM */
  switch (axis) {
  case 1:
    ipos = IPOS_1;
    break;
  case 2:
    ipos = IPOS_2;
    break;
  case 3:
    ipos = IPOS_3;
    break;
  case 4:
    ipos = IPOS_4;
    break;
  default:
    return 1;
  }

  if (read_pmac_uint32(ipos) == 1)
    return 1;
  return 0;
#endif
}

/* Returns 1 if the axis is at home, 0 if it is not, or -1
   if there is an error (bad axis number) */
int pmac_at_home(int axis)
{
#ifdef DEBUG_PMAC
  return 1;                     /* always at home in simulation */
#else
  int homed;

  /* set up the homed index into DP RAM */
  switch (axis) {
  case 1:
    homed = HOMED_1;
    break;
  case 2:
    homed = HOMED_2;
    break;
  case 3:
    homed = HOMED_3;
    break;
  default:
    return -1;                  /* only 3 axes supported */
  }

  if (read_pmac_uint32(homed) == 1)
    return 1;
  return 0;
#endif
}

/* Returns -1, 0, or 1 if the axis is at neg, not, or pos limit */
int pmac_at_limit(int axis)
{
#ifdef DEBUG_PMAC
  return 0;                     /* never at limit in simulation */
#else
  int limit;

  switch (axis)
  {
  case 1:
    limit = read_pmac_uint32(NEG_LIM_1) == 1 ? -1 :
      read_pmac_uint32(POS_LIM_1) == 1 ? 1 : 0;
    break;
  case 2:
    limit = read_pmac_uint32(NEG_LIM_2) == 1 ? -1 :
      read_pmac_uint32(POS_LIM_2) == 1 ? 1 : 0;
    break;
  case 3:
    limit = read_pmac_uint32(NEG_LIM_3) == 1 ? -1 :
      read_pmac_uint32(POS_LIM_3) == 1 ? 1 : 0;
    break;
  default:
    return -1;                  /* only 3 axes supported */
  }

  return limit;
#endif
}

/* returns -1, 0, or 1 if the axis is at software limit */
int pmac_at_sw_limit(int axis)
{
#ifdef DEBUG_PMAC
  return 0;                     /* never at limit in simulation */
#else
  int limit;

  switch (axis)
  {
  case 1:
    limit = read_pmac_uint32(SW_NEG_LIM_1) == 1 ? -1 :
      read_pmac_uint32(SW_POS_LIM_1) == 1 ? 1 : 0;
    break;
  case 2:
    limit = read_pmac_uint32(SW_NEG_LIM_2) == 1 ? -1 :
      read_pmac_uint32(SW_POS_LIM_2) == 1 ? 1 : 0;
    break;
  case 3:
    limit = read_pmac_uint32(SW_NEG_LIM_3) == 1 ? -1 :
      read_pmac_uint32(SW_POS_LIM_3) == 1 ? 1 : 0;
    break;
  case 4:
    limit = read_pmac_uint32(SW_NEG_LIM_4) == 1 ? -1 :
      read_pmac_uint32(SW_POS_LIM_4) == 1 ? 1 : 0;
    break;
  default:
    return -1;                  /* only 3 axes supported */
  }

  return limit;
#endif
}

/*
  Returns 1 if a PMAC motion program is running, 0 if not.
  Heuristics:  program running bit is 0.
  */
int pmac_prog_running()
{
#ifdef DEBUG_PMAC
  return !pmac_online_state;
#else
  return read_pmac_uint32(CS_PROG_RUNNING);
#endif
}

#ifdef DEBUG_PMAC
static double _pos[AXIS_MAX];
#endif

/* returns the actual position of the specified axis */
double pmac_pos(int axis)
{
#ifdef DEBUG_PMAC
  return 0.0;                   /* use _pos[] array if you start
                                   simulating PMAC pos; for now it's
                                   0 for all axes */
#else
  int index;
  int pos;

  /* set up the position index into DP RAM */
  switch (axis) {
  case 1:
    index = ACT_POS_1;
    break;
  case 2:
    index = ACT_POS_2;
    break;
  case 3:
    index = ACT_POS_3;
    break;
  case 4:                       /* 4 is spindle */
    index = ACT_POS_4;
    break;
  default:
    return -1;
  }

  pos = (int) read_pmac_uint32(index);
  return pos;                   /* in counts! */
#endif
}

/* returns the target position of the specified axis */
double pmac_target_pos(int axis)
{
#ifdef DEBUG_PMAC
  return 0.0;
#else
  int index;
  int target;

  /* set up the position index into DP RAM */
  switch (axis) {
  case 1:
    index = TARGET_POS_1;
    break;
  case 2:
    index = TARGET_POS_2;
    break;
  case 3:
    index = TARGET_POS_3;
    break;
  case 4:                       /* 4 is spindle */
    index = TARGET_POS_4;
    break;
  default:
    return -1;
  }

  target = (int) read_pmac_uint32(index);
  return target;                        /* in counts! */
#endif
}

/* pass the reply buffer of the PMAC when you get PMAC_ERR, and
   this prints a line with a more descriptive error, as documented
   in PMAC manual for I-var I6, pp. 5-7, 5-8*/
void pmac_print_error(int dperr, const char *reply)
{
  int error_number;

  switch (dperr)
  {
  case PMAC_ACK:
    return;

  case PMAC_BUF_TOO_SMALL:
#ifndef rtlinux
    rcs_print_error( "buffer too small to hold reply\n");
#endif
    return;

  case PMAC_BAD_PARAMS:
#ifndef rtlinux
    rcs_print_error( "bad parameters to call to pmac_writemsg()\n");
#endif
    return;

  case PMAC_TIMEOUT:
#ifndef rtlinux
    rcs_print_error( "timeout on read from PMAC\n");
#endif
    return;

  case PMAC_WRITE_TIMEOUT:
#ifndef rtlinux
    rcs_print_error( "timeout on write to PMAC\n");
#endif
    return;

  case PMAC_INVALID_COMM_PARAMS:
#ifndef rtlinux
    rcs_print_error( "invalid PMAC comm params\n");
#endif
    return;

  case PMAC_ERR:

    /* line will look like "ERR003" -- scan past the "ERR" */
    if (1 != sscanf(&reply[3], "%d", &error_number))
    {
#ifndef rtlinux
      rcs_print_error( "invalid error string: %s\n", reply);
#endif
      return;                   /* invalid string */
    }

    /* print the descriptive text */
    switch (error_number)
    {
    case 1:
#ifndef rtlinux
      rcs_print_error( "command not allowed during program execution\n");
#endif
      break;

    case 3:
#ifndef rtlinux
      rcs_print_error( "data error or unrecognized command\n");
#endif
      break;

    case 5:
#ifndef rtlinux
      rcs_print_error( "command not allowed unless buffer is open\n");
#endif
      break;

    case 6:
#ifndef rtlinux
      rcs_print_error( "no room in buffer for command\n");
#endif
      break;

    case 7:
#ifndef rtlinux
      rcs_print_error( "buffer already in use\n");
#endif
      break;

    case 9:
#ifndef rtlinux
      rcs_print_error( "program structural error (e.g., ENDIF without IF)\n");
#endif
      break;

    case 10:
#ifndef rtlinux
      rcs_print_error( "both overtravel limits set for a motor in the C.S.\n");
#endif
      break;

    case 11:
#ifndef rtlinux
      rcs_print_error( "previous move not completed\n");
#endif
      break;

    case 12:
#ifndef rtlinux
      rcs_print_error( "a motor in the coordinate system is open-loop\n");
#endif
      break;

    case 13:
#ifndef rtlinux
      rcs_print_error( "a motor in the coordinate system is not activated\n");
#endif
      break;

    case 14:
#ifndef rtlinux
      rcs_print_error( "no motors in the coordinate system\n");
#endif
      break;

    case 15:
#ifndef rtlinux
      rcs_print_error( "not pointing to a valid program buffer\n");
#endif
      break;

    case 16:
#ifndef rtlinux
      rcs_print_error( "running improperly structured program (e.g., missing ENDWHILE)\n");
#endif
      break;

    default:
      break;
    }                           /* case PMAC_ERR */

  default:
    return;
  }                             /* case dperr */
}

/* spindle stuff */

#ifdef DEBUG_PMAC

static int _spindle_enabled = 0;
static double _spindle_speed = 0.0;

#endif

/* rpm calibration data from linear regression (!) */

#define GEAR_1_A 39.4
#define GEAR_1_B 0.0

#define GEAR_2_A 12.1
#define GEAR_2_B 0.0

#define GEAR_3_A 3.66
#define GEAR_3_B 0.0

static int rpms_to_counts(double rpms, int gear)
{
  switch (gear)
  {
  case 1:
  case 4:                       /* in transition = low gear */
    return GEAR_1_A * rpms + GEAR_1_B;
  case 2:
    return GEAR_2_A * rpms + GEAR_2_B;
  case 3:
    return GEAR_3_A * rpms + GEAR_3_B;
  default:
    return 0;
  }
}

static double clip_rpms(double speed_factor, int gear)
{
 /* clip RPMs to limit:
     low gear: 0 - 335
     medium gear: 336 - 1086
     high gear: 1087 - 3000
     */
  switch (gear)
  {
  case 1:
  case 4:                       /* in transition = low gear */
    if (speed_factor > 336)
      speed_factor = 336;
    else if (speed_factor < -336)
      speed_factor = -336;
    break;
  case 2:
    if (speed_factor > 1086)
        speed_factor = 1086;
    else if (speed_factor < -1086)
      speed_factor = -1086;
    break;
  case 3:
    if (speed_factor > 3000)
      speed_factor = 3000;
    else if (speed_factor < -3000)
      speed_factor = -3000;
    break;
  default:
    /* coding error */
    break;
  }

  return speed_factor;
}

#define MAX_COUNTS 12000

/* speed is in RPMs, gear is 1=low, 2=med, 3=hi */
void pmac_spindle_speed(double rpms, int gear)
{
  int val;

  /* clip rpms */
  rpms = clip_rpms(rpms, gear);

  /* convert rpms to counts */
  val = rpms_to_counts(rpms, gear);

  /* clip counts */
  if (val < -MAX_COUNTS)
  {
    val = -MAX_COUNTS;
  }
  else if (val > MAX_COUNTS)
  {
    val = MAX_COUNTS;
  }

  val = -val;                   /* FIXME--works for kt800, remove for
                                   minimill-- need an ini file variable */

  pmac_writeint(SPINDLE_SPEED, val);
#ifdef DEBUG_PMAC
  printf("setting pmac spindle speed to %d\n", val);
  _spindle_speed = rpms;
#endif                          /* DEBUG_PMAC */
}

/* enable the spindle-- this means disable any servoing, and enable
   the spindle amp manually */
int pmac_enable_spindle()
{
  /* if we're in on-line mode, *don't* force on-line-- we may have
     motions queued that can't be aborted */
  if (pmac_prog_running())
  {
    /* the spindle cannot be enabled when a motion program is running--
       it should be done */
    /* FIXME-- check queue and report error if any motions are queued */
    if (-1 == pmac_online())
      return -1;
  }

  /* format and send on-line kill command */
  if (-1 == pmac_sendstring("#4K"))
    return -1;

  /* disable motor calcs */
  if (-1 == pmac_sendstring("I400=0"))
    return -1;

#ifdef DEBUG_PMAC
  _spindle_enabled = 1;
#endif

  return 0;
}

/* disable the spindle-- this means don't output any DAC voltage,
   and disable the spindle amp manually */
int pmac_disable_spindle()
{
  /* command no velocity */
  pmac_spindle_speed(0.0, 1);

  /* assure on-line command mode */
  if (pmac_prog_running())
  {
    if (-1 == pmac_online())
      return -1;
  }

  /* enable motor calcs and servo here*/
  if (-1 == pmac_sendstring("I400=1"))
    return -1;
  if (-1 == pmac_sendstring("#4J/"))
    return -1;


#ifdef DEBUG_PMAC
  _spindle_enabled = 0;
#endif

  return 0;
}

int pmac_spindle_is_open_loop()
{
  /* returns 1 if it's open loop, or 0 if it's closed loop.
     1 means that we're using it in cutting mode, by writing to
     the DAC; 0 means that we're using it for orienting */

  return read_pmac_uint32(OPEN_LOOP_4);
}

/* Probing */

/* Enables the use of motor 1-3's FAULT line for latching.
   Sets I902, I907, and I912 to 2 for flag select only,
   and sets flag select to 3 for FAULT. */
int pmac_probe_on()
{
  /* make sure we're in online mode */
  if (pmac_prog_running())
  {
    if (-1 == pmac_online())
    {
      return -1;
    }
  }

  /* set the I-vars to 2 for rising edge of flag */
  pmac_sendstring("I902=2");
  pmac_sendstring("I907=2");
  pmac_sendstring("I912=2");

  /* set the flag to FAULT */
  pmac_sendstring("I903=3");
  pmac_sendstring("I908=3");
  pmac_sendstring("I913=3");

  return 0;
}

/* Restores the use of motor 1-3's index pulse for homing.
   Restores the P-variable copies of I902, I907, and I912, and sets
   flag select to 0 for home flag. */
int pmac_probe_off()
{
  /* make sure we're in online mode */
  if (pmac_prog_running())
  {
    if (-1 == pmac_online())
    {
      return -1;
    }
  }

  /* restore the I-vars from P-vars */
  pmac_sendstring("I902=P902");
  pmac_sendstring("I907=P907");
  pmac_sendstring("I912=P912");

  /* set the flag to HOME */
  pmac_sendstring("I903=0");
  pmac_sendstring("I908=0");
  pmac_sendstring("I913=0");

  return 0;
}

int pmac_probe_clear(int axis)
{
  switch (axis)
  {
  case 1:
    pmac_writeint(CAPTURE_READY_1, 0);
    break;
  case 2:
    pmac_writeint(CAPTURE_READY_2, 0);
    break;
  case 3:
    pmac_writeint(CAPTURE_READY_3, 0);
    break;
  default:
    return -1;
  }
  return 0;
}

/* returns non-zero when the probe tripped and all axes positions have
   been latched. */
int pmac_probe_tripped(int axis)
{
  switch (axis)
  {
  case 1:
    return read_pmac_uint32(CAPTURE_READY_1);
  case 2:
    return read_pmac_uint32(CAPTURE_READY_2);
  case 3:
    return read_pmac_uint32(CAPTURE_READY_3);
  default:
    return 0;
  }
}

/* returns encoder counts of probe trip from 0 home */
int pmac_probe_value(int axis)
{
  int value;
  int offset;

  /* check axis */
  if (axis < 1 || axis > 3)
  {
    return 0;
  }

  /* read output */
  switch (axis)
  {
  case 1:
    value = read_pmac_uint32(CAPTURED_1);
    offset = read_pmac_uint32(HOME_OFFSET_1);
    break;
  case 2:
    value = read_pmac_uint32(CAPTURED_2);
    offset = read_pmac_uint32(HOME_OFFSET_2);
    break;
  case 3:
    value = read_pmac_uint32(CAPTURED_3);
    offset = read_pmac_uint32(HOME_OFFSET_3);
    break;
  }

  /* compute probe value in mm */
  return (value - offset);
}

---