做数字滤波器，使用adc+dma采样数据，处理后通过dac+dma输出，两个dma会影响滤波函数的问题。

luoye240

如题，想做一个数字滤波器，adc采样数据后再通过dac把滤波后的信号发送出去，然后卡在两个dma上面了。目前是在用adc+dma采样数据，通过滤波函数处理后串口发送出去，同时dac输出一个与” adc采样数据无关 “的正弦波，观察dac+dma能否正常工作。
遇到的问题是，dac在关闭的时候，adc接受的一个三次谐波，经过滤波函数，滤波函数正常工作，将滤波后信号串口打印，是一个正弦波。
dac在正常工作并输出正弦波的时候，adc同样接受的一个三次谐波，经过滤波函数，此时滤波函数滤波后的信号变为三次谐波，就是没起到作用，求大佬解惑。
下面是adc+dma的代码配置

1. #include "adc.h"
   
2. #include "delay.h"       
   
3. #include <string.h>
   
4. #include "filter.h"
   
5. 
   
6. #define TEST_LENGTH_SAMPLES  300
   
7. 
   
8. extern u16 ADC_Raw[TEST_LENGTH_SAMPLES];
   
9. u16 temp[TEST_LENGTH_SAMPLES];
   
10. extern float testInput_f32_50Hz_200Hz[TEST_LENGTH_SAMPLES];       
    
11. 
    
12. //初始化ADC                                                                                                                          
    
13. void DMA_Config(DMA_Stream_TypeDef *DMA_Streamx,uint32_t chx,uint32_t par,uint32_t mar,uint16_t ndtr,uint32_t pri)
    
14. {
    
15. 
    
16.         DMA_InitTypeDef  DMA_InitStructure;
    
17.        
    
18.         if((u32)DMA_Streamx>(u32)DMA2)                                                                                                                                                                        //得到当前stream是属于DMA2还是DMA1
    
19.         {
    
20.           RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2,ENABLE);                                                                                //DMA2时钟使能
    
21.                
    
22.         }else
    
23.         {
    
24.           RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1,ENABLE);                                                                                //DMA1时钟使能
    
25.         }
    
26.   DMA_DeInit(DMA_Streamx);
    
27.        
    
28.         while (DMA_GetCmdStatus(DMA_Streamx) != DISABLE){}                                                                                        //等待DMA可配置
    
29.        
    
30.   /* 配置 DMA Stream */
    
31.   DMA_InitStructure.DMA_Channel            = chx;                                                                                                 //通道选择
    
32.   DMA_InitStructure.DMA_PeripheralBaseAddr = par;                                                                                                  //DMA外设地址
    
33.   DMA_InitStructure.DMA_Memory0BaseAddr    = mar;                                                                                                        //DMA 存储器0地址
    
34.   DMA_InitStructure.DMA_DIR                = DMA_DIR_PeripheralToMemory;        //外设到内存
    
35.   DMA_InitStructure.DMA_BufferSize         = ndtr;                                                                                                //数据传输量
    
36.   DMA_InitStructure.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;                //外设非增量模式
    
37.   DMA_InitStructure.DMA_MemoryInc          = DMA_MemoryInc_Enable;                                //存储器增量模式
    
38.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; //外设数据长度:16位
    
39.   DMA_InitStructure.DMA_MemoryDataSize     = DMA_MemoryDataSize_HalfWord;                        //存储器数据长度:16位
    
40.   DMA_InitStructure.DMA_Mode               = DMA_Mode_Circular;                                                        //使用循环模式
    
41.   DMA_InitStructure.DMA_Priority           = pri;                                                        //优先级
    
42.   DMA_InitStructure.DMA_FIFOMode           = DMA_FIFOMode_Disable;         
    
43.   DMA_InitStructure.DMA_FIFOThreshold      = DMA_FIFOThreshold_Full;
    
44.   DMA_InitStructure.DMA_MemoryBurst        = DMA_MemoryBurst_Single;                        //存储器突发单次传输
    
45.   DMA_InitStructure.DMA_PeripheralBurst    = DMA_PeripheralBurst_Single;        //外设突发单次传输
    
46.   DMA_Init(DMA_Streamx, &DMA_InitStructure);                                                                                                                        //初始化DMA Stream
    
47.                                                                                                
    
48.                
    
49.         /* DMA2_Stream0 enable */
    
50.   DMA_ClearITPendingBit(DMA2_Stream0, DMA_IT_TC);
    
51.         DMA_ITConfig(DMA2_Stream0, DMA_IT_TC, ENABLE);
    
52.         DMA_Cmd(DMA_Streamx, ENABLE);     
    
