/* -------------------------------------------------------------- */
/* DEMO13: Software calibration                                   */
/* step1 : Connect PIO-DA16/8/4 calibration kit                   */
/* step2 : Run DEMO13.EXE                                         */
/* -------------------------------------------------------------- */
#include  <stdio.h>
#include  <conio.h>
#include  <stdlib.h>
#include  <dos.h>

#include "PIO.H"

#define TIMEOUT         12000L

#define PreSetN10V      500
#define PreSetP10V      15000
#define PreSet00mA      9000
#define PreSet20mA      15000

int   iComPort,iChksum,j,MaxChannel;
WORD  wBase,wIrq,EEP;
WORD  wDelay1=2000;
WORD  wN10V[16],wP10V[16],w00mA[16],w20mA[16];
float rr[16];
char  str1[40],str2[40],str3[40];

long int lBaudRate;

int  save_neg_10v_to_eeprom(void);
int  save_pos_10v_to_eeprom(void);
int  save_00mA_to_eeprom(void);
int  save_20mA_to_eeprom(void);
int  cal_N10V(void);
int  cal_P10V(void);
int  cal_00mA(void);
int  cal_20mA(void);
int  check_pioda_calibrator(void);
int  PIODA_AnalogOutput(int, int);
int  compute_now_neg_voltage(WORD wChannel, float *fVal);
int  compute_now_pos_voltage(WORD wChannel, float *fVal);
int  compute_now_current(WORD wChannel, float *fVal);
int  from_str_to_float1(char str[], float *f);
int  from_str_to_float2(char str[], float *f);
int  from_str_to_float3(char str[], float *f);

