//some things to try -- autodetect polarity and number of channels
//                              by taking readings in 'silent mode' after the lpt port# has been
//          input.  Take 5000 samples or so, with bipolar control bits set,
//          and if any are negative, keep software on bipolar mode, else
//          set the control bit to unipolar mode.
//        Another thing to try: autodetect which channels (0 thru 7) are on
//          the same way.  Take 5000 samples and for those channels that are
//          always between +1mv and -1mv, don't sample.
//        Another: autodetect the LPT number (1,2 or 3) write data to them..
//  These things make program More user friendly and more prone to errors...


#include <dos.h>                     //using the internal clk won't give a
#include <conio.h>                   //big speed boost -- see page 12, 13
#include <iostream.h>                //my program uses 24 clks/conversion
#include <math.h>                    //see page14 and pg15 diagram 11a,b
                                                                                                 //for program that uses 15 or 16 clks
                                                                                                 // per conversion. (5000/s -> 8000/s)

int DPORT;
int SPORT;
                                                                                                                //with mux on, this program
                                                                                                                //gets ~5000sps (not bad!!!)

clockTB1(int ch, int polarity);
 //predefined because it is called from within function setup()
doADC(int ch, int polarity);
 //predefined function because it is called from within clockTB1()



////////////////////////////////////////////////////////////////////////////
//////////////////// SETUP() ///////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

setup(){

int multiVar;
int channels, polarity;
char unibi[9];


cout << "Please enter your LPT port number (1,2 or 3)\n\n";
cin >> multiVar;
                                                                                                                                 //semi-autodetection part..
DPORT = *(( int far *)MK_FP(0x40, 6) + multiVar);
SPORT=DPORT+1;


cout << "\nHow many analogue channels would you like to work with today?\n\n";
cin >> channels;
if (channels > 8 || channels < 1){
        cout << "There are only 1 to 8 channels selectable, please try again.\n";
        return(0);}
clrscr();
cout << "OK, we will use analog input pins zero to " << channels-1;
cout << " which is " << channels << " channels\n\n\n";
delay(1000);
cout << "A later version of this program will allow you to select differential\n";
cout << "inputs, labelled channels and operation with some polar and some unipolar\n";
cout << "channels.\n\nBut for now please answer the question below..\n\n\n";
cout << "Do you want all your channels unipolar (0 to 5V analog inputs)\n";
cout << "Or do you want them all to be bipolar (-2.047 to +2.047V inputs)?\n\n";
cin >> unibi;

clrscr();
if (unibi[0] == 'u'){
        polarity = 'u';
        cout << "OK, all channels zero thru " << channels-1 << " will be set to unipolar\n";
        cout << "operation.. be sure to set the switch on the A2DMAX to unipolar operation.\n\n";
        delay(1000);
        }
else {
          polarity = 'b';
          cout << "OK, channels zero thru " << channels-1 << " will be set to bipolar\n";
          cout << "operation.. be sure to set the switch on the A2DMAX to bipolar operation.\n\n";
          delay(1000);
          }

cout << "\nPress any key to carry out your analog to digital conversions\n\n";
cout << "To quit anytime, press q.";


  while(getch()!='q'){

                clrscr();
                for(multiVar=0; multiVar<channels; multiVar++){
                clockTB1(multiVar, polarity);
                                        //first param: channel(0-7) second: bipolar or unipolar
                                        //clock in control byte to set options for max186 attributes
                                        //also calls 'doADC()' to do the analog to digital conversion.
                }
  }

}

////////////////////////////////////////////////////////////////////////////
//////////////////// CLOCKTB1() ////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

