/////////// Lira Nikolovska, MIT Dept of Architecture, Design and Computation
/////////// Independent study with Prof Chris Csikszentmihályi, MIT Media Lab Culture of Computing Group
/////////// Spring 2003
/////////// lira@mit.edu

#include <18f452.h>
#include <string.h>
#fuses HS,NOWDT,NOPROTECT,NOBROWNOUT,BORV45
//#use delay(clock=40000000)
#use delay(clock=13333333)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

#USE STANDARD_IO (A)
#USE STANDARD_IO (B)
#USE STANDARD_IO (C)
#USE STANDARD_IO (D)
#USE STANDARD_IO (E)

#define NUMLEDS 12       // total number of LEDs is to be 12, for testing was is set to 4
#define TIMEONINMS 200   // time ON for the LEDs is 200 miliseconds
#define NOISE_LEVEL_LEFT 3
#define NOISE_LEVEL_RIGHT 3
#define INSENSITIVE_INTERVAL 3     // cannot be larger than NUMLEDS;
#define QUANTIZATION_LEVEL 16

///////////////////////////////////////////////
// global variables
int myLeftMikeLEDs[NUMLEDS];  // array for the left mike
int myRightMikeLEDs[NUMLEDS]; // array for the right mike
int myLEDs[NUMLEDS];          // array that is sum of myLeftMikeLEDs+myRightMikeLEDs
int myTempArray[NUMLEDS];

///////////////////////////////////////////////
// functions
// void all_out()                // turns 12 pins off / sets to output_low;
// void cycle_forward (void)     // light animation 1
// void cycle_backward (void)    // light animation 2
// void initializeArrays (int myarrayPtr[], int initValue)  // myarray[] is pointer to an array of ints
// void printArray(int printArrayPtr[])      // function that prints an array
// void shiftRight(int shiftPtr[])           // function that shifts array cell values to the RIGHT
// void shiftLeft(int shiftPtrLeft[])        // function that shifts array cell values to the LEFT
// int* addArraysBitwise(int onePtr[], int twoPtr[]) // function that ADDS arrays, returns pointer to an array
// void  setCorrespondingBits(int *myfinalarray, int value) // function that turns appropriate pins on and off
// void main()


/////////////////////////// intialize arrays function
void initializeArrays (int myarrayPtr[], int initValue)  // myarray[] is pointer to array of ints
{
   //variable declarations
   int i; //counter

   //variable initialization
    for (i=0; i<NUMLEDS; i++)  // intialize array
    {
      myarrayPtr[i] = initValue;
    } // close for loop

} // close function initializeArrays


///////////////////// function that prints an array
void printArray(int printArrayPtr[])
{

   int i;  // loop counter

   for (i=0; i<NUMLEDS; i++)
   {
      printf("values of array are %u\n\r", printArrayPtr[i]);
   }
   printf("\n\r");
}  // close printArray


//////////////////// function that shifts cell values to the RIGHT
void shiftRight(int shiftPtr[])
{
   int i;

   for(i=NUMLEDS-1; i>0; i--)
   {
     shiftPtr[i]=shiftPtr[i-1];
     //printf("shift RIGHT index is: %u value is: %u\n\r", i, shiftPtr[i]);
   }
   shiftPtr[0]=0;
}


//////////////////// function that shifts cell values to the LEFT
void shiftLeft(int shiftPtrLeft[])
{
   int i;

   for(i=0; i<NUMLEDS-1; i++)
   {
     shiftPtrLeft[i]=shiftPtrLeft[i+1];
     //printf("shift LEFT index is: %u value is: %u\n\r", i, shiftPtrLeft[i]);
   }
  shiftPtrLeft[NUMLEDS-1]=0;
}


/////////////function that ADDS arrays
int* addArraysBitwise(int onePtr[], int twoPtr[])     // returns pointer to an array
{
   int i;
   int1 one;
   int1 two;
   int1 result;
   int *resultArray;  //this is the array that we will return


   for (i=0; i<NUMLEDS; i++)   //error checking loop
   {
      if (!(onePtr[i]==0 || onePtr[i]==1))      // if _not_ (!) zero or 1, there is an error
      {
         printf("error onePtr \n\r");
         break;
      }

      if (!(twoPtr[i]==0 || twoPtr[i]==1))      // if _not_ (!) zero or 1, there is an error
      {
         printf("error twoPtr \n\r");
         break;                                 // get out!
      }
   }

   initializeArrays(myTempArray,0);

   for (i=0; i<NUMLEDS; i++)
   {
      one = (int1)(onePtr[i]);  // first take the i-th element of the 1st array and cast it to a bit using (int1)
      two = (int1)(twoPtr[i]); // then do the same to the 2nd array
     // result = one && two;    // then add them; "&&" doesn't seem to work in this complier but "+"
      result = one + two;
      myTempArray[i] = (int)(result);  // inverse casting
   }
   //printf("RESULT Array: \n\r");
   //printArray(resultArray);

   resultArray=myTempArray;

   return resultArray;

}