53. }
    
54. 
    
55. //初始化ADC3IN7引脚
    
56. void ADCInit_GPIO(void)
    
57. {
    
58.         GPIO_InitTypeDef  GPIO_InitStructure;
    
59. 
    
60.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    
61. 
    
62.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    
63.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;  
    
64.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
65.   GPIO_Init(GPIOA, &GPIO_InitStructure);  
    
66. }
    
67. 
    
68. void ADC_Config(void)
    
69. {
    
70.         ADC_CommonInitTypeDef ADC_CommonInitStructure;
    
71.   ADC_InitTypeDef       ADC_InitStructure;
    
72.    
    
73.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC3, ENABLE);
    
74.    
    
75.   RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC3,ENABLE);      
    
76.   RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC3,DISABLE);   
    
77. 
    
78.   ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
    
79.   ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
    
80.   ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
    
81.   ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div4;
    
82.   ADC_CommonInit(&ADC_CommonInitStructure);
    
83.    
    
84.   ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
    
85.   ADC_InitStructure.ADC_ScanConvMode = ENABLE;
    
86.   ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    
87.   ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_Rising;
    
88.   ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_TRGO;//定时器2外部触发  
    
89.   ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    
90.   ADC_InitStructure.ADC_NbrOfConversion = 1; //M   
    
91.   ADC_Init(ADC3, &ADC_InitStructure);
    
92.     delay_ms(5);
    
93.   ADC_RegularChannelConfig(ADC3, ADC_Channel_0, 1, ADC_SampleTime_480Cycles);   
    
94.   ADC_DMARequestAfterLastTransferCmd(ADC3, ENABLE);//源数据变化时开启DMA传输
    
95.   ADC_DMACmd(ADC3, ENABLE);  //使能ADC的DMA传输
    
96.   ADC_Cmd(ADC3, ENABLE);
    
97.        
    
98. }
    
99. 
    
100. 
     
101. 
     
102. 
     
103. void NVIC_Config(void)
     
104. {
     
105.         NVIC_InitTypeDef NVIC_InitStructure;
     
106.   
     
107.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);//最高一位用于配置抢占优先级，低三位用于配置响应优先级
     
108.        
     
109.   NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;  
     
110.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;  
     
111.   NVIC_InitStructure.NVIC_IRQChannelSubPriority =1;        
     
112.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            
     
113.   NVIC_Init(&NVIC_InitStructure);   
     
114.    
     
115.   NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream0_IRQn;  
     
116.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;  
     
117.   NVIC_InitStructure.NVIC_IRQChannelSubPriority =1;        
     
118.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;           
     
119.   NVIC_Init(&NVIC_InitStructure);   
     
120. }
     
121. 
     
122. void Timer_Init(void)
     
123. {
     
124.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     
125. 
     
126. 
     
127.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);         
     
128. 
     
129. 
     
130.   TIM_Cmd(TIM2, DISABLE);
     
131.   TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
     
132.    
     
133.   //T=(84 * 625) / 84M = 625us = 20ms/32,1600HZ
     
134.   TIM_TimeBaseStructure.TIM_Prescaler = 4199        ;//84-1;
     
135.   TIM_TimeBaseStructure.TIM_Period = 1;//312500/CurrentFreq - 1;
     
136.   TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
     
137.   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up ;
     
138.   TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
     
139.    
     
140.    
     
141.   TIM_ARRPreloadConfig(TIM2, ENABLE);
     
142.   TIM_SelectOutputTrigger(TIM2, TIM_TRGOSource_Update);  
     
143. 
     
144.   TIM_Cmd(TIM2, ENABLE);
     
145. }
     
146. 
     
147. void TIM2_IRQHandler(void)  
     
148. {
     
149.   if(TIM_GetITStatus(TIM2, TIM_IT_Update))  
     
150.   {  
     
151.                 //LED0=~LED0;
     
152.     TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
     
153.   }
     
154.    
     
155. }
     
156. u16 adc_cov;
     
157. u16 ADC3_IN7_RES;
     
158. 
     
159. 
     
160. void DMA2_Stream0_IRQHandler(void)  
     
161. {
     
162.         u16 i=0;
     
163. if(DMA_GetITStatus(DMA2_Stream0, DMA_IT_TCIF0))
     
164. {
     
165.          memcpy(temp, ADC_Raw, sizeof(u16)*TEST_LENGTH_SAMPLES);
     
166.                 for(i=0;i<TEST_LENGTH_SAMPLES;i++){
     
167.                         testInput_f32_50Hz_200Hz[i]=(float)temp[i];
     
168.                 }
     
169.                 printf("\r\n-------arm_fir_f32_lp();-------\r\n");
     
170.                 arm_fir_f32_lp();
     
171.                 printf("\r\n------arm_fir_f32_lp();--------\r\n");
     
172.    DMA_ClearITPendingBit(DMA2_Stream0, DMA_IT_TCIF0);
     
173.          
     
174. }
     
175. }
     