clockTB1(int ch, int polarity){ //ch initially selects one of the 8 channels
                                                                                  //polarity selects unipolar or bipolar operation

int pol1, pol2, mux[] = {0,4,0,4,0,4, 2,6,0,4,0,4, 0,4,0,4,2,6, 2,6,0,4,2,6,
                                                                 0,4,2,6,0,4, 2,6,2,6,0,4, 0,4,2,6,2,6, 2,6,2,6,2,6};

ch=ch*6;  //set ch to fit the array above (move to the start of a subgroup..
                                                                                                          //which are actually the bits needed
                                                                                                          //to select the channel you want.)
                                                                                                          //if 0 passed in (means ch0 and
                                                                                                          //7 means ch7 etc...)

if (polarity == 'b'){  //bipolar operation
         pol1=0;
         pol2=4;}
  else{          //unipolar operation
         pol1=2;
         pol2=6;}

                outp(DPORT, 0x00);  //sets 'not cs' low (so we can start clocking in)

                                                                  //these values below reflect channel 3
                                                                  //unipolar operation, external clock (in this ())
                                                                  //and analog inputs are referenced to ground

                outp(DPORT, 2);       //Din high, defines beginning of control byte
                outp(DPORT, 6);

                outp(DPORT, mux[ch]);   //SEL2 - along with sel1 & 0, selects 1 of 8 ch
                outp(DPORT, mux[ch+1]);

                outp(DPORT, mux[ch+2]); //SEL1   (clock low   --   this is true for  )
                outp(DPORT, mux[ch+3]); //       (clock high  --   all 8 control bits)

                outp(DPORT, mux[ch+4]); //SEL0
                outp(DPORT, mux[ch+5]);

                outp(DPORT, pol1);       //uni/bip    //(0,4) --for bipolar
                outp(DPORT, pol2);                    //(2,6) --for unipolar

                outp(DPORT, 2);      //sgl/dif
                outp(DPORT, 6);

                outp(DPORT, 2);      //pd1
                outp(DPORT, 6);

                outp(DPORT, 2);      //pd0
                outp(DPORT, 6);

                outp(DPORT, 0x00); //sets Din low, so we clock in all zeros while
                                                                 //we retrieve bits 11 to 1  (RB2 and RB3)


ch = ch/6;     //put ch back to its old self for doADC()
                                        //(doADC needs this variable for its case statement)

                doADC(ch,polarity);   //calls the the aquisition function with a
                                                                         //bipolar or unipolar paramater.
}

////////////////////////////////////////////////////////////////////////////
//////////////////// DOADC() ///////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

doADC(int ch, int polarity){

int bit[12], i, digVal;

outp(DPORT, 4);         //sclk high
outp(DPORT, 0x00);      //sclk low
bit[11] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[10] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[9] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[8] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[7] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[6] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[5] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[4] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[3] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[2] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[1] = inp(SPORT);

outp(DPORT, 4);
outp(DPORT, 0x00);
bit[0] = inp(SPORT);

outp(DPORT, 4);        //(This program works without these 7 lines)
outp(DPORT, 0x00);
outp(DPORT, 4);        //getting ready for next conversion (clocking
outp(DPORT, 0x00);     //out useless bits, resetting 'not cs' to high
outp(DPORT, 4);
outp(DPORT, 0x00);
outp(DPORT, 1);        //sets 'not cs' to high (end of conversion)


for (i=0; i<12; i++){
        if(bit[i] > 100)
                bit[i] = 1;
        else
                bit[i] = 0;

        bit[i] = bit[i] * pow(2, i);  // (i = i*2^i)   (binary to decimal formula)
        }

digVal = bit[0]+bit[1]+bit[2]+bit[3]+bit[4]+bit[5]+bit[6]+bit[7]+bit[8]+bit[9]+bit[10]+bit[11];



if (polarity == 'b'){         //bipolar operation
        if (digVal>2047){          //2047 is as high as it gets, anything above
                digVal = digVal-4095;}  //2047 is actually negative.
        }


/*       switch (ch)
         {
                case 0:
                  cout << "\n\n\n  ch0 " << digVal << "mv";
                  break;
                case 1:
                  cout << "  ch1 " << digVal << "mv";
                  break;
                case 2:
                  cout << "  ch2 " << digVal << "mv";
                  break;
                case 3:
                  cout << "  ch3 " << digVal << "mv" << "\n\n\n";
                  break;
                case 4:
                  cout << "  ch4 " << digVal << "mv";
                  break;
                case 5:
                  cout << "  ch5 " << digVal << "mv";
                  break;
                case 6:
                  cout << "  ch6 " << digVal << "mv";
                  break;
                case 7:
                  cout << "  ch7 " << digVal << "mv\n";
         }  */

         switch (ch)
         {
                case 0:
                  cout << "\n\n  ch0 " << digVal << "mv\n\n";
                  break;
                case 1:
                  cout << "  ch1 " << digVal << "mv\n\n";
                  break;
                case 2:
                  cout << "  ch2 " << digVal << "mv\n\n";
                  break;
                case 3:
                  cout << "  ch3 " << digVal << "mv\n\n";
                  break;
                case 4:
                  cout << "  ch4 " << digVal << "mv\n\n";
                  break;
                case 5:
                  cout << "  ch5 " << digVal << "mv\n\n";
                  break;
                case 6:
                  cout << "  ch6 " << digVal << "mv\n\n";
                  break;
                case 7:
                  cout << "  ch7 " << digVal << "mv\n\n";
         }
}


////////////////////////////////////////////////////////////////////////////
//////////////////// MAIN() ////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

void main(){

setup();

}