; [$ d) }# j5 X基于STM32F446的交流真有效值电压表
; M3 H0 N9 J, s1 R9 a
    一般的数字万用表的交流电压的测量是采用将交流电压经过整流后测量其有效值，由于整流二极管的非线性，使得该测量结果误差较大，不是真有效值，特别是对非正弦波的测量更是如此。
   本方案基于使用意法半导体的ARM CORTEX内核的STM32F446交流真有效值电压表，克服上述方案的缺点，使得对交流电的测量更加准确。
    交流电的有效值定义为：
2 j& a5 @& J% V; v7 q& L
) q, j; W( L$ d) N

    对其一个周期内连续采样后，根据以下公式进行计算得到结果。

硬件连接：



& N" g, q4 z/ a220V交流电经过1：1电压互感器后与STM32F446的ADC0连接。


' w2 ^1 T& h7 h# @
. F$ x# i* \$ _+ m9 r- _                             ADC通道配置

                        时钟配置

8 k9 t" K2 y% K7 j( S          ADC参数配置

关键代码：
+ Q9 Q$ g9 H% P! F% R5 |! b

1. //MAIN.C
   
2. 
   % y- [  l3 H' G( L( E
3. #include "main.h"
   
4. #include "stm32f4xx_hal.h"
   " P$ d  l; y( v5 b% @9 m, ^, I
5. #include "adc.h"
   " g) _+ Z% J. K7 \/ f( q
6. #include "dma.h"
   
7. #include "tim.h"
   - M2 i" k$ m5 D; E. e# H1 N
8. #include "gpio.h"
   8 _4 Z' z4 P% q5 Q
9. #include "math.h"
   
10. 
    , X: _9 l) p  [/ p4 X5 }# p
11. #include "oled.h"
    $ d" i# \# X; N; ]. `4 K; v- y5 Q
12. uint16_t   aADCxConvertedData[48][10];
    
13. uint32_t Resture=0;
    + P, ?8 g) t1 h' m% O+ e5 z
14. uint8_t Disp_buf[8],Flag;
    + K. o* h5 N' i% ~" B% h' u7 t" r
15. uint8_t j=0;
    $ U. d& Z/ a& K8 S0 F8 M" ?6 ]
16. void SystemClock_Config(void);
    ) z# p$ ?3 |/ \
17. 
    
18. void Get_ADC(void)
    