int main()
{
int   i,h,l;
WORD  wBoards,wRetVal,t1,t2,t3,t4,t5,t6;
WORD  wSubVendor,wSubDevice,wSubAux,wSlotBus,wSlotDevice;
WORD  k,wStart,wBegin1,wBegin2;
char  c,str1[80];

clrscr();

/* step1 : find address-mapping of PIO/PISO cards                 */
wRetVal=PIO_DriverInit(&wBoards,0x80,0x04,0x00);  /* for PIO-DA16 */
printf("\n(1) Threr are %d PIO-DA16/8/4 Cards in this PC",wBoards);
if ( wBoards==0 )  exit(0);

printf("\n\n-------------- The Configuration Space --------------");
for(i=0;i<wBoards;i++)
   {
   PIO_GetConfigAddressSpace(i,&wBase,&wIrq,&wSubVendor,&wSubDevice,&wSubAux,&wSlotBus,&wSlotDevice);

   printf("\nCard_%d: wBase=%x,wIrq=%x,subID=[%x,%x,%x],SlotID=[%x,%x]",i,wBase,wIrq,wSubVendor,wSubDevice,wSubAux,wSlotBus,wSlotDevice);

   printf(" --> ");
   ShowPioPiso(wSubVendor,wSubDevice,wSubAux);
   }

PIO_GetConfigAddressSpace(0,&wBase,&wIrq,&t1,&t2,&t3,&t4,&t5);
                                                 /* select card_0 */
/* step2 : enable all D/I/O port                                  */
outportb(wBase,0x11);                             /* /RESET -> 1  */

outportb(wBase+2,0x1C);           /* AUX 4/3/2 are D/O, othes D/I */
outportb(wBase+3,0);              /* all D/O are Low              */

printf("\n\n(2) DEMO13 D/A Calibrator test");

iComPort=1; iChksum=0; lBaudRate=9600L;
OPEN_COM(iComPort,lBaudRate);                          /* default */

i=check_pioda_calibrator();
if ((i&0x01) != 0) printf("\n Modul-1 Error");
if ((i&0x02) != 0) printf("\n Modul-2 Error");
if ((i&0x04) != 0) printf("\n Modul-3 Error");
if ((i&0x08) != 0) printf("\n Modul-4 Error");
if ((i&0x0f) == 0) printf("\n Check PIODA Calibrator OK");

printf("\n(1) PIO-DA16");
printf("\n(2) PIO-DA8");
printf("\n(3) PIO-DA4\n\n");
do
{
printf("\rSelect (1-3): \b");
c=getche();
switch(c)
   {
   case '1': MaxChannel=16;
             break;
   case '2': MaxChannel=8;
             break;
   case '3': MaxChannel=4;
             break;
   default : MaxChannel=0;
   }
}
while(MaxChannel==0);

init();

for(;;)
   {
   clrscr();
   gotoxy(1,1);
   printf("***************************************");
   printf("\n*            D/A Calibrator           *");
   printf("\n*-------------------------------------*");
   printf("\n* (1) -10V          (2) +10V          *");
   printf("\n* (3)  0mA          (4) 20mA          *");
   printf("\n* (5)  All          (6) QUIT          *");
   printf("\n***************************************");
   printf("\n\nSelect (1-5):");c=getche();
   printf("\n\nWait ....");
   switch (c)
      {
      case '1': cal_N10V();
                break;
      case '2': cal_P10V();
                break;
      case '3': cal_00mA();
                break;
      case '4': cal_20mA();
                break;
      case '5': cal_N10V();
                cal_P10V();
                cal_00mA();
                cal_20mA();
                break;
      case '6': return;
      default : return;
      }

   clrscr();
   gotoxy(1,15);
   for (i=0; i<16; i++)
       {
       EEP_READ(i,&j,&k);
       l=wN10V[i]&0xff;
       h=(wN10V[i]>>8)&0xff;
       printf("\nREAD i=%2d, j=%2x, k=%2x, h=%2x, l=%2x",i,j,k,h,l);
       }
   getch();

   clrscr();
   gotoxy(1,15);
   for (i=16; i<32; i++)
       {
       EEP_READ(i,&j,&k);
       l=wP10V[i-16]&0xff;
       h=(wP10V[i-16]>>8)&0xff;
       printf("\nREAD i=%2d, j=%2x, k=%2x, h=%2x, l=%2x",i,j,k,h,l);
       }
   getch();

   clrscr();
   gotoxy(1,15);
   for (i=32; i<48; i++)
       {
       EEP_READ(i,&j,&k);
       l=w00mA[i-32]&0xff;
       h=(w00mA[i-32]>>8)&0xff;
       printf("\nREAD i=%2d, j=%2x, k=%2x, h=%2x, l=%2x",i,j,k,h,l);
       }
   getch();

   clrscr();
   gotoxy(1,15);
   for (i=48; i<64; i++)
       {
       EEP_READ(i,&j,&k);
       l=w20mA[i-48]&0xff;
       h=(w20mA[i-48]>>8)&0xff;
       printf("\nREAD i=%2d, j=%2x, k=%2x, h=%2x, l=%2x",i,j,k,h,l);
       }
   getch();

   }
outportb(wBase+3,0);                           /* all D/O are Low */
outportb(wBase+2,0);                           /* all AUX as D/I  */
PIO_DriverClose();
}

/* -------------------------------------------------------------- */
int check_pioda_calibrator()
{
int iCheckCode=0;

SEND_CMD(iComPort,"~**",TIMEOUT,iChksum);   /* send initial state */
RECEIVE_CMD(iComPort,str1,TIMEOUT,iChksum);

SEND_CMD(iComPort,"$012",TIMEOUT,iChksum);
RECEIVE_CMD(iComPort,str1,TIMEOUT,iChksum);
strcpy(str2,"!01080600");
if (memcmp(str2,str1,strlen(str2))!=0) iCheckCode=iCheckCode+1;

SEND_CMD(iComPort,"$022",TIMEOUT,iChksum);
RECEIVE_CMD(iComPort,str1,TIMEOUT,iChksum);
strcpy(str2,"!02080600");
if (memcmp(str2,str1,strlen(str2))!=0) iCheckCode=iCheckCode+2;

SEND_CMD(iComPort,"$032",TIMEOUT,iChksum);
RECEIVE_CMD(iComPort,str1,TIMEOUT,iChksum);
strcpy(str2,"!03090600");
if (memcmp(str2,str1,strlen(str2))!=0) iCheckCode=iCheckCode+4;

SEND_CMD(iComPort,"$042",TIMEOUT,iChksum);
RECEIVE_CMD(iComPort,str1,TIMEOUT,iChksum);
strcpy(str2,"!04090600");
if (memcmp(str2,str1,strlen(str2))!=0) iCheckCode=iCheckCode+8;

return(iCheckCode);
}

