---

stgmembs.c File Reference

#include "locdefs.h"
#include "offsets.h"
#include "stgdefs.h"
#include "locsysio.h"

Include dependency graph for stgmembs.c:

Go to the source code of this file.

Defines
#define	__attribute__(x)
#define	assert(a)
Functions
char	__attribute__ ((unused)) ident[]="$Id
void	fOutPW (unsigned short port, unsigned short data)
unsigned char	fInP (unsigned short port)
unsigned short	fInPW (unsigned short port)
unsigned short	BaseAddress (void)
unsigned short	GetBoardPresence (void)
unsigned short	GetAxes (void)
unsigned short	GetIrq (void)
unsigned short	GetAddr (void)
unsigned short	GetModel (void)
void	ServoToGoConstructor (unsigned short wRequestedIrq)
void	ServoToGoDestructor (void)
void	SetIrq (unsigned short wRequestedIrq)
unsigned short	BaseFind (void)
unsigned short	BrdtstOK (unsigned short BaseAddress)
void	Initialize (unsigned short wRequestedIrq)
void	StartADC (unsigned short wAxis)
short	SpinReadADC (unsigned short wAxis)
long	ReadADC (unsigned short wAxis, short *counts_ptr)
void	EncoderInit (void)
void	SelectInterruptPeriod (long lPeriodSelect)
void	RawDAC (unsigned short nAxis, long lCounts)
void	EncReadAll (LONGBYTE *lbEnc)
void	ResetIndexLatch ()
void	ResetIndexLatches (unsigned char byLatchBits)
void	SelectIndexAxis (unsigned char byAxis)
void	SelectIndexAxisWithPolarity (unsigned char byAxis, unsigned char byPol)
void	SelectIndexOrExtLatch (unsigned char bySelectBits)
void	EnableCounterLatchOnIndexOrExt (unsigned char bySelectBits)
unsigned char	CurrentIRR (void)
unsigned short	IndexPulseLatch (void)
unsigned char	GetIndexLatches ()
unsigned long	RawDIAll ()
unsigned char	RawDIBitPort (unsigned char byBitNumber, short nPort)
unsigned char	RawDIPort (short nPort)
void	RawDOAll (unsigned long lOutBits)
void	RawDOBitValPort (unsigned char byBitNumber, unsigned char bySet0or1, unsigned short nPort)
void	RawDOBytePort (unsigned char byData, short nPort)
short	PortBits2Index (short nPort)
void	DigitalOut1 (unsigned char byData, short nPortBits)
void	DigitalOut2 (unsigned char byBitNumber, unsigned char bySet0or1, unsigned short nPortBits)
void	DioDirection1 (unsigned short nPortBits, unsigned short nDirection)
void	DioDirection2 (const unsigned short nSwDir)
void	SetDDir (unsigned short nSwDir)
void	MotSim (void)
void	AutoZeroAdc (void)
void	DontAutoZeroAdc (void)
void	CalADC (void)
void	SetEncoderCounts (unsigned short nAxis, long lCounts)
void	EncoderLatch (void)
void	EncoderResetAddr (void)
unsigned char	GetSELDI ()
unsigned char	GetIDLEN ()
unsigned char	GetCNTRL0 ()
unsigned char	GetCNTRL1 ()
void	ResetWatchdogLatch ()
unsigned char	GetBRDTST ()
short	IndexPulse (void)
void	StopTimer ()
void	Timer2Delay (unsigned short counts)
void	StartTimer2TerminalCount (unsigned short count)
void	StartTimer2RTI (unsigned short count)
unsigned short	ReadTimer2TerminalCount (void)
short	PollTimer2 (void)
void	MaskTimer2Interrupt ()
void	UnMaskTimer2Interrupt ()
void	StartInterrupts (void)
void	StopInterrupts (void)
Variables
unsigned short	wBaseAddress
unsigned short	wIrq
unsigned short	wModel
unsigned short	wNoBoardFlag
unsigned short	wAxesInSys
unsigned short	wSaveDirs
unsigned char	byIndexPollAxis
unsigned char	byIndexPulsePolarity
long	lSimDac [MAX_AXIS]
long	lSimEnc [MAX_AXIS]
const int	aPortOffset_1 [] = {DIO_A, DIO_B, DIO_C, DIO_D}
const int	aPortOffset_2 [] = {PORT_A, PORT_B, PORT_C, PORT_D}
unsigned char	byEncHighByte [MAX_AXIS]
unsigned char	byOldByte2 [MAX_AXIS]

---

Define Documentation

#define __attribute__ (  x    )

Definition at line 27 of file stgmembs.c.

#define assert (  a    )

Referenced by DioDirection1().

---

Function Documentation

void AutoZeroAdc (  void    )

