audio_record.c

00001 //EXTERNAL FUNCTIONS/VARIABLES:
00002 //AudioRecord_demo
00003 //AudioSample
00004 //PWRCONTROLMSE
00005 //PHSCONTROLMSE
00006 //CONTROLPWR0
00007 //CONTROLPHASE0
00008 //DISPLAYFFT
00009 
00010 #include "main.h"
00011 
00012 //GLOBAL VARIABLES
00013 
00014 int EXIT=0; //WHILE LOOP EXIT FLAG
00015 float32_t compare[1024]; //BUFFER VARIABLE FOR MSE FUNCTIONS
00016 uint32_t counter=0; //COUNTER for lenthg of record
00017 uint32_t n;  //Generic variable for "for" loops
00018 
00019 float32_t PWRCONTROLMSE=0; //CONTROL POWER MSE
00020 float32_t PHSCONTROLMSE=0; //CONTROL PHASE MSE 
00021  
00022 float32_t CONTROLPWR0[1024];  //CONTROL RECRODING 0 MAGNITUDE
00023 float32_t CONTROLPHASE0[1024];//CONTROL RECORDING 0 PHASE
00024 
00025 float32_t DISPLAYFFT[1024];
00026 
00027                                                         
00028 const static arm_cfft_instance_f32 *S=&arm_cfft_sR_f32_len2048;
00029 
00030 void AudioRecord_demo(void)
00031 {
00032     
00033     static uint16_t RecordBuffer[2048]; //RECORDING BUFFER FOR Control #0
00034     static uint16_t RecordBuffer1[2048];//RECORDING BUFFER FOR Control #1
00035 
00036     float32_t FloatBuff0[2048]; //Casting Int array to float array 
00037     float32_t FloatBuff1[2048];
00038      
00039     float32_t CONTROLPWR1[1024];  //CONTROL RECRODING 1 MAGNITUDE
00040     float32_t CONTROLPHASE1[1024];//CONTROL RECORDING 1 PHASE
00041     
00042     float32_t CONTROLREAL0[1024]; //CONTROL RECORDING 0 REAL
00043     float32_t CONTROLIMAG0[1024]; //CONTROL RECORDING 0 IMAGINARY
00044     float32_t CONTROLREAL1[1024]; //CONTROL RECORDING 1 REAL
00045     float32_t CONTROLIMAG1[1024]; //CONTROL REOCRDING 1 REAL
00046     
00047     float32_t FloatBuffout0[4096];//CONTROL RECORDING WITH ZEROS ADDED FOR COMPLEX PORTIONS
00048     float32_t FloatBuffout1[4096];  
00049     
00050 
00051   //INITIALIZE RECORDING #0
00052 
00053   /* Initialize audio input */                            
00054     BSP_AUDIO_IN_Init(48000, DEFAULT_AUDIO_IN_BIT_RESOLUTION, DEFAULT_AUDIO_IN_CHANNEL_NBR);
00055   
00056   /* Start the audio record */
00057 
00058     BSP_AUDIO_IN_Record(&RecordBuffer[0], 2048);
00059   
00060   /* PCM samples recording loop */
00061   while (EXIT != SET)
00062   {
00063         
00064         if (counter==10000000) //Approximately 3 seconds of record time
00065         {
00066             EXIT=1;
00067         }
00068         else
00069         {
00070             counter=counter++;
00071         }
00072   }
00073   /* Stop audio input */
00074   BSP_AUDIO_IN_Stop();
00075     
00076   BSP_AUDIO_IN_Record(&RecordBuffer1[0], 2048);
00077     EXIT = 0; //RESET AUDIO RECORD FLAG
00078     counter=0;                   //RESET COUNTER
00079   /* PCM samples recording loop */ //COPIED FROM ABOVE USE '1' WHEN REFERENCING VARIABLES
00080   while (EXIT != SET)
00081   {
00082         
00083         if (counter==10000000) //Approximately 3 seconds of record time
00084         {
00085             EXIT=1;   //FLAG IS REGISTER R5
00086         }
00087         else
00088         {
00089             counter=counter++;
00090         }
00091 
00092   }
00093     /* Stop audio input */
00094     BSP_AUDIO_IN_Stop();
00095     /* De-initialize audio input */
00096     BSP_AUDIO_IN_DeInit();
00097 
00098   //END OF RECORDING #1
00099   
00100   /* Reset EXIT flag */
00101   EXIT = 0;
00102     
00103     //CASTS THE RECORD BUFFER AS A SINGLE FLOAT
00104         //RECORDING 0
00105             for (n=0; n<2048; n++)
00106                 {FloatBuff0[n]=(float)RecordBuffer[n];}
00107         //RECORDING 1
00108             for (n=0; n<2048; n++)
00109                 {FloatBuff1[n]=(float)RecordBuffer1[n];}
00110                 
00111         for(n=0;n<2048;n++)
00112             {FloatBuffout0[n*2] = FloatBuff0[n];
00113              FloatBuffout0[(n*2)+1] = 0.0;
00114              FloatBuffout1[n*2] = FloatBuff1[n];
00115              FloatBuffout1[(n*2)+1] = 0.0;}
00116 
00117     //PERFORMS THE FFT
00118         //RECORDING 0
00119             arm_cfft_f32(S, FloatBuffout0, 0,0); //Output of FFT is half the record buffer size
00120         //RECORDING 1
00121             arm_cfft_f32(S, FloatBuffout1, 0,0);
00122     
00123             //FloatBuffout0[0]=0;
00124             //FloatBuffout1[0]=0;
00125              //     //RECORDING 0
00126             for(n=0;n<2048;n=n+2)
00127                 {CONTROLREAL0[n]=FloatBuffout0[n];}//Parses Real parts from the buffer
00128             for(n=1;n<2048;n=n+2)
00129                 {CONTROLIMAG0[n]=FloatBuffout0[n];}//Parses Imaginary parts from the buffer
00130         //RECORDING 1
00131             for(n=0;n<2048;n=n+2)
00132                 {CONTROLREAL1[n]=FloatBuffout1[n];}//Parses Real parts from the buffer
00133             for(n=1;n<2048;n=n+2)
00134                 {CONTROLIMAG1[n]=FloatBuffout1[n];}//Parses Imaginary parts from the buffer     
00135 
00136         
00137     //CALCULATES PHASE AND MAGITUDE
00138         //RECORDING 0
00139             for(n=0;n<1024;n++)
00140                 {CONTROLPHASE0[n]=atan2(CONTROLIMAG0[n],CONTROLREAL0[n]);}//Calculates control phase
00141             for(n=0;n<1024;n++)
00142                 {CONTROLPWR0[n]=sqrt((CONTROLIMAG0[n]*CONTROLIMAG0[n])+(CONTROLREAL0[n]*CONTROLREAL0[n]));} //calculates control power
00143         //RECORDING 1
00144             for(n=0;n<1024;n++)
00145                 {CONTROLPHASE1[n]=atan2(CONTROLIMAG1[n],CONTROLREAL1[n]);}//Calculates control phase
00146             for(n=0;n<1024;n++)
00147                 {CONTROLPWR1[n]=sqrt((CONTROLIMAG1[n]*CONTROLIMAG1[n])+(CONTROLREAL1[n]*CONTROLREAL1[n]));} //calculates control power
00148     
00149     //MEAN SQUARED ERROR FOR CONTROL MAGNITUDES
00150         for(n=0;n<1024;n++)
00151             {compare[n]=CONTROLPWR0[n]-CONTROLPWR1[n];} //Error between FFT magnitudes, stored in compare
00152             
00153         for(n=0;n<1024;n++)
00154             {compare[n]=(compare[n]*compare[n]);} //Squares the error, stores back in compare
00155         
00156         for(n=0;n<1024;n++)
00157             {PWRCONTROLMSE=PWRCONTROLMSE+compare[n];} //Takes the mean of the error, stores MSE in CONTROLMSE
00158         PWRCONTROLMSE=PWRCONTROLMSE/1024.0f;
00159     //MEAN SQUARED ERROR FOR CONTROL PHASE
00160         for(n=0;n<1024;n++)
00161             {compare[n]=CONTROLPHASE0[n]-CONTROLPHASE1[n];} //Error between FFT magnitudes, stored in compare
00162             
00163         for(n=0;n<1024;n++)
00164             {compare[n]=(compare[n]*compare[n]);} //Squares the error, stores back in compare
00165         
00166         for(n=0;n<1024;n++)
00167             {PHSCONTROLMSE=PHSCONTROLMSE+compare[n];} //Takes the mean of the error, stores MSE in CONTROLMSE
00168         PHSCONTROLMSE=PHSCONTROLMSE/1024.0f;    
00169 }
00170 
00171 void AudioSample(void)
00172 {
00173     //SAMPLE VARIABLES
00174  static uint16_t SampleBuffer[2048]; //SAMPLE RECORDING 
00175  
00176  float32_t FloatBuffSAMPLE[2048]; //Casting Int array to float array 
00177     
00178  float32_t SAMPLEPWR[1024];  //SAMPLE RECRODING 1 MAGNITUDE
00179  float32_t SAMPLEPHASE[1024];//SAMPLE RECORDING 1 PHASE
00180 
00181  float32_t SAMPLEREAL[1024]; //SAMPLE RECORDING 0 REAL
00182  float32_t SAMPLEIMAG[1024]; //SAMPLE RECORDING 0 IMAGINARY
00183  
00184  float32_t SAMPLEPWRMSE=0; //MSE
00185  float32_t SAMPLEPHASEMSE=0; //MSE
00186 
00187   //INITIALIZE RECORDING
00188 
00189 BSP_AUDIO_IN_Init(48000, DEFAULT_AUDIO_IN_BIT_RESOLUTION, DEFAULT_AUDIO_IN_CHANNEL_NBR);
00190     
00191 
00192       BSP_AUDIO_IN_Record(&SampleBuffer[0], 2048);
00193     EXIT = 0; //RESET AUDIO RECORD FLAG
00194     counter=0;                   //RESET COUNTER
00195   /* PCM samples recording loop */ //COPIED FROM ABOVE USE '1' WHEN REFERENCING VARIABLES
00196   while (EXIT != SET)
00197   {
00198         
00199         if (counter==10000000) //Approximately 3 seconds of record time
00200         {
00201             EXIT=1;   //FLAG IS REGISTER R5
00202         }
00203         else
00204         {
00205             counter=counter++;
00206         }
00207 
00208   }
00209     /* Stop audio input */
00210     BSP_AUDIO_IN_Stop();
00211     /* De-initialize audio input */
00212     BSP_AUDIO_IN_DeInit();
00213 
00214   //END OF RECORDING
00215     
00216     //CASTS THE RECORDING BUFFER AS A FLOAT
00217         for (n=0; n<2048; n++)
00218         {FloatBuffSAMPLE[n]=(float)SampleBuffer[n];}
00219         
00220             float32_t FloatBuffSAMPLEout[4096];         
00221 
00222         for(n=0;n<2048;n++)
00223             {FloatBuffSAMPLEout[n*2] = FloatBuffSAMPLE[n];
00224              FloatBuffSAMPLEout[(n*2)+1] = 0.0;}
00225         
00226     //PERFORMS THE 
00227         arm_cfft_f32(S, FloatBuffSAMPLEout, 0,0); //Output of FFT is half the record buffer size
00228         //FloatBuffSAMPLEout[0]=0;
00229     //MSE FUNCTION
00230     //SEPARATES REAL AND IMAGINARY PARTS
00231         for(n=0;n<2048;n=n+2)
00232             {SAMPLEREAL[n]=FloatBuffSAMPLEout[n];}//Parses Real parts from the buffer
00233         for(n=1;n<2048;n=n+2)
00234             {SAMPLEIMAG[n]=FloatBuffSAMPLEout[n];}//Parses Imaginary parts from the buffer
00235         
00236     //CALCULATES PHASE AND MAGITUDE
00237     //SAMPLE RECORDING
00238         for(n=0;n<1024;n++)
00239             {SAMPLEPHASE[n]=atan2(SAMPLEIMAG[n],SAMPLEREAL[n]);}//Calculates control phase
00240         for(n=0;n<1024;n++)
00241             {SAMPLEPWR[n]=sqrt((SAMPLEIMAG[n]*SAMPLEIMAG[n])+(SAMPLEREAL[n]*SAMPLEREAL[n]));} //calculates control power
00242             
00243         //ASSIGNS SAMPLE MAGNITUDE TO DISPLAY EXTERNAL FOR GRAPHING 
00244         for(n=0;n<1024;n++)                         
00245             {DISPLAYFFT[n]=SAMPLEPWR[n];}
00246             
00247 
00248     //MEAN SQUARED ERROR FOR SAMPLE MAGNITUDES
00249         SAMPLEPWRMSE=0;
00250         for(n=0;n<1024;n++)
00251             {compare[n]=CONTROLPWR0[n]-SAMPLEPWR[n];} //Error between FFT magnitudes, stored in compare
00252             
00253         for(n=0;n<1024;n++)
00254             {compare[n]=(compare[n]*compare[n]);} //Squares the error, stores back in compare
00255         
00256         for(n=0;n<1024;n++)
00257             {SAMPLEPWRMSE=SAMPLEPWRMSE+compare[n];} //Takes the mean of the error, stores MSE in CONTROLMSE
00258         SAMPLEPWRMSE=SAMPLEPWRMSE/1024.0f;
00259     //MEAN SQUARED ERROR FOR SAMPLE PHASE
00260         SAMPLEPHASEMSE=0;
00261         for(n=0;n<1024;n++)
00262             {compare[n]=CONTROLPHASE0[n]-SAMPLEPHASE[n];} //Error between FFT magnitudes, stored in compare
00263             
00264         for(n=0;n<1024;n++)
00265             {compare[n]=(compare[n]*compare[n]);} //Squares the error, stores back in compare
00266         
00267         for(n=0;n<1024;n++)
00268             {SAMPLEPHASEMSE=SAMPLEPHASEMSE+compare[n];} //Takes the mean of the error, stores MSE in CONTROLMSE
00269             SAMPLEPHASEMSE=SAMPLEPHASEMSE/1024.0f;  
00270     
00271                 float32_t TEST[6];
00272             TEST[0]=PWRCONTROLMSE;
00273             TEST[1]=PHSCONTROLMSE;
00274             TEST[2]=SAMPLEPHASEMSE;
00275             TEST[3]=SAMPLEPWRMSE;
00276             TEST[4]=(SAMPLEPWRMSE/PWRCONTROLMSE); //The ratio of sample MSE and control MSE
00277             TEST[5]=(SAMPLEPHASEMSE/PHSCONTROLMSE);
00278                         float32_t low=.001; //LOW END OF ACCEPTED TOLERANCE RANGE
00279                         float32_t high=20;  //HIGH END OF ACCEPTED TOLERANCE RANGE
00280                         
00281                 //COMPARISON
00282                     //if(SAMPLEPHASEMSE>(10*PHSCONTROLMSE))
00283                         //{
00284                             //SEND ERROR MESSAGE
00285                             //CREATE EVENT
00286                         //}
00287                     if(TEST[4]>high)//MODEM FUNCTIONS
00288                         {
00289                             //SEND ERROR MESSAGE
00290                             //CREATE EVENT
00291                         }
00292                     if(TEST[4] < low)
00293                         {   
00294                             //SEND ERROR MESSAGE
00295                             //CREATE EVENT
00296                         }
00297 }