/* 
 *
 * Template for solution to EE 4770, RTS, 1997 Homework 5.
 *
 */

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
/* random should be in the include file but isn't on Solaris. */
long random(void);  

#define SIZE 1000    /* Number of samples to store. */

/* 
 * Routines below are stubs for interface and timing functions.
 * 
 */

double get_current_time()
{
 struct timespec tp;
 /* clock_gettime is part of the Posix library. If it is not available
    on your system substitute time() or, since
    the return value isn't really used, comment out completely. */
 clock_gettime(CLOCK_REALTIME, &tp); 
 return ((double)tp.tv_sec) + tp.tv_nsec * 1e9;
}

static int ri_sample_history[SIZE];
static int ri_next_sample = -1;
static int ri_delta = SIZE / 2;

/* Generate and store random numbers for sensor output. Numbers are stored
   so that readInterfaceB can generate a time-delayed version. */
int readInterfaceA() 
{
 if( ri_next_sample == -1 ){
  int i;
  for(i=0;i<SIZE;i++)ri_sample_history[i]=0;
  ri_next_sample = 0;
 } else {
  ri_next_sample++;
 }
 if( ri_next_sample == SIZE ) ri_next_sample = 0;

 return (ri_sample_history[ri_next_sample] = random() & 0x7FFF);
}

/* Generate a time-delayed version of readInterfaceA's output, with a small
   random fluctuation added. */
int readInterfaceB() {
 int index =  ri_next_sample - ri_delta;
 if( index < 0 ) index += SIZE;
 return ri_sample_history[ index ] + ( random() & 0x7FFF );
}

/* Does nothing, since we're not really reading sensors we don't need
   to sleep. */
void sleep_until(double wake_time){return;}

/* Only display to stdout, and only display after some number of iterations. */
void display(double value){
 static count=0;
 count++;
 if( count > 1000 ) printf("Flow velocity %f\n",value); 
 if( count == 1020 )exit(0); 
}

/*
 * Routine containing main loop and where solution should be placed.
 *
 */

void cross_cor()
{
 int samp_A[SIZE];   /* Hold values read from sensor A. */
 int samp_B[SIZE];   /* Hold values read from sensor B. */
 double next_sample_time;      /* Time at which sensors will be read. */
 double sample_interval = 0.1; /* Second, time between reading sensors. */
 
 int i;

 for(i=0;i<SIZE;i++)samp_A[i]=samp_B[i]=0.0;   /* Inititalize arrays. */

 next_sample_time = get_current_time();	       /* Initialize to now. */

 while(1){
  int a = readInterfaceA();	/* Read sesnor A. */
  int b = readInterfaceB();	/* Read sesnor B. */
  double flow_velocity;		
  int delta;

  next_sample_time += sample_interval;  /* Compute when sensors next read. */

  /* Make room for new samples. */
  for(i=SIZE-1; i>0; i--){
   samp_A[i] = samp_A[i-1]; samp_B[i] = samp_B[i-1];
  }
  /* Store new samples. */
  samp_A[0]=a; samp_B[0]=b;


  /* Code to compute flow velocity. */  
  /* (The solution starts here.) */



  
  flow_velocity = ????
  /* (The solution ends here.) */

  /* Display flow velocity. */
  display(flow_velocity);

  /* Function will return at next_sample_time. */
  sleep_until( next_sample_time );

 }
}

int main(int argv, char **argc)
{
 cross_cor(); /* Never returns. */
 return 0;
}