176.          
     
177. 
     
178. 
     
179. 
     
180. 
     
181. 
     
182. 
     
183. 
     
184. 
     
185. 
     

复制代码

以下是dac+dma和定时器的配置

1. //dac.c
   
2. 
   
3. #include "dac.h"
   
4. 
   
5. 
   
6. //DAC通道1输出初始化
   
7. void DAC_Mode_Init(u16 mar)
   
8. {
   
9.     DAC_InitTypeDef DAC_InitType;
   
10.     DMA_InitTypeDef DMA_InitStre;
    
11.     GPIO_InitTypeDef  GPIO_InitStructure;
    
12.    
    
13.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);//使能GPIOA时钟
    
14.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);//使能DAC时钟
    
15.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);//DMA时钟
    
16.        
    
17.        
    
18.                 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    
19.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;//模拟输入
    
20.                 GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//下拉
    
21.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;  
    
22.                 GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
23.                 GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化
    
24.     /************************* 通道1 ***************************/
    
25.     //使用DMA模式-寄存器到外设
    
26.     DAC_InitType.DAC_Trigger=DAC_Trigger_T2_TRGO;    //必须使用触发功能 TEN1=0
    
27.     DAC_InitType.DAC_WaveGeneration=DAC_WaveGeneration_None;//不使用波形发生
    
28.     DAC_InitType.DAC_LFSRUnmask_TriangleAmplitude=DAC_LFSRUnmask_Bit0;//屏蔽、幅值设置
    
29.     DAC_InitType.DAC_OutputBuffer=DAC_OutputBuffer_Disable;    //DAC1输出缓存关闭 BOFF1=1
    
30.                 DAC_Init(DAC_Channel_1,&DAC_InitType);     //初始化DAC通道1
    
31.     DAC_Cmd(DAC_Channel_1, ENABLE);  //使能DAC通道1
    
32.    
    
33.    
    
34.     //DMA初始化
    
35.     DMA_DeInit(DMA1_Stream5);//复位
    
36.     DMA_InitStre.DMA_PeripheralBaseAddr=(uint32_t)&(DAC->DHR12R1);//外设 DAC1_DR
    
37.     DMA_InitStre.DMA_PeripheralBurst=DMA_PeripheralBurst_Single;
    
38.     DMA_InitStre.DMA_PeripheralDataSize=DMA_PeripheralDataSize_HalfWord;//半字
    
39.     DMA_InitStre.DMA_PeripheralInc=DMA_PeripheralInc_Disable;//外设地址增加失能
    
40.    
    
41.     DMA_InitStre.DMA_Memory0BaseAddr=mar;    //内存地址
    
42.     DMA_InitStre.DMA_MemoryInc=DMA_MemoryInc_Enable;//寄存器（变量）地址增加
    
43.     DMA_InitStre.DMA_MemoryDataSize=DMA_MemoryDataSize_HalfWord;//半字
    
44.     DMA_InitStre.DMA_MemoryBurst=DMA_MemoryBurst_Single;
    
45.    
    
46.     DMA_InitStre.DMA_Channel=DMA_Channel_7;
    
47.     DMA_InitStre.DMA_DIR=DMA_DIR_MemoryToPeripheral;//寄存器到外设输出
    
48.     DMA_InitStre.DMA_BufferSize=300;//一个输出循环中数据长度
    
49.     DMA_InitStre.DMA_Mode=DMA_Mode_Circular;//循环发送
    
50.    
    
51.     DMA_InitStre.DMA_Priority=DMA_Priority_High;
    
52.     DMA_InitStre.DMA_FIFOMode=DMA_FIFOMode_Disable;
    
53.     DMA_InitStre.DMA_FIFOThreshold=DMA_FIFOThreshold_1QuarterFull;
    
54.     DMA_Init(DMA1_Stream5,&DMA_InitStre);//初始化
    
55.    
    
56.     DMA_Cmd(DMA1_Stream5,ENABLE);//DMA使能
    
57.     DAC_DMACmd(DAC_Channel_1, ENABLE);//DAC-DMA使能
    
58.         }
    
59. 
    
60. //time.c
    
61. #include "timer.h"
    
62. #include "led.h"
    
63. 
    
64. 
    
65. //通用定时器4中断初始化
    
66. //arr：自动重装值。
    