19. {uint8_t i;
    
20.         static uint32_t total;
    8 H+ ?& F/ y2 X" y
21.         double temp;
    
22.         
    
23. 
    # R% ]" h! F2 ~5 C9 k$ H0 H
24.         total=0;
    
25.         for(i=0;i<48;i++)
    
26.                 {
    
27.                 total +=(aADCxConvertedData[i][0]*aADCxConvertedData[i][0]);
    
28.                 }
    
29.                 total /=48;
    2 l- A0 W; L; V( k! n: I
30.                 temp=sqrt(total)        ;
      V2 D$ h6 F9 p/ m% P
31.                 Resture +=(uint16_t)temp;
    , t" i* |3 ]  [% g2 [( j
32.                 j++;
    0 b- T$ C9 g3 y. s* {# E
33.                 if(j==32)
    9 U/ y% `3 }. ^. C3 i2 V5 J
34.                 {
    & b0 @8 [( \2 T
35.                 Resture=Resture/64;
    
36.                 Disp_buf[0]=(Resture%1000/100)+0x30;        
    $ F1 v1 p: v! Q- H  L
37.                 Disp_buf[1]=(Resture%100/10)+0x30;        
    : m' W5 A: d3 ]1 ^* J$ n2 M
38.                 Disp_buf[2]=(Resture%10)+0x30;        
    1 A2 a0 l7 k/ I2 o! I8 _, V
39.                 Disp_buf[3]='\0';
    ' h5 ^$ i: V4 A5 I3 J
40.                 LCD_Print(40,46,Disp_buf,TYPE16X16,TYPE8X16);        
    
41.                 Resture=0;        
    
42.                 j=0;
    
43.                 }
    
44. }
    
45. 
    
46. 
    
47. 
    4 ~' B* ]. s* v! C+ q
48. 
    
49. int main(void)
    ' Z% ]9 V) O+ D/ w/ y' ~
50. {
    4 ?; V, I; J* y3 |1 W& T
51. 
    
52.   HAL_Init();
    
53.   SystemClock_Config();
    
54.   MX_GPIO_Init();
    
55.   MX_DMA_Init();
    
56.   MX_ADC1_Init();
    
57.   MX_TIM8_Init();
    
58.         HAL_TIM_PWM_Start(&htim8, TIM_CHANNEL_1);
    
59. 
    
60.                 LCD_Init();
    % }6 _" a3 Q+ U2 \
61.                 LCD_Print(0, 0,"STM32F446 Nucleo",TYPE16X16,TYPE8X16);
    ! m- D7 X6 e7 L6 J; ^
62.                 LCD_Print(0, 16, "True effective",TYPE16X16,TYPE8X16);
    
63.                 LCD_Print(74,46, "V",TYPE16X16,TYPE8X16);
    % u* R1 }; H+ U% \3 T  b2 N
64.                
    - Q5 K  M3 b4 }# ^6 m; m
65.         if(HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&aADCxConvertedData,480) != HAL_OK)
    0 R9 ?4 ^" w8 D
66.   {
    : _, @1 V8 T, A' B! [4 Q1 s
67.     Error_Handler();
    1 M5 H' [# l1 S) C9 D
68.   }        
    ; B* S, r. a5 W3 T
69. 
    - }' c3 ?% s6 c$ W
70.   while (1)
    / {' B" Y) f0 x2 P
71.   {
    
72.         if(Flag==1)
    
73.         {        
    
74.                 Get_ADC();
    
75.                 Flag=0;
    $ g$ f9 p- C) s! T* R0 W$ R1 R
76.         }
    
77. 
    : I3 f: J& B" o: b
78.   }
    . [3 f: Z0 C9 k% f
79. 
    - T! a0 N2 b! e: Z' x# x
80. }
    
81. 
    
82. 
    
83. //ADC.C
    # y9 j! ^: N5 b0 o" f9 X2 w& `$ O
84. #include "adc.h"
    
85. #include "gpio.h"
    
86. #include "dma.h"
    
87. ADC_HandleTypeDef hadc1;
    
88. DMA_HandleTypeDef hdma_adc1;
    
89. void MX_ADC1_Init(void)
    9 a5 t% Z; q6 J3 `% E0 ]
90. {
    6 ?! E% _! L, A
91.   ADC_ChannelConfTypeDef sConfig;
    + ]  E; j% @" I5 a) C
92.   hadc1.Instance = ADC1;
    5 M: u, y% ~) ^' [) e
93.   hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV8;
    ; \4 X- a, ~- r  ~% t
94.   hadc1.Init.Resolution = ADC_RESOLUTION_12B;
    ) ~2 M) o6 s& n
95.   hadc1.Init.ScanConvMode = ENABLE;
      @  ]$ K/ m9 R' B
96.   hadc1.Init.ContinuousConvMode = ENABLE;
    - z; m# F: e4 R3 V8 b; ?9 d
97.   hadc1.Init.DiscontinuousConvMode = DISABLE;
    
98.   hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
    
99.   hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    ( h* j' R$ U" }: A7 ]8 a4 `; w
100.   hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
     
101.   hadc1.Init.NbrOfConversion = 10;
     
102.   hadc1.Init.DMAContinuousRequests = ENABLE;
     
103.   hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
     
104.   if (HAL_ADC_Init(&hadc1) != HAL_OK)
     
105.   {
     
106.     _Error_Handler(__FILE__, __LINE__);
     & q4 Y2 C  ?0 U
107.   }
     & I5 c4 D$ B; U5 G
108.   sConfig.Channel = ADC_CHANNEL_0;
     
109.   sConfig.Rank = 1;
     . X% s2 [) }) c9 D
110.   sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
     
111.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     9 k, e1 A6 ~7 |) c
112.   {
     
113.     _Error_Handler(__FILE__, __LINE__);
     7 v7 a' _4 T" p+ ]6 G: I( ?
114.   }
     ! R2 A  y' t' X2 b! z8 L- t
115. 
     
116.   sConfig.Channel = ADC_CHANNEL_1;
     
117.   sConfig.Rank = 2;
     4 }: R  T# r9 P' D
118.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     1 Q  m6 |" h; }2 {
119.   {
     
120.     _Error_Handler(__FILE__, __LINE__);
     " j9 ]! w5 w; F0 V- ]+ U/ z+ `; x1 k
121.   }
     7 f, S% }( }, Y. U- A2 Z
122. 
     
123.   sConfig.Channel = ADC_CHANNEL_2;
     
124.   sConfig.Rank = 3;
     
