#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>

#define FIFOHALF 1024  //The FIFO is 2048 samples long, half is 1024 words

unsigned short Buf[FIFOHALF];
unsigned long IRQCount;

unsigned int BASE=0x300;
unsigned int IRQPIN=5;




//INSW - input string of words
void insw(unsigned short Port, void far *Buf, int Count)
{
   _ES = FP_SEG(Buf);   /* Segment of Buf */
   _DI = FP_OFF(Buf);   /* Offset of Buf  */
   _CX = Count;         /* Number to read */
   _DX = Port;          /* Port           */
   asm   REP INSW;
}



char far *VM = (char far *)MK_FP(0xB800, 0);
const char HexDigit[16] = "0123456789ABCDEF";

char *WordToPChar(unsigned short Data)
{
  static char Lit[5];

  Lit[4] = 0;
  Lit[3] = HexDigit[Data & 0xF];
  Lit[2] = HexDigit[(Data >> 4) & 0xF];
  Lit[1] = HexDigit[(Data >> 8) & 0xF];
  Lit[0] = HexDigit[(Data >> 12) & 0xF];
  return Lit;
}

void PrintWord(int XR, int Y, unsigned short Data)
{
  char far *Tar = VM + (Y * 80 + XR) * 2;
  *Tar = HexDigit[Data & 0xF];
  Data >>= 4;
  Tar -= 2;
  *Tar = HexDigit[Data & 0xF];
  Data >>= 4;
  Tar -= 2;
  *Tar = HexDigit[Data & 0xF];
  Data >>= 4;
  Tar -= 2;
  *Tar = HexDigit[Data & 0xF];
}

void PrintNybble(int X, int Y, unsigned char Data)
{
  char far *Tar = VM + (Y * 80 + X) * 2;
  *Tar = HexDigit[Data & 0xF];
}

void PrintChar(int X, int Y, char Data)
{
  char far *Tar = VM + (Y * 80 + X) * 2;
  *Tar = Data;
}

unsigned AskFor(char *prompt, unsigned int OldOne)
{
	char msg[8];
	unsigned int NewOne = 0, Success = 0, Dummy;
	int AddrInputPosX, AddrInputPosY;

	printf("\n\nPlease enter the %s for your card (in hex)",prompt);
	printf("or press ENTER for %X.\n>", OldOne);
	AddrInputPosX = wherex(); AddrInputPosY = wherey();
	do {
		gotoxy(AddrInputPosX, AddrInputPosY);
		clreol();
		msg[0] = 3; msg[1] = 0;
		cgets(msg);
		sscanf(msg + 2, "%x", &NewOne);
		if ( (NewOne >= 0x2) && (NewOne <= 0xF) )
		{
			Success = 1;
			Dummy = NewOne;
		} else if (msg[1] == 0) {
			gotoxy(AddrInputPosX, AddrInputPosY);
			printf("%X", OldOne);
			Success = 1;
			Dummy = OldOne;
		}
	} while(!Success);
	return (Dummy);
} /* end of AskForIRQ */



//8254 functions
void CtrMode(unsigned char Ctr, unsigned char Mode)
{
    unsigned char Ctrl = (Ctr << 6) | 0x30 | (Mode << 1);
    outportb(BASE+0x14+3, Ctrl);
}

void CtrLoad(unsigned char Ctr, unsigned short Data)
{
    outportb(BASE+0x14+Ctr, Data & 0xFF);
    outportb(BASE+0x14+Ctr, Data >> 8);
}

//Baseless 8254 functions
void CtrMode(unsigned short Base, unsigned char Ctr, unsigned char Mode)
{
    unsigned char Ctrl = (Ctr << 6) | 0x30 | (Mode << 1);
    outportb(Base+3, Ctrl);
}

void CtrLoad(unsigned short Base, unsigned char Ctr, unsigned short Data)
{
    outportb(Base+Ctr, Data & 0xFF);
    outportb(Base+Ctr, Data >> 8);
}




//IRQ array and functions

//In C++, ISRs take (...) arguments
#ifdef __cplusplus
  #define __CPPARGS ...
#else
  #define __CPPARGS
#endif

void interrupt far (*oldisr[16])(__CPPARGS);  //global to store old handler pointer

void SendEOI(void)
{
   outportb(0xA0, 0x20);
   outportb(0x20, 0x20);
}

unsigned char initirq(char IRQnumber,void interrupt (*ISR)(__CPPARGS))
{
   unsigned char intmask, oldmask;

   if (IRQnumber <=7) {
      oldmask = inportb(0x21);
      oldisr[IRQnumber] = getvect(IRQnumber + 8);
      setvect(IRQnumber + 8,ISR);
      intmask = oldmask & (~(1 << IRQnumber));
      outportb(0x21,intmask);
   } else {
      oldmask = inportb(0xA1);
      oldisr[IRQnumber] = getvect(IRQnumber + 0x70 - 8);
      setvect(IRQnumber - 8 + 0x70, ISR);
      intmask = oldmask & (~(1 << (IRQnumber - 8)));
      outportb(0xA1, intmask);
   }
   return(oldmask);
}

