#define numberofrepeatspersram 16

#define DEFAULT_ADDRESS 0x300
#define COUNTER_OFFSET  0x14

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

#ifndef FALSE
#define FALSE 0
#define TRUE  !FALSE
#endif

#define PI 3.14159265L

//bindex is the static ram address, 17 significant digits
unsigned long bindex;

//value is the 16-bit value (12 bit DAC data, 4 bit DAC control) we write
unsigned int value;

unsigned int base;

//wavepoint is the floating point waveform we are generating
double wavepoint;

typedef unsigned uint;

unsigned long IRQCount=0L;

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)())
{
   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);
   }
}

void interrupt far newisr()
{
//  IRQOccurred |= InPortB(Base + 1);
  ++IRQCount;
  outportb(base+0x1E,0);
  sendEOI();
}
#pragma inline
unsigned long InPortDW(unsigned Port)
{
  register unsigned long Value;
  asm {
    mov dx,[Port]
    in eax,dx
    mov [Value],eax
  }
  return Value;
}

void OutPortDW(unsigned Port, unsigned long Value)
{
  asm {
    mov dx,[Port]
    mov eax,[Value]
    out dx,eax
  }
}

void CtrMode(uint addr, char cntr, char mode)
{
  int ctrl;
  ctrl = (cntr << 6) | 0x30 | (mode << 1);
  outp(addr+3,ctrl);
}

void CtrLoad(uint addr ,int c,int val)
{
  outp(addr+c,val & 0x00FF);
  outp(addr+c,(val>>8) & 0x00FF);
}

uint CtrRead(uint addr , uint c)
{
  outp(addr+3,c<<6);
  return inp(addr+c) + (inp(addr+c) << 8);
}

unsigned AskForNumDACs(void)
{
    char key;
    int Success = FALSE;
    int AddrInputPosX, AddrInputPosY;

    clrscr();
    puts("The program will output the waveform you've specified onto as many\n"
         "DACs as you choose.  Each DAC will receive the waveform at half the\n"
         "rate of the previous DAC.\n"
         "Please enter the number of DACs to which you wish to output:"
        );
    AddrInputPosX = wherex(); AddrInputPosY = wherey();
    do {
        gotoxy(AddrInputPosX, AddrInputPosY);
        clreol();
        key=getche();
        if ((key>'0') && (key<'9')) Success=TRUE;
    } while(!Success);
    return (key-'0');
} /* end of AskForNumDACs */


unsigned AskForBaseAddress(unsigned int OldOne)
{
    char msg[7];
    int NewOne = 0, Success = 0, Dummy;
    int AddrInputPosX, AddrInputPosY;

    puts("Please enter the Base Address for your card (in hex)");
    printf("or press ENTER for %X.\n>", OldOne);
    AddrInputPosX = wherex(); AddrInputPosY = wherey();
    do {
        gotoxy(AddrInputPosX, AddrInputPosY);
        clreol();
        msg[0] = 5; msg[1] = 0;
        cgets(msg);
        sscanf(msg + 2, "%x", &NewOne);
      Success = 1;
      Dummy = NewOne;
        if (msg[1] == 0) {
            gotoxy(AddrInputPosX, AddrInputPosY);
            printf("%X", OldOne);
            Success = 1;
            Dummy = OldOne;
        }
    } while(!Success);
    return (Dummy);
} /* end of AskForBaseAddress */


//returns a number between 0 and 1
double mathfunc(uint whichfunc,unsigned long int index)
{ double temp=0.0L;
  switch(whichfunc)
  {
    case 0:temp=sin(index * PI / 4096L);
           temp=temp * sin(index * PI * 15.0L / 4096);
           break;
    default:
           temp=sin(index * whichfunc * PI / 4096L);
           temp=temp * sin(index*whichfunc * PI * 16.0L / 4096);
           temp=((index&2)==2)?temp:-temp;
           break;
  };//case
  return temp;
}

//turns a number that should be between -1 and 1 into 0-4096 safely
unsigned dacfunc(uint f,unsigned long int i)
{
  return ((uint)(mathfunc(f,i)*2047)+2048) & 0x0FFF;
}

void main(void)
{
   uint curnumdacs=0,numdacs=0,dac=0;
   unsigned long bindex=0L,findex=0L;
   char done=0;

   clrscr();
   puts("Buffered Sample\n"
        "This sample loads the SRAM with an analog waveform.\n"
        "The waveform is output on all DACs, with each dac being updated half\n"
        "as often as the previous dac.\n"
        "A different waveform is loaded in each DAC:\n"
        "\n"
       );

   base= 0x300;  //AskForBaseAddress( DEFAULT_ADDRESS);
   numdacs=AskForNumDACs();
   CtrMode( base+COUNTER_OFFSET, 0, 2);
   CtrMode( base+COUNTER_OFFSET, 1, 2);
   CtrMode( base+COUNTER_OFFSET, 2, 2);
   CtrLoad( base+COUNTER_OFFSET, 0, 10000);
   CtrLoad( base+COUNTER_OFFSET, 1, 8);
   CtrLoad( base+COUNTER_OFFSET, 2, 5);

   initirq(5,newisr);
   outportb(base+0x10,0);//STOP any previous GO
   outportb(base+0x10,0x42);//clear voltage restrict - enable CTR0 IRQs
   outportb(base+0x1E,0);//clear pending IRQs


   clrscr();
   gotoxy(1, 15);
   value=0;
   dac=0;
   curnumdacs=0;
   do
   {
     for (dac=0;dac<=curnumdacs;dac++)
     {
       value=dacfunc(dac,findex/(dac+1));
//write address and value to the SRAM buffer
       OutPortDW(base+0x18,bindex);
       outport(base+0x1C,value | ((dac==curnumdacs) ? 0x2000:0));
       bindex+=2;
     }
     findex++;
     curnumdacs++;
     curnumdacs%=numdacs;
   }while(bindex<0x1FFFC);

   outport(base+0x1c,value|0x7000);

   puts("Press any key to exit (without stopping dac buffered outputs)");

   outportb(base+0x10,1);//GO

   while(!done)
   { if (kbhit())
     {
       done=(getch()==27);
       while(kbhit())getch();
     }
     gotoxy(20,20);
     printf("%ld",IRQCount);
   };
   puts("Done. (not stopped)");
   restoreirq(5);

}