/* -------------------------------------------------------------- */
/* Output to DA channel                                           */
/* channel : 0 - 15                                               */
/* value   : 0 - 16383 (0x3FFF)                                   */
/* -------------------------------------------------------------- */
int PIODA_AnalogOutput(int channel, int da_value)
{
  int arg1, arg2, command;

  command = 0xe0 + (channel/4) * 4;         /* address of D/A /CS */
  arg1 = channel%4;
  arg1 = arg1 * 64 + da_value/256;          /* da_value high byte */
  arg2 = da_value%256;                      /* da_value low  byte */

  outportb(wBase+0xf0, arg2&0x0ff);
  outportb(wBase+0xf4, arg1&0x0ff);
  outportb(wBase+command, 0);
  return;
}

/* -------------------------------------------------------------- */
save_neg_10v_to_eeprom()
{
WORD k,high,low;

EEP_WR_EN();
for (k=0; k<MaxChannel; k++)
    {
    low=wN10V[k]&0x0ff;
    high=(wN10V[k]>>8)&0x0ff;
    EEP_WRITE(k+0,high,low);
    }
}

/* -------------------------------------------------------------- */
save_pos_10v_to_eeprom()
{
WORD k,high,low;

EEP_WR_EN();
for (k=0; k<MaxChannel; k++)
    {
    low=wP10V[k]&0x0ff;
    high=(wP10V[k]>>8)&0x0ff;
    EEP_WRITE(k+16,high,low);
    }
}

/* -------------------------------------------------------------- */
save_00mA_to_eeprom()
{
WORD k,high,low;

EEP_WR_EN();
for (k=0; k<MaxChannel; k++)
    {
    low=w00mA[k]&0x0ff;
    high=(w00mA[k]>>8)&0x0ff;
    EEP_WRITE(k+32,high,low);
    }
}

/* -------------------------------------------------------------- */
save_20mA_to_eeprom()
{
WORD k,high,low;

EEP_WR_EN();
for (k=0; k<MaxChannel; k++)
    {
    low=w20mA[k]&0x0ff;
    high=(w20mA[k]>>8)&0x0ff;
    EEP_WRITE(k+48,high,low);
    }
}

/* -------------------------------------------------------------- */
compute_now_neg_voltage(WORD wChannel, float *fVal)
{
WORD i;
float val;

if (wChannel<8)
   {
   strcpy(str1,"#010"); i=wChannel;
   }
else
   {
   strcpy(str1,"#020"); i=wChannel-8;
   }

str1[3]=i+'0';
SEND_CMD(iComPort,str1,TIMEOUT,iChksum);
RECEIVE_CMD(iComPort,str2,TIMEOUT,iChksum);
from_str_to_float1(str2,&val);
*fVal=val;
}

/* -------------------------------------------------------------- */
from_str_to_float1(char str[], float *f)
{
WORD k;
float val;

    k=str[2]-'0'; val=k*10.0;
    k=str[3]-'0'; val+=k;
    k=str[5]-'0'; val+=k*0.1;
    k=str[6]-'0'; val+=k*0.01;
    k=str[7]-'0'; val+=k*0.001;
*f=val*(-1.0);
}

/* -------------------------------------------------------------- */
compute_now_pos_voltage(WORD wChannel, float *fVal)
{
WORD i;
float val;

if (wChannel<8)
   {
   strcpy(str1,"#010"); i=wChannel;
   }
else
   {
   strcpy(str1,"#020"); i=wChannel-8;
   }

str1[3]=i+'0';
SEND_CMD(iComPort,str1,TIMEOUT,iChksum);
RECEIVE_CMD(iComPort,str2,TIMEOUT,iChksum);
from_str_to_float2(str2,&val);
*fVal=val;
}

/* -------------------------------------------------------------- */
from_str_to_float2(char str[], float *f)
{
WORD k;
float val;

    k=str[2]-'0'; val=k*10.0;
    k=str[3]-'0'; val+=k;
    k=str[5]-'0'; val+=k*0.1;
    k=str[6]-'0'; val+=k*0.01;
    k=str[7]-'0'; val+=k*0.001;
*f=val;
}