void restoreirq(char IRQnumber)
{
   unsigned char intmask;

   if (IRQnumber <=7 ){
      intmask = inportb(0x21);
      intmask |= (1 << IRQnumber);
      setvect(IRQnumber + 8,oldisr[IRQnumber]);
      outportb(0x21, intmask);
   } else {
      intmask = inportb(0xA1);
      intmask |= (1 << (IRQnumber - 8));
      setvect(IRQnumber - 8 + 0x70, oldisr[IRQnumber]);
      outportb(0xA1, intmask);
   }
}




//board config variables and utility functions
unsigned char ADRange, dacArange, dacBrange;

//sbitd takes data and bit, then returns 0x81 or 0x01 based on data[bit]
unsigned char sbitd(unsigned int data,unsigned char bit)
{
  return (data & (1<<bit))?0x81:0x01;
}

unsigned int EEPROM_Read(unsigned int addr)
{
  unsigned int data=0;
  outportb(BASE+0x0a,0x81);//Start Bit
  outportb(BASE+0x0a,0x81);//Opcode Bit 0 (10=Read)
  outportb(BASE+0x0a,0x01);//Opcode Bit 1  ""
  outportb(BASE+0x0a,sbitd(addr,5));//a5 (address to write to)
  outportb(BASE+0x0a,sbitd(addr,4));//a4
  outportb(BASE+0x0a,sbitd(addr,3));//a3
  outportb(BASE+0x0a,sbitd(addr,2));//a2
  outportb(BASE+0x0a,sbitd(addr,1));//a1
  outportb(BASE+0x0a,sbitd(addr,0));//a0

  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d15
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d14
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d13
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d12
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d11
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d10
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d9
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d8
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d7
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d6
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d5
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d4
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d3
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d2
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d1
  data=(data<<1) | ((inportb(BASE+0x0a) & 0x80)?1:0);//d0
  outportb(BASE+0x0a,0x00);//end com
  return data;
}

void CAL_ADC(unsigned char M,unsigned char B)
{ //write cal to A/D, offset first, then slope
  outportb(BASE+0x0b,0x01);//a1 pot 00 is offset
  outportb(BASE+0x0b,0x01);//a0 ""
  outportb(BASE+0x0b,sbitd(B,7));//data bit 7 of offset
  outportb(BASE+0x0b,sbitd(B,6));//data bit 6 of offset
  outportb(BASE+0x0b,sbitd(B,5));//data bit 5 of offset
  outportb(BASE+0x0b,sbitd(B,4));//data bit 4 of offset
  outportb(BASE+0x0b,sbitd(B,3));//data bit 3 of offset
  outportb(BASE+0x0b,sbitd(B,2));//data bit 2 of offset
  outportb(BASE+0x0b,sbitd(B,1));//data bit 1 of offset
  outportb(BASE+0x0b,sbitd(B,0));//data bit 0 of offset
  outportb(BASE+0x0b,0x00);//end trans
  //write slope now
  outportb(BASE+0x0b,0x01);//a1 pot 01 is slope of A/D
  outportb(BASE+0x0b,0x81);//a0 pot 01 is slope of A/D
  outportb(BASE+0x0b,sbitd(M,7));//data bit 7 of slope
  outportb(BASE+0x0b,sbitd(M,6));//data bit 6 of slope
  outportb(BASE+0x0b,sbitd(M,5));//data bit 5 of slope
  outportb(BASE+0x0b,sbitd(M,4));//data bit 4 of slope
  outportb(BASE+0x0b,sbitd(M,3));//data bit 3 of slope
  outportb(BASE+0x0b,sbitd(M,2));//data bit 2 of slope
  outportb(BASE+0x0b,sbitd(M,1));//data bit 1 of slope
  outportb(BASE+0x0b,sbitd(M,0));//data bit 0 of slope
  outportb(BASE+0x0b,0x00);//end trans
}

void CAL_DAC(unsigned char DACNum,unsigned char M)
{
  outportb(BASE+0x0b,0x81);//a1 pot 10 is slope of DAC0
  outportb(BASE+0x0b,sbitd(DACNum,0));//a0 pot 11 is slope of DAC1
  outportb(BASE+0x0b,sbitd(M,7));//data bit 7 of slope
  outportb(BASE+0x0b,sbitd(M,6));//data bit 6 of slope
  outportb(BASE+0x0b,sbitd(M,5));//data bit 5 of slope
  outportb(BASE+0x0b,sbitd(M,4));//data bit 4 of slope
  outportb(BASE+0x0b,sbitd(M,3));//data bit 3 of slope
  outportb(BASE+0x0b,sbitd(M,2));//data bit 2 of slope
  outportb(BASE+0x0b,sbitd(M,1));//data bit 1 of slope
  outportb(BASE+0x0b,sbitd(M,0));//data bit 0 of slope
  outportb(BASE+0x0b,0x00);//end trans
}

