合力为HLW8032计量芯片设计资料包 含8266源程序

资料包为深圳市合力为科技的计量芯片HLW8032的应用开发包；包含datasheet,软件参考设计，硬件参考设计，常见问题等文档。笔者已经参考资料包打样了电路板；测试效果还不错，欢迎一起交流，学习！


8266参考代码
1、采样电阻：0.001R
2、电压分压电阻:1M【参考设计资料是1.88M】

源程序如下:

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. /* run this program using the console pauser or add your own getch, system("pause") or input loop */
   
5. #define SAMPLE_RESISTANCE_MR    1//使用的采样锰铜电阻mR值
   
6. 
   
7. #define UART_IND_HD            0
   
8. #define UART_IND_5A            1
   
9. #define UART_IND_VK            2
   
10. #define UART_IND_VT            5
    
11. #define UART_IND_IK            8
    
12. #define UART_IND_IT            11
    
13. #define UART_IND_PK            14
    
14. #define UART_IND_PT            17
    
15. #define UART_IND_FG            20
    
16. #define UART_IND_EN            21
    
17. #define UART_IND_SM            23
    
18. 
    
19. #define ARRAY_LEN       3//平滑滤波buf长度
    
20. #define COUNT_NUM       1//超时更新数据次数
    
21. 
    
22. //8032电能计数脉冲溢出时的数据
    
23. #define ENERGY_FLOW_NUM            65536   //电量采集，电能溢出时的脉冲计数值
    
24. 
    
25. typedef struct RuningInf_s{
    
26.     unsigned short  voltage;//当前电压值，单位为0.1V
    
27.     unsigned short  electricity;//当前电流值,单位为0.01A
    
28.     unsigned short  power;//当前功率,单位为0.1W
    
29.    
    
30.     unsigned long   energy;//当前消耗电能值对应的脉冲个数
    
31.     unsigned short  energyCurrent;//电能脉冲当前统计值
    
32.     unsigned short  energyLast;//电能脉冲上次统计值
    
33.     unsigned char   energyFlowFlag;//电能脉冲溢出标致
    
34.    
    
35.     unsigned long   energyUnit;//0.001度点对应的脉冲个数
    
36. }RuningInf_t;
    
37. 
    
38. RuningInf_t runingInf;
    
39. 
    
40. //获取电压、电流、功率的有限数据
    
41. unsigned long getVIPvalue(unsigned long *arr)//更新电压、电流、功率的列表
    
42. {
    
43.     int maxIndex = 0;
    
44.     int minIndex = 0;
    
45.     unsigned long sum = 0;
    
46.     int j = 0;
    
47.     for(j = 1; j<ARRAY_LEN; j++){
    
48.         if(arr[maxIndex] <= arr[j]){//避免所有数据一样时minIndex等于maxIndex
    
49.             maxIndex = j;
    
50.         }
    
51.         if(arr[minIndex] > arr[j]){
    
52.             minIndex = j;
    
53.         }
    
54.     }
    
55.    
    
56.     for(j = 0; j<ARRAY_LEN; j++){
    
57.         if((maxIndex == j)||(minIndex == j)){
    
58.             continue;
    
59.         }
    
60.         else{
    
61.             return arr[j];
    
62.         }
    
63.     }
    
64. }
    
65. 
    
66. int isUpdataNewData(unsigned long *arr,unsigned long dat)//检测电压电流功率是否需要更新
    
67. {
    
68.     if(arr[0] == dat){
    
69.         return 0;
    
70.     }
    
71.     else{
    
72.         return 1;
    
73.     }
    
74. }
    
75. 
    
76. void updataVIPvalue(unsigned long *arr,unsigned long dat)//更新电压、电流、功率的列表
    
77. {
    
78.     int ii = ARRAY_LEN-1;
    
79.     for(ii = ARRAY_LEN-1; ii > 0; ii--){
    
80.         arr[ii] = arr[ii-1];
    
81.     }
    
82.     arr[0] = dat;
    
83. }
    
84. 
    
85. void resetVIPvalue(unsigned long *arr,unsigned long dat)//更新所有电压、电流、功率的列表
    
86. {   
    
87.     int ii = ARRAY_LEN-1;
    
88.     for(ii = ARRAY_LEN-1; ii >= 0; ii--){
    
89.         arr[ii] = dat;
    
90.     }
    
91. }
    
92. 
    