Definition at line 1316 of file stgmembs.c. { // set the Analog to Digital converter to autozero on each conversion if (wModel == MODEL1) fOutP(wBaseAddress + INTC, fInP(wBaseAddress + INTC) & ~AUTOZERO); else // MODEL2 fOutP(wBaseAddress + CNTRL0, fInP(wBaseAddress + CNTRL0) | CNTRL0_AZ); }

unsigned short BaseAddress (  void    )

Definition at line 79 of file stgmembs.c. { return wBaseAddress; }

unsigned short BaseFind (  void    )

Definition at line 197 of file stgmembs.c. { short i; unsigned short io_add; for (i = 15; i >= 0; i--) // search all possible addresses { io_add = i * 0x20 + 0x200; if ( BrdtstOK(io_add) ) return io_add; } return(0); }

unsigned short BrdtstOK (  unsigned short    BaseAddress )

Definition at line 219 of file stgmembs.c. Referenced by BaseFind(). { unsigned short BrdtstAddress; unsigned short SerSeq, HighNibble; int j; BrdtstAddress = BaseAddress + BRDTST; SerSeq = 0; for ( j = 7; j >= 0; j--) { HighNibble = fInP(BrdtstAddress) >> 4; if (HighNibble & 8) // is SER set { // shift bit to position specifed by Q2, Q1, Q0 // which are the lower three bits. Put bit in SerSeq. SerSeq |= 1 << (HighNibble & 7); } } if (SerSeq == 0x75) // SER sequence is 01110101 { wModel = MODEL1; return 1; //true } if (SerSeq == 0x74) // SER sequence is 01110100 { wModel = MODEL2; return 1; // true } // wModel = MODEL_NO_ID; return 0; // false }

void CalADC (  void    )

Definition at line 1336 of file stgmembs.c. { // Start calibration cycle on ADC chip unsigned char Cntrl0; if (wModel == MODEL2) // this function only in Model 2 board. { Cntrl0 = fInP(wBaseAddress + CNTRL0) & 0x07; // save irq fOutP(wBaseAddress + CNTRL0, Cntrl0); // cal is low // cal pulse should be 60 ns. The ISA bus is 10 MHz. or 100 ns. // so we can just set it back high. fOutP(wBaseAddress + CNTRL0, Cntrl0 | 0x08); // cal is high } }

unsigned char CurrentIRR (  void    )

Definition at line 903 of file stgmembs.c. { fOutP(wBaseAddress + OCW3, 0x0a); // IRR on next read return fInP(wBaseAddress + IRRreg); }

void DigitalOut1 (  unsigned char    byData, short    nPortBits )

Definition at line 1138 of file stgmembs.c. { RawDOBytePort(byData, PortBits2Index(nPortBits)); }

void DigitalOut2 (  unsigned char    byBitNumber, unsigned char    bySet0or1, unsigned short    nPortBits )

Definition at line 1143 of file stgmembs.c. { RawDOBitValPort(byBitNumber, bySet0or1, PortBits2Index(nPortBits)); }

void DioDirection1 (  unsigned short    nPortBits, unsigned short    nDirection )

Definition at line 1158 of file stgmembs.c. { unsigned short nSwDir; // sometimes you want to set the direction of a port, but may not know // what direction other ports are. Here we select the port (or ports) // that we want to set the direction of, in nPortBits. Then the direction, // either input or output, with nDirection. // assert(nDirection <= 1); // direction is either 0 or 1 if (nDirection > 1) return; nSwDir = wSaveDirs; if (nDirection == STG_PORT_OUTPUT) nSwDir |= nPortBits; else nSwDir &= ~nPortBits; DioDirection2(nSwDir); }

void DioDirection2 (  const unsigned short    nSwDir )

Definition at line 1193 of file stgmembs.c. Referenced by DioDirection1(), ServoToGoDestructor(), and stgDioInit(). { unsigned char byHwDir; // direction bits for hardware unsigned long lCurrentData; if (wNoBoardFlag == NO_BOARD) { return; } // get the current data in the I/O ports. We'll replace it when we're // done. When you change a port to output, it will start at what the // input was (usually high). This way, bits won't change (except for a // glitch) when a port is set to output. lCurrentData = RawDIAll(); byHwDir = 0x9b; // initially all ports input if (nSwDir & STG_PORT_A) // check the bit for A out byHwDir &= ~A_DIR_BIT; // if output, set bit to 0 if (nSwDir & STG_PORT_B) byHwDir &= ~B_DIR_BIT; if (nSwDir & STG_PORT_C_LO) byHwDir &= ~C_LOW_DIR_BIT; if (nSwDir & STG_PORT_C_HI) byHwDir &= ~C_HI_DIR_BIT; fOutP(wBaseAddress + ABC_DIR, byHwDir); // set direction for A, B and C SetDDir(nSwDir); wSaveDirs = nSwDir; // save, mostly for other function RawDOAll(lCurrentData); }

void DontAutoZeroAdc (  void    )

Definition at line 1326 of file stgmembs.c. { // set the Analog to Digital converter to NOT autozero if (wModel == MODEL1) fOutP(wBaseAddress + INTC, fInP(wBaseAddress + INTC) | AUTOZERO); else // MODEL2 fOutP(wBaseAddress + CNTRL0, fInP(wBaseAddress + CNTRL0) & ~CNTRL0_AZ); }

void EnableCounterLatchOnIndexOrExt (  unsigned char    bySelectBits )

Definition at line 892 of file stgmembs.c. { // routine for Model 2 fOutP(wBaseAddress + IDLEN, bySelectBits); }

void EncReadAll (  LONGBYTE *    lbEnc )

Definition at line 731 of file stgmembs.c. Referenced by EncoderInit(), ppmcEncoderReadAll(), and stgEncoderReadAll(). { WORDBYTE wbTransfer; unsigned short add; short i; int max_axes = wAxesInSys; unsigned short maxAdd; if(max_axes != 8) { max_axes = 4; } // static unsigned char byOldByte2[MAX_AXIS]; // static unsigned char byEncHighByte[MAX_AXIS]; if (wNoBoardFlag == NO_BOARD) { for (i = 0; i < 8; i++) { lbEnc[i].Long = lSimEnc[i]; } return; } // Disable interrupts here? No, the timer will latch new data in the // hardware anyway. Maybe we should stop the timer? In an interrupt // service routine, you're synchronized with the timer; so the readings // will never change while you're reading them. If you're polling, you // would first latch the encoder counts with the EncoderLatch() function. // But, the timer could latch the counts again, in the middle of the read. // A critical section will help in some extreme cases. // reset counter internal addr ptr to point to first byte maxAdd = (wBaseAddress + ((max_axes>4)?CNT6_C:CNT2_D)); for (add = wBaseAddress + CNT0_C; add <= maxAdd; add +=4) fOutPW(add, 0x0101); for (i = 0; i < 3; i++) // 24 bits means get 3 bytes each { wbTransfer.Word = fInPW(wBaseAddress + CNT0_D); lbEnc[0].Byte[i] = wbTransfer.Byte.high; lbEnc[1].Byte[i] = wbTransfer.Byte.low; wbTransfer.Word = fInPW(wBaseAddress + CNT2_D); lbEnc[2].Byte[i] = wbTransfer.Byte.high; lbEnc[3].Byte[i] = wbTransfer.Byte.low; if(max_axes >= 8) { wbTransfer.Word = fInPW(wBaseAddress + CNT4_D); lbEnc[4].Byte[i] = wbTransfer.Byte.high; lbEnc[5].Byte[i] = wbTransfer.Byte.low; wbTransfer.Word = fInPW(wBaseAddress + CNT6_D); lbEnc[6].Byte[i] = wbTransfer.Byte.high; lbEnc[7].Byte[i] = wbTransfer.Byte.low; } } // 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 < max_axes; 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 } };

void EncoderInit (  void    )

Definition at line 462 of file stgmembs.c. { LONGBYTE enc[8]; unsigned short wAdd,wA; unsigned short const wTestPat = 0x5aa5; if (wNoBoardFlag == NO_BOARD) { wAxesInSys = MAX_AXIS; return; } // It is possible that the encoder counts are being held by battery // backup, so we'll read the encoders, and save the values // Then we'll initialize the encoder chips, since it's more likely that // the ecoders were not kept alive by battery and need to be initialized EncReadAll(enc); // probably the right thing is to sign extend the 24 bits, so, instead // of a 24 bit unsigned count, we have +/- 23 bits. // for ( i = 0; i < 8; i++) // { // byEncHighByte[i] = enc[i].Byte[2] & 0x80 ? 0xff : 0; // byOldByte2[i] = enc[i].Byte[2]; // } for (wAdd = wBaseAddress + CNT0_C; wAdd <= wBaseAddress + CNT6_C; wAdd +=4) { // we're going to be slick and do two chips at a time, that's why // the registers are arranged data, data, control, control. You // can do two at a time, by using word operations, instead of // byte operations. Not a big deal for initializing, but reading is // done pretty often. fOutPW(wAdd, 0x2020); // master reset // Set Counter Command Register - Input Control, OL Load (P3), // and Enable Inputs A and B (INA/B). fOutPW(wAdd, 0x6868); // Set Counter Command Register - Output Control fOutPW(wAdd, 0x8080); // Set Counter Command Register - Quadrature fOutPW(wAdd, 0xc3c3); fOutPW(wAdd, 0x0404); //reset counter to zero } // Figure out how many axes are on the card for ( wA = wBaseAddress + CNT0_D; wA <= wBaseAddress + CNT6_D; wA +=4) { // reset address pointer fOutPW(wA + 2, 0x0101); // write a pattern to the preset register fOutPW(wA, wTestPat); fOutPW(wA, wTestPat); fOutPW(wA, wTestPat); // transfer the preset register to the count register fOutPW(wA + 2, 0x0909); // transfer counter to output latch fOutPW(wA + 2, 0x0202); // read the output latch and see if it matches if (fInPW(wA) != wTestPat) break; if (fInPW(wA) != wTestPat) break; if (fInPW(wA) != wTestPat) break; // now replace the values that you saved previously, in case the // encoder was battery backed up fOutP(wA, enc[wAxesInSys].Byte[0]); fOutP(wA, enc[wAxesInSys].Byte[1]); fOutP(wA, enc[wAxesInSys].Byte[2]); fOutP(wA + 1, enc[wAxesInSys + 1].Byte[0]); fOutP(wA + 1, enc[wAxesInSys + 1].Byte[1]); fOutP(wA + 1, enc[wAxesInSys + 1].Byte[2]); // transfer the preset register to the count register fOutPW(wA + 2, 0x0909); wAxesInSys += 2; // write zeros to preset register, we don't want to do a master reset // (MRST), because then we would need to re-initialize the counter // fOutPW(wA, 0); // fOutPW(wA, 0); // fOutPW(wA, 0); // reset counter, BRW and CRY and address pointer (RADR) // fOutPW(wA + 2, 0x0505); } };

void EncoderLatch (  void    )

Definition at line 1386 of file stgmembs.c. { #if 0 unsigned short wAdd; #endif int max_axes = wAxesInSys; if (wNoBoardFlag == NO_BOARD) { return; } if(max_axes != 8) { max_axes = 4; } // normally you'll have the timer latch the data in hardware, but // if the timer isn't running, we need to latch it ourselves. #if 0 for ( wAdd = wBaseAddress + CNT0_C; wAdd <= wBaseAddress + CNT6_C; wAdd +=4) fOutPW(wAdd, 0x0303); #endif /* BUG FIX-- don't go past 4 axes on 4 axis board */ fOutPW(wBaseAddress + CNT0_C, 0x0303); fOutPW(wBaseAddress + CNT2_C, 0x0303); if (max_axes > 4) { fOutPW(wBaseAddress + CNT4_C, 0x0303); fOutPW(wBaseAddress + CNT6_C, 0x0303); } };

void EncoderResetAddr (  void    )

Definition at line 1423 of file stgmembs.c. { unsigned short wAdd; if (wNoBoardFlag == NO_BOARD) { return; } // This function resets all the counter's internal address pointers to point // to the first byte in the 3 byte sequence for (wAdd = wBaseAddress + CNT0_C; wAdd <= wBaseAddress + CNT6_C; wAdd +=4) fOutPW(wAdd, 0x0101); };

unsigned short GetAddr (  void    )

Definition at line 87 of file stgmembs.c. {return wBaseAddress;};

unsigned short GetAxes (  void    )

Definition at line 85 of file stgmembs.c. {return wAxesInSys;};

unsigned char GetBRDTST (  void    )

Definition at line 1468 of file stgmembs.c. { return fInP(wBaseAddress + BRDTST); }

unsigned short GetBoardPresence (  void    )

Definition at line 84 of file stgmembs.c. {return wNoBoardFlag;};

unsigned char GetCNTRL0 (  void    )

Definition at line 1449 of file stgmembs.c. { return fInP(wBaseAddress + CNTRL0); }

unsigned char GetCNTRL1 (  void    )

Definition at line 1454 of file stgmembs.c. { return fInP(wBaseAddress + CNTRL1); }

unsigned char GetIDLEN (  void    )

Definition at line 1444 of file stgmembs.c. { return fInP(wBaseAddress + IDLEN); }

unsigned char GetIndexLatches (  void    )

Definition at line 938 of file stgmembs.c. { // routine for Model 2 board return fInP(wBaseAddress + IDL); }

unsigned short GetIrq (  void    )

Definition at line 86 of file stgmembs.c. {return wIrq;};

unsigned short GetModel (  void    )

Definition at line 88 of file stgmembs.c. {return wModel;};

unsigned char GetSELDI (  void    )

Definition at line 1439 of file stgmembs.c. { return fInP(wBaseAddress + SELDI); }

short IndexPulse (  void    )

Definition at line 1478 of file stgmembs.c. { // poll for the index pulse of the axis that was previously set up. // Normally you would look at the latched pulse. This function will // probably only get used during testing. unsigned char byIRR, byAxisMask; byIRR = CurrentIRR(); byAxisMask = (byIndexPollAxis & 1) ? IXODD : IXEVN; // even or odd axis? // The raw index pulse isn't inverted by the hardware if the index pulse is // low active (only the latched pulse is). For consistancy, we'll invert // the pulse in software. if (byIndexPulsePolarity == 0) // if pulse is low true byIRR ^= byAxisMask; // flip bit if (byIRR & byAxisMask) // check index pulse return 1; return 0; }

unsigned short IndexPulseLatch (  void    )

Definition at line 914 of file stgmembs.c. { // routine for Model 1 board // poll the latched index pulse of the axis that was previously set up unsigned char byIRR, byAxisMask; byIRR = CurrentIRR(); byAxisMask = (byIndexPollAxis & 1) ? LIXODD : LIXEVN; // even or odd axis? if (byIRR & byAxisMask) // check latched index pulse return 1; return 0; // // a faster, but messier way // //fOutP(wBaseAddress + OCW3, 0x0a); // IRR on next read // //return ( fInP(wBaseAddress + IRR) // & ( (byIndexPollAxis & 1) ? LIXODD : LIXEVN ) // mask for even or odd // ); }

void Initialize (  unsigned short    wRequestedIrq )

Definition at line 257 of file stgmembs.c. Referenced by ServoToGoConstructor(), and stgMotInit(). { /* * First find the the base I/O address of the board. * * only do this in the DOS example. It's dangerous under 95, and can't be * done under NT */ wBaseAddress = BaseFind(); if (wBaseAddress == 0) { wNoBoardFlag = NO_BOARD; } wNoBoardFlag = BOARD_PRESENT; /* * Initialize the interrupt controller */ if (wModel == MODEL1) { fOutP(wBaseAddress + MIO_2, 0x92); // initialize INTC as output reg. // sets port D to input since we have // to set it to something. SetIrq(wRequestedIrq); // selects the IRQ in INTC. Now, if a stray // interrupt is issued (see below) it will // go to an interrupt that isn't enabled on // the motherboard yet (if your system is // set up correctly). fOutP( wBaseAddress + ICW1, 0x1a ); // initialize 82C59 as single chip, // level triggered fOutP( wBaseAddress + ICW2, 0x00 ); // icw2 - not used, must write // could issue stray interrupt here - danger! fOutP( wBaseAddress + OCW1, 0xff); // mask off all interrupt sources (the // interrupt on the motherboard isn't // enabled yet, you do that when you install // your interrupt handler.). } else // must be a Model 2 { fOutP(wBaseAddress + MIO_2, 0x8b); // initialize CNTRL0 as output reg. // BRDTST to input. // sets port D, high and low, to input // since we have to set it to something. SetIrq(wRequestedIrq); // selects the IRQ in CNTRL0. Now, if a stray // interrupt is issued (see below) it will // go to an interrupt that isn't enabled on // the motherboard yet (if your system is // set up correctly). } };

void MaskTimer2Interrupt (  void    )

Definition at line 1615 of file stgmembs.c. { if (wNoBoardFlag == NO_BOARD) { return; } if (wModel == MODEL1) fOutP(wBaseAddress + OCW1, CurrentIRR() | TP2); else // Model 2 // we want to save the state of the slave mode, and set the // high nibble bits high, so you don't reset any latches. // bit pattern: 1111x000 where x is don't change fOutP(wBaseAddress + CNTRL1, (fInP(wBaseAddress + CNTRL1) & CNTRL1_NOT_SLAVE) | 0xf0); }

void MotSim (  void    )

Definition at line 1291 of file stgmembs.c. { static long lState_1[MAX_AXIS] = {0}; // state variables long lScaledUp; const short nScale = 10; int nAxis; for (nAxis = 0; nAxis < MAX_AXIS; nAxis++) { // The input is guaranteed to be +/- 12 bits // Scale up state so we don't loose resolution lScaledUp = lSimDac[nAxis] << nScale; // note: I assume right shift is sign preserving (for signed value) // lag lState_1[nAxis] += (lScaledUp - lState_1[nAxis]) >> (4 + nAxis); //lint !e704 // ^^^^^^^ time constant // is different for each axis // integrator (shift out the scale factor and then some) lSimEnc[nAxis] += lState_1[nAxis] >> (nScale + 1); //lint !e704 } }

short PollTimer2 (  void    )

Definition at line 1578 of file stgmembs.c. { if (wNoBoardFlag == NO_BOARD) { return 0; } if (wModel == MODEL1) return !(CurrentIRR() & TP2); // mask selects bit for TP2 else // MODEL 2 { unsigned char byRegCntrl1, byNewCntrl1; byRegCntrl1 = fInP(wBaseAddress + CNTRL1); if (byRegCntrl1 & CNTRL1_INT_T2) { // If it's set, we want to reset the latch, by writing a zero // to CNTRL1_INT_T2. // When we write to CNTRL1, we don't want to change SLAVE, IEN_G2 // IEN_T2, or IEN_T0 -- the lower 4 bits. So, we start with byNewCntrl1 = byRegCntrl1 & 0x0f; // (0000xxxx) // We don't want to reset WDTOUT, INT_G2, or INT_T0--we only want // to reset ...T2. (1101xxxx) byNewCntrl1 |= CNTRL1_WDTOUT | CNTRL1_INT_G2 | CNTRL1_INT_T0; fOutP(wBaseAddress + CNTRL1, byNewCntrl1); // reset bit return 1; // true } } return 0; // false }

short PortBits2Index (  short    nPort )

Definition at line 1112 of file stgmembs.c. Referenced by DigitalOut1(), and DigitalOut2(). { int nPortIndex = 9; switch(nPort) { case STG_PORT_A: nPortIndex = 0; break; case STG_PORT_B: nPortIndex = 1; break; case STG_PORT_C_LO: case STG_PORT_C_HI: case STG_PORT_C: nPortIndex = 2; break; case STG_PORT_D_LO: case STG_PORT_D_HI: case STG_PORT_D: nPortIndex = 3; break; } return nPortIndex; }

void RawDAC (  unsigned short    nAxis, long    lCounts )

Definition at line 678 of file stgmembs.c. Referenced by ServoToGoDestructor(), ppmcDacWrite(), and stgDacWrite(). { if (wNoBoardFlag == NO_BOARD) { return; } if ( nAxis > 7 ) // is axis within range? return; // input / output: // // lCounts (decimal) ... -lCounts ... +0x1000 ... volts // // 0x1000 (4096) 0xfffff000 0 +10 // 0 0 0x1000 0 // 0xfffff001 (-4095) 0xfff 0x1fff -10 // So, the domain might be different than you expected. I expected: // 0xf000 (-4096) to 0xfff (4095), rather than // 0xf001 (-4095) to 0x1000 (4096) // reverse slope so positive counts give positive voltage lCounts = - lCounts; // shift for DAC lCounts += 0x1000; if (lCounts > 0x1FFF) // clamp + output { lCounts = 0x1FFF; } if (lCounts < 0) // clamp - output { lCounts = 0; } if (wNoBoardFlag == NO_BOARD) // are we simulating? { lSimDac[nAxis] = lCounts; return; } // nCounts = (USHORT) (lCounts + 0x1000); // correct range for DAC fOutPW(wBaseAddress + DAC_0 + (nAxis << 1), (unsigned short)lCounts); };

unsigned long RawDIAll (  void    )

Definition at line 953 of file stgmembs.c. { IO32 xInBits; if (wNoBoardFlag == NO_BOARD) { xInBits.all = 0; return(xInBits.all); } if (wModel == MODEL1) { xInBits.port.A = fInP(wBaseAddress + DIO_A); xInBits.port.B = fInP(wBaseAddress + DIO_B); xInBits.port.C = fInP(wBaseAddress + DIO_C); xInBits.port.D = fInP(wBaseAddress + DIO_D); } else // Model 2 { xInBits.port.A = fInP(wBaseAddress + PORT_A); xInBits.port.B = fInP(wBaseAddress + PORT_B); xInBits.port.C = fInP(wBaseAddress + PORT_C); xInBits.port.D = fInP(wBaseAddress + PORT_D); } return (xInBits.all); };

unsigned char RawDIBitPort (  unsigned char    byBitNumber, short    nPort )

Definition at line 980 of file stgmembs.c. Referenced by stgDioCheck(), and stgDioRead(). { unsigned char nData; if (nPort > 3) return 0; if (wModel == MODEL1) nData = fInP(wBaseAddress + aPortOffset_1[nPort]); else // Model 2 nData = fInP(wBaseAddress + aPortOffset_2[nPort]); return nData & (1 << byBitNumber); }

unsigned char RawDIPort (  short    nPort )

Definition at line 993 of file stgmembs.c. Referenced by stgDioByteCheck(), stgDioByteRead(), stgDioShortRead(), and stgDioWordRead(). { if (nPort > 3) return 0; if (wModel == MODEL1) return fInP(wBaseAddress + aPortOffset_1[nPort]); else return fInP(wBaseAddress + aPortOffset_2[nPort]); }

void RawDOAll (  unsigned long    lOutBits )

Definition at line 1042 of file stgmembs.c. Referenced by DioDirection2(). { if (wNoBoardFlag == NO_BOARD) { return; } if (wModel == MODEL1) { fOutP(wBaseAddress + DIO_A, ((IO32 *)&lOutBits)->port.A); fOutP(wBaseAddress + DIO_B, ((IO32 *)&lOutBits)->port.B); fOutP(wBaseAddress + DIO_C, ((IO32 *)&lOutBits)->port.C); fOutP(wBaseAddress + DIO_D, ((IO32 *)&lOutBits)->port.D); } else // Model 2 { fOutP(wBaseAddress + PORT_A, ((IO32 *)&lOutBits)->port.A); fOutP(wBaseAddress + PORT_B, ((IO32 *)&lOutBits)->port.B); fOutP(wBaseAddress + PORT_C, ((IO32 *)&lOutBits)->port.C); fOutP(wBaseAddress + PORT_D, ((IO32 *)&lOutBits)->port.D); } };

void RawDOBitValPort (  unsigned char    byBitNumber, unsigned char    bySet0or1, unsigned short    nPort )

Definition at line 1064 of file stgmembs.c. Referenced by DigitalOut2(), stgAmpEnable(), and stgDioWrite(). { unsigned nOffset; unsigned char byData; if (wNoBoardFlag == NO_BOARD) { return; } if (nPort > 3) return; if (wModel == MODEL1) nOffset = aPortOffset_1[nPort]; else // Model 2 nOffset = aPortOffset_2[nPort]; byData = fInP(wBaseAddress + nOffset); if (bySet0or1 == 1) byData |= 1 << byBitNumber; else byData &= ~(1u << byBitNumber); fOutP(wBaseAddress + nOffset, byData); };

void RawDOBytePort (  unsigned char    byData, short    nPort )

Definition at line 1091 of file stgmembs.c. Referenced by DigitalOut1(), and stgDioByteWrite(). { if (wNoBoardFlag == NO_BOARD) { return; } if (nPort > 3) return; if (wModel == MODEL1) fOutP(wBaseAddress + aPortOffset_1[nPort], byData); else // Model 2 fOutP(wBaseAddress + aPortOffset_2[nPort], byData); };

long ReadADC (  unsigned short    wAxis, short *    counts_ptr )

Definition at line 407 of file stgmembs.c. { short counts; if(counts_ptr == 0) { return 0; } counts = *counts_ptr; if (wNoBoardFlag == NO_BOARD) { return STG_SUCCESS; } if (wAxis > 7) return STG_FAILURE; if (wModel == MODEL1) { if ( !(CurrentIRR() & 0x08) ) // is the conversion done? return STG_FAILURE; // no, return failure // conversion is done, get counts. // counts = fInPW(wBaseAddress + ADC_0 + (wAxis << 1)); // counts = fInPW(wBaseAddress + ADC_1); // debug } else // Model 2 { // is the conversion done? if ( fInP(wBaseAddress + BRDTST) & BRDTST_EOC ) return STG_FAILURE; // no, return failure // conversion is done, get counts. // counts = fInPW(wBaseAddress + ADC_1); } counts = fInPW(wBaseAddress + ADC_0 + (wAxis << 1)); if (counts & 0x1000) // is sign bit negative? counts |= 0xf000; // sign extend else counts &= 0xfff; // make sure high order bits are zero. *counts_ptr = counts; return STG_SUCCESS; };

unsigned short ReadTimer2TerminalCount (  void    )

Definition at line 1568 of file stgmembs.c. { unsigned short count; char *pByte = (char *)&count; fOutP(wBaseAddress + TMRCMD, 0x80); // timer 2, latch *pByte++ = fInP(wBaseAddress + TIMER_2); // LSB *pByte = fInP(wBaseAddress + TIMER_2); // MSB return count; }

void ResetIndexLatch (  void    )

Definition at line 829 of file stgmembs.c. { // routine for Model 1 fInP(wBaseAddress + ODDRST); //lint !e534 reset index pulse latch for ODD axis fInP(wBaseAddress + BRDTST); //lint !e534 reset index pulse latch for EVEN axis }

void ResetIndexLatches (  unsigned char    byLatchBits )

Definition at line 837 of file stgmembs.c. Referenced by stgEncoderResetIndex(). { // routine for Model 2 fOutP(wBaseAddress + IDL, byLatchBits); }

void ResetWatchdogLatch (  void    )

Definition at line 1459 of file stgmembs.c. { unsigned char byCntrl1 = fInP(wBaseAddress + CNTRL1); byCntrl1 &= ~CNTRL1_WDTOUT; //set bit low, to reset // don't reset other latches byCntrl1 |= CNTRL1_INT_G2 | CNTRL1_INT_T2 | CNTRL1_INT_T0; fOutP(wBaseAddress + CNTRL1, byCntrl1); }

void SelectIndexAxis (  unsigned char    byAxis )

Definition at line 849 of file stgmembs.c. Referenced by stgEncoderReadLatch(), stgEncoderReadLevel(), and stgEncoderResetIndex(). { // routine for Model 1 // overloaded function. Use this if you don't need to set polarity SelectIndexAxisWithPolarity(byAxis, byIndexPulsePolarity); }

void SelectIndexAxisWithPolarity (  unsigned char    byAxis, unsigned char    byPol )

Definition at line 858 of file stgmembs.c. Referenced by SelectIndexAxis(). { // routine for Model 1 // // initialize stuff to poll index pulse // unsigned char byIntc; byIndexPollAxis = byAxis; // save axis to check later byIndexPulsePolarity = byPol; // save polarity as new default byAxis &= 0x6; // ignore low bit, we check 2 axes at a time byAxis <<= 3; // shift into position for IXS1, IXS0 byIntc = fInP(wBaseAddress + INTC); // get a copy of INTC, we'll change // some bits in it, not all byIntc &= ~(IXLVL | IXS1 | IXS0); // zero bits for axis and polarity byIntc |= byAxis; // put axes address in INTC if (byPol != 0) // is index pulse active high? byIntc |= IXLVL; fOutP(wBaseAddress + INTC, byIntc); // ResetIndexLatch(); // The latched index pulse should be low now. If it's not, either something's // wrong, or we happened to initialize it while the index pulse was active. }

void SelectIndexOrExtLatch (  unsigned char    bySelectBits )

Definition at line 885 of file stgmembs.c. { // routine for Model 2 fOutP(wBaseAddress + SELDI, bySelectBits); }

void SelectInterruptPeriod (  long    lPeriodSelect )

Definition at line 584 of file stgmembs.c. Referenced by ServoToGoConstructor(). { if (wNoBoardFlag == NO_BOARD) { return; } if (lPeriodSelect != MAX_PERIOD) { fOutP(wBaseAddress + TMRCMD, 0x56); // timer 1, read/load LSB (MSB is 0) // mode 3 (square wave) fOutP(wBaseAddress + TIMER_1, 0xb4); // 0xb4 = 180 -> 25 uSec period } else { fOutP(wBaseAddress + TMRCMD, 0x76); // timer 1, read/load LSB then MSB // mode 3 (square wave) fOutP(wBaseAddress + TIMER_1, 0xff); // LSB fOutP(wBaseAddress + TIMER_1, 0xff); // MSB } switch (lPeriodSelect) { case _500_MICROSECONDS: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0x14); // 0x14 = 20 = .5 mS fOutP(wBaseAddress + TIMER_0, 0x00); break; case _1_MILLISECOND: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0x28); // 0x28 = 40 = 1 mS fOutP(wBaseAddress + TIMER_0, 0x00); break; case _2_MILLISECONDS: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0x50); // 0x50 = 80 = 2 mS fOutP(wBaseAddress + TIMER_0, 0x00); break; case _3_MILLISECONDS: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0x78); // 0x78 = 120 = 3 mS fOutP(wBaseAddress + TIMER_0, 0x00); break; case _4_MILLISECONDS: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0xA0); // 0xA0 = 160 = 4 mS fOutP(wBaseAddress + TIMER_0, 0x00); break; case _5_MILLISECONDS: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0xC8); // 0xC8 = 200 = 5 mS fOutP(wBaseAddress + TIMER_0, 0x00); break; case _10_MILLISECONDS: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0x90); // 0x0190 = 400 = 10 mS fOutP(wBaseAddress + TIMER_0, 0x01); break; case _100_MILLISECONDS: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0xA0); // 0x0FA0 = 4000 = 100 mS fOutP(wBaseAddress + TIMER_0, 0x0F); break; case _1_SECOND: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0x40); // 0x9C40 = 40000 = 1 S fOutP(wBaseAddress + TIMER_0, 0x9c); break; case MAX_PERIOD: fOutP(wBaseAddress + TMRCMD, 0x34); // timer 0, read/load LSB followed by // MSB, mode 2 (real-time interrupt) fOutP(wBaseAddress + TIMER_0, 0xff); // LSB fOutP(wBaseAddress + TIMER_0, 0xff); // MSB break; default: // wrong input? then don't change it break; } };

void ServoToGoConstructor (  unsigned short    wRequestedIrq )

Definition at line 97 of file stgmembs.c. Referenced by __attribute__(), and stgMotInit(). { #if defined ( STG_LINUX ) iopl(3); // get access to I/O ports, must be root. #endif wNoBoardFlag = NO_BOARD; Initialize(wRequestedIrq); // figure out board address, init irq controller EncoderInit(); SelectInterruptPeriod(_1_MILLISECOND); // initialize timer byIndexPulsePolarity = 1; // default active level high if (wModel == MODEL2) fOutP(wBaseAddress + CNTRL1, CNTRL1_NOT_SLAVE); };

void ServoToGoDestructor (  void    )

Definition at line 117 of file stgmembs.c. { unsigned short nAxis; StopInterrupts(); // set all the DAC outputs to 0. for (nAxis = 0; nAxis < MAX_AXIS; nAxis++) RawDAC(nAxis, 0); // set all the digital I/O bits to input DioDirection2(0); }

void SetDDir (  unsigned short    nSwDir )

Definition at line 1228 of file stgmembs.c. Referenced by DioDirection(), and DioDirection2(). { unsigned char byHwDir; // direction bits for hardware unsigned char bySaveReg, bySaveIMR, bySaveCntrl1, bySaveCntrl0; if (wModel == MODEL1) { bySaveReg = fInP(wBaseAddress + INTC); // INTC needs to be saved, because // MIO_2 reinitializes the 8255 which // implements the INTC register. byHwDir = 0x92; // initialize port D input if (nSwDir & STG_PORT_D) // is port D output? byHwDir &= ~D_DIR_BIT; // if yes, set bit to 0, bySaveIMR = fInP(wBaseAddress + IMR); // get the current interrupt mask fOutP(wBaseAddress + OCW1, 0xff); // mask off all interrupts fOutP(wBaseAddress + MIO_2, byHwDir); // set direction for port D fOutP(wBaseAddress + INTC, bySaveReg); // restore interrupt control reg. fOutP(wBaseAddress + OCW1, bySaveIMR); // restore interrupt mask } else // Model 2 { bySaveCntrl0 = fInP(wBaseAddress + CNTRL0); // CNTRL0 needs to be saved, because // D_DIR reinitializes the 8255 which // implements the CNTRL0 register. byHwDir = 0x8b; // initialize CNTRL0 as output reg. // BRDTST to input. // sets port D, high and low, to input if (nSwDir & STG_PORT_D_LO) // low nibble byHwDir &= ~D_LOW_DIR_BIT; if (nSwDir & STG_PORT_D_HI) // high nibble byHwDir &= ~D_HI_DIR_BIT; bySaveCntrl1 = fInP(wBaseAddress+CNTRL1);// save for interrupt enables // don't reset any latches; put in slave state; // disable interrupts, so the glitch in CTRL0 doesn't // cause an interrupt on wrong irq fOutP(wBaseAddress + CNTRL1, 0xf0); fOutP(wBaseAddress + D_DIR, byHwDir); // set port D direction // restore CNTRL0, because it was re-initialized, which // lost any previous contents. fOutP(wBaseAddress + CNTRL0, bySaveCntrl0); // re-enable interrupts, and restore slave state, don't // reset any latches. (1111xxxx) fOutP(wBaseAddress+CNTRL1, (bySaveCntrl1 & 0x0f) | 0xf0); } };

void SetEncoderCounts (  unsigned short    nAxis, long    lCounts )

Definition at line 1357 of file stgmembs.c. { unsigned short wAddress; char *ByteUnion = (char *)&lCounts; // get pointer to lCounts, so you // can take it apart byte by byte wAddress = wBaseAddress + CNT0_D; wAddress += (nAxis & 0x6) << 1; // shift to multiply by 2 // pairs of data regs seperated by pairs // of control regs, skip over control. wAddress += nAxis & 1; fOutP(wAddress, ByteUnion[0]); fOutP(wAddress, ByteUnion[1]); fOutP(wAddress, ByteUnion[2]); // transfer the preset register to the count register fOutP(wAddress + 2, 0x09); // set things for the part that extends the 24 bit counter // to 32 bits. byEncHighByte[nAxis] = ByteUnion[3]; byOldByte2[nAxis] = ByteUnion[2]; }

void SetIrq (  unsigned short    wRequestedIrq )

Definition at line 135 of file stgmembs.c. Referenced by Initialize(). { unsigned char byIntReg; if (wNoBoardFlag == NO_BOARD) return; wIrq = wRequestedIrq; // assume it's OK for now, check later if (wModel == MODEL1) byIntReg = 0x80; // initial value for the high bits in the register // sets auto zero off else // MODEL2 byIntReg = 0x88; // cal high too, not calibrating ADC // now put low bits into byIntReg to select irq switch (wRequestedIrq) { case 3: break; // add zero case 5: byIntReg |= 4; break; case 7: byIntReg |= 2; break; case 9: byIntReg |= 6; break; case 10: byIntReg |= 5; break; case 11: byIntReg |= 7; break; case 12: byIntReg |= 3; break; case 15: byIntReg |= 1; break; default: wIrq = 5; // ERROR, requested irq not valid, use 5 byIntReg |= 4; // There is no safe value, leaving zero // here would select IRQ 3 which is worse // than 5 because IRQ 3 is usually for COM 2 break; } if (wModel == MODEL1) fOutP(wBaseAddress + INTC, byIntReg); // set irq else // MODEL2 fOutP(wBaseAddress + CNTRL0, byIntReg); }

short SpinReadADC (  unsigned short    wAxis )

Definition at line 366 of file stgmembs.c. Referenced by stgAdcRead(). { short counts; short j; if (wNoBoardFlag == NO_BOARD) { return 0; } if (wAxis > 7) return -1; if (wModel == MODEL1) { // make sure conversion is done, assume polling delay is done. // EOC (End Of Conversion) is bit 0x08 in IIR (Interrupt Request // Register) of Interrupt Controller. Don't wait forever though // bail out eventually. for ( j = 0; (!(CurrentIRR() & 0x08)) && (j < 10000); j++); counts = ( fInPW(wBaseAddress + ADC_0 + (wAxis << 1)) ); } else { // is the conversion done? for ( j = 0; (fInP(wBaseAddress + BRDTST) & BRDTST_EOC) && (j < 10000); j++); // conversion is done, get counts. counts = fInPW(wBaseAddress + ADC); } if (counts & 0x1000) // is sign bit negative? counts |= 0xf000; // sign extend else counts &= 0xfff; // make sure high order bits are zero. return counts; };

void StartADC (  unsigned short    wAxis )

Definition at line 313 of file stgmembs.c. Referenced by stgAdcStart(), and stgAioRead(). { if (wNoBoardFlag == NO_BOARD) { return; } if (wAxis > 7) return; if (wModel == MODEL1) { // do a dummy read from the ADC, just to set the input multiplexer to // the right channel fInPW(wBaseAddress + ADC_0 + (wAxis << 1)); //lint !e534 // wait 4 uS for settling time on the multiplexer and ADC // you probably shouldn't really have a delay in // a driver. Timer2Delay(28); // now start conversion. fOutPW(wBaseAddress + ADC_0 + (wAxis << 1), 0); } else // Model 2 { unsigned char Cntrl0; Cntrl0 = fInP(wBaseAddress + CNTRL0) & 0x07; // save irq Cntrl0 |= (wAxis << 4) | 0x88; // shift bits to AD2, AD1, AD0 // set bit 0x80 high for autozero // set bit 0x08 high, not calibrating fOutP(wBaseAddress + CNTRL0, Cntrl0); // select ADC channel // don't have to do a dummy read for a model 2 // wait 4 uS for settling time on the multiplexer and ADC // you probably shouldn't really have a delay in // a driver. Timer2Delay(28); // now start conversion. fOutPW(wBaseAddress + ADC, 0); } };

void StartInterrupts (  void    )

Definition at line 1651 of file stgmembs.c. { if (wNoBoardFlag == NO_BOARD) { return; } if (wModel == MODEL1) fOutP(wBaseAddress + OCW1, ~0x04); // enable interrupt for timer 0 else // MODEL2 // we want to save the state of the slave mode, and set the // high nibble bits high, so you don't reset any latches. // 1111x001, where x means don't change { fOutP(wBaseAddress + CNTRL1, CNTRL1_IEN_T0 | CNTRL1_NOT_SLAVE); } };

void StartTimer2RTI (  unsigned short    count )

Definition at line 1553 of file stgmembs.c. { char *pByte; if (wNoBoardFlag == NO_BOARD) { return; } pByte = (char *)&count; fOutP(wBaseAddress + TMRCMD, 0xb4); // timer 2, read/load LSB followed // by MSB, mode 2 (real time int). fOutP(wBaseAddress + TIMER_2, *pByte++); // LSB (little endian) fOutP(wBaseAddress + TIMER_2, *pByte); // MSB }

void StartTimer2TerminalCount (  unsigned short    count )

Definition at line 1538 of file stgmembs.c. Referenced by Timer2Delay(). { char *pByte; if (wNoBoardFlag == NO_BOARD) { return; } pByte = (char *)&count; fOutP(wBaseAddress + TMRCMD, 0xb0); // timer 2, read/load LSB followed // by MSB, mode 0 (terminal count) fOutP(wBaseAddress + TIMER_2, *pByte++); // LSB (little endian) fOutP(wBaseAddress + TIMER_2, *pByte); // MSB }

void StopInterrupts (  void    )

Definition at line 1673 of file stgmembs.c. { if (wNoBoardFlag == NO_BOARD) { return; } if (wModel == MODEL1) fOutP(wBaseAddress + OCW1, 0xff); // disable all interrupts else // MODEL2 // we want to save the state of the slave mode, and set the // high nibble bits high, so you don't reset any latches. // disable all interrupts, since only one can be enabled at // a time (currently). If more than one was enabled, it's // an error (currently). // 1111x000, where x means not changed. fOutP(wBaseAddress + CNTRL1, (fInP(wBaseAddress + CNTRL1) & CNTRL1_NOT_SLAVE) | 0xf0); };

void StopTimer (  void    )

Definition at line 1506 of file stgmembs.c. { if (wNoBoardFlag == NO_BOARD) { return; } // stop the timer by putting it into one shot mode, it will never get // a trigger // bug bug this doesn't work fOutP(wBaseAddress + TMRCMD, 0x0a); // timer 0, mode 1 }

void Timer2Delay (  unsigned short    counts )

Definition at line 1526 of file stgmembs.c. Referenced by StartADC(). { if (wNoBoardFlag == NO_BOARD) { return; } StartTimer2TerminalCount(counts); while (PollTimer2()); }

void UnMaskTimer2Interrupt (  void    )

Definition at line 1632 of file stgmembs.c. { if (wModel == MODEL1) fOutP(wBaseAddress + OCW1, CurrentIRR() & ~TP2); else // Model 2 { // we want to save the state of the slave mode, and set the // high nibble bits high, so you don't reset any latches. // bit pattern: 1111x010 where x is don't change fOutP(wBaseAddress + CNTRL1, (fInP(wBaseAddress + CNTRL1) & CNTRL1_NOT_SLAVE) | CNTRL1_IEN_T2); } }

char __attribute__ (  (unused)    )  [static]

Definition at line 31 of file stgmembs.c. : stgmembs.c,v 1.5 2001/11/05 16:59:55 wshackle Exp $"; #include "locdefs.h" #define assert(a) #include "offsets.h" #include "stgdefs.h" #include "locsysio.h" inline void fOutP(unsigned short port, unsigned char data) { outb(data, port); }

unsigned char fInP (  unsigned short    port )  [inline]

Definition at line 52 of file stgmembs.c. { return inb(port); }

unsigned short fInPW (  unsigned short    port )  [inline]

Definition at line 57 of file stgmembs.c. { return inw(port); }

void fOutPW (  unsigned short    port, unsigned short    data )  [inline]

Definition at line 47 of file stgmembs.c. { outw(data, port); }

---

Variable Documentation

const int aPortOffset_1[] = {DIO_A, DIO_B, DIO_C, DIO_D} [static]

Definition at line 73 of file stgmembs.c.

const int aPortOffset_2[] = {PORT_A, PORT_B, PORT_C, PORT_D} [static]

Definition at line 74 of file stgmembs.c.

unsigned char byEncHighByte[MAX_AXIS] [static]

Definition at line 76 of file stgmembs.c.

unsigned char byIndexPollAxis [static]

Definition at line 68 of file stgmembs.c.

unsigned char byIndexPulsePolarity [static]

Definition at line 69 of file stgmembs.c.

unsigned char byOldByte2[MAX_AXIS] [static]

Definition at line 77 of file stgmembs.c.

long lSimDac[MAX_AXIS] [static]

Definition at line 70 of file stgmembs.c.

long lSimEnc[MAX_AXIS] [static]

Definition at line 71 of file stgmembs.c.

unsigned short wAxesInSys [static]

Definition at line 66 of file stgmembs.c.

unsigned short wBaseAddress [static]

Definition at line 62 of file stgmembs.c.

unsigned short wIrq [static]

Definition at line 63 of file stgmembs.c.

unsigned short wModel [static]

Definition at line 64 of file stgmembs.c.

unsigned short wNoBoardFlag [static]

Definition at line 65 of file stgmembs.c.

unsigned short wSaveDirs [static]

Definition at line 67 of file stgmembs.c.

---