void CAL(void)
{
  unsigned char zDAM, zDBM, zAM, zAB;

  zAB=EEPROM_Read((ADRange+0))&0xff;  //byte 0-7 in EEPROM holds "B" for ADC
  zAM=EEPROM_Read((ADRange+8))&0xff;  //byte 8-f in EEPROM holds "M" for ADC
  zDAM=EEPROM_Read((dacArange+0x10))&0xff; //byte x10,x11 in EEPROM holds "M" for DAC0
  zDBM=EEPROM_Read((dacBrange+0x12))&0xff; //byte x12,x13 in EEPROM holds "M" for DAC1
  CAL_DAC(0,zDAM);//write the calibration value from EEPROM to CAL Pots
  CAL_DAC(1,zDBM);// ""
  CAL_ADC(zAM,zAB);// ""
}




void Init(void)
{
  unsigned char jumpers;
  jumpers = inportb(BASE+0x08);//jumper configuration readback
  ADRange = jumpers & 0x07;//d0,d1,d2 are 16ch, 5V, Bip
  dacBrange = (jumpers>>3) & 0x01;//d4,d3 are 5V for daca,b
  dacArange = (jumpers>>4) & 0x01;
  CAL();
}

void StopAndReset(void)  //Checked vs Manual
{
  inportb(BASE+0x1D);//perform master RESET
  outportb(BASE+0x1E, 0x00);
  outportb(BASE+0x1A, 0x00);
  outportb(BASE+0x1C,0x00);
  outportb(BASE+0x03, 0x00);
}

void StartTimedConversions(void)  //Checked vs Manual
{
   //Start process
  outportb(BASE+0x01, 0x00); //Clear FIFO
  outportb(BASE+0x0C, 0x10); //Enable FIFO half full IRQs
  CtrMode(0, 2);
  CtrLoad(0, 0x0005); //Ctr 0 is an unknown, but we think it needs to be set like this
  //Ctr 1 & 2 total divisor of 80 (with our 10MHz clock) gives 125kHz scan rate.
  //  125kHz is the maximum scan rate for two channel operation on this card
  CtrMode(1, 2);
  CtrMode(2, 2);
  CtrLoad(1, 0x0002);
  CtrLoad(2, 0x0028); //0x02 x 0x28 == 80 decimal

  outportb(BASE+0x1A, 0x10); //Enable Operation
  outportb(BASE+0x1E, 0x40); //Enable triggered conversions
}

void interrupt far newisr(__CPPARGS)
{
  insw(BASE + 0x0, Buf, FIFOHALF); //Read half a fifo from the card on each IRQ
  ++IRQCount;
  PrintChar(13, 6, IRQCount);
  outportb(BASE+0x0C, 0x10); //Clear/enable FIFO half full IRQs
  SendEOI();
}

void PrintHeader(void)
{
  clrscr();
  cputs("Speed Sample\r\n");
  cprintf("Card at Base Address %04X and IRQ %02X (hex).\n\r",BASE,IRQPIN);
  cputs("This sample acquires from A/D channels 0 and 1 at 125kHz per channel.\r\n");
  cputs("Data is displayed in the idle time between acquisition.\r\n\r\n");

  cprintf("A/D:   %s %s\r\n\r\n",
	 (ADRange&0x02)?
	   ((ADRange&0x04)?"ñ5V":"ñ10V")
	 :
	   ((ADRange&0x04)?"0-10V":"0-10V(Low Res)") //0-10V(Low Res) is
	 ,                                           //in theory 0-20V,
	 (ADRange&0x01)?"16ch":"8ch"                 //but the amps cap
						     //at 10V
  );

  gotoxy(11, 9);
  cputs("Ch 0      Ch 1");
  gotoxy(11, 10);
  cputs("....      ....");

  gotoxy(1, 12);
  cputs("Press any key to exit.\r\n");
}

void main(void)
{
  unsigned long OIRQCount = 0;
  IRQCount = 0;

  directvideo = 1;
  clrscr();

  BASE = AskFor("Base Address",BASE);

  IRQPIN = AskFor("IRQ Number",IRQPIN);

  StopAndReset();
  Init();
  PrintHeader();

  outport(BASE + 0x04, 0x0000);//set all gains to code zero, which is "times 1" of the jumper configured range.
  outportb(BASE + 0x02, 0x10);//set start channel to zero, set end channel to one.
  StartTimedConversions();

  initirq(IRQPIN, newisr);


/*

  This sample demonstrates how to acquire fast data in the background using
  IRQs on FIFO HALF.  It does NOT properly demonstrate how to use or display
  that data.

  Specifically, multiple IRQs can occur between display passes.  kbhit() is
  very slow, for example.

  This sample takes all the data off the card, but only displays as it can.

  Also, we're only displaying the first reading in the FIFO for each channel.
  The rest of the data is thrown away.

*/


  while(-1)
  {
    if ( IRQCount != OIRQCount )
    {
      OIRQCount = IRQCount;

      PrintWord(13, 9, Buf[0]);
      PrintWord(23, 9, Buf[1]);
    }

    if ( kbhit() )
    {
      getch();
      break;
    }
  }

  StopAndReset();
  restoreirq(IRQPIN);
}