67. //psc：时钟预分频数
    
68. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    
69. //Ft=定时器工作频率,单位:Mhz
    
70. //这里使用的是定时器2
    
71. void TIM2_Int_Init(u16 arr,u16 psc)
    
72. {
    
73.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    
74.         NVIC_InitTypeDef NVIC_InitStructure;
    
75.        
    
76.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);   ///使能TIM2时钟
    
77.        
    
78.        
    
79.         TIM_DeInit(TIM2); // 初始化
    
80.         TIM_TimeBaseStructInit(&TIM_TimeBaseInitStructure); // 初始化
    
81.        
    
82.   TIM_TimeBaseInitStructure.TIM_Period = arr;         //自动重装载值
    
83.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;  //定时器分频
    
84.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
85.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
86.        
    
87.         TIM_TimeBaseInit(TIM2,&TIM_TimeBaseInitStructure);//初始化TIM2
    
88.        
    
89.         TIM_SelectOutputTrigger(TIM2,TIM_TRGOSource_Update); // **与上一方案不同**
    
90.         TIM_Cmd(TIM2,ENABLE); //使能定时器2
    
91.        
    
92.        
    
93. }

复制代码

以下是滤波函数

1. #include "filter.h"
   
2. #include "arm_math.h"
   
3. 
   
4. #define TEST_LENGTH_SAMPLES  300    /* 采样点数 */
   
5. #define BLOCK_SIZE           1             /* 调用一次arm_fir_f32处理的采样点个数 */
   
6. #define NUM_TAPS             29      /* 滤波器系数个数 */
   
7. 
   
8. float32_t testInput_f32_50Hz_200Hz[TEST_LENGTH_SAMPLES]; /* 采样点 */
   
9. static float32_t testOutput[TEST_LENGTH_SAMPLES];               /* 滤波后的输出 */
   
10. static float32_t firStateF32[BLOCK_SIZE + NUM_TAPS - 1];        /* 状态缓存，大小numTaps + blockSize - 1*/
    
11. 
    
12. uint32_t blockSize = BLOCK_SIZE;
    
13. uint32_t numBlocks = TEST_LENGTH_SAMPLES/BLOCK_SIZE;            /* 需要调用arm_fir_f32的次数 */
    
14. 
    
15. 
    
16. const float32_t firCoeffs32LP[NUM_TAPS] = {
    
17.    0.001066399611256, 0.002126085729052, 0.003159337947181, 0.003059846159226,
    
18.   -1.968950437715e-18, -0.00705866005337, -0.01651859315877, -0.02329385602413,
    
19.    -0.01997951839664,5.751341766627e-18,  0.03857458762271,  0.09055123279738,
    
20.      0.1441009644858,   0.1844676143613,    0.199489117838,   0.1844676143613,
    
21.      0.1441009644858,  0.09055123279738,  0.03857458762271,5.751341766627e-18,
    
22.    -0.01997951839664, -0.02329385602413, -0.01651859315877, -0.00705866005337,
    
23.   -1.968950437715e-18, 0.003059846159226, 0.003159337947181, 0.002126085729052,
    
24.    0.001066399611256
    
25. };
    
26. 
    
27. 
    
28. void arm_fir_f32_lp(void)
    
29. {
    
30.         uint32_t i;
    
31.         arm_fir_instance_f32 S;
    
32.         float32_t  *inputF32, *outputF32;
    
33. 
    
34.         /* 初始化输入输出缓存指针 */
    
35.         inputF32 = &testInput_f32_50Hz_200Hz[0];
    
36.         outputF32 = &testOutput[0];
    
37. 
    
38.         /* 初始化结构体S */
    
39.         arm_fir_init_f32(&S,                           
    
40.                                          NUM_TAPS,
    
41.                         (float32_t *)&firCoeffs32LP[0],
    
42.                          &firStateF32[0],
    
43.                          blockSize);
    
44. 
    
45.         /* 实现FIR滤波，这里每次处理1个点 */
    
46.         for(i=0; i < numBlocks; i++)
    
47.         {
    
48.                 arm_fir_f32(&S, inputF32 + (i * blockSize),  outputF32 + (i * blockSize),  blockSize);
    
49.         }
    
50.        
    
51. 
    
52.         /* 打印滤波后结果 */
    
53.         for(i=0; i<TEST_LENGTH_SAMPLES; i++)
    
54.         {
    
55.                 printf("%f\r\n",  outputF32[i]);
    
56.         }
    
57. 
    
58. }

复制代码

LcwSwust

看你DMA都是循环模式，取数据时DMA没停，不怕乱套吗。

GJJ1999

帮顶