/* -------------------------------------------------------------- */
compute_now_current(WORD wChannel, float *fVal)
{
WORD i;
float val,r;

if (wChannel<8)
   {
   strcpy(str1,"#030"); i=wChannel;
   }
else
   {
   strcpy(str1,"#040"); i=wChannel-8;
   }

str1[3]=i+'0';
SEND_CMD(iComPort,str1,TIMEOUT,iChksum);
RECEIVE_CMD(iComPort,str2,TIMEOUT,iChksum);
from_str_to_float3(str2,&val);
r=rr[wChannel];
*fVal=val*1000.0/r;
}

/* -------------------------------------------------------------- */
from_str_to_float3(char str[], float *f)
{
WORD k;
float val;

    k=str[2]-'0'; val+=k;
    k=str[4]-'0'; val+=k*0.1;
    k=str[5]-'0'; val+=k*0.01;
    k=str[6]-'0'; val+=k*0.001;
    k=str[7]-'0'; val+=k*0.0001;
*f=val;
}

/* -------------------------------------------------------------- */
delay_ms(int t)
{
int   i,j,k;
float p,q,r;

for (i=0; i<t; i++)
for (k=0; k<wDelay1; k++)
    {
    p=i+t;
    q=i+k;
    r=p*q;
    }
}

/* -------------------------------------------------------------- */
/* AUX2= D/O = CS of EEP            AUX3= D/O = SK of EEP         */
/* AUX4= D/O = DI of EEP            AUX5= D/I = DO of EEP         */
/* -------------------------------------------------------------- */

COMM()                                  /* send start 2-bit (0,1) */
{
EEP=0x04; outportb(wBase+3,EEP);        /* CS=H */
EEP=0x0C; outportb(wBase+3,EEP);        /* SK=H */
                                        /* DI=0 */
EEP=0x04; outportb(wBase+3,EEP);        /* SK=L */
EEP=0x14; outportb(wBase+3,EEP);        /* DI=1 */
EEP=0x1c; outportb(wBase+3,EEP);        /* SK=H */
}

/* -------------------------------------------------------------- */
WR_BYTE(int val)                           /* send the next 8-bit */
{
int i,j;

for (i=0; i<8; i++)
    {
    EEP=EEP&0x14; outportb(wBase+3,EEP);   /* SK=L */
    j=val&0x80; val=val<<1;
    if (j==0)                              /* DI=0 */
       {
       EEP=EEP&0x0C; outportb(wBase+3,EEP);
       }
    else                                   /* DI=1 */
       {
       EEP=EEP|0x10; outportb(wBase+3,EEP);
       }
    EEP=EEP|0x08; outportb(wBase+3,EEP);   /* SK=H */
    }
}

/* -------------------------------------------------------------- */
RD_BYTE()                                  /* read the next 8-bit */
{
int i,j,val,k;

val=0x80; k=0;
for (i=0; i<8; i++)
    {
    EEP=EEP&0x14; outportb(wBase+3,EEP);   /* SK=L */
    j=(inportb(wBase+7))&0x20;
    if (j!=0) k+=val;                      /* DO=1 */
    EEP=EEP|0x08; outportb(wBase+3,EEP);   /* SK=H */
    val=val>>1;
    }
return(k);
}

/* -------------------------------------------------------------- */
EEP_WR_EN()                               /* write Enable */
{
COMM();
WR_BYTE(0x30);                            /* write enable command */
EEP=EEP&0x14; outportb(wBase+3,EEP);      /* SK=L */
EEP=EEP&0x18; outportb(wBase+3,EEP);      /* CS=L */
EEP=EEP&0x0C; outportb(wBase+3,EEP);      /* DI=0 */
}

/* -------------------------------------------------------------- */
EEP_WR_DIS()                             /* write Disable */
{
COMM();
WR_BYTE(0);                              /* write disable command */
EEP=EEP&0x14; outportb(wBase+3,EEP);     /* SK=L */
EEP=EEP&0x18; outportb(wBase+3,EEP);     /* CS=L */
EEP=EEP&0x0C; outportb(wBase+3,EEP);     /* DI=0 */
}

