//-------------------------------------------------------------------------------------------------------
//
//   This program drives a bitscope USB-scope to capture DCS signals and return their voltage
//   capture.c program
//
//   Requirements:   
//   Trigger on the rising edge of CHA 
//   Save 12000 Samples from CHA at the fastest rate possible
//   Write those 12000 values to a file when done
//
//-------------------------------------------------------------------------------------------------------

//Includes
#include <stdio.h>
#include <limits.h>
#include <bitlib.h>
#include <time.h>
#include <tgmath.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <termios.h>
#include <stdlib.h>
#include <wiringPi.h>


//Constants
#define MY_DEVICES 1 
#define MY_PROBE_FILE "/home/bitscope.prb"        // default probe file if unspecified 
#define MY_DEVICE 0             // device number
#define CHANNELA 0
#define CHANNELB 1
#define MY_MODE BL_MODE_FAST
#define MY_RATE 20000000       // capture sample rate... this is 20MS/s 
#define MY_SIZE 12000          // number of samples to capture 
#define GNUPLOT "gnuplot"

//Defines the baud rate of the USB Link to the LCD Panel
#define BAUDRATE B57600

//Define the buffer size for the FTL interface
#define BUF_SIZE 0x100000 // 1 Megabyte Data Buffer



//this function is for printing to GNU plot
void gnuprint(FILE *gp, double x[], int N)
{
int i;

fprintf(gp, "plot '-' with lines \n");
for (i=0;i<N;i++){fprintf(gp, "%g $g\n", x[i]);}
fflush(gp);
fprintf(gp, "e\n");
}


