void FiltInitDSP(Filt * flt )
{
int index;
FiltInit(flt);
for (index=0;index<DEV_PeriodSamples;index++)
{
coefs[index] = flt->filtCoef[index];
}
arm_fir_init_f32(&S, NUMTAPS, &(coefs[0]), &(firState[0]), BLOCKSIZE);
}
int32_t main(void)
{
uint32_t i;
arm_fir_instance_f32 S;
arm_status status;
float32_t *inputF32, *outputF32;
/* Initialize input and output buffer pointers */
inputF32 = &testInput_f32_1kHz_15kHz[0];
outputF32 = &testOutput[0];
/* Call FIR init function to initialize the instance structure. */
arm_fir_init_f32(&S, NUM_TAPS, (float32_t *)&firCoeffs32[0], &firStateF32[0], blockSize);
/* ----------------------------------------------------------------------
** Call the FIR process function for every blockSize samples
** ------------------------------------------------------------------- */
for(i=0; i < numBlocks; i++)
{
Enable_Performance_Monitor(0); // Init PMU
Performance_Monitor_Start(0); // start PMU counters
arm_fir_f32(&S, inputF32 + (i * blockSize), outputF32 + (i * blockSize), blockSize);
Performance_Monitor_Stop(0); // stop PMU counters
PMU_counter0_result[i] = Performance_Monitor_Read_Counter0(0);
PMU_counter1_result[i] = Performance_Monitor_Read_Counter1(0);
PMU_counter2_result[i] = Performance_Monitor_Read_Counter2(0);
PMU_cycle_count[i] = Performance_Monitor_Read_CycleCount(0);
}
/* ----------------------------------------------------------------------
** Compare the generated output against the reference output computed
** in MATLAB.
** ------------------------------------------------------------------- */
snr = arm_snr_f32(&refOutput[0], &testOutput[0], TEST_LENGTH_SAMPLES);
if (snr < SNR_THRESHOLD_F32)
{
status = ARM_MATH_TEST_FAILURE;
}
else
{
status = ARM_MATH_SUCCESS;
}
/* ----------------------------------------------------------------------
** Loop here if the signal does not match the reference output.
** ------------------------------------------------------------------- */
if( status != ARM_MATH_SUCCESS)
{
while(1);
}
}
int main (void) { //Main function
gpio_set_mode(P2_10,Output);
arm_fir_init_f32(&S,N,h,state,DMA_BUFFER_SIZE/2);
audio_init ( hz8000, line_in, dma, DMA_HANDLER);
while(1){
while (!(rx_buffer_full && tx_buffer_empty)){};
gpio_set(P2_10, HIGH);
proces_buffer();
gpio_set(P2_10, LOW);
}
}
int main(void)
{
uint32_t i;
arm_fir_instance_f32 S;
arm_status status;
float32_t *inputF32, *outputF32;
/* Initialize input and output buffer pointers */
inputF32 = &testInput_f32_1kHz_15kHz[0];
outputF32 = &testOutput[0];
/* Call FIR init function to initialize the instance structure. */
arm_fir_init_f32(&S, NUM_TAPS, (float32_t *)&firCoeffs32[0], &firStateF32[0], blockSize);
/* ----------------------------------------------------------------------
** Call the FIR process function for every blockSize samples
** ------------------------------------------------------------------- */
for(i=0; i < numBlocks; i++)
{
arm_fir_f32(&S, inputF32 + (i * blockSize), outputF32 + (i * blockSize), blockSize);
}
/* ----------------------------------------------------------------------
** Compare the generated output against the reference output computed
** in MATLAB.
** ------------------------------------------------------------------- */
snr = arm_snr_f32(&refOutput[0], &testOutput[0], TEST_LENGTH_SAMPLES);
if (snr < SNR_THRESHOLD_F32)
{
status = ARM_MATH_TEST_FAILURE;
}
else
{
status = ARM_MATH_SUCCESS;
}
/* ----------------------------------------------------------------------
** Loop here if the signal does not match the reference output.
** ------------------------------------------------------------------- */
if( status != ARM_MATH_SUCCESS)
{
while(1);
}
while(1); /* main function does not return */
}
void FIRprocessing(uint32_t* input, float32_t* output) {
arm_fir_instance_f32 S;
input = &g_ulADCValues[0];
output = &g_fFIRResult[0];
arm_fir_init_f32(&S, NUM_TAPS, (float32_t*) &firCoeffs32[0],
&firStateF32[0], FilterNode[0].blockSize);
uint32_t i = 0;
for (i = 0; i < FilterNode[0].blockSize; i++)
arm_fir_f32(&S, (float32_t*) input + (i * FilterNode[0].blockSize),
output + (i * FilterNode[0].blockSize),
FilterNode[0].blockSize);
setAgainSampling();
}
int32_t main(void)
{
uint32_t i;
arm_status status;
uint32_t index;
float32_t minValue;
/* Initialize the LMSNorm data structure */
arm_lms_norm_init_f32(&lmsNorm_instance, NUMTAPS, lmsNormCoeff_f32, lmsStateF32, MU, BLOCKSIZE);
/* Initialize the FIR data structure */
arm_fir_init_f32(&LPF_instance, NUMTAPS, (float32_t *)FIRCoeff_f32, firStateF32, BLOCKSIZE);
/* ----------------------------------------------------------------------
* Loop over the frames of data and execute each of the processing
* functions in the system.
* ------------------------------------------------------------------- */
for(i=0; i < NUMFRAMES; i++)
{
/* Read the input data - uniformly distributed random noise - into wire1 */
arm_copy_f32(testInput_f32 + (i * BLOCKSIZE), wire1, BLOCKSIZE);
/* Execute the FIR processing function. Input wire1 and output wire2 */
arm_fir_f32(&LPF_instance, wire1, wire2, BLOCKSIZE);
/* Execute the LMS Norm processing function*/
arm_lms_norm_f32(&lmsNorm_instance, /* LMSNorm instance */
wire1, /* Input signal */
wire2, /* Reference Signal */
wire3, /* Converged Signal */
err_signal, /* Error Signal, this will become small as the signal converges */
BLOCKSIZE); /* BlockSize */
/* apply overall gain */
arm_scale_f32(wire3, 5, wire3, BLOCKSIZE); /* in-place buffer */
}
status = ARM_MATH_SUCCESS;
/* -------------------------------------------------------------------------------
* Test whether the error signal has reached towards 0.
* ----------------------------------------------------------------------------- */
arm_abs_f32(err_signal, err_signal, BLOCKSIZE);
arm_min_f32(err_signal, BLOCKSIZE, &minValue, &index);
if (minValue > DELTA_ERROR)
{
status = ARM_MATH_TEST_FAILURE;
}
/* ----------------------------------------------------------------------
* Test whether the filter coefficients have converged.
* ------------------------------------------------------------------- */
arm_sub_f32((float32_t *)FIRCoeff_f32, lmsNormCoeff_f32, lmsNormCoeff_f32, NUMTAPS);
arm_abs_f32(lmsNormCoeff_f32, lmsNormCoeff_f32, NUMTAPS);
arm_min_f32(lmsNormCoeff_f32, NUMTAPS, &minValue, &index);
if (minValue > DELTA_COEFF)
{
status = ARM_MATH_TEST_FAILURE;
}
/* ----------------------------------------------------------------------
* Loop here if the signals did not pass the convergence check.
* This denotes a test failure
* ------------------------------------------------------------------- */
if( status != ARM_MATH_SUCCESS)
{
while(1);
}
}
void main (void)
{
/*开硬件浮点*/
SCB->CPACR |=((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
uint16 flag;
uint16 i,j;
DisableInterrupts;
LCD_init(1);
Disp_single_colour(Black);
LCD_PutString(10, 50,"Frequency: ", White, Black);
LCD_PutString(145, 50," KHz", White, Black);
LCD_PutString(10, 80,"Power: ", White, Black);
LCD_PutString(145, 80," W", White, Black);
LCD_PutString(10, 110,"Amplify: ", White, Black);
LCD_PutString(165, 110,"Restrain: ", White, Black);
init_ADC();
init_DAC();
init_DMA();
init_PDB();
init_PIT();
init_gpio_PE24();
EnableInterrupts;
LPLD_LPTMR_DelayMs(100);
flag = Result_flag;
uint16 ShowAFlag = 0;
uint16 ShowBFlag = 0;
uint16 ShowCFlag = 0;
arm_fir_init_f32(&S, NUM_TAPS, (float32_t *)&firCoeffs32[0], &firStateF32[0], blockSize);
while(1)
{
if( flag==Result_flag && Result_flag == 0)
{
if(++ShowAFlag<10)
{
for(j = 0;j<LENGTH;j++)
testInput_x[j*2] = Result_A[j];
for(j = 0;j<LENGTH;j++)
testInput_x[j*2+1] = 0;
arm_cfft_f32(&arm_cfft_sR_f32_len2048, testInput_x, ifftFlag, doBitReverse);
/* Process the data through the Complex Magnitude Module for
calculating the magnitude at each bin */
arm_cmplx_mag_f32(testInput_x, testOutput, fftSize);
testOutput[0] = 0;
/* Calculates maxValue and returns corresponding BIN value */
arm_max_f32(testOutput, fftSize, &maxValue, &testIndex);
}
else
{
ShowAFlag = 0;
if(starfir !=2 )
LCD_Put_Float(100, 50,"",testIndex*40.0/2048, White, Black);
}
if(starfir == 1)
{
PTE24_O = 1;
for(j = 0;j<LENGTH;j++)
firInput[j] = Result_A[j];
inputF32 = &firInput[0];
outputF32 = &firOutput[0];
for(i=0; i < numBlocks; i++)
arm_fir_f32(&S, inputF32 + (i * blockSize), outputF32 + (i * blockSize), blockSize);
for(j = 0;j<LENGTH;j++)
Result_A[j] = firOutput[j];
PTE24_O = 0;
}
flag = 1;
}
else if(flag==Result_flag && Result_flag == 1)
{
if(starfir !=2 )
{
if(++ShowBFlag<10)
{
power = 0;
for(i=0;i<LENGTH;i++)
power+=((Result_B[i] - OFFEST)/1241.0)*((Result_B[i] - OFFEST)/1241.0)*90*MyDb/8.0;
power = power/LENGTH;
}
else
{
ShowBFlag = 0;
LCD_Put_Float(100, 80,"",power, White, Black);
}
}
else
{
for(i = 0;i<160;i++)
{
FFT_RESULT_NEW[i] = testOutput[i*6]/FFT_VALUE;
if(FFT_RESULT_NEW[i]>239) FFT_RESULT_NEW[i] = 239;
}
}
// {
// for(j = 0;j<LENGTH;j++)
// testInput_x[j*2] = Result_B[j];
// for(j = 0;j<LENGTH;j++)
// testInput_x[j*2+1] = 0;
//
// arm_cfft_f32(&arm_cfft_sR_f32_len2048, testInput_x, ifftFlag, doBitReverse);
//
// /* Process the data through the Complex Magnitude Module for
// calculating the magnitude at each bin */
// arm_cmplx_mag_f32(testInput_x, testOutput, fftSize);
//
// testOutput[0] = 0;
// /* Calculates maxValue and returns corresponding BIN value */
// arm_max_f32(testOutput, fftSize, &maxValue, &testIndex);
// }
if(starfir == 1)
{
PTE24_O = 1;
for(j = 0;j<LENGTH;j++)
firInput[j] = Result_B[j];
inputF32 = &firInput[0];
outputF32 = &firOutput[0];
for(i=0; i < numBlocks; i++)
arm_fir_f32(&S, inputF32 + (i * blockSize), outputF32 + (i * blockSize), blockSize);
for(j = 0;j<LENGTH;j++)
Result_B[j] = firOutput[j];
PTE24_O = 0;
}
flag = 2;
}
else if(flag==Result_flag && Result_flag == 2)
{
//
// {
// for(j = 0;j<LENGTH;j++)
// testInput_x[j*2] = Result_C[j];
// for(j = 0;j<LENGTH;j++)
// testInput_x[j*2+1] = 0;
//
// arm_cfft_f32(&arm_cfft_sR_f32_len2048, testInput_x, ifftFlag, doBitReverse);
//
// /* Process the data through the Complex Magnitude Module for
// calculating the magnitude at each bin */
// arm_cmplx_mag_f32(testInput_x, testOutput, fftSize);
//
// testOutput[0] = 0;
// /* Calculates maxValue and returns corresponding BIN value */
// arm_max_f32(testOutput, fftSize, &maxValue, &testIndex);
// }
if(starfir == 1)
{
// PTE24_O = 1;
for(j = 0;j<LENGTH;j++)
firInput[j] = Result_C[j];
inputF32 = &firInput[0];
outputF32 = &firOutput[0];
for(i=0; i < numBlocks; i++)
arm_fir_f32(&S, inputF32 + (i * blockSize), outputF32 + (i * blockSize), blockSize);
for(j = 0;j<LENGTH;j++)
Result_C[j] = firOutput[j];
// PTE24_O = 0;
}
if(starfir != 2)
{
if(++ShowCFlag<5)
{
}
else
{
if(ShowMenu)
{
Disp_single_colour(Black);
LCD_PutString(10, 50,"Frequency: ", White, Black);
LCD_PutString(145, 50," KHz", White, Black);
LCD_PutString(10, 80,"Power: ", White, Black);
LCD_PutString(145, 80," W", White, Black);
LCD_PutString(10, 110,"Amplify: ", White, Black);
LCD_PutString(165, 110,"Restrain: ", White, Black);
ShowMenu = 0;
}
LCD_Put_Float(100, 110,"",MyDb/0.5, White, Black);
if(starfir)
LCD_PutString(260, 110,"On ", White, Black);
else
LCD_PutString(260, 110,"Off", White, Black);
}
}
else
{
if(ShowMenu)
{
Disp_single_colour(Black);
ShowMenu = 0;
}
draw_fft();
}
flag = 0;
}
}
}
int main(void)
{
int nsamp, i;
float32_t *input, *output1, *output2;
initialize(FS_48K, MONO_IN, STEREO_OUT); // Set up the DAC/ADC interface
// Allocate Required Memory
nsamp = getblocksize();
input = (float32_t *)malloc(sizeof(float)*nsamp);
output1 = (float32_t *)malloc(sizeof(float)*nsamp);
output2 = (float32_t *)malloc(sizeof(float)*nsamp);
if (input==NULL || output1==NULL || output2==NULL) {
flagerror(MEMORY_ALLOCATION_ERROR);
while(1);
}
// Impulse response/FIR coefficient array
float32_t h[20] = {0.000168,
-0.000883,
-0.004735,
-0.010728,
-0.013639,
-0.004205,
0.025992,
0.077462,
0.138625,
0.188861,
0.208333,
0.188861,
0.138625,
0.077462,
0.025992,
-0.004205,
-0.013639,
-0.010728,
-0.004735,
-0.000883};
// state buffer used by arm routine of size NUM_TAPS + BLOCKSIZE -1
float32_t *state = (float32_t *) malloc(sizeof(float)*(20+nsamp-1));
// arm FIR filter struct initialization
arm_fir_instance_f32 f1;
arm_fir_init_f32(&f1,20,&h[0],state,nsamp);
// Infinite Loop to process the data stream, "nsamp" samples at a time
while(1){
/*
* Ask for a block of ADC samples to be put into the working buffer
* getblock() will wait until the input buffer is filled... On return
* we work on the new data buffer.
*/
getblock(input); // Wait here until the input buffer is filled... Then process
// signal processing code to calculate the required output buffers
// copy input to output2 for reference
for(i=0;i<nsamp;i++) {
output2[i] = input[i];
}
DIGITAL_IO_SET(); // Use a scope on PC4 to measure execution time
// Call the arm provided FIR filter routine
arm_fir_f32(&f1, input, output1, nsamp);
DIGITAL_IO_RESET(); // (falling edge.... done processing data )
// pass the processed working buffer back for DAC output
putblockstereo(output1, output2);
}
}
/**
* Initialize PPG
* @param void No arguments
* @return void No return
*/
void PPG_Init(void)
{
// Init FIR
arm_fir_init_f32(&g_Ppg_FirInst, s_PPG__FIR_NUM_TAPS, (float32_t *)&s_PPPG_FIR_COEFFS[0], &g_Ppg_FirState[0], s_PPG__FIR_BLOCK_SIZE);
}
/**
* @brief [initialize eq struct for equalizer routines]
*
* @param low_gain [bass gain in dB]
* @param mid_gain [mid gain in dB]
* @param high_gain [treble gain in dB]
* @param block_size [number of samples to work on]
* @param FS [sampling frequency used in the delay routine]
* @return [pointer to the eq struct]
*/
EQ_T * init_eq(float low_gain, float mid_gain, float high_gain, int block_size, int FS) {
int i, j;
// set up struct for eq -------------------------------------------------------------------------------------
EQ_T * Q = (EQ_T *)malloc(sizeof(EQ_T)); // allocate struct
if(Q == NULL) return NULL; // errcheck malloc call
Q->block_size = block_size;
// pow(dB / 20) = gain
Q->low_scale = pow(10, (low_gain / 20.0));
Q->mid_scale = pow(10, (mid_gain / 20.0));
Q->high_scale = pow(10, (high_gain / 20.0));
// initialize delays for keeping the outputs in phase with each other ---------------------------------------
// delay the same amount as the delay caused by the fir routine
// both filters have the same number of coefs, so the delays will be the same
int sample_delay = ((eq_low_num - 1) / 2); // delay for fir is (M-1)/2
Q->D1 = init_delay(0, FS, sample_delay, 1, block_size); // 0 is delay in samples instead of in seconds
Q->D2 = init_delay(0, FS, sample_delay, 1, block_size);
Q->D3 = init_delay(0, FS, sample_delay, 1, block_size);
if(Q->D1 == NULL || Q->D2 == NULL || Q->D3 == NULL) return NULL;
// declare and initialize variables necessary for arm fir routines ------------------------------------------
float * low_state = (float *)malloc(sizeof(float) * (eq_low_num + block_size - 1));
float * mid_state = (float *)malloc(sizeof(float) * (eq_mid_num + block_size - 1));
if(low_state == NULL || mid_state == NULL) return NULL;
// declare arm struct
arm_fir_instance_f32 S_low;
arm_fir_instance_f32 S_mid;
// initialize arm struct
arm_fir_init_f32(&S_low, eq_low_num, &(eq_low_coefs[0]), low_state, block_size);
arm_fir_init_f32(&S_mid, eq_mid_num, &(eq_mid_coefs[0]), mid_state, block_size);
Q->S_low = S_low;
Q->S_mid = S_mid;
// initialize band output buffers --------------------------------------------------------------------------
Q->low_band_out = (float *)malloc(sizeof(float) * block_size);
Q->mid_band_out = (float *)malloc(sizeof(float) * block_size);
Q->high_band_out = (float *)malloc(sizeof(float) * block_size);
if(Q->low_band_out == NULL || Q->mid_band_out == NULL || Q->high_band_out == NULL) return NULL;
for(i = 0; i < block_size; i++) {
Q->low_band_out[i] = 0.0;
Q->mid_band_out[i] = 0.0;
Q->high_band_out[i] = 0.0;
}
// initialize eq output buffer -----------------------------------------------------------------------------
Q->output = (float *)malloc(sizeof(float) * block_size);
if(Q->output == NULL) return NULL;
for(j = 0; j < block_size; j++) {
Q->output[j] = 0.0;
}
// return pointer to struct---------------------------------------------------------------------------------
return Q;
}