125.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     5 s4 ?3 V( K8 V: O, [  A
126.   {
     
127.     _Error_Handler(__FILE__, __LINE__);
     9 o( V9 H+ D) Q" K1 n
128.   }
     $ f9 b  F4 D# z) ^" Y
129. 
     ) `$ |0 e5 r2 e& p/ D4 v
130.   sConfig.Channel = ADC_CHANNEL_3;
     ' }  [* t8 }) z) \
131.   sConfig.Rank = 4;
     5 e/ |9 z2 I3 ~9 l+ T
132.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     % c- v+ K  P) x7 q1 C; ~/ G
133.   {
     
134.     _Error_Handler(__FILE__, __LINE__);
     * m' ?3 q8 B. X( i' @8 ]- T! v
135.   }
     
136. 
     
137.   sConfig.Channel = ADC_CHANNEL_4;
     
138.   sConfig.Rank = 5;
     8 x& Z  A& U' ]2 l9 u2 U
139.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     3 Q* _$ t1 u9 L* \5 {+ k. j
140.   {
     0 Y; ]( U4 U3 u  l3 l  M- H
141.     _Error_Handler(__FILE__, __LINE__);
     
142.   }
     
143. 
     ( p0 {1 g. x7 |  e  u& Y6 \0 t3 S
144.   sConfig.Channel = ADC_CHANNEL_6;
     
145.   sConfig.Rank = 6;
     3 K" o/ B" R3 v5 g: X/ K
146.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     
147.   {
     5 z7 ^; ?( h, S
148.     _Error_Handler(__FILE__, __LINE__);
     
149.   }
     
150. 
     
151.   sConfig.Channel = ADC_CHANNEL_7;
     
152.   sConfig.Rank = 7;
     8 }( n% f5 z/ i+ d5 ]/ n  J4 ^
153.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     $ Y$ T5 G  L# Y: r* I
154.   {
     3 Y3 Z0 G3 b0 S7 e
155.     _Error_Handler(__FILE__, __LINE__);
     
156.   }
     - y- d3 |$ h- m4 ~4 z" N1 R' X& W
157. 
     : n9 X$ K/ Y! F3 N5 A2 y2 e* B- u: T6 p
158.   sConfig.Channel = ADC_CHANNEL_8;
     2 z; ]& R1 }, b) X6 L% e$ D
159.   sConfig.Rank = 8;
     
160.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     
161.   {
     
162.     _Error_Handler(__FILE__, __LINE__);
     ' t1 _) N0 j6 R0 Y" g
163.   }
     : C+ ?) {2 g+ `- P$ O# \! D
164. 
     
165.   sConfig.Channel = ADC_CHANNEL_9;
     + m. V1 C/ l) X) v: e+ `
166.   sConfig.Rank = 9;
     
167.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     
168.   {
     
169.     _Error_Handler(__FILE__, __LINE__);
     
170.   }
     & P7 Z5 _7 H  ~; z9 v: n0 F+ o
171. 
     
172.   sConfig.Channel = ADC_CHANNEL_10;
     
173.   sConfig.Rank = 10;
     
174.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
     9 J7 T: I! h" U! Y
175.   {
     
176.     _Error_Handler(__FILE__, __LINE__);
     ; P9 Z' y9 ]9 p( S4 o, ?- g% R) F
177.   }
     
178. 
     
179. }
     
180. 
     
181. void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
     $ f0 n3 w9 a. J2 ]! o
182. {
     
183. 
     . J8 K3 J, R  w0 t* j8 g9 \
184.   GPIO_InitTypeDef GPIO_InitStruct;
     
185.   if(adcHandle->Instance==ADC1)
     - y9 S0 V1 v. \; d
186.   {
     0 c0 Q  S/ b7 K+ r6 l. h2 i% L
187.     __HAL_RCC_ADC1_CLK_ENABLE();
     & X( L6 O& L3 z+ a; v& |; N& ]0 N' C
188. 
     
189.     GPIO_InitStruct.Pin = GPIO_PIN_0;
     
190.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     
191.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     ' _, \4 G% l5 v2 S/ ]1 d% v8 |
192.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     
193.     GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
     
194.                           |GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_7;
     - ^! Y" B" F: `8 c+ r
195.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     
196.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     
197.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
198. 
     ! ^* F0 ?3 ]' |. }- i8 O
199.     GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
     - @- I3 j0 \- I/ Y: ?  u$ ~6 ]+ C
200.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     - ?; u9 e. b0 O3 ]: @$ w) H
201.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     ) x( K2 X, e3 f
202.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
     1 ^( n& Y; B/ o3 g9 d* v
203.     hdma_adc1.Instance = DMA2_Stream0;
     ) |) |0 n- H3 r; L8 y2 e
