---

ppmc_encoder.c

Go to the documentation of this file.

#include "ppmc.h"
#include "extintf.h"

#ifdef RTLINUX
#ifndef MODULE
#define MODULE
#endif
#define DO_IT
#endif

#ifdef LINUX
#define DO_IT
/*
  Compiling this for LINUX (not RTLINUX) means linking this into a Linux
  process, running non-real-time in user space. This is useful for debugging.
  If this is done, then the following stuff needs to be done to access the
  IO space.
  */

/*
  Because of a limitation in gcc (present at least in 2.7.2.1 and below), you
  _have to_ compile any source code that uses these routines with optimisation
  turned on (gcc -O1 or higher), or alternatively #define extern to be
  empty before #including <asm/io.h>.

  Otherwise, you'll get errors at link time like:

  stg.c:475: undefined reference to `__inbc'
 */
#define extern

/*
  Need to access ports in range 0x278 - 0x378, for default
  PPMC base address. ioperm() only enables up to 0x3FF, so we need to use
  iopl() to grant full access to IO space.
  */
// already included in ppmc_internal.c
//# include <unistd.h>          /* iopl() */

#endif /* LINUX  */

#ifdef DO_IT
// io.h already included in ppmc_internal.c
//# include <asm/io.h>  /*for faster I/O we have to eliminate subroutine calls */
#else
/* otherwise do nothing */

#include <stdio.h>

static int iopl(int level)
{
  return 0;
}

#endif

//extern unsigned int ppmc_base_addr;

#define CONTROLPORT ppmc_base_addr+2
#define DATAPORT ppmc_base_addr+4


//ppmc encoder functions
int EncoderInit(void)
{
#ifdef PPMC_8_AXES
  unsigned int wAdd;
#endif
  short success=0;
        

  /* set all channels to normal mode (no find index, no load counters */
  SelWrt(ENCCTRL_0,0);
#ifdef PPMC_8_AXES
  SelWrt(ENCCTRL_1,0);
  SelWrt(ENCRATE_1,0);  // in all cases, the 2nd encoder board is slaved to first
#endif
  //  SelWrt(ENCRATE_0,0x10);  // make encoder board 0 master
  SelWrt(ENCRATE_0,0x00);  // don't make encoder board 0 master for software latch
 // zero the encoder counters  ( not needed )
  SelWrt(ENCLOAD_0,0);             /* clear 3-byte preload register */
  WriteData(0);
  WriteData(0);
  SelWrt(ENCCTRL_0,0xF0);  /* select load pos counter # and enable */
  SelWrt(ENCCTRL_0,0xF0);  /* select load pos counter # and enable */
  SelWrt(ENCCTRL_0,0xF0);  /* delay to give time for load to take place */
  SelWrt(ENCCTRL_0,0xF0);  /* more delay */
  SelWrt(ENCCTRL_0,0);         /* turn off load position counter function */
      
#ifdef PPMC_8_AXES
  SelWrt(ENCLOAD_1,0);             /* clear 3-byte preload register */
  WriteData(0);
  WriteData(0);
  for (wAdd = 0; wAdd <= 3; wAdd ++)
    {
      SelWrt(ENCCTRL_1,(unsigned char)((wAdd>>3)+32));  /* select load pos counter # and enable */
    }
  SelWrt(ENCCTRL_1,0);         /* turn off load position counter function */
#endif
        return success;
}
int EncoderQuit(void)
{
        return 0;
}
void SelectInterruptPeriod(long lPeriodSelect)   
{
#ifdef PPMC_8_AXES
  SelWrt(ENCRATE_1,0);             /* set 2nd board to slave timer mode */
#endif 
   
  switch (lPeriodSelect)
    {
    case _500_MICROSECONDS:
      SelWrt(ENCRATE_0,0x0B);                   /* master mode, 10 KHz / 5 = 2 KHz */
      break;
    case _1_MILLISECOND:
      SelWrt(ENCRATE_0,0x16);                   /* master mode, 10 KHz / 10 = 1 KHz */
      break;
    case _2_MILLISECONDS:
      SelWrt(ENCRATE_0,0x00);                   /* master mode, 10 KHz / 16 = 0.667 KHz */
      break;
    case _3_MILLISECONDS:
      SelWrt(ENCRATE_0,0x10);                   /* master mode, 10 KHz / 10 = 1 KHz */
      break;
    case _4_MILLISECONDS:
      SelWrt(ENCRATE_0,0x10);                   /* master mode, 10 KHz / 10 = 1 KHz */
      break;
    case _5_MILLISECONDS:
      SelWrt(ENCRATE_0,0x10);                   /* master mode, 10 KHz / 10 = 1 KHz */
      break;
    case _10_MILLISECONDS:
      SelWrt(ENCRATE_0,0x10);                   /* master mode, 10 KHz / 10 = 1 KHz */
      break;
    case _100_MILLISECONDS:
      SelWrt(ENCRATE_0,0x10);                   /* master mode, 10 KHz / 10 = 1 KHz */
      break;
    case _1_SECOND:
      SelWrt(ENCRATE_0,0x10);                   /* master mode, 10 KHz / 10 = 1 KHz */
      break;
    default:
      /* wrong input? then don't change it */
      break;
    }
}


int EncoderLatch()
{
        SelWrt(ENCRATE_0, 0x20);           /* pulse software generated strobe pulse */
        SelWrt(ENCRATE_0, 0x00);  // no need to do anything to 2nd encoder,
        // it is automatically slaved to first
     
  return 0;
}

