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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › 单片机单相电能表源码
返回列表 发新帖
查看: 4357|回复: 3
打印 上一主题 下一主题
收起左侧

单片机单相电能表源码

[复制链接]
跳转到指定楼层
楼主
ID:112003 发表于 2016-4-3 08:04 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
单相飞控智能电表源码，单相多功能电能表源码。电能计量，485通讯，总线通讯，液晶显示等功能

全部源码下载： 单相多功能电能表源码.rar (80.05 KB, 下载次数: 44)

主程序预览：
  1. ///
  2. ///      @file  main.c
  3. ///     系统主程序
  4. ///
  5. ///
  6. ///=====================================================================================
  7. ///

  9. #define        MAIN
  10. #define AUTOCAL

  12. #include "Liger.h"
  13. #include "typemeter.h"

  15. /**
  16. * 系统默认校表参数
  17. *
  18. * Detailed description starts here.
  19. * 该表记录的电能表的默认校准参数，但系统发生恢复参数失败或是第一次上电等
  20. * 情况时，会从该表中恢复参数
  21. */

  23. unsigned long code meterprm_table[]=
  24. {  0x00000000,                                 //有功门限高1
  25.     0x5A55D125,                                 //有功门限低1
  26.     0x00000000,                                 //有功门限高2
  27.     0xA3E30760,                                 //有功门限低2
  28.     0x0000001a,                                 //有效值门限高1
  29.     0x67F16719,                                 //有效值门限低1
  30.     0x0018F380,                                 //启动门限1
  31.     0x0018F380,                                 //启动门限2
  32.     0x022EA846,                                 //有功功率比差1
  33.     0x022EA846,                                 //有功功率比差2
  34.     0xFE75A15D,                                 //U比差
  35.     0x10000000,                                 //I1比差
  36.     0x10000000,                                 //I2比差
  37.     0x00000000,                                 //补偿1
  38.     0x00000000,                                 //补偿2
  39.     0x05,                                         //A通道角差校正
  40.     0x05,                                         //B通道角差校正
  41.     0x00000000,                                                  //有功启动门限高位
  42.     0xB4ABA24A,                                   //有功启动门限低位
  43.     0x00000001,                                   //无功启动门限高位
  44.     0x47C60EC0                                    //无功启动门限低位
  45. };


  48. /**
  49. *  根据所给的ID号从外部存储器中恢复数据项，恢复的数据会放在wr_buff中
  50. * @param  chk_id 数据项ID
  51. * @return 1 成功
  52. *         0 失败
  53. //limin   修改 返回值恒定为0
  54. */
  55. unsigned char recover_item(unsigned int chk_id)
  56. {
  57.         unsigned char i,j,num,value,datanum;
  58.           value=0;
  59.           num=addr_from_coreID(1,chk_id);
  60.           for(i=0;i<num;i++)
  61.              { if((*ID_coretalbpoint[i]).stortype==EEPROM)
  62.               { data_addr.word[1]=(*ID_coretalbpoint[i]).dataaddr;
  63.                     datanum=(*ID_coretalbpoint[i]).datalong;
  64.                     Read_data(EEPROM,datanum);
  65.                         wr_buff[datanum]=0;
  66.                         for(j=0;j<datanum-1;j++)                            //校验和判断
  67.                            { wr_buff[datanum]+=wr_buff[j];
  68.                            }
  69.             if(wr_buff[datanum]==(wr_buff[datanum-1]-0x33))            //如果校验和正确
  70.                         {
  71.                                 if((*ID_coretalbpoint[i]).datatype==BCD)
  72.                                 {
  73.                                         if(check_X_bcd((datanum-1),wr_buff)==1)         //BCD嘛校验
  74.                                         {
  75.                                                 value=1;                                  //检测到合法数据，放在wr_buff中
  76.                                                 break;
  77.                                         }
  78.                                 }
  79.                                      else
  80.                                 {
  81.                                         value=1;                                  //检测到合法数据，放在wr_buff中
  82.                                         break;
  83.                                 }
  84.                         }
  85.                 }
  86.         }

  88.         return value;
  89. }

  91. //===================================================================================
  92. //函数功能：恢复第一个脉冲的门限
  93. //
  94. //=====================================================================================
  95. void Recover_pd01(void)
  96. {         unsigned char i,value;
  97.           Word32 read_buff;
  98.     //40 bit
  99.           for(i=0;i<2;i++)                                                      //门限值恢复
  100.              {
  101.                      if(recover_item(0x8500+i)==1)                                 //恢复参数正确
  102.                    { read_buff.lword=Longdate_from_xbcd(&wr_buff[1],4);
  103.                  u8PMdatah=wr_buff[0];
  104.                  u32PMdatal= read_buff.lword;
  105.                  u8PMdatah=u8PMdatah<<1;
  106.                                  if((u32PMdatal&0x80000000)==0x80000000)
  107.                                     u8PMdatah|=0x01;
  108.                  u32PMdatal=u32PMdatal<<1;
  109.                  SetMeterCfg(0x10f4+i*6);
  110.                }
  111.                        else                                                          //恢复参数失败
  112.                       { u8PMdatah=(uint8)meterprm_table[2*i];
  113.                  u32PMdatal=meterprm_table[1+2*i];
  114.                                  u8PMdatah=u8PMdatah<<1;
  115.                                  if((u32PMdatal&0x80000000)==0x80000000)
  116.                                     u8PMdatah|=0x01;
  117.                  u32PMdatal=u32PMdatal<<1;
  118.                      SetMeterCfg(0x10f4+i*6);
  119.                
  120.                        }
  121.             }

  123.         for(i=0;i<2;i++)
  124.           {value=0;
  125.                    ReadMeterPara(0x10f5+i*6);
  126.                    if(recover_item(0x8503+i)==1)                                   //防潜门限值设定
  127.                  { read_buff.lword=Longdate_from_xbcd(&wr_buff[0],4);
  128.                            if(u32PMdatal!= read_buff.lword)
  129.                  { u32PMdatal= read_buff.lword;
  130.                                    value=1;
  131.                                  }
  132.              }
  133.                       else                                                                 //恢复参数失败
  134.                     { if(u32PMdatal!=meterprm_table[6+i])
  135.                              { u32PMdatal=meterprm_table[6+i];
  136.                                    value=1;
  137.                                  }
  138.                  }
  139.                    if(value==1)
  140.                    {
  141.                      u32PMdatal <<= 1;
  142.                      SetMeterCfg(0x10f5+i*6);
  143.                        }
  144.             }
  145. }

  147. //===================================================================
  148. //函数功能:恢复第一个CF之后的门限值
  149. //===================================================================
  150. void Recover_pd(void)
  151. { unsigned char i,value;
  152.   Word32 read_buff;
  153.   for(i=0;i<2;i++)                                                  //门限值恢复
  154.      { value=0;
  155.            ReadMeterPara(0x10f4+i*6);
  156.            if(recover_item(0x8500+i)==1)                                 //恢复参数正确
  157.            { read_buff.lword=Longdate_from_xbcd(&wr_buff[1],4);
  158.              if(u8PMdatah!=wr_buff[0])
  159.                 { u8PMdatah=wr_buff[0];
  160.                   value=1;
  161.                 }   
  162.              if(u32PMdatal!=read_buff.lword)
  163.                 { u32PMdatal= read_buff.lword;
  164.                   value=1;
  165.                 }
  166.             }
  167.        else                                                          //恢复参数失败
  168.            { if(u8PMdatah!=(uint8)meterprm_table[2*i])
  169.                         { u8PMdatah=(uint8)meterprm_table[2*i];
  170.                                   value=1;
  171.                                  }
  172.                          if(u32PMdatal!=meterprm_table[1+2*i])
  173.                  { u32PMdatal=meterprm_table[1+2*i];
  174.                                    value=1;
  175.                                  }
  176.                }
  177.            if(value==1)
  178.             SetMeterCfg(0x10f4+i*6);
  179.      }

  181.          for(i=0;i<2;i++)
  182.      {     value=0;
  183.                    ReadMeterPara(0x10f5+i*6);
  184.                    if(recover_item(0x8503+i)==1)                                   //防潜门限值设定
  185.                  { read_buff.lword=Longdate_from_xbcd(&wr_buff[0],4);
  186.                            if(u32PMdatal!= read_buff.lword)
  187.                  { u32PMdatal= read_buff.lword;
  188.                                    value=1;
  189.                                  }
  190.              }
  191.                       else                                                                 //恢复参数失败
  192.                     { if(u32PMdatal!=meterprm_table[6+i])
  193.                              { u32PMdatal=meterprm_table[6+i];
  194.                                    value=1;
  195.                                  }
  196.                  }
  197.                    if(value==1)
  198.                    {
  199.                      SetMeterCfg(0x10f5+i*6);
  200.                         }
  201.      }

  203. }
  204. //===============================================================================
  205. //函数功能：恢复除门限值之外的参数
  206. //================================================================================
  207. void Recover_metprim(void)
  208. {         uint8 i,value;
  209.         unsigned char xdata *point;
  210.           Word32 read_buff;
  211.     for(i=0;i<7;i++)                                                      //参数恢复
  212.         { value=0;
  213.               ReadMeterPara(0x10dd+i*6);   
  214.                   if(recover_item(0x8505+i)==1)                                   //恢复参数正确
  215.                 { read_buff.lword=Longdate_from_xbcd(&wr_buff[0],4);
  216.               if(u32PMdatal!=read_buff.lword)
  217.                              { u32PMdatal= read_buff.lword;
  218.                                    value=1;
  219.                                  }
  220.             }
  221.                      else                                                             //恢复参数失败
  222.                    { if(u32PMdatal!=meterprm_table[8+i])
  223.                          { u32PMdatal=meterprm_table[8+i];
  224.                    value=1;
  225.                                  }
  226.                  }
  227.                   if(value==1)
  228.              SetMeterCfg(0x10dd+i);
  229.           }
  230.         point=&PHCCtrl1;
  231.     for(i=0;i<2;i++)                                                        //角差值设定
  232.           { if(recover_item(0x850e+i)==1)                                   
  233.                  { if(*(point+i)!=wr_buff[0])
  234.                               *(point+i)=wr_buff[0];
  235.              }
  236.                       else                                                                 //恢复参数失败
  237.                     { if(*(point+i)!=meterprm_table[15+i])
  238.                               *(point+i)=meterprm_table[15+i];
  239.                      }
  240.           }
  241. }
  242. /**
  243. *  回复校表参数
  244. * @param  void
  245. * @return void
  246. */
  247. void Recover_meter(void)
  248. {
  249.    Recover_pd01();                //恢复门限
  250.    Recover_metprim();             //恢复比差等其他参数
  251. }



  255. /**
  256. *  初始化IO口
  257. * @param  void
  258. * @return void
  259. */
  260. void port_init(void)
  261. {

  263.         P0OE = DISABLE_PORT_OUTPUT_ALL;
  264.         P1OE = DISABLE_PORT_OUTPUT_ALL;
  265.         P2OE = DISABLE_PORT_OUTPUT_ALL;
  266.         P3OE = DISABLE_PORT_OUTPUT_ALL;
  267.         P4OE = DISABLE_PORT_OUTPUT_ALL;
  268.         P5OE = DISABLE_PORT_OUTPUT_ALL;
  269.         P6OE = DISABLE_PORT_OUTPUT_ALL;
  270.         P7OE = DISABLE_PORT_OUTPUT_ALL;
  271.         P8OE = DISABLE_PORT_OUTPUT_ALL;
  272.        
  273.         P0IE = DISABLE_PORT_INPUT_ALL;
  274.         P1IE = DISABLE_PORT_INPUT_ALL;
  275.         P2IE = DISABLE_PORT_INPUT_ALL;
  276.         P3IE = DISABLE_PORT_INPUT_ALL;
  277.         P4IE = DISABLE_PORT_INPUT_ALL;
  278.         P5IE = DISABLE_PORT_INPUT_ALL;
  279.         P6IE = DISABLE_PORT_INPUT_ALL;
  280.         P7IE = DISABLE_PORT_INPUT_ALL;
  281.         P8IE = DISABLE_PORT_INPUT_ALL;
  282.     P2OE&=(~BIT5);                                  //输出使能
  283.         P2OD|=BIT5;                                     //输出高电平
  284. }

  286. void IO_Sleep()
  287. {
  288.     P0OE = DISABLE_PORT_OUTPUT_ALL;
  289.         P1OE = DISABLE_PORT_OUTPUT_ALL;
  290.         P2OE = DISABLE_PORT_OUTPUT_ALL;
  291.         P3OE = DISABLE_PORT_OUTPUT_ALL;
  292.         P4OE = DISABLE_PORT_OUTPUT_ALL;
  293.         P5OE = DISABLE_PORT_OUTPUT_ALL;
  294.         P6OE = DISABLE_PORT_OUTPUT_ALL;
  295.         P7OE = DISABLE_PORT_OUTPUT_ALL;
  296.         P8OE = DISABLE_PORT_OUTPUT_ALL;
  297.        
  298.         P0IE = DISABLE_PORT_INPUT_ALL;
  299.         P1IE = DISABLE_PORT_INPUT_ALL;
  300.         P2IE = DISABLE_PORT_INPUT_ALL;
  301.         P3IE = DISABLE_PORT_INPUT_ALL;
  302.         P4IE = DISABLE_PORT_INPUT_ALL;
  303.         P5IE = DISABLE_PORT_INPUT_ALL;
  304.         P6IE = DISABLE_PORT_INPUT_ALL;
  305.         P7IE = DISABLE_PORT_INPUT_ALL;
  306.         P8IE = DISABLE_PORT_INPUT_ALL;

  308. }
  309. /**
  310. *  初始化TIMER0，10ms中断一次
  311. * @param  void
  312. * @return void
  313. */

  315. void Init_Timer0(void)
  316. {       
  317.         TMOD = 0x01;             // 工作在模式1
  318.         CKCON|=0x08;         // clk
  319.     TL0  = 0xff;         //10ms
  320.            TH0  = 0x7f;
  321.            TR0 = 1;                     // 开定时器0
  322.         SetInterrupt(1);     //打开中断
  323.    
  324. }


  327. /**
  328. *  初始化ADC，设定当前的测量频率
  329. * @param  void
  330. * @return void
  331. */
  332. void Inti_anlmode(void)
  333. {  
  334.         InitAnalog();                          //初始化模拟模块
  335.           SetADC(SETADC_IA,SETADC_CLOSE);                    //A通道电流关闭
  336.            SetADC(SETADC_IB,SETADC_IT16);                         //B通道电流，采用16倍增益
  337.            SetADC(SETADC_U,SETADC_IT1);                //电压通道，采用1倍增益
  338.            SetMChannel(SETM_TEMP,SETM_T1);      //开m通道，1倍增益，测量温度测量模式
  339.            Alt_50_60Hz(ALT_50HZ);                //50hz         
  340.            PowerDown=0;
  341. }


  344. /**
  345. *  初始化计量系统
  346. * @param  void
  347. * @return void
  348. */
  349. void Inti_metermode(void)
  350. {
  351.     SysCtrl&=0xef;                //开启计量电路时钟
  352.     PMCtrl4=0x00;
  353.         PMCtrl1&=(~0xe0);
  354.            Inti_anlmode();                // AD增益
  355.            PMCtrl1=0x70;                  //选择B通道剂量
  356.     InitMeter();                   //初始化计量电路
  357.     u32PMdatal=0x01;
  358.     SetMeterCfg(0x10f5);           //潜动门限1
  359.     SetMeterCfg(0x10fb);
  360.            Recover_meter();               //恢复校表参数
  361.     PMCtrl1=0x7b;                                        //使能U,B,UM通路，选择B路计量，使能角差校准
  362.     PMCtrl3=0x20;                                        //一路有功计量，一路无功计量,开启次谐波滤波
  363.         PMCtrl4=0x20;                                        //??????
  364.     CFCtrl=0x00;                                        //用正反有功产生CF1
  365.     CFNumber=0;
  366.     CF1Number=0;
  367.     ULowFlag=0;
  368.         CF1Flag=0;
  369.     CFFlag=0xd5;
  370.            count_opencftime=100;            //CF延时1妙打开
  371.            F_PmIdle = 0;
  372.         pmIdleCnt = 0;
  373. }


  376. /**
  377. *  系统初始化,初始化模拟部分和数字部分寄存器
  378. * @param   void
  379. * @return void
  380. */
  381. void Init_System(void)
  382. {  
  383.            port_init();                //初始化io口
  384.            SetXRam(1);                 //开启对XRAM的写保护
  385.            Init_Timer0();
  386.            Inti_metermode();
  387.    
  388. }


  391. /**
  392. *  复位计量模块,当检测到计量有问题是会调用该函数
  393. * @param  void
  394. * @return void
  395. */
  396. void reset_primjiaobiao(void)
  397. {
  398.           Inti_metermode();                              //初始化计量模块

  400. }


  403. /**
  404. *  检测CF脉冲是否有异常，通过将1s内产生的CF脉冲个数与门限CF脉冲个数比较，决定是否需要复位计量模块
  405. * @param  data_cf  CF脉冲个数
  406. * @return 0   脉冲个数异常
  407. *          data_cf 正常脉冲个数
  408. */
  409. unsigned long check_jump(unsigned char data_cf)
  410. {
  411.         unsigned long value;
  412.         if(data_cf>max_CF)
  413.       {
  414.                       value=0;                                            //停止能量计量
  415.                     if(count_errenergmode<10)
  416.                 {
  417.                         count_errenergmode++;
  418.                          reset_primjiaobiao();                          //重新初始化计量模块
  419.                }
  420.         }
  421.         else
  422.       {
  423.                       count_errenergmode=0;
  424.                     value=data_cf;
  425.         }
  426.        
  427.         return value;
  428. }


  431. /**
  432. *  读取CF active energy 脉冲个数，累加脉冲
  433. * @param  void
  434. * @return void
  435. */
  436. /*
  437. void read_encount(void)
  438. {
  439.         unsigned char temp_CF1,temp_CF2,temp_data;
  440.         unsigned int Temp_CFNumber;
  441.           temp_data=PMCtrl4;
  442.         temp_CF1=0;
  443.       
  444.     ReadMeterPara(0x10f2);
  445.     buffer_energ[0]=u32PMdatal;
  446.     ReadMeterPara(0x10f3);    //读有功脉冲数
  447.     buffer_energ[2]=u32PMdatal;
  448.           if(buffer_energ[0]>buffer_energ[1])                    //如果脉冲数有增加
  449.             { temp_CF1=buffer_energ[0]-buffer_energ[1];           //计算增加的脉冲数
  450.               temp_CF1=check_jump(temp_CF1);                       //防飞走
  451.               }
  452.         if(buffer_energ[2]>buffer_energ[3])
  453.         {
  454.                   temp_CF2=buffer_energ[2]-buffer_energ[3];  
  455.                  // temp_CF2=check_jump(temp_CF2);                       //防飞走
  456.         }
  457.         if(CFFlag==0x55)
  458.         {
  459.         if((temp_CF1!=0)||(temp_CF2!=0))
  460.                 {
  461.                      
  462.                   sumCF_Z=sumCF_Z+temp_CF1+temp_CF2;                           //能量脉冲累加  
  463.                  
  464.                 }
  465.         }
  466.         if(CFFlag==0xd5)
  467.                 {
  468.         if((temp_CF1==1)||(temp_CF2==1))
  469.           {
  470.            sumCF_Z=sumCF_Z+temp_CF1+temp_CF2+1;
  471.            CFFlag=0x55;
  472.           }
  473.             }
  474.          
  475.                        
  476.           
  477.            

  479.        
  480.           buffer_energ[1]=buffer_energ[0];   
  481.         buffer_energ[3]=buffer_energ[2];
  482.          ReadMeterPara(0x10f2);
  483.                  Temp_CFNumber=u32PMdatal;
  484.          if(Temp_CFNumber>0xf000)
  485.             {
  486.              buffer_energ[1]=0;
  487.              u32PMdatal=0;
  488.              SetMeterCfg(0x10f2);
  489.             }
  490.        ReadMeterPara(0x10f3);
  491.              Temp_CFNumber=u32PMdatal;
  492.             if(Temp_CFNumber>0xf000)
  493.             {
  494.             buffer_energ[3]=0;
  495.              u32PMdatal=0;
  496.              SetMeterCfg(0x10f3);
  497.             }
  498. }

  500. */


  503. /**
  504. *  恢复电量整数部分，3字节
  505. * @param  rec_id  电量整数部分的ID
  506. * @return  void
  507. */
  508. void Recover_int(unsigned int rec_id)
  509. {
  510.         check_engint(rec_id);
  511. }

  513. /**
  514. *  恢复电量小数部分，在存放小数的时候，每走1万度存放的位置向后移动一个字节
  515. * @param  void
  516. * @return void
  517. */
  518. void Recover_dot(unsigned int dotaddress,unsigned int ID)
  519. {  
  520.         unsigned int temp_addr;
  521.         addr_baseonIDandtype(RAM,ID);
  522.     temp_addr=(*ID_coretalbpoint[0]).dataaddr;
  523.            temp_addr=(ram[temp_addr]&0x0f);
  524.            data_addr.lword=dotaddress+temp_addr;
  525.            Read_data(EEPROM,1);
  526.            if(checkone_bcd(wr_buff[0])==0)
  527.            {
  528.                    Read_data(EEPROM,1);
  529.                 if(checkone_bcd(wr_buff[0])==0)
  530.                         wr_buff[0]=0;
  531.            }
  532.                      
  533.            addr_baseonIDandtype(RAM,ID);
  534.            data_addr.word[1]=(*ID_coretalbpoint[0]).dataaddr+3;
  535.            Write_data(RAM,1);
  536. }

  538. //=========================================================
  539. //函数功能：恢复电量数据
  540. //=========================================================
  541. void Recover_eng(void)
  542. {
  543.         Recover_int(ID_POSENGSUM);                           //恢复组合电量整数部分
  544.         Recover_dot(EEP_Save_engdot,ID_POSENGSUM);           //恢复组合电量小数部分
  545.        
  546.         Recover_int(0x0200);                                                                //正向
  547.         Recover_dot(EEP_Save_engdotZ,0x0200);

  549.         Recover_int(0x0300);                                                                //反向
  550.         Recover_dot(EEP_Save_engdotF,0x0300);
  551. }



  555. /**
  556. *  恢复电能表的参数，如果读取外部存储器失败，将默认的参数写入存储器
  557. * @param  void
  558. * @return void
  559. */
  560. void Recover_prim(void)
  561. {
  562.         unsigned char i,len;

  564.     wr_buff[0]=0;
  565.         wr_buff[1]=0x12;                                           //默认为1200
  566.         wr_buff[2]=0;
  567.         addr_baseonIDandtype(RAM,ID_CHANGSHU);
  568.         data_addr.word[1]=(*ID_coretalbpoint[0]).dataaddr;
  569.         Write_data(RAM,(*ID_coretalbpoint[0]).datalong);

  571.         if(recover_item(ID_BANTRATA)==0)                                   //如果恢复波特率出错
  572.            {
  573.                      wr_buff[0]=0x08;                                                   //默认参数2400
  574.            }
  575.         addr_baseonIDandtype(RAM,ID_BANTRATA);
  576.         data_addr.word[1]=(*ID_coretalbpoint[0]).dataaddr;
  577.         Write_data(RAM,(*ID_coretalbpoint[0]).datalong);

  579.         if(recover_item(ID_COMADDR)==0)                                   //恢复表地址错误
  580.            {
  581.                    for(i=0;i<6;i++)
  582.                               wr_buff[i]=0x11;
  583.            }
  584.         addr_baseonIDandtype(RAM,ID_COMADDR);
  585.         data_addr.word[1]=(*ID_coretalbpoint[0]).dataaddr;
  586.         len=(*ID_coretalbpoint[0]).datalong;
  587.         Write_data(RAM,len);

  589.         if(recover_item(0x8400)==0)                                     //恢复表号错误0000001
  590.            { for(i=0;i<5;i++)
  591.         wr_buff[i]=0;
  592.           wr_buff[5]=0x01;
  593.            }
  594.         addr_baseonIDandtype(RAM,0x8400);
  595.         data_addr.word[1]=(*ID_coretalbpoint[0]).dataaddr;
  596.         len=(*ID_coretalbpoint[0]).datalong;
  597.         Write_data(RAM,len);

  599. }


  602. /**
  603. *  恢复CF脉冲余量
  604. * @param  void
  605. * @return void
  606. */
  607. void Recover_tindiandata(void)
  608. {   
  609.           data_addr.word[1]=EEP_Save_cf;                                        //CF 恢复
  610.           Read_data(EEPROM,2);

  612.           if(wr_buff[1]==(wr_buff[0]+0x33))
  613.     { if(wr_buff[0]>128)
  614.            wr_buff[0]=0;
  615.         }
  616.         else
  617.            wr_buff[0]=0;

  619.    sumCF=wr_buff[0];

  621. }

  623. /*
  624. void RTCIOOff()
  625. {
  626.   CfgPort(4,0);
  627.   P1ID&=~(BIT0);
  628.   P1OE|=BIT0;
  629.   P1IE&=~(BIT0);
  630. }
  631. */
  632. //==================================================
  633. //函数功能：恢复数据
  634. //备注：
  635. //===================================================
  636. void Recover_data(void)
  637. {
  638.         Recover_eng();                 //恢复电量
  639.           Recover_tindiandata();         //恢复停电时保存的数据
  640.           Recover_prim();                //恢复参数
  641. }


  644. /**
  645. *  检测当前的供电模式
  646. * @param  void
  647. * @return 1  市电供电
  648. *         0  电池供电
  649. */
  650. unsigned char check_powertype(void)
  651. {
  652.         unsigned char value;
  653.           if((Systate&0x01)==0x01)
  654.                       value=1;                    //正常供电
  655.           else
  656.       {
  657.                       if((Systate&0x01)==0x01)
  658.                              value=1;
  659.                  else
  660.                              value=0;
  661.         }
  662.        
  663.           return  value;
  664. }

  666. /**
  667. *  初始化系统各个模块
  668. * @param  void
  669. * @return void
  670. */
  671. void Init_modul(void)
  672. {
  673.           Init_disp();                             //初始化显示模块
  674.           init_RTCmode();                          //初始化RTC模块
  675.           int_energeadd();                         //初始化能量计量模块
  676.           Init_checkmode();                          //初始化check模块
  677.     init_485comm();                          //初始化485模块
  678.     InitInfrComm();                          //初始化红外模块
  679.         Initcommu();                             //初始化通讯驱动
  680.         Init_Mchannel();                           //初始化M通道
  681.     SysInitAutoCal();                         //初始化自动校
  682. }


  685. /**
  686. *  初始化停电模块
  687. * @param  void
  688. * @return void
  689. */
  690. void ini_sleepmode(void)
  691. { CfgInterrupt(0);                //关所有中断
  692.   EA=0;                           //关总中断
  693. //  time_jihuo=0;
  694. //  time_lostiv=0;
  695. //  CfgPort(4,0);                   //秒脉冲输出打开
  696.   port_init();                    //禁止IO口输入输出
  697. }


  700. /**
  701. *  停电初始化
  702. * @param  void
  703. * @return void
  704. */
  705. //void Init_jihuo(void)
  706. //{
  707. //  Init_disp();                             //初始化显示模块
  708. //  sta_meterrun=5;                          //激活模式
  709. //  time_jihuo=0;
  710. //}





  716. /**
  717. *  停电保存各类数据，备注：包括：电量小数，CF脉冲位数，当月平均功率因数、停电时间
  718. * @param  void
  719. * @return void
  720. */
  721. void savedata_tingdian(void)
  722. {
  723.   //======================================================================CF
  724.   wr_buff[0]=sumCF;
  725.   wr_buff[1]=wr_buff[0]+0x33;
  726.   data_addr.word[1]=EEP_Save_cf;
  727.   Write_data(EEPROM,2);
  728. }

  730. /**
  731. *  开启CF脉冲输出
  732. * @param  void
  733. * @return void
  734. */
  735. void Open_CF(void)
  736. {  
  737.         unsigned char i;
  738.         if(count_opencftime==0)
  739.             { i=PMCtrl4;
  740.                     if((i&0x18)!=0x18)                                  //如果cf没有开
  741.                 {
  742.                         i=PMCtrl4;  
  743.                              if((i&0x18)!=0x18)  
  744.                              { i|=0x18;                                 //开CF
  745.                            PMCtrl4=i;
  746.                    SetInterrupt(14);                        //开CF1中断
  747.                  }
  748.                     }
  749.            }
  750.     if(ULowFlag==0)
  751.        { if(CFNumber>=1)
  752.                 { ULowFlag=1;
  753.                           Recover_pd();                   //第一个脉冲之后,恢复正常门限值
  754.                     }
  755.              
  756.              }
  757.       
  758. }

  760. //计量防潜动 判断
  761. void pm_Idle(void)
  762. {
  763.    unsigned int temp_int;
  764.    unsigned long xdata  temp;

  766.    //if((PMCtrl4&0x18)==0)
  767.    //  return;
  768.    //--------------------------获取脉冲常数
  769.            addr_baseonIDandtype(RAM,ID_CHANGSHU);                                //获取脉冲常数指针
  770.            data_addr.word[1]=(*ID_coretalbpoint[0]).dataaddr;
  771.            Read_data((*ID_coretalbpoint[0]).stortype,(*ID_coretalbpoint[0]).datalong);
  772.            temp_int=value_hex_from_2bcd(&wr_buff[1]);
  773.            if((temp_int>12800)||(temp_int<200))                                  //脉冲常数是否异常
  774.        temp_int=1200;                  
  775. ///计算0.4%IB启动电流时的功率
  776.    temp=meterprm_table[1];
  777.    temp >>= 11;
  778.    temp |= (meterprm_table[0]<<21);
  779.    temp *= type_Ib;
  780.    temp /= 2250;
  781.    temp *= temp_int;
  782.    temp *= type_volit;                  //220V x 10A /100  
  783.    temp /= 312500;
  784.    

  786.    ReadMeterPara(DATAP);
  787.    if(u32PMdatal&0x80000000)
  788.           u32PMdatal = (~u32PMdatal) +1;
  789.    if(u32PMdatal>=((temp*6)/10) )  //加启动电流时的功率的 60%
  790.    {
  791.      if(F_PmIdle)
  792.          {
  793.              if(pmIdleCnt<5)
  794.                            pmIdleCnt++;
  795.                  else
  796.                  {
  797.                     F_PmIdle = 0;
  798.                         pmIdleCnt = 0;
  799.                         PMCtrl4 &= ~BIT5;        //关闭防潜功能,         复位防潜能量桶
  800.                         PMCtrl4 |= BIT5;        //开启防潜,重新进行防潜计算
  801.                  }
  802.          }
  803.          else
  804.              pmIdleCnt = 0;
  805.    }
  806.    else if(u32PMdatal<= ((temp*3)/10) )         //加启动电流时的功率的 30%  
  807.    {
  808.       if(!F_PmIdle)
  809.           {
  810.              if(pmIdleCnt<5)
  811.                            pmIdleCnt++;
  812.                  else
  813.                  {
  814.                     F_PmIdle = 1;
  815.                         pmIdleCnt = 0;
  816.                  }
  817.           }
  818.           else
  819.                 pmIdleCnt = 0;
  820.    }
  821. }
  822. /**
  823.       * 流程描述
  824.       *
  825.       * 主程序根据系统状态寄存器的状态来判断当前是执行哪类操作
  826.       * RTC 唤醒 （BIT2）  快速休眠（注意快速休眠必须配合PLL快速流程，不然无法休眠）
  827.       * 看门狗复位(BIT4)   恢复系统状态
  828.       * IO口复位(BIT3)     更新显示
  829.       * 正常上电(BIT0)     正常上电流程
  830.       */
  831. void main(void)
  832. {   uint8 dispflashtime,waketime;   
  833. jumpsta:
  834.      F0=1;                              
  835.      CLKFRQ=1;                     
  836.      
  837.      SPCFNC=0x01;
  838.      XBYTE [0x8002] = 0x86;
  839.      SPCFNC=0x00;
  840.      SetMeterFunc(0);                                           //关CF输出
  841.      if(Systate & BIT2)                                         // rtc reset
  842.             {  CtrlMEAS = 0x80;                                     //关LDO33
  843.                    if(sta_meterrun==run_sleepdisp)                      //程序在停电显示模式
  844.               { waketime=0;       
  845.                 dispflashtime++;
  846.                                 if(dispflashtime==5)
  847.                                     { Disp_close();
  848.                                         }
  849.                             else if(dispflashtime==10)
  850.                     { if(BatteryInfo==1)
  851.                           Disp_err1();                          //显示err1
  852.                       else
  853.                                             Disp_oninsleep();                      //显示电量
  854.                                        }
  855.                 else if(dispflashtime==15)
  856.                     { Disp_close();
  857.                                         }
  858.                 else if(dispflashtime>19)
  859.                     { dispflashtime=0;
  860.                       Disp_oninsleep();                      //显示电量
  861.                     }
  862.                 if(save_lastday!=RTCHC)               
  863.                     { save_lastday=RTCHC;
  864.                       times_cutpower++;
  865.                       if(times_cutpower>TIMDISOCUTP)            //显示7天，超过7点则进入休眠模式
  866.                          { times_cutpower=0;
  867.                            CloseLCD();
  868.                            sta_meterrun=run_sleep;             //进入睡眠模式
  869.                                                    waketime=3;                         //一天唤醒一次  
  870.                          }
  871.                     }
  872.                        }
  873.           else
  874.                      waketime=3;
  875.          CfgRTC(0,waketime);                                     //32768，定时唤醒
  876.          if(check_powertype()==1)
  877.            { ClearWDT();
  878.              goto jumprun;
  879.                    }
  880.                  Sleep();
  881.                  if(check_powertype()==1)
  882.            { ClearWDT();
  883.              goto jumprun;
  884.                    }
  885.         }
  886.      #ifdef        DEBUG
  887.      #else       
  888.      else if(Systate & BIT4)                    
  889.            { SetPLL(SETPLL_3_2M);                       //开启pll  
  890.          Init_System();
  891.              Recover_data();                            //恢复数据 re
  892.          Init_modul();
  893.          EA = 1;                                    //开总中断
  894.          ClearWDT();
  895.        }
  896.      #endif       
  897.            else if(Systate & BIT3)                    // io reset
  898.            {if(check_powertype()==1)
  899.            { ClearWDT();
  900.              goto jumprun;
  901.                    }
  902.                  Sleep();
  903.         }
  904.          else              // 正常上电复位
  905.            {
  906. jumprun:
  907.          SetPLL(SETPLL_3_2M);                       //开启pll
  908.          Init_System();
  909.          Recover_data();                            //恢复数据
  910.              Init_modul();
  911.              EA = 1;                                    //开总中断
  912.          ClearWDT();  
  913.        }
  914.          
  915.          /**
  916.           * 正常运行部分，该部分中，系统反复执行以下流程
  917.           * RTC时钟刷新模块
  918.           * 计量模块CF打开
  919.           *
  920.           */
  921.          
  922. run_zhengchang:

  924.         while(check_powertype()==1)                               //市电供电
  925.            {             
  926.               PowerDown=0;
  927.           ClearWDT();                                   //喂狗
  928.                   if(check_powertype()==0)
  929.                      break;
  930.                   Rtc_refreshmode();                            //时钟刷新
  931.                   if(check_powertype()==0)
  932.                      break;
  933.                   commu_mode();                                  //通讯模块
  934.               if(check_powertype()==0)
  935.                       break;
  936.                   Open_CF();
  937.               if(check_powertype()==0)
  938.                      break;
  939.                   display_mode();                               //显示模块
  940.                   if(check_powertype()==0)
  941.                      break;
  942.               energ_addmode();                              //能量计量模块
  943.           if(check_powertype()==0)
  944.                      break;
  945.           check_mode();                                   //自检模块
  946.           if(check_powertype()==0)
  947.                      break;
  948.            Mchannelmode();                                   //M通道测量
  949.                          
  950.            }
  951. //==============================================================================================停电处理部分
  952.    if(check_powertype()== 0)                                   //电池供电
  953.       { while(1)
  954.               { if(check_powertype()==1)
  955.                     { ClearWDT();
  956.                       PowerDown=0;
  957.                       goto run_zhengchang;
  958.                            }
  959.                 else
  960.                           { PowerDown++;
  961.                          delay_1ms();
  962.                          ClearWDT();
  963.                             if(PowerDown>3)
  964.                                    goto xiumian;
  965.                           }
  966.           }
  967.       xiumian:          
  968.          savedata_tingdian();                                  //停电保存数据
  969.          ClearWDT();
  970.              CfgRTC(0,0);                                          //32768，1秒唤醒
  971.                  ini_sleepmode();                                      //初始化停电模式
  972.                  IO_Sleep();
  973.                  times_cutpower=0;                                      //停电计时器
  974.                  dispflashtime=0;                                       //闪烁时间
  975.                Ini_sleepdisp();
  976.          if(check_powertype()==1)
  977.            { ClearWDT();
  978.              goto jumpsta;
  979.                    }
  980.                 sta_meterrun=run_sleepdisp;                            //程序进入停电显示模式
  981.                  Sleep();
  982.          }
  983.    else
  984.      goto run_zhengchang;
  985. }
  986.          
  987. //=========================================================================================停电激活
  988. #undef AUTOCAL
  989. #undef        MAIN

复制代码


电能表

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

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

相关帖子
回复

使用道具 举报

沙发
ID:103296 发表于 2016-4-3 10:40 | 只看该作者
你好，能够把源码发给我学习一下，可以吗？谢谢！！！
回复

使用道具 举报

板凳
ID:1 发表于 2016-4-3 13:08 来自手机 | 只看该作者
卖源码，请到供求信息发布去
回复

使用道具 举报

地板
ID:197648 发表于 2017-7-1 10:51 | 只看该作者
楼主，有没有更详细的电能表设计方案
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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