设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › MSP430采集交流信号程序
返回列表 发新帖
查看: 1521|回复: 1
打印 上一主题 下一主题
收起左侧

MSP430采集交流信号程序

[复制链接]
跳转到指定楼层
楼主
ID:599388 发表于 2019-8-12 15:22 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
     本程序利用MSP较高的采样速度和12位AD精度，采用均方根算法，求电压、电流有效值；四象限有功功率，无功功率；电能值。
需要整体源代码及原理图的朋友请和我联系。珠海的朋友可以项目合作。扣扣：2544931233

单片机源程序如下:
  1. //本程序的主要功能是：
  2. //                  1.计算各电参数每周波的有效值；
  3. //                  2.计算各电参数多个周波有效值的平均值（滤波），每分钟进行计算
  4. //                  3.产生电能脉冲输出；
  5. //                  4.计算电能
  6. //                  5.产生告警记录，（在每一分钟进行统计）
  7. //                  6.统计最大值最小值
  8. #include "msp430x14x.h"
  9. #include "my.h"
  10. #include "stdlib.h"

  12. void Process1s(void);
  13. void Process10s(void);
  14. void Process1m(void);
  15. void ProcessT(void);
  16. void ProcessMonth(void);
  17. void InitMaxMin(void);
  18. void CalculateEnergy(void);
  19. void CalculateVirtualValue(void);
  20. void  CalPower(void);
  21. void ClearEnergyRegister(void);

  23. static WORD CalPf(WORD p,WORD q);
  24. static WORD MExtract(DWORD sqr);

  26. extern BYTE FlashErase(UWORD *address);
  27. extern BYTE FlashWrite(UWORD *dataaddr,UWORD *flashaddr,UWORD counter);
  28. extern void FlashRead(UWORD *dataaddr,UWORD *flashaddr,UWORD counter);
  29. extern void WriteMainRecord(BYTE type);
  30. extern void GetHext(UDWORD ASECOND);
  31. BYTE  RecordErr;


  34. //相角补偿表
  35. const WORD Compensate[60]=
  36. {
  37.     -54,-52,-50,-48,-46,-45,-43,-41,-39,-38,
  38.      -36,-34,-32,-30,-29,-27,-25,-23,-21,-20,
  39.      -18,-16,-14,-13,-11, -9, -7, -5, -4, -2,
  40.        0,  2,  4,  5,  7,  9, 11, 13, 14, 16,
  41.       18, 20, 21, 23, 25, 27, 29, 30, 32, 34,
  42.       36, 38, 39, 41, 43, 45, 46, 48, 50, 52,
  43. };

  45. //===========================================================================
  46. SUM   Sum,SumTemp;
  47. WORD  CalSeq;
  48. DWORD DDataEPaP,DDataEPbP,DDataEPcP,DDataEPaN,DDataEPbN,DDataEPcN;
  49. DWORD DDataEQaP,DDataEQbP,DDataEQcP,DDataEQaN,DDataEQbN,DDataEQcN;
  50. DWORD CounterPulseP,CounterPulseQ;
  51. RECORD RecordTemp;

  53. DWORD  V_Sum_1m[3], I_Sum_1m[4];
  54. WORD   Power[6];
  55. BYTE   Count_Sum_1m;
  56. UWORD  FlagAlarm;
  57. VIRTUALDATA VirtualData;

  59. //extern BYTE Flag1s,Flag10s,Flag1m,FlagT;
  60. extern BYTE  FlagTime;
  61. extern PARAMETER ParameterTemp;
  62. extern CLOCK Clock;
  63. extern FREEZE_ENERGY FreezeEnergy[3];
  64. extern UWORD FreezeEnergyCounter;
  65. extern UDWORD  RSECOND;
  66. extern UDWORD PRODUCTNUMBER;
  67. extern UDWORD ProductNumber;
  68. extern SAMPLEDATA SampleData;

  70. extern COEFF Coeff,CoeffTemp;
  71. extern ENERGY Energy;
  72. extern BYTE Page;
  73. extern BYTE NewMonthFlag;
  74. extern WORD Frequency;
  75. extern UWORD RecordNumber;
  76. extern BYTE FlagCalculate;

  78. //==================================================================================
  79. //计算电流电压功率温度平均值
  80. void Process1s(void)
  81. {
  82.         BYTE i,FlagAlarm1s;      
  83.         WORD TemptErr;   //温度差                       
  84.             WORD *ptr0,*ptr1,reg0,reg1;
  85.             DWORD *dptr,dreg;
  86.             UDWORD TimeTemp;
  87.            
  88.             FlagTime&=~BIT0;
  89.         
  90.         TemptErr = VirtualData.Tempt-30;
  91.         
  92.             ptr0=(WORD*)&VirtualData.Ua;           
  93.             ptr1=(WORD*)&CoeffTemp.Ua;
  94.             dptr=&Sum.Ua;
  95.             for(i=0;i<3;i++)
  96.             {
  97.                 reg1=*dptr>>4;                              //   *dptr=0;
  98.                 reg0 = reg1;//-(DWORD)reg1*3*TemptErr/10000;
  99.                 *ptr0=((DWORD)reg0*(*ptr1))>>10;            //U
  100.                 if((UWORD)*ptr0>0x7fff) *ptr0=0x7fff;
  101.                 V_Sum_1m[i]+=*ptr0;                         //电压和累计
  102.         
  103.                 reg1=*(dptr+1)>>4;
  104.                 reg0 = reg1;//-(DWORD)reg1*3*TemptErr/10000;  //温度补偿
  105.                 *(ptr0+1)=((DWORD)reg0*(*(ptr1+1)))>>10;    //I               
  106.                 if((UWORD)(*(ptr0+1))>0x7fff) *(ptr0+1)=0x7fff;
  107.                 I_Sum_1m[i]+=*(ptr0+1);
  108.       
  109.                 ptr0+=2;ptr1+=2;dptr+=2;
  110.             }
  111.            
  112.             CalPower();
  113.            
  114.             ptr0=(WORD*)&VirtualData.Pa;
  115.             ptr1=(WORD*)&CoeffTemp.Pa;           
  116.         for(i = 0;i<3;i++)
  117.         {               
  118.                 *ptr0=Power[2*i]+(((DWORD)Power[2*i+1]*Compensate[*ptr1])>>10);
  119.                 if(abs(*ptr0)<10) *ptr0=0;          //判断绝对值
  120.                
  121.                 *(ptr0+1)=Power[i*2+1]-(((DWORD)Power[2*i]*Compensate[*(ptr1+1)])>>10);
  122.                 if(abs(*(ptr0+1))<10) *(ptr0+1)=0;          //判断绝对值
  123.                
  124.                 ptr0+=2; ptr1+=2;
  125.             }
  126.            
  127.             reg0=Sum.I0>>4;
  128.             reg1=(DWORD)reg0*Coeff.Ib>>10;    //乘以IB的系数
  129.             if((UWORD)reg1>0x7fff)reg1=0x7fff;           
  130.             VirtualData.I0=reg1;
  131.             I_Sum_1m[3]+=reg1;   
  132.                     
  133.             Count_Sum_1m++;                              //和累计次数   
  134.    
  135.    
  136.             if(VirtualData.Ia<10)VirtualData.Pfa=0;
  137.             else  VirtualData.Pfa=CalPf(VirtualData.Pa,VirtualData.Qa);
  138.    
  139.             if(VirtualData.Ib<10)VirtualData.Pfb=0;
  140.             else  VirtualData.Pfb=CalPf(VirtualData.Pb,VirtualData.Qb);
  141.    
  142.             if(VirtualData.Ic<10)VirtualData.Pfc=0;
  143.             else  VirtualData.Pfc=CalPf(VirtualData.Pc,VirtualData.Qc);
  144.            
  145.             if(Frequency==0)Frequency = 5000;
  146.             VirtualData.Freq=Frequency;
  147.             dreg=0;
  148.             for(i=0;i<24;i++)dreg+=(DWORD)SampleData.Tempt[i];
  149.             reg0=dreg/24-1560;//1580;
  150.             VirtualData.Tempt=((DWORD)reg0*10)/80;
  151.    
  152.         
  153.             FlagAlarm1s=FALSE;
  154.             ptr0=&VirtualData.Ua;
  155.             for(i=0;i<3;i++)
  156.             {
  157.                 if(*ptr0>ParameterTemp.OverVoltage)FlagAlarm1s=TRUE;
  158.                 if(*ptr0<ParameterTemp.LowVoltage) FlagAlarm1s=TRUE;
  159.                 ptr0+=2;
  160.             }
  161.             ptr0=&VirtualData.Ia;
  162.             for(i=0;i<3;i++)
  163.             {
  164.                 if(*ptr0>ParameterTemp.OverCurrent)FlagAlarm1s=TRUE;
  165.                 ptr0+=2;
  166.             }
  167.            
  168.             if(VirtualData.I0>ParameterTemp.OverCurrent0)FlagAlarm1s=TRUE;
  169.    
  170.             if(FlagAlarm1s)P1OUT|=BIT2;                          //告警指示灯亮   
  171.             else           P1OUT&=~BIT2;                         //熄灭告警指示灯   
  172.            
  173.             _DINT();
  174.             TimeTemp = RSECOND;
  175.             _EINT();
  176.             if(Page!=0x01)GetHext(TimeTemp);
  177.            
  178.             if(Clock.month!=Clock.monthR)
  179.             {
  180.                     NewMonthFlag=true;            //判断是否进入新的一月
  181.             //        ProcessMonth();
  182.             }   
  183.    
  184. }
  185. //====================================================================================================
  186. void CalPower(void)
  187. {
  188.         BYTE i;
  189.         DWORD *dptr;
  190.         WORD  reg0,*ptr1;
  191.        
  192.         dptr =(DWORD *)&Sum.Pa;
  193.         ptr1=(WORD *)&CoeffTemp.Ua;
  194.        
  195.         for(i = 0;i <3 ; i++)
  196.         {               
  197.                 reg0=*dptr>>4;     //P
  198.                 reg0=((DWORD)reg0*(*ptr1))>>10;      //*Coeff_U
  199.                 reg0=((DWORD)reg0*(*(ptr1+1)))>>10;  //*Coeff_I         
  200.                 Power[i*2] = reg0;
  201.                 dptr++;
  202.                
  203.                 reg0=*dptr>>4;   //Q
  204.                 reg0=((DWORD)reg0*(*ptr1))>>10;      //*Coeff_U
  205.                 reg0=((DWORD)reg0*(*(ptr1+1)))>>10;  //*Coeff_I         
  206.                 Power[2*i+1] = reg0;
  207.                 dptr++;
  208.                 ptr1+=2;
  209.         }
  210. }      

  212. //====================================================================================================
  213. //函数名：ProcessMonth
  214. //功能：  对每月的电能进行冻结，统计，存储。可以连续存3个月。
  215. //====================================================================================================
  216. void ProcessMonth(void)
  217. {
  218.         BYTE i;
  219.         DWORD temp1,temp2,*ptr1;
  220.         UWORD *ptr3,*ptr4;
  221.         UWORD j;
  222.        
  223.         FREEZE_ENERGY FreezeEnergyTemp[3];
  224.        
  225.        
  226.         NewMonthFlag=false;
  227.         Clock.monthR=Clock.month;
  228.        
  229.         ptr1=(DWORD*)&VirtualData.EPaP;
  230.         temp1=0;
  231.         for(i=0;i<3;i++)temp1+=*ptr1++;    //统计有功电能
  232.        
  233.         ptr1=(DWORD*)&VirtualData.EQaP;
  234.         temp2=0;
  235.         for(i=0;i<3;i++)temp2+=*ptr1++;    //统计无功电能
  236.        
  237.         ptr3=(UWORD*)&FreezeEnergy[0].SECOND1;
  238.         ptr4=(UWORD*)&FreezeEnergyTemp[0].SECOND1;
  239.         for(i=0;i<21;i++)*ptr4++=*ptr3++;   //读出已经存起来的统计电能
  240.                
  241.         j=FreezeEnergyCounter;
  242.        
  243.         _DINT();
  244.         FreezeEnergyTemp[j%3].SECOND1=RSECOND;
  245.         _EINT();
  246.         FreezeEnergyTemp[j%3].SumEP=temp1;
  247.         FreezeEnergyTemp[j%3].SumEQ=temp2;
  248.         FreezeEnergyTemp[j%3].FreezeFlag=0x55aa;
  249.         j++;
  250.        
  251.         ProductNumber=PRODUCTNUMBER;       
  252.         FlashErase((UWORD*)&PRODUCTNUMBER);
  253.        
  254.         FlashWrite((UWORD*)&ProductNumber,(UWORD*)&PRODUCTNUMBER,2);       
  255.         FlashWrite((UWORD*)&FreezeEnergyTemp[0].SECOND1,(UWORD*)&FreezeEnergy[0].SECOND1,21);       
  256.         FlashWrite((UWORD*)&j,(UWORD*)&FreezeEnergyCounter,1);               
  257.        
  258. }
  259. //====================================================================================================
  260. //函数名： Process10s
  261. //功能： 每10秒钟处理事情，包括比较U，I，P，Q最大值，最小值，以供统计； 保存电能值。
  262. void Process10s(void)
  263. {      
  264.         BYTE i;
  265.         WORD *ptrdata,*ptrdata1;
  266.         WORD *ptr1,*ptr2;
  267.         //Flag10s=FALSE;
  268.         FlagTime&=~BIT1;

  270.         ptrdata=&VirtualData.Ua;ptrdata1=&RecordTemp.Ua[0];
  271.         for(i=0;i<13;i++)
  272.         {
  273.                 if(*ptrdata1<*ptrdata)*ptrdata1=*ptrdata;
  274.                 ptrdata1++;
  275.                 if(*ptrdata1>*ptrdata)*ptrdata1=*ptrdata;
  276.                 ptrdata1++;
  277.                 ptrdata++;
  278.         }
  279.         
  280.          if(RecordTemp.Frequency[0]<VirtualData.Freq)RecordTemp.Frequency[0]=VirtualData.Freq;
  281. //计算最小值
  282.          if(RecordTemp.Frequency[1]>VirtualData.Freq)RecordTemp.Frequency[1]=VirtualData.Freq;
  283.         
  284.          if(RecordTemp.Ua[0]<RecordTemp.Ua[1])InitMaxMin();
  285.          else  RecordErr=0;  
  286.          
  287.         ptr1=(WORD*)&VirtualData.EPaP;
  288.                ptr2=(WORD*)&Energy.EPaP;    //读电能
  289.                for(i=0;i<24;i++) *ptr2++=*ptr1++ ;   
  290.       
  291. }
  292. //====================================================================================================
  293. //函数名： Process1m
  294. //功能：   1.得到每分钟U I  的平均值
  295. //         2.根据平均值与设置的阀值进行比较，形成告警记录。
  296. //修改记录：
  297. void  Process1m(void)
  298. {
  299.         WORD avargeV[3],avargeI[4];             
  300.               BYTE i;  
  301.               FlagTime&=~BIT2;
  302.       
  303.       
  304.               if(Count_Sum_1m!=0)                                       //求1分钟之内的电压、电流平均值
  305.                {
  306.                     for (i=0;i<3;i++)
  307.                      {
  308.                             avargeV[i]=V_Sum_1m[i]/Count_Sum_1m;        //计算电压在1分钟内的平均值
  309.                             V_Sum_1m[i]=0;                              //清除累加和
  310.                      }
  311.                     for (i=0;i<4;i++)
  312.                      {
  313.                             avargeI[i]=I_Sum_1m[i]/Count_Sum_1m;        //计算电流在1分钟内的平均值
  314.                             I_Sum_1m[i]=0;                                     //清除累加和
  315.                      }
  316.                      Count_Sum_1m=0;                                    //清除累加次数
  317.         }
  318.       
  319.               for(i=0;i<3;i++)
  320.                {
  321.                     if(avargeV[i]>ParameterTemp.OverVoltage)
  322.                      {
  323.                            if(!((FlagAlarm>>i)&0x01))
  324.                             {
  325.                                     FlagAlarm|=(0x01<<i);
  326.                                     WriteMainRecord(0x0003+i);      //过压告警
  327.                             }
  328.                      }
  329.                     else
  330.                      {
  331.                            if((FlagAlarm>>i)&0x01)
  332.                             {
  333.                                      FlagAlarm&=~(0x01<<i);
  334.                                      WriteMainRecord(0x0006+i);      //过压恢复
  335.                             }
  336.                       }               
  337.                }

  339.         
  340.               for(i=3;i<6;i++)
  341.                {
  342.                     if(avargeV[i-3]<ParameterTemp.LowVoltage)
  343.                      {
  344.                            if(!((FlagAlarm>>i)&0x01))
  345.                             {
  346.                                     FlagAlarm|=(0x01<<i);
  347.                                     WriteMainRecord(0x0006+i);      //欠压告警
  348.                             }
  349.                      }
  350.                     else
  351.                     {
  352.                            if((FlagAlarm>>i)&0x01)
  353.                            {
  354.                                     FlagAlarm&=~(0x01<<i);
  355.                                     WriteMainRecord(0x0009+i);      //欠压恢复
  356.                             }
  357.                     }
  358.                
  359.               }
  360.       
  361.              for(i=6;i<9;i++)
  362.               {
  363.                     if(avargeI[i-6]>ParameterTemp.OverCurrent)
  364.                     {
  365.                            if(!((FlagAlarm>>i)&0x01))
  366.                            {
  367.                                    FlagAlarm|=(0x01<<i);
  368.                                    WriteMainRecord(0x0009+i);      //过流告警
  369.                            }
  370.                     }
  371.                    else
  372.                     {
  373.                            if((FlagAlarm>>i)&0x01)
  374.                            {
  375.                                   FlagAlarm&=~(0x01<<i);
  376.                                   WriteMainRecord(0x000c+i);      //过流恢复
  377.                            }
  378.                     }
  379.               
  380.                }
  381.               
  382.                 if(avargeI[3]>ParameterTemp.OverCurrent0)
  383.          {
  384.                if(!((FlagAlarm>>9)&0x01))
  385.                 {
  386.                           FlagAlarm|=(0x01<<9);
  387.                           WriteMainRecord(0x0015);      //零序告警
  388.                 }
  389.          }
  390.          else
  391.          {
  392.                if((FlagAlarm>>9)&0x01)
  393.                 {
  394.                           FlagAlarm&=~(0x01<<9);
  395.                           WriteMainRecord(0x0016);      //零序恢复
  396.                 }
  397.          }
  398. }
  399. //===================================================================================================
  400. //函数名： ProcessT
  401. //功能 ：  1.根据存储间隔 形成定时记录，同时保存记录  
  402. //         2.初始化U I P Q最大值，最小值。
  403. void ProcessT(void)
  404. {
  405.         //FlagT=FALSE;
  406.         FlagTime&=~BIT3;
  407.        
  408.         if(RecordErr)return;         //判断记录是否有效
  409.         WriteMainRecord(0x0000);     //定时记录
  410.        
  411.         InitMaxMin();               //清除最大值最小值       
  412. }
  413. //===================================================================================================
  414. //
  415. void InitMaxMin(void)
  416. {
  417.         BYTE i;
  418.         WORD *ptrdata;
  419.        
  420.         ptrdata=&RecordTemp.Ua[0];
  421.         for(i=0;i<13;i++)
  422.         {
  423.                 *ptrdata++=0xffff;
  424.                 *ptrdata++=0x7fff;
  425.         }
  426.         RecordTemp.Frequency[0]=0;
  427.         RecordTemp.Frequency[1]=0x7fff;
  428.         RecordErr=TRUE;
  429. }
  430. //===================================================================================================
  431. //计算电能
  432. //由50ms处调用该功能函数
  433. void CalculateEnergy(void)
  434. {
  435.         BYTE i;
  436.             DWORD *ptr0,*ptr1;

  438.             if(VirtualData.Pa>=0)DDataEPaP+=VirtualData.Pa;
  439.             else DDataEPaN-=VirtualData.Pa;
  440.             if(VirtualData.Pb>=0)DDataEPbP+=VirtualData.Pb;
  441.             else DDataEPbN-=VirtualData.Pb;
  442.             if(VirtualData.Pc>=0)DDataEPcP+=VirtualData.Pc;
  443.             else DDataEPcN-=VirtualData.Pc;
  444.             if(VirtualData.Qa>=0)DDataEQaP+=VirtualData.Qa;
  445.             else DDataEQaN-=VirtualData.Qa;
  446.             if(VirtualData.Qb>=0)DDataEQbP+=VirtualData.Qb;
  447.             else DDataEQbN-=VirtualData.Qb;
  448.             if(VirtualData.Qc>=0)DDataEQcP+=VirtualData.Qc;
  449.             else DDataEQcN-=VirtualData.Qc;
  450.    
  451.             CounterPulseP+=(DWORD)VirtualData.Pa+(DWORD)VirtualData.Pb+(DWORD)VirtualData.Pc;
  452.             CounterPulseQ+=(DWORD)VirtualData.Qa+(DWORD)VirtualData.Qb+(DWORD)VirtualData.Qc;

  454. //有功电度脉冲输出,3200imp/kw.h
  455.             if(CounterPulseP>=11636364)        //232727~3200   465455~1600
  456.              {
  457.                       TBCCTL6=0x04;              //0000,0000,0000,0100     点亮灯        P
  458.                  TBCCTL6=0x0a0;             //0000,0000,1010,0000        
  459.                  TBCCR6=1800+TBR;
  460.                  CounterPulseP-=11636364;
  461.         
  462.              }
  463. //无功电度脉冲输出,3200imp/kvar.h
  464.             if(CounterPulseQ>=11636364)
  465.              {
  466.                
  467.                   TBCCTL5=0x04;             //0000,0000,0000,0100     点亮灯      Q
  468.                   TBCCTL5=0x0a0;            //0000,0000,1010,0000        
  469.                   TBCCR5=1800+TBR;
  470.                   CounterPulseQ-=11636364;  //232727*50;         
  471.              }

  473.             ptr0=&DDataEPaP;ptr1=&VirtualData.EPaP;      //电度累积,0.01kwh=0x4000*3600*20*10/(264*6)
  474.             for(i=0;i<12;i++)
  475.             {
  476.                 while((*ptr0)>=372363636)        //7447273*50
  477.                 {
  478.                             (*ptr1)++;
  479.                             if(((*ptr1)>999999)||((*ptr1)<0))(*ptr1)=0;
  480.                             (*ptr0)-=372363636;
  481.                        }
  482.                 ptr0++;ptr1++;
  483.             }
  484. }
  485. //==================================================================================
  486. //计算功率因数
  487. //p:有功功率
  488. //q:无功功率
  489. //return:功率因数
  490. WORD CalPf(WORD p,WORD q)
  491. {
  492.             DWORD ddata0,ddata1;

  494.             ddata0=(DWORD)p*p;
  495.             ddata1=(DWORD)q*q;
  496.             ddata0+=ddata1;
  497.             q=MExtract(ddata0);
  498.             ddata0=(DWORD)p<<10;
  499.             ddata0/=q;
  500.             return((WORD)ddata0);
  501. }
  502. //==================================================================================
  503. //开方算法
  504. WORD MExtract(DWORD sqr)
  505. {
  506.             WORD ax=0,bx=0x8000;
  507.             DWORD temp;   

  509.             if(sqr>0x3fffffff)return(0);
  510.             while(bx!=0)
  511.             {
  512.                 ax|=bx;
  513.                 temp=(DWORD)ax*ax;
  514.                 if(temp==sqr)return(ax);
  515.                 if(temp>sqr)ax^=bx;
  516.                 bx=(UWORD)bx>>1;
  517.             }
  518.             return(ax);
  519. }
  520. //====================================================================================
  521. //计算有效值
  522. //从采样中断中进行调用该函数
  523. void CalculateVirtualValue(void)
  524. {
  525.             WORD i,zerodrift[6],reg0,reg1;
  526.             DWORD i_0[24];   
  527.             DWORD sum0,sum1,sum2,sum3,sqsumi_0;
  528.             DWORD *dptr0,*dptr1;
  529.             DWORD regtemp;
  530.             BYTE  FlagIMin;
  531.            
  532.             FlagCalculate = false;
  533.    

  535. //计算通道零漂
  536.             sum0=0;
  537.             for(i=0;i<24;i++)sum0+=SampleData.Ua[i];
  538.             zerodrift[0]=sum0/24;
  539.             sum0=0;
  540.             for(i=0;i<24;i++)sum0+=SampleData.Ia[i];
  541.             zerodrift[1]=sum0/24;
  542.             sum0=0;
  543.             for(i=0;i<24;i++)sum0+=SampleData.Ub[i];
  544.             zerodrift[2]=sum0/24;
  545.             sum0=0;
  546.             for(i=0;i<24;i++)sum0+=SampleData.Ib[i];
  547.             zerodrift[3]=sum0/24;
  548.             sum0=0;
  549.             for(i=0;i<24;i++)sum0+=SampleData.Uc[i];
  550.             zerodrift[4]=sum0/24;
  551.             sum0=0;
  552.             for(i=0;i<24;i++)sum0+=SampleData.Ic[i];
  553.             zerodrift[5]=sum0/24;

  555. //---------------------------------------------------------------------
  556.            sqsumi_0=0;
  557.            for(i=0;i<24;i++)                  //计算零序电流  
  558.            {
  559.                    i_0[i]=(DWORD)SampleData.Ia[i]+(DWORD)SampleData.Ib[i]+(DWORD)SampleData.Ic[i];
  560.                    i_0[i]=i_0[i]-zerodrift[1]-zerodrift[3]-zerodrift[5];
  561.                    sqsumi_0+=(DWORD)i_0[i]*i_0[i];    //求平方和
  562.            }            
  563.            FlagIMin=0;  
  564.    
  565. //计算平方和,有效值
  566.             sum0=0;sum1=0;sum2=0;sum3=0;
  567.             for(i=0;i<24;i++)
  568.             {
  569.                 reg0=SampleData.Ua[i]-zerodrift[0];
  570.                 sum0+=(DWORD)reg0*reg0;                 //Ua
  571.                 reg1=SampleData.Ia[i]-zerodrift[1];
  572.                 sum1+=(DWORD)reg1*reg1;                 //Ia
  573.                 sum2+=(DWORD)reg0*reg1;                 //Pa
  574.                 reg1=SampleData.Ia[i+6]-zerodrift[1];
  575.                 sum3+=(DWORD)reg0*reg1;                 //Qa
  576.             }   
  577.      
  578.             regtemp=(DWORD)MExtract(sum0);
  579.             if(regtemp<30)regtemp>>=3;
  580.             SumTemp.Ua+= regtemp;
  581.    
  582.             regtemp=(DWORD)MExtract(sum1);   
  583.             if(regtemp<30)                           //电流零漂  //1000
  584.               {
  585.                  regtemp>>=3;
  586.                  sum2>>=3;
  587.                  sum3>>=3;
  588.                  FlagIMin|=BIT0;
  589.               }  
  590.             SumTemp.Ia+=regtemp;        
  591.             SumTemp.Pa+=sum2>>16;
  592.             SumTemp.Qa+=sum3>>16;

  594.             sum0=0;sum1=0;sum2=0;sum3=0;
  595.             for(i=0;i<24;i++)
  596.             {
  597.                 reg0=SampleData.Ub[i]-zerodrift[2];
  598.                 sum0+=(DWORD)reg0*reg0;                 //Ub
  599.                 reg1=SampleData.Ib[i]-zerodrift[3];
  600.                 sum1+=(DWORD)reg1*reg1;                 //Ib
  601.                 sum2+=(DWORD)reg0*reg1;                 //Pb
  602.                 reg1=SampleData.Ib[i+6]-zerodrift[3];
  603.                 sum3+=(DWORD)reg0*reg1;                 //Qb
  604.             }
  605.             regtemp=(DWORD)MExtract(sum0);   
  606.             if(regtemp<30) regtemp>>=3;      
  607.             SumTemp.Ub+= regtemp;
  608.    
  609.             regtemp=(DWORD)MExtract(sum1);   
  610.             if(regtemp<30)                           //电流零漂
  611.               {
  612.                  regtemp>>=3;
  613.                  sum2>>=3;
  614.                  sum3>>=3;
  615.                  FlagIMin|=BIT1;
  616.               }   
  617.             SumTemp.Ib+=regtemp;   
  618.             SumTemp.Pb+=sum2>>16;
  619.             SumTemp.Qb+=sum3>>16;

  621.             sum0=0;sum1=0;sum2=0;sum3=0;
  622.             for(i=0;i<24;i++)
  623.             {
  624.                 reg0=SampleData.Uc[i]-zerodrift[4];
  625.                 sum0+=(DWORD)reg0*reg0;                 //Uc
  626.                 reg1=SampleData.Ic[i]-zerodrift[5];
  627.                 sum1+=(DWORD)reg1*reg1;                 //Ic
  628.                 sum2+=(DWORD)reg0*reg1;                 //Pc
  629.                 reg1=SampleData.Ic[i+6]-zerodrift[5];
  630.                 sum3+=(DWORD)reg0*reg1;                 //Qc
  631.             }
  632.             regtemp=(DWORD)MExtract(sum0);
  633.             if(regtemp<30)regtemp>>=3;
  634.             SumTemp.Uc+=regtemp;
  635.    
  636.             regtemp=(DWORD)MExtract(sum1);
  637.             if(regtemp<30)
  638.             {
  639.                 regtemp>>=3;
  640.                 sum2>>=3;
  641.                 sum3>>=3;
  642.                 FlagIMin|=BIT2;
  643.             }   
  644.             SumTemp.Ic+=regtemp;
  645.             SumTemp.Pc+=sum2>>16;
  646.             SumTemp.Qc+=sum3>>16;
  647.    
  648.             if(FlagIMin!=0x07)                     //需判断各相电流是否都为0
  649.             {
  650.                     regtemp=(DWORD)MExtract(sqsumi_0);
  651.                     if(regtemp<1638) regtemp>>=4;              //判断零序电流是否大于取值的5%，0x7fff*5%=1638
  652.                     SumTemp.I0+=regtemp;                   
  653.             }
  654.    

  656. //计算平均值
  657.             if(++CalSeq>15)
  658.             {
  659.                 dptr0=(DWORD*)∑
  660.                 dptr1=(DWORD*)&SumTemp;
  661.                 CalSeq=0;
  662.                 for(i=0;i<13;i++)
  663.                  {
  664.                            *dptr0++=*dptr1;
  665.                            *dptr1++=0;
  666.                  }
  667.             }
  668.             ADC12CTL0&=~0x02;
  669.             ADC12CTL0|=0x02;            //Enable conversion
  670. //===============================================           
  671.             CCR1+=833;                  //2005-11-14
  672.         CCTL1&=0xffdf;              //Reset Timer_A.OUT1
  673.         CCTL1|=0x0020;
  674. }

  676. void ClearEnergyRegister(void)
  677. {
  678.         DDataEPaP = 0;
  679.         DDataEPbP = 0;
  680.         DDataEPcP = 0;
  681.         DDataEPaN = 0;
  682.         DDataEPbN = 0;
  683.         DDataEPcN = 0;
  684.         DDataEQaP = 0;
  685.         DDataEQbP = 0;
  686.         DDataEQcP = 0;
  687.         DDataEQaN = 0;
  688.         DDataEQbN = 0;
  689.         DDataEQcN = 0;
  690. }
复制代码



分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:839438 发表于 2021-9-30 10:20 | 只看该作者
先记录一下，以后会用到
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表