204.     hdma_adc1.Init.Channel = DMA_CHANNEL_0;
     
205.     hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
     
206.     hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
     9 B+ h* d/ V3 m
207.     hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
     & I1 A& D, W$ k5 x% S% ]0 j0 g
208.     hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
     2 H: J: V4 a* \2 k% O( _+ h8 E# l
209.     hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
     ( e; l0 w. n3 v
210.     hdma_adc1.Init.Mode = DMA_CIRCULAR;
     2 y% c9 e2 U$ s9 E( |0 K- B/ i
211.     hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;
     
212.     hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
     ) Y* k( g( Q& ]
213.     if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
     & \! \% H  f: `/ z
214.     {
     
215.       _Error_Handler(__FILE__, __LINE__);
     
216.     }
     
217. 
     
218.     __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);
     1 Q) \9 r( P  D$ J
219. 
     ' T8 F1 z8 a8 g) z+ l- P' q
220.   }
     
221. }
     $ n8 a. i9 w; L( G, `. w
222. 
     
223. 
     . Q5 k) a0 s. ]9 d
224. 
     
225. 
     
226. 
     
227. 
     % F  n6 G  ?! V; U! c' Y  r

复制代码

http://player.youku.com/player.php/sid/XMjk0ODczODg5Ng==/v.swf

由于STM32F446的快速处理信号能力，本方案中同时开启10路带DMA的ADC处理10路50HZ交流电压绰绰有余。演示中在OLED屏幕上显示ADC0通道的转换结果。
; x- f) r5 z3 x& b! `/ e, O. E

wenyangzeng 发表于 2017-9-26 07:24
# u+ S4 X3 F6 C- Y5 s互感器次级把初级的负电压“垫”高到VSS了。

楼主，你没有用示波器实际量，采样电阻出来的是个交流正弦波，有正负。所以你直接采样ADC等于把负的忽略l了，这样采样玩玩还可以，会对单片机的ADC有影响的,实际工程项目不能这样做的。

wenyangzeng 发表于 2017-9-27 09:52
% ~) y- @2 b2 K6 A& j* S, i那个电阻应该在300K-470K以上，否则互感器会磁饱和而烧毁。

$ T9 x. r+ ~3 @% s: \" T: T输入级的电阻我知道，我选用300K 的，我是说输出级的、后面我查阅相关资料，你选用的互感器没有标明线性取样电阻，我选用的标明了。

wenyangzeng 发表于 2017-9-26 21:02
  H# L4 q* }4 A1 m* G' ?7 \精密整流后再积分,只能算是“有效值”，而非“真有效值”

相当于取了绝对值，求RMS无影响。。。。。。。。还有疑问你这个互感器DATASHEET上就是写采样电阻那么大？就我所知道的，都是采样都是100R以下的

谢谢支持啦~

楼主你那是什么软件，配置MCU的那个

csgtli5608 发表于 2017-8-8 14:10
楼主你那是什么软件，配置MCU的那个

) d9 `# i3 g5 j" tSTM32CubeMX,到ST官方网站下载。
https://www.stmcu.org.cn/document/detail/index/id-218002
" d2 |! r' k% x
2 M  d+ \+ g# L& W2 d$ U$ O2 t
1 K$ f! X" [. s  J' h

顶一个

谢谢分享！

顶

最后ADC测得应该是半波，即在正弦波X轴上半部分?

Draway 发表于 2017-9-25 18:01
0 u! k% V3 P4 @最后ADC测得应该是半波，即在正弦波X轴上半部分?

经过电压互感器后，次级是完整的正弦波。采样48次耗时20mS，就能够覆盖整个交流电的一个周期。

wenyangzeng 发表于 2017-9-25 20:47
! t$ H6 o4 ~2 G/ |: H: H9 ^经过电压互感器后，次级是完整的正弦波。采样48次耗时20mS，就能够覆盖整个交流电的一个周期。 ...

0 T% q$ R3 z' k* r. Q+ o, A" ~那互感器出来没有负电压么？我看的采样后直接接ADC了

Draway 发表于 2017-9-25 22:19
那互感器出来没有负电压么？我看的采样后直接接ADC了

互感器次级把初级的负电压“垫”高到VSS了。

给楼主点赞。但是实用意义不大。

wenyangzeng 发表于 2017-9-26 07:24
% U; m3 m' P+ H* l% f互感器次级把初级的负电压“垫”高到VSS了。

2 V! p4 f* |+ O. Q  ^噢，你用的是什么型号的互感器？