93. int DealUartInf(unsigned char *inDataBuffer,int recvlen)
    
94. {
    
95.     unsigned char     startFlag     = 0;
    
96.    
    
97.     unsigned long      voltage_k        = 0;
    
98.     unsigned long      voltage_t     = 0;
    
99.     unsigned long      voltage       = 0;
    
100.     static unsigned long voltage_a[ARRAY_LEN]  = {0};
     
101.     static unsigned int  voltageCnt    = 0;
     
102. 
     
103.     unsigned long      electricity_k = 0;
     
104.     unsigned long      electricity_t = 0;
     
105.     unsigned long      electricity   = 0;
     
106.     static unsigned long electricity_a[ARRAY_LEN]  = {0};
     
107.     static unsigned int  electricityCnt    = 0;
     
108. 
     
109.     unsigned long      power_k = 0;
     
110.     unsigned long      power_t = 0;
     
111.     unsigned long      power      = 0;
     
112.     static unsigned long power_a[ARRAY_LEN]= {0};
     
113.     static unsigned int  powerCnt    = 0;
     
114.     static unsigned long powerNewFlag = 1;
     
115.    
     
116.     unsigned int      energy_cnt     = 0;
     
117.     unsigned char      energyFlowFlag = 0;
     
118. 
     
119.     startFlag = inDataBuffer[UART_IND_HD];
     
120.     switch(startFlag)
     
121.     {
     
122.         case 0x55:
     
123.             if((inDataBuffer[UART_IND_FG]&0x40) == 0x40){//获取当前电压标致，为1时说明电压检测OK
     
124.                 voltage_k = ((inDataBuffer[UART_IND_VK] << 16)|(inDataBuffer[UART_IND_VK+1] << 8)|(inDataBuffer[UART_IND_VK+2]));//电压系数
     
125.                 voltage_t = ((inDataBuffer[UART_IND_VT] << 16)|(inDataBuffer[UART_IND_VT+1] << 8)|(inDataBuffer[UART_IND_VT+2]));//电压周期
     
126.                
     
127.                 if(isUpdataNewData(voltage_a,voltage_t)){
     
128.                     updataVIPvalue(voltage_a,voltage_t);
     
129.                     voltageCnt = 0;
     
130.                 }
     
131.                 else{
     
132.                     voltageCnt++;
     
133.                     if(voltageCnt >= COUNT_NUM){
     
134.                         voltageCnt = 0;
     
135.                         updataVIPvalue(voltage_a,voltage_t);
     
136.                     }
     
137.                 }
     
138.                 printf("voltage:%d,%d,%d\r\n",voltage_a[0],voltage_a[1],voltage_a[2]);
     
139.                 voltage_t = getVIPvalue(voltage_a);
     
140.                
     
141.                 if(voltage_t == 0){
     
142.                     voltage = 0;
     
143.                 }
     
144.                 else{
     
145.                     voltage = voltage_k * 100 / voltage_t;//电压10mV值，避免溢出
     
146.                     voltage = voltage * 10;//电压mV值
     
147.                 }
     
148.                 printf("Vk = %d,Vt = %d,v = %d\r\n",voltage_k,voltage_t,voltage);
     
149.             }
     
150.             else{
     
151.                 printf("%s(%d):V Flag Error\r\n",__func__,__LINE__);
     
152.             }
     
153.             
     
154.             if((inDataBuffer[UART_IND_FG]&0x20) == 0x20){
     
155.                 electricity_k = ((inDataBuffer[UART_IND_IK] << 16)|(inDataBuffer[UART_IND_IK+1] << 8)|(inDataBuffer[UART_IND_IK+2]));//电流系数
     
156.                 electricity_t = ((inDataBuffer[UART_IND_IT] << 16)|(inDataBuffer[UART_IND_IT+1] << 8)|(inDataBuffer[UART_IND_IT+2]));//电流周期
     
157. 
     
158.                 if(isUpdataNewData(electricity_a,electricity_t)){
     
159.                     updataVIPvalue(electricity_a,electricity_t);
     
160.                     electricityCnt = 0;
     
161.                 }
     
162.                 else{
     
163.                     electricityCnt++;
     
164.                     if(electricityCnt >= COUNT_NUM){
     
165.                         electricityCnt = 0;
     
166.                         updataVIPvalue(electricity_a,electricity_t);
     
167.                     }
     
168.                 }
     
169.                 printf("electricity:%d,%d,%d\r\n",electricity_a[0],electricity_a[1],electricity_a[2]);
     
170.                 electricity_t = getVIPvalue(electricity_a);
     
171.                
     
172.                 if(electricity_t == 0){
     
173.                     electricity = 0;
     
174.                 }
     
175.                 else{
     
176.                     electricity = electricity_k * 100 / electricity_t;//电流10mA值，避免溢出
     
177.                     electricity = electricity * 10;//电流mA值
     
178.                     #if(SAMPLE_RESISTANCE_MR == 1)
     
179.                     //由于使用1mR的电阻，电流和功率需要不除以2
     
180.                     #elif(SAMPLE_RESISTANCE_MR == 2)
     
181.                     //由于使用2mR的电阻，电流和功率需要除以2
     
182.                     electricity >>= 1;
     
183.                     #endif
     
184.                 }
     
185.                 printf("Ik = %d,It = %d,I = %d\r\n",electricity_k,electricity_t,electricity);
     
186.             }
     
187.             else{
     
188.                 printf("%s(%d):I Flag Error\r\n",__func__,__LINE__);
     
189.             }
     
190. 
     
191.             if((inDataBuffer[UART_IND_FG]&0x10) == 0x10){
     
192.                 powerNewFlag = 0;
     
193.                 power_k = ((inDataBuffer[UART_IND_PK] << 16)|(inDataBuffer[UART_IND_PK+1] << 8)|(inDataBuffer[UART_IND_PK+2]));//功率系数
     
194.                 power_t = ((inDataBuffer[UART_IND_PT] << 16)|(inDataBuffer[UART_IND_PT+1] << 8)|(inDataBuffer[UART_IND_PT+2]));//功率周期
     
195.                
     
196.                 if(isUpdataNewData(power_a,power_t)){
     
197.                     updataVIPvalue(power_a,power_t);
     
198.                     powerCnt = 0;
     
199.                 }
     
200.                 else{
     
201.                     powerCnt++;
     
202.                     if(powerCnt >= COUNT_NUM){
     
203.                         powerCnt = 0;
     
204.                         updataVIPvalue(power_a,power_t);
     
205.                     }
     
206.                 }
     
207.                 printf("power:%d,%d,%d\r\n",power_a[0],power_a[1],power_a[2]);
     
208.                 power_t = getVIPvalue(power_a);
     
209.                
     
210.                 if(power_t == 0){
     
211.                     power = 0;
     
212.                 }
     
213.                 else{
     
214.                     power = power_k * 100 / power_t;//功率10mw值，避免溢出
     
215.                     power = power * 10;//功率mw值
     
216.                     #if(SAMPLE_RESISTANCE_MR == 1)
     
217.                     //由于使用1mR的电阻，电流和功率需要不除以2
     
218.                     #elif(SAMPLE_RESISTANCE_MR == 2)
     
219.                     //由于使用2mR的电阻，电流和功率需要除以2
     
220.                     power >>= 1;
     
221.                     #endif
     
222.                 }
     
223.                 printf("Pk = %d,Pt = %d,P = %d\r\n",power_k,power_t,power);
     
224.             }
     
225.             else if(powerNewFlag == 0){
     
226.                 power_k = ((inDataBuffer[UART_IND_PK] << 16)|(inDataBuffer[UART_IND_PK+1] << 8)|(inDataBuffer[UART_IND_PK+2]));//功率系数
     
227.                 power_t = ((inDataBuffer[UART_IND_PT] << 16)|(inDataBuffer[UART_IND_PT+1] << 8)|(inDataBuffer[UART_IND_PT+2]));//功率周期
     
228.                
     
229.                 if(isUpdataNewData(power_a,power_t)){
     
230.                     unsigned long powerData = getVIPvalue(power_a);
     
231.                     if(power_t > powerData){
     
232.                         if((power_t - powerData) > (powerData >> 2)){
     
233.                             resetVIPvalue(power_a,power_t);
     
234.                         }
     
235.                     }
     
236.                 }
     
237.                 printf("power:%d,%d,%d\r\n",power_a[0],power_a[1],power_a[2]);
     
238.                 power_t = getVIPvalue(power_a);
     
239.                
     
240.                 if(power_t == 0){
     
241.                     power = 0;
     
242.                 }
     
243.                 else{
     
244.                     power = power_k * 100 / power_t;//功率10mw值，避免溢出
     
245.                     power = power * 10;//功率mw值
     
246.                     #if(SAMPLE_RESISTANCE_MR == 1)
     
247.                     //由于使用1mR的电阻，电流和功率需要不除以2
     
248.                     #elif(SAMPLE_RESISTANCE_MR == 2)
     
249.                     //由于使用2mR的电阻，电流和功率需要除以2
     
250.                     power >>= 1;
     
251.                     #endif
     
252.                 }
     
253.                 printf("Pk = %d,Pt = %d,P = %d\r\n",power_k,power_t,power);
     
254.             }
     
255.             
     
256.             energyFlowFlag = (inDataBuffer[UART_IND_FG] >> 7);//获取当前电能计数溢出标致
     
257.             runingInf.energyCurrent = ((inDataBuffer[UART_IND_EN] << 8)|(inDataBuffer[UART_IND_EN+1]));//更新当前的脉冲计数值
     
258.             if(runingInf.energyFlowFlag != energyFlowFlag){//每次计数溢出时更新当前脉冲计数值
     
259.                 runingInf.energyFlowFlag = energyFlowFlag;
     
260.                 if(runingInf.energyCurrent > runingInf.energyLast){
     
261.                     runingInf.energyCurrent = 0;
     
262.                 }
     
263.                 energy_cnt = runingInf.energyCurrent + ENERGY_FLOW_NUM - runingInf.energyLast;
     
264.             }
     
265.             else{
     
266.                 energy_cnt = runingInf.energyCurrent - runingInf.energyLast;
     
267.             }
     
268.             runingInf.energyLast = runingInf.energyCurrent;
     
269.             runingInf.energy += (energy_cnt * 10);//电能个数累加时扩大10倍，计算电能是除数扩大10倍，保证计算精度
     
270.             
     
271.             runingInf.energyUnit = 0xD693A400 >> 1;
     
272.             runingInf.energyUnit /= (power_k >> 1);//1mR采样电阻0.001度电对应的脉冲个数
     
273.             #if(SAMPLE_RESISTANCE_MR == 1)
     
274.             //1mR锰铜电阻对应的脉冲个数
     
275.             #elif(SAMPLE_RESISTANCE_MR == 2)
     
276.             //2mR锰铜电阻对应的脉冲个数
     
277.             runingInf.energyUnit = (runingInf.energyUnit << 1);//2mR采样电阻0.001度电对应的脉冲个数
     
278.             #endif
     
279.             runingInf.energyUnit =runingInf.energyUnit * 10;//0.001度电对应的脉冲个数(计算个数时放大了10倍，所以在这里也要放大10倍)
     
280.             
     
281.             //电能使用量=runingInf.energy/runingInf.energyUnit;//单位是0.001度
     
282.             break;
     
283.         
     
284.         case 0xAA:
     
285.             //芯片未校准
     
286.             printf("HLW8032 not check\r\n");
     
287.             break;
     
288. 
     
289.         default :
     
290.             if((startFlag & 0xF1) == 0xF1){//存储区异常，芯片坏了
     
291.                 //芯片坏掉，反馈服务器
     
292.                 printf("HLW8032 broken\r\n");
     
293.             }
     
294. 
     
295.             if((startFlag & 0xF2) == 0xF2){//功率异常
     
296.                 runingInf.power = 0;//获取到的功率是以0.1W为单位
     
297.                 power = 0;
     
298.                 //printf("Power Error\r\n");
     
299.             }
     
300.             else{
     
301.                 if((inDataBuffer[UART_IND_FG]&0x10) == 0x10){
     
302.                     powerNewFlag = 0;
     
303.                     power_k = ((inDataBuffer[UART_IND_PK] << 16)|(inDataBuffer[UART_IND_PK+1] << 8)|(inDataBuffer[UART_IND_PK+2]));//功率系数
     
304.                     power_t = ((inDataBuffer[UART_IND_PT] << 16)|(inDataBuffer[UART_IND_PT+1] << 8)|(inDataBuffer[UART_IND_PT+2]));//功率周期
     
305.                     
     
306.                     if(isUpdataNewData(power_a,power_t)){
     
307.                         updataVIPvalue(power_a,power_t);
     
308.                         powerCnt = 0;
     
309.                     }
     
310.                     else{
     
311.                         powerCnt++;
     
312.                         if(powerCnt >= COUNT_NUM){
     
313.                             powerCnt = 0;
     
314.                             updataVIPvalue(power_a,power_t);
     
315.                         }
     
316.                     }
     
317.                     //printf("power:%d,%d,%d\r\n",power_a[0],power_a[1],power_a[2]);
     
318.                     power_t = getVIPvalue(power_a);
     
319.                     
     
320.                     if(power_t == 0){
     
321.                         power = 0;
     
322.                     }
     
323.                     else{
     
324.                         power = power_k * 100 / power_t;//功率10mw值，避免溢出
     
325.                         power = power * 10;//功率mw值
     
326.                         #if(SAMPLE_RESISTANCE_MR == 1)
     
327.                         //由于使用1mR的电阻，电流和功率需要不除以2
     
328.                         #elif(SAMPLE_RESISTANCE_MR == 2)
     
329.                         //由于使用2mR的电阻，电流和功率需要除以2
     
330.                         power >>= 1;
     
331.                         #endif
     
332.                     }
     
333.                     printf("Pk = %d,Pt = %d,P = %d\r\n",power_k,power_t,power);
     
334.                 }
     
335.                 else if(powerNewFlag == 0){
     
336.                     power_k = ((inDataBuffer[UART_IND_PK] << 16)|(inDataBuffer[UART_IND_PK+1] << 8)|(inDataBuffer[UART_IND_PK+2]));//功率系数
     
337.                     power_t = ((inDataBuffer[UART_IND_PT] << 16)|(inDataBuffer[UART_IND_PT+1] << 8)|(inDataBuffer[UART_IND_PT+2]));//功率周期
     
338.                     
     
339.                     if(isUpdataNewData(power_a,power_t)){
     
340.                         unsigned long powerData = getVIPvalue(power_a);
     
341.                         if(power_t > powerData){
     
342.                             if((power_t - powerData) > (powerData >> 2)){
     
343.                                 resetVIPvalue(power_a,power_t);
     
344.                             }
     
345.                         }
     
346.                     }
     
347.                     //printf("power:%d,%d,%d\r\n",power_a[0],power_a[1],power_a[2]);
     
348.                     power_t = getVIPvalue(power_a);
     
349.                     
     
350.                     if(power_t == 0){
     
351.                         power = 0;
     
352.                     }
     
353.                     else{
     
354.                         power = power_k * 100 / power_t;//功率10mw值，避免溢出
     
355.                         power = power * 10;//功率mw值
     
356.                         #if(SAMPLE_RESISTANCE_MR == 1)
     
357.                         //由于使用1mR的电阻，电流和功率需要不除以2
     
358.                         #elif(SAMPLE_RESISTANCE_MR == 2)
     
359.                         //由于使用2mR的电阻，电流和功率需要除以2
     
360.                         power >>= 1;
     
361.                         #endif
     
362.                     }
     
363.                     printf("Pk = %d,Pt = %d,P = %d\r\n",power_k,power_t,power);
     
364.                 }
     
365.             }
     
366. 
     
367.             if((startFlag & 0xF4) == 0xF4){//电流异常
     
368.                 runingInf.electricity = 0;//获取到的电流以0.01A为单位               
     
369.                 electricity = 0;
     
370.             }
     
371.             else{
     
372.                 if((inDataBuffer[UART_IND_FG]&0x20) == 0x20){
     
373.                     electricity_k = ((inDataBuffer[UART_IND_IK] << 16)|(inDataBuffer[UART_IND_IK+1] << 8)|(inDataBuffer[UART_IND_IK+2]));//电流系数
     
374.                     electricity_t = ((inDataBuffer[UART_IND_IT] << 16)|(inDataBuffer[UART_IND_IT+1] << 8)|(inDataBuffer[UART_IND_IT+2]));//电流周期
     
375. 
     
376.                     if(isUpdataNewData(electricity_a,electricity_t)){
     
377.                         updataVIPvalue(electricity_a,electricity_t);
     
378.                         electricityCnt = 0;
     
379.                     }
     
380.                     else{
     
381.                         electricityCnt++;
     
382.                         if(electricityCnt >= COUNT_NUM){
     
383.                             electricityCnt = 0;
     
384.                             updataVIPvalue(electricity_a,electricity_t);
     
385.                         }
     
386.                     }
     
387.                     //printf("electricity:%d,%d,%d\r\n",electricity_a[0],electricity_a[1],electricity_a[2]);
     
388.                     electricity_t = getVIPvalue(electricity_a);
     
389.                     
     
390.                     if(electricity_t == 0){
     
391.                         electricity = 0;
     
392.                     }
     
393.                     else{
     
394.                         electricity = electricity_k * 100 / electricity_t;//电流10mA值，避免溢出
     
395.                         electricity = electricity * 10;//电流mA值
     
396.                         #if(SAMPLE_RESISTANCE_MR == 1)
     
397.                         //由于使用1mR的电阻，电流和功率需要不除以2
     
398.                         #elif(SAMPLE_RESISTANCE_MR == 2)
     
399.                         //由于使用2mR的电阻，电流和功率需要除以2
     
400.                         electricity >>= 1;
     
401.                         #endif
     
402.                     }
     
403.                     printf("Ik = %d,It = %d,I = %d\r\n",electricity_k,electricity_t,electricity);
     
404.                 }
     
405.                 else{
     
406.                     printf("%s(%d):I Flag Error\r\n",__func__,__LINE__);
     
407.                 }
     
408.             }
     
409.             
     
410.             if((startFlag & 0xF8) == 0xF8){//电压异常
     
411.                 runingInf.voltage = 0;//获取到的电压是以0.1V为单位               
     
412.                 voltage = 0;
     
413.             }
     
414.             else{
     
415.                 if((inDataBuffer[UART_IND_FG]&0x40) == 0x40){//获取当前电压标致，为1时说明电压检测OK
     
416.                     voltage_k = ((inDataBuffer[UART_IND_VK] << 16)|(inDataBuffer[UART_IND_VK+1] << 8)|(inDataBuffer[UART_IND_VK+2]));//电压系数
     
417.                     voltage_t = ((inDataBuffer[UART_IND_VT] << 16)|(inDataBuffer[UART_IND_VT+1] << 8)|(inDataBuffer[UART_IND_VT+2]));//电压周期
     
418.                     
     
419.                     if(isUpdataNewData(voltage_a,voltage_t)){
     
420.                         updataVIPvalue(voltage_a,voltage_t);
     
421.                         voltageCnt = 0;
     
422.                     }
     
423.                     else{
     
424.                         voltageCnt++;
     
425.                         if(voltageCnt >= COUNT_NUM){
     
426.                             voltageCnt = 0;
     
427.                             updataVIPvalue(voltage_a,voltage_t);
     
428.                         }
     
429.                     }
     
430.                     //printf("voltage:%d,%d,%d\r\n",voltage_a[0],voltage_a[1],voltage_a[2]);
     
431.                     voltage_t = getVIPvalue(voltage_a);
     
432.                     
     
433.                     if(voltage_t == 0){
     
434.                         voltage = 0;
     
435.                     }
     
436.                     else{
     
437.                         voltage = voltage_k * 100 / voltage_t;//电压10mV值，避免溢出
     
438.                         voltage = voltage * 10;//电压mV值
     
439.                     }
     
440.                     printf("Vk = %d,Vt = %d,v = %d\r\n",voltage_k,voltage_t,voltage);
     
441.                 }
     
442.                 else{
     
443.                     printf("%s(%d):V Flag Error\r\n",__func__,__LINE__);
     
444.                 }
     
445.             }
     
446.             printf("0x%x:V = %d;I = %d;P = %d;\r\n",startFlag,voltage,electricity,power);
     
447.             break;
     
448.     }
     
449.     return 1;
     
450. }
     
451. 
     
452. int main(int argc, char *argv[]) {
     
453.     //模拟8032发送的一包数据 ，220V-5A-1100W
     
454.     unsigned char dataTemp[24] = {0x55,0x5A,
     
455.                          0x02,0xDE,0xC4,0x00,0x03,0x57,
     
456.                          0x00,0x3F,0x66,0x00,0x0C,0xAE,
     
457.                          0x52,0x90,0x54,0x00,0x13,0x37,
     
458.                          0x71,0x00,0x13,0x61};//串口接收到的 8032发送的一包有效数据
     
459.     DealUartInf(dataTemp,24);//处理8032数据
     
460.     DealUartInf(dataTemp,24);//处理8032数据
     
461.     DealUartInf(dataTemp,24);//处理8032数据
     
462.     return 0;
     
463. }
     
464. 
     

复制代码

所有资料51hei提供下载:
合力为HLW8032设计资料包V34.zip (17.82 MB, 下载次数: 126)

2020-9-12 09:59 上传

点击文件名下载附件

记号一下！谢谢分享！