int EncReadAll(LONGBYTE * lbEnc)
{
  static unsigned char byOldByte2[PPMC_MAX_AXIS];
  static unsigned char byEncHighByte[PPMC_MAX_AXIS];
  short i,max;

  SelAddr(ENCCNT0);
  //  outb(0x24,CONTROLPORT);    // set EPP port to input mode
  max = PPMC_MAX_AXIS;
  if (max > 4) max = 4;
  for (i = 0; i < max; i++)            /* 24 bits means get 3 bytes each */
    {
      lbEnc[i].Byte[0] = ReadData();
      lbEnc[i].Byte[1] = ReadData();
      lbEnc[i].Byte[2] = ReadData();  
      /* lbEnc[i].Byte[0] = inb(DATAPORT);
      lbEnc[i].Byte[1] = inb(DATAPORT);
      lbEnc[i].Byte[2] = inb(DATAPORT); */
    }
#ifdef PPMC_8_AXES
  if (PPMC_MAX_AXIS > 4)
    {
      SelAddr(ENCCNT4);
      for (i = 4; i < PPMC_MAX_AXIS; i++)            /* 24 bits means get 3 bytes each */
        {
          lbEnc[i].Byte[0] = ReadData();
          lbEnc[i].Byte[1] = ReadData();
          lbEnc[i].Byte[2] = ReadData();
        }
    }
#endif
  
  /* code to sign extend the 24 bit value */
  /* but we won't do this. */
  /*for ( i = 0; i < 8; i++) */
  /*  lbEnc[i].Byte[3] = lbEnc[i].Byte[2] & 0x80 ? 0xff : 0; */
  
  /* maintain the high byte, to extend the counter to 32 bits */
  /* */
  /* base decisions to increment or decrement the high byte */
  /* on the highest 2 bits of the 24 bit value.  To get the */
  /* highest 2 bits, use 0xc0 as a mask on byte [2] (the third */
  /* byte). */
  
  for (i = 0; i < PPMC_MAX_AXIS; i++)
    {
      /* check for -1 to 0 transition */

      if (    ( (byOldByte2[i]    & 0xc0) == 0xc0 ) /* 11xxxxxx */
              && ( (lbEnc[i].Byte[2] & 0xc0) == 0 ) /* 00xxxxxx */
              )
        byEncHighByte[i]++;

      /* check for 0 to -1 transition */

      if (    ( (byOldByte2[i]    & 0xc0) == 0 ) /* 00xxxxxx */
              && ( (lbEnc[i].Byte[2] & 0xc0) == 0xc0 ) /* 11xxxxxx */
              )
        byEncHighByte[i]--;

      lbEnc[i].Byte[3] = byEncHighByte[i];
      byOldByte2[i] = lbEnc[i].Byte[2]; /* current byte 2 becomes old one */
    }

  return 0;
}



int ppmcEncoderSetIndexModel(unsigned int model)//eek not sure i got this right
{
  if (model != EXT_ENCODER_INDEX_MODEL_MANUAL)
    {
      return -1;
    }
  
  return 0;
}

int ppmcEncoderNum()
{
  return PPMC_MAX_AXIS;
}

int ppmcEncoderRead(int encoder, double * counts)
{
        double allCounts[PPMC_MAX_AXIS];

  if (encoder < 0 ||
      encoder >= PPMC_MAX_AXIS) {
    *counts = 0.0;
    return 0;
  }

  ppmcEncoderReadAll(encoder + 1, allCounts);

  *counts = allCounts[encoder];

  return 0;
  
}

int ppmcEncoderReadAll(int max, double * counts)
{
  LONGBYTE lbEnc[PPMC_MAX_AXIS];
  int t;
  int smax;                     /* how many we actually have */

  /* clip smax to max supported-- if they want more, give
     them zeros */
  if (max > PPMC_MAX_AXIS) {
    smax = PPMC_MAX_AXIS;
  }
  else {
    smax = max;
  }

  EncoderLatch();
  EncReadAll(lbEnc);

  /* fill ours with the actual values */
  for (t = 0; t < smax; t++) {
    counts[t] = (double) lbEnc[t].Long;
  }
  /* and fill the rest with zeros */
  for (t = smax; t < max; t++) {
    counts[t] = 0.0;
  }

  return 0;
}

/*
//this routine reads the latch.  the index
//may not still be valid.  For a manual mode encoder
//interface such as this they may want to know if the
//index pulse has gone past.  Generally, emc 
//resets the latch before reading the latch
*/

int ppmcEncoderReadLatch(int encoder, int * flag)
{
#ifdef NO_INDEX_PULSE
  *flag = 1;
  return 0;
#else
  short int index_sense_data;
  short int index_mask;
  
  if (encoder>PPMC_MAX_AXIS) return -1; //not that many encoders
#ifdef PPMC_8_AXES
          if (encoder>=4)
          {  
                  index_sense_data=SelRead(ENCISR_1);
                  index_mask=(1<<((short)encoder-4));
                  if(index_sense_data&index_mask)*flag=1;
                  else *flag=0;
                  return 0;
          }
#endif 
          //either wasn't 8 axis or was first encoder board
                  index_sense_data=SelRead(ENCISR_0);
                  index_mask=(1<<((short)encoder));
                  if(index_sense_data&index_mask)*flag=1;
                  else *flag=0;
                  return 0;

#endif
}

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

//read the latch to clear it
int ppmcEncoderResetIndex(int encoder)
{
  int dummyflag;
  return ppmcEncoderReadLatch(encoder,&dummyflag);

}

---