/***********************************************************************/
/* PSL DEMONSTRATION USING 'C' LANGUAGE (TURBO C 2.0)                  */
/*                                                                     */
/* JAMES R. CHAMPION, IBM CORPORATION  02-20-90                        */
/*                                                                     */
/* Created using Turbo C, Copyright Borland 1987,1988                  */
/***********************************************************************/
/* DEMONSTRATION OF TEMPERATURE AND DISTANCE PROBE SOFTWARE            */
/***********************************************************************/
 
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
 
                                       /* FUNCTION DECLARATIONS        */
int find_module(char,char *);
void wait_resp(int);
void identify(char,char *);
long int pulse_timer_trig(char,char,char,char,char,char);
 
                                       /* GLOBAL VARIABLE DECLARATIONS */
int pslio,num;
 
void main()
{
                                       /* MAIN DECLARATIONS            */
char cmd[20];
char id[5],modtype[5][20];
int module;
float tempcoeff;
 
				       /* FIRST SCREEN */
clrscr();
puts("Personal Science Lab\n\n");
puts("Temperature and Distance Module Demonstration\n\n\n");
                                       /* OPEN COMMUNICATIONS WITH PSL */
{
int devnum;
char dev[][5] = {"PSL1","PSL2","PSL3","PSL4"};
printf("Which communications port will PSL use? (1,2,3,4): ");
scanf("%d]",&devnum);
devnum=(devnum-1);
if ((pslio=open(dev[devnum],O_RDWR|O_BINARY)) == -1)
{
 printf("failed to open\n");
 exit(-1);
}
}
                                          /* GET TEMP PROBE COEFFICIENT */
printf("\n\nEnter channel 1 temperature probe coefficient: ");
scanf("%f",&tempcoeff);
                                          /* SET PSL DEVICE TO BINARY */
cmd[0]='\x01';
num=ioctl(pslio,3,cmd,1);
 
				       /* CONFIGURE BASE UNIT          */
cmd[0]='\x01';cmd[1]='\x00';cmd[2]='\x00';
num=write(pslio,cmd,3);
 
				       /* RESET MODULES                */
cmd[0]='\x04';cmd[1]='\x00';
num=write(pslio,cmd,2);
 
clrscr();
puts("\nPSL Temperature and Distance Probes DEMO");
				       /* IDENTIFY MODULES             */
{
puts("\n\nIdentify Modules Demo:\n");
identify('\x00',id);
for(module=1;module<=4;module++)
{
 if(id[module]=='\x10')                 /* list the avilable modules */
   {strcpy(modtype[module],"TLp");}
 else if (id[module]=='\x11')
  {strcpy(modtype[module],"Distance");}
 else if (id[module]=='\xFF')
  {strcpy(modtype[module],"(empty)");}
 else
  {strcpy(modtype[module],"??");}
 printf("Module%1d ID: %3d     %s\n",
       module,(unsigned char)id[module],modtype[module]);
}
}
while(kbhit()==0)                      /* TOP OF DEMO LOOP             */
{
gotoxy(1,10);
                                       /* TLp PROBE DEMO               */
{
long int a,b,c,d;
float temp;
 
puts("\n\n\nTLp Module Demo:\n");
 
module=find_module('\x10',id);              /* find TLp module */
if(module>4)
 {puts("TLp module not present\n");}
else
{
                                            /* send temp meas cmds */
b=d=pulse_timer_trig(module,'\x18','\x01','\x44','\x28','\x05');
a=pulse_timer_trig(module,'\x11','\x01','\x44','\x28','\x05');
c=pulse_timer_trig(module,'\x10','\x01','\x44','\x28','\x05');
/* printf("reading(x'18',x'11',x'10'): %6ld %6ld %6ld\n",b,a,c); */
 
temp=373.15*(a-b)/(c-d);                  /* calculate Kelvin temp */
temp=temp*((tempcoeff+9500.)/10000.)-0.2; /* apply coefficient     */
temp=temp-273.15;                         /* convert to Celcius    */
 
printf("Temperature is %4.1f degrees C  (%4.1f degrees F)\n",
	temp,temp*9./5.+32);
} /* end if */
}
 
                                      /* DISTANCE PROBE DEMO          */
{
long int a;
float distance;
 
printf("\n\nDistance Module Demo:\n\n");
 
module=find_module('\x11',id);           /* find Distance module */
if (module>4)
 {puts("Distance module not present\n");}
else
{
a=pulse_timer_trig(module,'\xAA','\x01','\x44','\xFF','\x01');
/* printf("reading(x'AA'): %6ld\n",a); */
distance = ((float)(a-85))*331.3*.000001;   /* total distance @ 0 deg C */
distance = distance*1.041;                  /* 1.04 = 23 deg C constant */
distance = distance/2.;                     /* one way distance         */
 
printf("Distance = %5.2f meters (%5.2f feet)\n",distance,distance*3.2808);
} /* end if */
}
puts("\n                                            Press any key to exit");
 
} /* end while */                      /* BOTTOM OF DEMO LOOP         */
 
                                       /* CLOSE PSL DEVICE            */
num=close (pslio);
}   /* end main */
/**********************************************************************/
/*                           PULSE TIMER TRIGGERED COMMAND SUBROUTINE */
long int pulse_timer_trig(
  char unit_mod,char address,char number,
  char options,char period,char trig_width)
{
unsigned char cmd13[7],resp13[5];
 
cmd13[0]='\x13';cmd13[1]=unit_mod;cmd13[2]=address;cmd13[3]=number;
cmd13[4]=options;cmd13[5]=period;cmd13[6]=trig_width;
num=write(pslio,cmd13,7);       /* send PULSE TIMER TRIGGERED command */
 
wait_resp(5);                   /* wait for response bytes */
 
num=read(pslio,resp13,5);       /* read response bytes */
 
                                /* return value from response bytes */
return(resp13[2]+resp13[3]*256+resp13[4]*256*256);
} /* end pulse_timer_trig */
/**********************************************************************/
/*                           IDENTIFY COMMAND SUBROUTINE              */
void identify(char unit,char *id_list)
{
char cmd06[2],resp06[7];
int i;
 
cmd06[0]='\x06';cmd06[1]=unit;
num=write(pslio,cmd06,2);        /* send IDENTIFY command   */
 
wait_resp(7);                    /* wait for response bytes */
 
num=read(pslio,resp06,7);        /* read response bytes     */
 
for (i=1;i<=4;i++)               /* load id_list with module ID's */
 {id_list[i]=resp06[2+i];}
} /* end identify */
/**********************************************************************/
/*                           WAIT FOR RESPONSE BYTES SUBROUTINE       */
void wait_resp(int bytes)
{
char resp_ioctl[12];
do
 {num=ioctl(pslio,2,resp_ioctl,12);} /* Get ioctl psl device info. */
while (resp_ioctl[2]<bytes);             /* Loop until all bytes */
} /* end wait */                         /* have been received.  */
/**********************************************************************/
/*                           FIND MODULE WITH SPECIFIED ID            */
int find_module(char idnum,char *id_list)
{
int i=1;
while(id_list[i] != idnum && i<=4)
 {i++;}
return(i);
} /* end find */
/**********************************************************************/