//-------------------------------------------------------------------------------------------------------
//
//                                     PROGRAM MAIN THREAD
//
//-------------------------------------------------------------------------------------------------------
int main(int argc, char *argv[]) {
printf("----------------------------------------------------------------------------------------\n");
printf("\n");
printf("                   DCS Monitor Program Version 1.30                                     \n");
printf("                       Adrian Tang AGHR Nov 2017                                        \n");
printf("\n");
printf("----------------------------------------------------------------------------------------\n");
wiringPiSetup () ;
printf("WiringPi supposedly OK\n");


//


//---------------------------------------------------------------
//                LCD READOUT
//---------------------------------------------------------------
printf("\n");
printf("*****************************************************************************************************************\n");
printf("                                Setting up ACM0 communications                                                     ");
printf("*****************************************************************************************************************\n");

// Create a Port Structure for USB COM port
int USB;
int n;


  // Open the Port regardless of what DCTS is doing
      USB = open("/dev/ttyACM0", O_RDWR | O_NOCTTY );
       if (USB == -1) {
       perror("open_port: Unable to open -");
       return(-1);
      }
      printf("State: FTDI PORT open without any adventure\n");




//define the tty port stucture
    struct termios options;



//get the current port settings
     if (tcgetattr(USB, &options) != 0) {
     perror("get attribute: Unable to get -");
}

      printf("State: PORT attributes loaded - no suprises\n");



//Set the FTDI Baud Rate
  cfsetispeed(&options, BAUDRATE);
  cfsetospeed(&options, BAUDRATE);
  printf("State: Baudrate set to (8'H%i) I think\n",BAUDRATE);



  //Set USB port to to 8n1-FTDI configuration
  options.c_cflag &= ~PARENB;   // No Parity
  options.c_cflag &= ~CSTOPB;   // 1 stopbit
  options.c_cflag &= ~CSIZE;    // no masked bits
  options.c_cflag |= CS8;       // 8n1 config

  options.c_cflag &= ~CRTSCTS;  // Turn of DCTS
  options.c_cc[VMIN] = 0;      //blocking disabled
  options.c_cc[VTIME] =10;     //inter-character time delay
  
  options.c_cflag |= CREAD | CLOCAL;   //Local mode ... ignore CTS

  cfmakeraw(&options);                 //Clear any other settings in the termios
  printf("State: makeraw FTDI pipe for direct access set\n");


  tcflush(USB, TCIFLUSH);                //flush the current port
  printf("State: TCIFLUSH to remove all unwanted inital flags probably a success\n");

  if (tcsetattr(USB, TCSANOW, &options)) {      //update the attributes
     perror("could not set serial port");
     return -99;}
else {
  printf("State: TCsetattr direct pipe config supposedly went okay\n");
      }






//---------------------------------------------------------------
//                PLOTTER
//---------------------------------------------------------------
FILE *gp;
gp = popen(GNUPLOT,"w");  /* open the pipe to GNUplot */	
if (gp==NULL) {
printf("GNU plot has an issue");
return(0);
}

//---------------------------------------------------------------
//                Readback Variables
//---------------------------------------------------------------
double true_rate;     //Actual Sample Rate
int true_size;        //Actual Sample Length
double true_range;    //Actual voltage range
double true_offset;   //Actual voltage offset
char TimeString[128]; //Variables for timestamp
time_t curTime;       //Variables for timestamp
char buf_stream[6];   //LCD Buffer
    //---------------------------------------------------------------
    //                Basic BitScope Startup
    //---------------------------------------------------------------

    //Initialize the library
    BL_Initialize;
    printf("State: BL Init Ok \n");
  
    
    //open the bitscope device
    if ( ! BL_Open("USB:/dev/tty_bitscope",MY_DEVICE) ) {       
        goto exit;}
    printf("State: opened device %d \n",MY_DEVICES);


    //select the bitscope device
    if ( BL_Select(BL_SELECT_DEVICE,MY_DEVICE) != MY_DEVICE ) {   
        goto exit; }
    printf("State: selected device %d \n",MY_DEVICES);
  


    //--------------------------------------------------------------------------------------------------
    //                  Channel B configuration
    //                  not used
    //--------------------------------------------------------------------------------------------------

    //Select Channel B
    if ( BL_Select(BL_SELECT_CHANNEL,CHANNELB) != CHANNELB ) {
        goto exit;}   
    printf("State: selected channel B\n");  

    
    //Disable the channel as we don't want to capture data from the trigger
    BL_Enable(FALSE);  //false
    printf("State: enabled Channel B\n");



    //--------------------------------------------------------------------------------------------------
    //                  Channel A configuration
    //             This is the one actually reading back the data
    //--------------------------------------------------------------------------------------------------
    
    //Select Channel A
    if ( BL_Select(BL_SELECT_CHANNEL,CHANNELA) != CHANNELA ) {
        goto exit;}   
    printf("State: selected channel A\n");


    //Enable Channel A
    BL_Enable(TRUE);
    printf("State: enabled Channel A\n");


    //Put the scope into fast mode
    if ( BL_Mode(BL_MODE_FAST) != BL_MODE_FAST ) {
        goto exit;      
    }
    printf("State: set BL FAST MODE on A\n");

    //Set the trigger on this channel at 1.65V
    BL_Trigger(0.5,BL_TRIG_RISE); 
    printf("State: trigger set to channel A\n");


    //No delay or pre-trigger data is needed
    BL_Intro(BL_ZERO); 
    BL_Delay(BL_ZERO);     
    printf("State: set delay and pre-trigger to zero on channel A\n");


    //Set the sample rate and report the true rate
    true_rate = BL_Rate(MY_RATE);
    printf("State: set sample rate A. Requested Rate: %lf Hz  Actual Rate : %lf Hz\n",MY_RATE,true_rate);


    //Set the sample count and report the number
    true_size=BL_Size(MY_SIZE);
    printf("State: Set sample size A. Requested Size: %d   Actual Size : %d\n",MY_SIZE,true_size);
 

    //Select the input voltage range
    true_range = BL_Range(4);
    printf("State: set voltage range: %lf\n", true_range);   


    //Select the input offset
    true_offset = BL_Offset(BL_ZERO); 
    printf("State: set voltage offset: %lf\n", true_offset); 

    //Select the source
    BL_Select(BL_SELECT_SOURCE,BL_SOURCE_X50);







    //--------------------------------------------------------
    //                  Acqusition
    //--------------------------------------------------------
    while (1==1){
        // Complete the trace... If the trace capture is successful run this code
        if ( BL_Trace(BL_TRACE_FOREVER,BL_SYNCHRONOUS) ) {         


            //Create a result register to store the data
            int n;  
            int ctr;
            double voltageL;     
            double voltageH;     
            double voltage;  
            double power;   
            n = MY_SIZE; 
            double results[n]; 
            int actual_read;
        
            // Goto the channel with the radar return data
            BL_Select(BL_SELECT_CHANNEL,CHANNELA); 


            // Acquire the data and note the sample count 
            actual_read =  BL_Acquire(n, results);  

            //generate the timestamp
            gettimeofday(&curTime,NULL);     
            strftime(TimeString, 80, "%Y-%m-%d-%H:%M:%S", localtime(&curTime));
         
            //timestamp first 
            printf("%s, ",TimeString);                         
            
//---------------------------------------------------------------
//             POST PROCESSING SECTION
//---------------------------------------------------------------         
         
          //compensate for resistor divider
           for (ctr=0;ctr<12000;ctr++){
           results[ctr]=results[ctr]*2;
           }
  
  
           //compute the mean power
           power = 0;
           for (ctr=0;ctr<4000;ctr++){
           power=power+results[ctr]*results[ctr];
           }
           power=power/12000;           


            //Find the minimum and maximum voltage to determine the peak-to-peak value
            voltageL = 10;
            for (ctr=1;ctr<4000;ctr++){
                 if (results[ctr] < voltageL){            
                 voltageL = results[ctr];}
            }
            voltageH = -10;
            for (ctr=1;ctr<4000;ctr++){
                 if (results[ctr] > voltageH){            
                 voltageH = results[ctr];}
            }
            voltage=voltageH-voltageL;


//---------------------------------------------------------------
//             RESULT PLOTING FOR GNUPLOT
//---------------------------------------------------------------         
            //set the gnu plot bounds
		results[11998] = -12;
		results[11999] =  12;
            printf("DCS detected: %d values captured  pk-pk-voltage %5.3f: power %lf \n",actual_read, voltage, power);
            gnuprint(gp,results,12000);
            
//---------------------------------------------------------------
//             RESULT PLOTING FOR LCD
//---------------------------------------------------------------         
           //convert voltage to a string

           if (voltage <10){
	           sprintf(buf_stream, "%5.3lf",voltage);
           }
	   else
        	   sprintf(buf_stream, "%5.2lf",voltage);
           }
           printf("LCD: %s\n",buf_stream);
           sleep(2); //Wait before the next DCS packet comes


       
         //Configure Stream
         char LCD[5];
   

      LCD[0] = buf_stream[0];
      LCD[1] = buf_stream[1];
      LCD[2] = buf_stream[2];     
      LCD[3] = buf_stream[3];
      LCD[4] = buf_stream[4];
      n = write(USB,LCD,5);
      if (n<0){
      perror("send command failed -");
      }
}


         

    //Shut down the bitscope to release system resources
    exit:
    delay(500);
    BL_Close();
    printf("State: BL Close complete\n");  
    close(USB);
    return(0);
}