/////////////////////////////////////////////////////////////////
void  setCorrespondingBits(int *myfinalarray, int value)  // value needs to be zero or one
{
    int i;

    for(i=0; i<NUMLEDS; i++)
      {
        switch(i)
        {
        case 0:
         if(myfinalarray[0]==1)
          (value==1) ? (output_high(PIN_D2)) : (output_low(PIN_D2));
          //printf("case 0 and myfinalarray[0] %u\n\r", myfinalarray[0]);
          //(value==1) ? (printf("output high")) : (printf("output low"));
          //printf("\n\r");
        break;
        case 1:
         if(myfinalarray[1]==1)
          (value==1) ? (output_high(PIN_D3)) : (output_low(PIN_D3));
          //printf("case 1 and myfinalarray[1] %u\n\r", myfinalarray[1]);
          //(value==1) ? (printf("output high")) : (printf("output low"));
          //printf("\n\r");
        break;
        case 2:
         if(myfinalarray[2]==1)
          (value==1) ? (output_high(PIN_C4)) : (output_low(PIN_C4));
          //printf("case 2 and myfinalarray[2] %u\n\r", myfinalarray[2]);
          //(value==1) ? (printf("output high")) : (printf("output low"));
        //printf("\n\r");
        break;
        case 3:
         if(myfinalarray[3]==1)
         (value==1) ? (output_high(PIN_C5)) : (output_low(PIN_C5));
         //printf("case 3 and myfinalarray[3] %u\n\r", myfinalarray[3]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 4:
         if(myfinalarray[4]==1)
         (value==1) ? (output_high(PIN_D4)) : (output_low(PIN_D4));
         //printf("case 4 and myfinalarray[4] %u\n\r", myfinalarray[4]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 5:
         if(myfinalarray[5]==1)
         (value==1) ? (output_high(PIN_D5)) : (output_low(PIN_D5));
         //printf("case 5 and myfinalarray[5] %u\n\r", myfinalarray[5]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 6:
         if(myfinalarray[6]==1)
         (value==1) ? (output_high(PIN_D6)) : (output_low(PIN_D6));
         //printf("case 3 and myfinalarray[6] %u\n\r", myfinalarray[6]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 7:
         if(myfinalarray[3]==1)
         (value==1) ? (output_high(PIN_D7)) : (output_low(PIN_D7));
         //printf("case 3 and myfinalarray[7] %u\n\r", myfinalarray[7]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 8:
         if(myfinalarray[3]==1)
         (value==1) ? (output_high(PIN_B4)) : (output_low(PIN_B4));
         //printf("case 3 and myfinalarray[8] %u\n\r", myfinalarray[8]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 9:
         if(myfinalarray[3]==1)
         (value==1) ? (output_high(PIN_B5)) : (output_low(PIN_B5));
         //printf("case 9 and myfinalarray[9] %u\n\r", myfinalarray[9]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 10:
         if(myfinalarray[3]==1)
         (value==1) ? (output_high(PIN_B6)) : (output_low(PIN_B6));
         //printf("case 10 and myfinalarray[10] %u\n\r", myfinalarray[10]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        case 11:
         if(myfinalarray[3]==1)
         (value==1) ? (output_high(PIN_B7)) : (output_low(PIN_B7));
         //printf("case 11 and myfinalarray[11] %u\n\r", myfinalarray[11]);
         //(value==1) ? (printf("output high")) : (printf("output low"));
         //printf("\n\r");
        break;
        }
      }
}


///////////////////// end of function declaration /////////////////

