БПФ для STM32F103

#include "arm_math.h" 
 
#define TEST_LENGTH_SAMPLES 2048 
 
/* ------------------------------------------------------------------- 
* External Input and Output buffer Declarations for FFT Bin Example 
* ------------------------------------------------------------------- */ 
extern float32_t testInput_f32_10khz[TEST_LENGTH_SAMPLES]; 
static float32_t testOutput[TEST_LENGTH_SAMPLES/2]; 
 
/* ------------------------------------------------------------------ 
* Global variables for FFT Bin Example 
* ------------------------------------------------------------------- */ 
uint32_t fftSize = 1024; 
uint32_t ifftFlag = 0; 
uint32_t doBitReverse = 1; 
 
/* Reference index at which max energy of bin ocuurs */ 
uint32_t refIndex = 213, testIndex = 0; 
 
/* ---------------------------------------------------------------------- 
* Max magnitude FFT Bin test 
* ------------------------------------------------------------------- */ 
 
int32_t main(void) 
{ 
   
        arm_status status; 
        arm_cfft_radix4_instance_f32 S; 
        float32_t maxValue; 
         
        status = ARM_MATH_SUCCESS; 
         
        /* Initialize the CFFT/CIFFT module */  
        status = arm_cfft_radix4_init_f32(&S, fftSize,  
                                                                        ifftFlag, doBitReverse); 
         
        /* Process the data through the CFFT/CIFFT module */ 
        arm_cfft_radix4_f32(&S, testInput_f32_10khz); 
         
         
        /* Process the data through the Complex Magnitude Module for  
        calculating the magnitude at each bin */ 
        arm_cmplx_mag_f32(testInput_f32_10khz, testOutput,  
                                        fftSize);  
         
        /* Calculates maxValue and returns corresponding BIN value */ 
        arm_max_f32(testOutput, fftSize, &maxValue, &testIndex); 
         
        if(testIndex !=  refIndex) 
        { 
                status = ARM_MATH_TEST_FAILURE; 
        } 
         
        /* ---------------------------------------------------------------------- 
        ** Loop here if the signals fail the PASS check. 
        ** This denotes a test failure 
        ** ------------------------------------------------------------------- */ 
         
        if( status != ARM_MATH_SUCCESS) 
        { 
                while(1); 
        } 
 
    while(1);                             /* main function does not return */
}

int max = 0;
     int freq = 0;
     for(int i = 1; i < 1024; i++) {
        if(testOutput[i] > max) {
                max = testOutput[i];
                freq = i;
        }
     }

extern void cr4_fft_1024_stm32(void *pssOUT, void *pssIN, uint16_t Nbin);

#include "stm32f10x.h"
#include "table_fft.h"
#include "math.h"
#include "indicator.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "stdlib.h"
#include "cr4_fft_1024_stm32.h"
 
#define N   1024 /*Number of points*/
#define Fs  1024
#define f   Fs/N //Step
uint32_t x[N],y[N]; /* input and output arrays */
uint16_t real[N], imag[N]; /* real and imaginary arrays */
 
 
uint16_t i = 0;
#define steady 2048
#define pi 3.14159265359
uint16_t max = 0;
uint16_t freq = 0;
 
int main() {
    
    ledInit();
 
for(i = 0; i < N; i++) {
    real[i] = steady + 800*sin(2*pi*300*i/Fs);
    imag[i] = 0;
}
 
for (i = 0; i < N; i++) {
    x[i] = (((uint16_t)(real[i])) | ((uint32_t)(imag[i]<<16)));
}
    
    cr4_fft_1024_stm32(y, x, N);    /*computes the FFT of the x[N] samples*/
 
 
for(i = 1; i < N/2; i++) {
    if(y[i] > max) {
        max = y[i];
        freq = i*f;
    }
}
 
while(1) {
        show(freq); //show result на индикатор
    }
    
}

for(i = 1; i < N/2; i++) {
    if(y[i] > max) {
        max = y[i];
        freq = i;
    }
}
 
while(1) {
        show(freq*f); //show result на индикатор
    }
    
}

int main() {
 
    arm_rfft_instance_q15 S;
    arm_cfft_radix4_instance_q15 S_CFFT;
    
     for(i = 0; i < SAMPLE; i++) {
            Input[i] = steady + 800*sin(2*pi*300*i/Fs);
     }       
     
    arm_rfft_init_q15(&S, &S_CFFT, FFT_SIZE, ifftFlagR, doBitReverse);
    arm_rfft_q15(&S, Input, Output);
     
     for (i=0; i<SAMPLE; i++) {
            Output[i]<<=10;
     }   
     
    arm_cmplx_mag_q15(Output, Input, FFT_SIZE); 
     
    ledInit();
     
    for(i = 0; i < SAMPLE; i++) {
        if(Input[i] > max) {
            max = Input[i];
            freq = i;
        }
    }
 
    while(1) show((uint16_t)(10*freq*f));    
 
}

Input[i] = steady + 800*sin(2*pi*300*i/Fs);

#include "stm32f10x.h"
#include "Adc.h"
 
ADC_InitTypeDef ADC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
__IO uint16_t ADCConvertedValue;
 
void RCC_Configuration(void);
void GPIO_Configuration(void);
 
void ADC_DMA_Init(void) {
  RCC_Configuration();
  GPIO_Configuration();
 
  DMA_DeInit(DMA1_Channel1);
  DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&ADCConvertedValue;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize = 1;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel1, &DMA_InitStructure);
 
  DMA_Cmd(DMA1_Channel1, ENABLE);
  
  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_InitStructure.ADC_ScanConvMode = ENABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfChannel = 1;
  ADC_Init(ADC1, &ADC_InitStructure);
 
  ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_55Cycles5);
  
  ADC_DMACmd(ADC1, ENABLE); 
  
  ADC_Cmd(ADC1, ENABLE);    
  
  ADC_ResetCalibration(ADC1);        
  
  while(ADC_GetResetCalibrationStatus(ADC1));       
  
  ADC_StartCalibration(ADC1);   
  
  while(ADC_GetCalibrationStatus(ADC1));    
     
  ADC_SoftwareStartConvCmd(ADC1, ENABLE);       
    
}
 
void RCC_Configuration(void) {
#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
  
  RCC_ADCCLKConfig(RCC_PCLK2_Div2); /* ADCCLK = PCLK2/2 */
#else
  RCC_ADCCLKConfig(RCC_PCLK2_Div4); /* ADCCLK = PCLK2/4 */
#endif
  /* Enable peripheral clocks ------------------------------------------------*/
  /* Enable DMA1 clock */
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
 
  /* Enable ADC1 and GPIOC clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE);
}
 
/**/
 
void GPIO_Configuration(void) {
  GPIO_InitTypeDef GPIO_InitStructure;
 
  /* Configure PC.04 (ADC Channel14) as analog input -------------------------*/
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
}