/* -------------------------------------------------------------- */
EEP_WRITE(int ADDR, int HI, int LO)   /* write 16-bit data to EEP */
{
int i,j,k;

COMM();
ADDR=ADDR|0x40; WR_BYTE(ADDR);        /* write command & address  */
WR_BYTE(HI);                          /* high 8-bit data          */
WR_BYTE(LO);                          /* low  8-bit data          */

EEP=EEP&0x14; outportb(wBase+3,EEP);  /* SK=L */
EEP=EEP&0x18; outportb(wBase+3,EEP);  /* CS=L */
EEP=EEP&0x0C; outportb(wBase+3,EEP);  /* DI=0 */

for (i=0; i<10; i++)                  /* delay>250 ns (for EEP)   */
{
EEP=EEP|0x08; outportb(wBase+3,EEP);  /* SK=H */
EEP=EEP&0x14; outportb(wBase+3,EEP);  /* SK=L */
}

EEP=EEP|0x04; outportb(wBase+3,EEP);  /* CS=H */

for (k=0; k<10; k++)                  /* wait until write finish  */
for (i=0; i<30000; i++)
    {
    EEP=EEP|0x08; outportb(wBase+3,EEP);/* SK=H */
    j=inportb(wBase+7)&0x20;
    EEP=EEP&0x14; outportb(wBase+3,EEP);/* SK=L */
    if (j!=0) return(0);                /* write is finished      */
    }
EEP=EEP&0x18; outportb(wBase+3,EEP);    /* CS=L */
return(1);                              /* error --> time out ?   */
}

/* -------------------------------------------------------------- */
EEP_READ(int ADDR, int *HI, int *LO) /* read 16-bit data from EEP */
{
int i,j,k;

COMM();
ADDR=ADDR|0x80; WR_BYTE(ADDR);          /* read command & address */
EEP=EEP&0x0C; outportb(wBase+3,EEP);    /* DI=0 */
EEP=EEP&0x14; outportb(wBase+3,EEP);    /* SK=L */
EEP=EEP|0x08; outportb(wBase+3,EEP);    /* SK=H */
EEP=EEP&0x14; outportb(wBase+3,EEP);    /* SK=L */
(*HI)=RD_BYTE();                        /* read high 8-bit data   */
(*LO)=RD_BYTE();                        /* read low  8-bit data   */
EEP=EEP&0x14; outportb(wBase+3,EEP);    /* SK=L */
EEP=EEP&0x18; outportb(wBase+3,EEP);    /* CS=L */
}

/* -------------------------------------------------------------- */
cal_N10V()
{
int   i,j;
float fDelta,fVal;
WORD  wOffset;

for (i=0; i<MaxChannel; i++)
    {
    PIODA_AnalogOutput(i,PreSetN10V);
    delay_ms(500);
    }

fDelta=20.2/16384.0;
for (i=0; i<MaxChannel; i++)
    {
    printf("\n\n-------------------------------------");
    printf("\n-10v START chan_%d",i);

    compute_now_neg_voltage(i,&fVal);
    if (fVal>=-10.0)
       {
       wOffset=(int) ((fVal+10.0)/fDelta);
       j=(PreSetN10V-wOffset)+20;
       for (;;)
           {
           PIODA_AnalogOutput(i,j);
           delay_ms(500);
           compute_now_neg_voltage(i,&fVal);
           printf("\nNew Start=%5d , true value =%2.6f",j,fVal);
           if (fVal<=-10.0) {j++; break;}
           j=j-2;
           }
       }
    wN10V[i]=j;
    PIODA_AnalogOutput(i,j);
    delay_ms(500);
    compute_now_neg_voltage(i,&fVal);
    delay_ms(500);
    printf("\n\nwN10V[%2d]=%5d , true =%2.6f",i,wN10V[i],fVal);

    if (kbhit()!=0) return;
    }

printf("\n\nWrite data to EEPROM, wait .....");
save_neg_10v_to_eeprom();
}