void main(){

   //////////////////// 0. variable declarations  //////////////////////
   int mikeADC_left;         // left mike
   int mikeADC_right;        // right mike

   int quantizedOutput_left;
   int quantizedOutput_right;

   char mikeStringOutput_left[100];    //originally empty string to which we keep adding quantizedOutput
   char mikeStringOutput_right[100];   //originally empty string to which we keep adding quantizedOutput
   char mySpaceLeft[1];
   char mySpaceRight[1];
   char terminateString_LEFT[2];
   char terminateString_RIGHT[2];
   int k;   // counter for the switch statement
   int i;   // variable for the counter
   int j;   // variable for second counter
   int *myPTR;
   int count_interval_left;
   int count_interval_right;

   int leftMicOn;    // behaves likes boolean -- above threshold
   int rightMicOn;   // behaves likes boolean -- above thresold

   //////////////////// end of variable declarations  //////////////////////

   //printf("variables declared \n\r");
   //////////////////// set up ADC /////////////////////
   setup_adc( ADC_CLOCK_INTERNAL );   // turn on ADC
   setup_adc_ports( ALL_ANALOG );		// this sets all the pins on port a to be analog pins

   delay_us(10);
   //printf("adc ports initialized \n\r");
   //////////////////// end of set up ADC /////////////////////


   //////////////////// 1. variable initialization/////////////////////

   strcpy(mySpaceLeft,"L");
   delay_us(10);
   strcpy(terminateString_LEFT,"\0");
   delay_us(10);
   strcpy(mySpaceRight,"R");
   delay_us(10);
   strcpy(terminateString_RIGHT,"\0");
   delay_us(10);
   // fake scope == shows noise level picked up by the mikes
   // tune noise treshold with the #define

   leftMicOn = 0;     // initialize leftMikeOn
   rightMicOn = 0;    // initialize rightMikeOn
   mikeADC_left = 0;
   mikeADC_right = 0;

   initializeArrays (myLeftMikeLEDs,0);    // we can use anything instead of 0
   //printf("myLeftMikeLEDs: \n\r");
   //printArray(myLeftMikeLEDs);

   initializeArrays (myRightMikeLEDs,0);
   //printf("myRightMikeLEDs: \n\r");
   //printArray(myRightMikeLEDs);

   count_interval_left = INSENSITIVE_INTERVAL;
   count_interval_right = INSENSITIVE_INTERVAL;
   //////////////////// end variable initialization/////////////////////

// never come back here; program always lives inside the while loop after this point
  while(true){          // loop forever

  // 2. initialize flags and other stuff


 // if any what is value of mic input ?

// check left mic first
     set_adc_channel(0);
     //printf("set_adc channel A0 \n\r");
     delay_us(10);
     mikeADC_left = read_adc();
	  //printf("mikeADC_left AD value = %2u\n\r", mikeADC_left);

     quantizedOutput_left = (int)((float)mikeADC_left/QUANTIZATION_LEVEL);  // cast quantizedOutput to an integer value
     //printf("quantizedOutput_left is %2u\n\r", quantizedOutput_left);
     strcpy(mikeStringOutput_left, "");

     for (i=0; i<quantizedOutput_left; i++) {
         strcat(mikeStringOutput_left,mySpaceLeft);
         //printf("iteration: %2u  ", i);
         //printf(mikeStringOutput_left);
         //printf("\n\r");
     }
     strcat(mikeStringOutput_left,terminateString_LEFT);

      printf(mikeStringOutput_left);
      printf("\n\r");

      if( quantizedOutput_left > NOISE_LEVEL_LEFT )
         leftMicOn=1;

// end of check left mic

// now check right mic
       set_adc_channel(1);
       //printf("set_adc channel A1 \n\r");
       delay_us(10);
       mikeADC_right = read_adc();
	    //printf("mikeADC_right AD value = %2u\n\r", mikeADC_right);

       quantizedOutput_right = (int)((float)mikeADC_right/QUANTIZATION_LEVEL);  // cast quantizedOutput to an integer value
       //printf("quantizedOutput_right is %2u\n\r", quantizedOutput_right);
       strcpy(mikeStringOutput_right, "");

       for (j=0; j<quantizedOutput_right; j++)
         strcat(mikeStringOutput_right,mySpaceRight);
       strcat(mikeStringOutput_right,terminateString_RIGHT);

       printf(mikeStringOutput_right);
       printf("\n\r");

       if(quantizedOutput_right > NOISE_LEVEL_RIGHT)
         rightMicOn=1;
// end of check right mic


     // set first bit of array if "good" mic input
     if(leftMicOn) {
     count_interval_left++;   // increment counter
       if(count_interval_left > INSENSITIVE_INTERVAL) {
          myLeftMikeLEDs[0]=1;   // turn on the first LED in the array
          count_interval_left=0; // start the counter
          }
     }

     if(rightMicOn) {
       count_interval_right++;
       if(count_interval_right > INSENSITIVE_INTERVAL) {
         myRightMikeLEDs[NUMLEDS-1]=1; // turn on the last LED in the array
         count_interval_right=0; // start the counter
         }
     }

/////////// now light on LEDs //////////////////
     myPTR = addArraysBitwise(myLeftMikeLEDs, myRightMikeLEDs);   // 2 arrays added
         //printf("RESULT array: \n\r");
         //printArray(myPTR);

     setCorrespondingBits(myPTR, 1); // output_high
     //printf("i am at setCorrespondingBits 1 \n\r");

/////////////// pause so that LEDs stay on //////////////////
     if(leftMicOn==1 || rightMicOn==1)
       delay_ms(TIMEONINMS);
     else
       delay_ms(10); // wait only a little time if both mics are off
    // so that it is ready to pick up a signal
//////////////////// end pause ///////////////////////////////
     setCorrespondingBits(myPTR, 0);  // output_low
     //printf("i am at setCorrespondingBits 0 \n\r");

//////////////////////// clean up //////////////////////
     // shift array

       shiftRight(myLeftMikeLEDs);
 //      printf("myLeftMikeLEDs SHIFTED RIGHT: \n\r");
 //      printArray(myLeftMikeLEDs);

        shiftLeft(myRightMikeLEDs);
 //       printf("myRightMikeLEDs SHIFTED LEFT: \n\r");
 //       printArray(myRightMikeLEDs);

  ///////////////////////////
  // cleaning up flag values before the next loop
     //4. flag and counters management at the end of the loop
     leftMicOn = 0;
     rightMicOn = 0;


  } //end of while loop
} // end of main