/* -------------------------------------------------------------- */
cal_P10V()
{
int   i,j;
float fDelta,fVal;
WORD  wOffset;

for (i=0; i<MaxChannel; i++)
    {
    PIODA_AnalogOutput(i,PreSetP10V);
    delay_ms(500);
    }

fDelta=20.2/16384.0;
for (i=0; i<MaxChannel; i++)
    {
    printf("\n\n-------------------------------------");
    printf("\n+10v START chan_%d",i);

    compute_now_pos_voltage(i,&fVal);
    if (fVal<10.0)
       {
       wOffset=(int) ((10-fVal)/fDelta);
       j=(PreSetP10V+wOffset)-20;
       for (;;)
           {
           PIODA_AnalogOutput(i,j);
           delay_ms(500);
           compute_now_pos_voltage(i,&fVal);
           printf("\nNew Start=%5d , true value =%2.6f",j,fVal);
           if (fVal>=10.0) {j--; break;}
           j=j+2;
           }
       }
    wP10V[i]=j;
    PIODA_AnalogOutput(i,j);
    delay_ms(500);
    compute_now_pos_voltage(i,&fVal);
    delay_ms(500);
    printf("\n\nwP10V[%2d]=%5d , true =%2.6f",i,wP10V[i],fVal);

    if (kbhit()!=0) return;
    }

printf("\n\nWrite data to EEPROM, wait .....");
save_pos_10v_to_eeprom();
}

/* -------------------------------------------------------------- */
cal_00mA()
{
int   i,j;
float fDelta,fVal;
WORD  wOffset;

for (i=0; i<MaxChannel; i++)
    {
    PIODA_AnalogOutput(i,PreSet00mA);
    delay_ms(500);
    }

fDelta=21/8192.0;
for (i=0; i<MaxChannel; i++)
    {
    printf("\n\n-------------------------------------");
    printf("\n 0mA START chan_%d",i);

    compute_now_current(i,&fVal);
    if (fVal>=0.001)
       {
       wOffset=(fVal/fDelta);
       j=(PreSet00mA-wOffset)+20;
       for (;;)
           {
           PIODA_AnalogOutput(i,j);
           delay_ms(500);
           compute_now_current(i,&fVal);
           printf("\nNew Start=%5d , true value =%2.6f",j,fVal);
	   if (fVal<=0.001) {j++; break;}
           j=j-2;
           }
       }
    w00mA[i]=j;
    PIODA_AnalogOutput(i,j);
    delay_ms(500);
    compute_now_current(i,&fVal);
    delay_ms(500);
    printf("\n\nw00mA[%2d]=%5d , true =%2.6f",i,w00mA[i],fVal);

    if (kbhit()!=0) return;
    }

printf("\n\nWrite data to EEPROM, wait .....");
save_00mA_to_eeprom();
}

/* --------------------------------------------------------------------- */
cal_20mA()
{
int   i,j;
float fDelta,fVal;
WORD  wOffset;

for (i=0; i<MaxChannel; i++)
    {
    PIODA_AnalogOutput(i,PreSet20mA);
    delay_ms(500);
    }

fDelta=21/8192.0;
for (i=0; i<MaxChannel; i++)
    {
    printf("\n\n-------------------------------------");
    printf("\n20mA START chan_%d",i);

    compute_now_current(i,&fVal);
    if (fVal<=20.00)
       {
       wOffset=((20.0-fVal)/fDelta);
       j=(PreSet20mA+wOffset)-20;
       for (;;)
           {
           PIODA_AnalogOutput(i,j);
           delay_ms(500);
           compute_now_current(i,&fVal);
           printf("\nNew Start=%5d , true value =%2.6f",j,fVal);
           if (fVal>=20.0) {j--; break;}
           j=j+2;
           }
       }
    w20mA[i]=j;
    PIODA_AnalogOutput(i,j);
    delay_ms(500);
    compute_now_current(i,&fVal);
    delay_ms(500);
    printf("\n\nw20mA[%2d]=%5d , true =%2.6f",i,w20mA[i],fVal);

    if (kbhit()!=0) return;
    }

printf("\n\nWrite data to EEPROM, wait .....");
save_20mA_to_eeprom();
}

/* -------------------------------------------------------------- */
init()
{
rr[ 0]=125.10;                 /* used for ISODA calibration kits */
rr[ 1]=124.27;
rr[ 2]=125.14;
rr[ 3]=125.02;
rr[ 4]=125.13;
rr[ 5]=125.11;
rr[ 6]=125.13;
rr[ 7]=125.04;
rr[ 8]=125.16;
rr[ 9]=125.14;
rr[10]=125.13;
rr[11]=125.10;
rr[12]=125.10;
rr[13]=125.13;
rr[14]=125.10;
rr[15]=125.13;
}