TI

【TI 技术资料分享】+基于MSP430单片机的智能电表

2019-07-30 18:38发布

站内问答 / TI MCU
20781 0 1663
基于MSP430单片机的智能电表 基于MSP430单片机的智能电表.zip (96.77 KB, 下载次数: 22) 2015-3-10 17:09 上传 点击文件名下载附件
  1. #include "msp430x41x.h"
  2. #include "string.h"
  3. #include "Def.h"
  4. #include "EepromAddr.h"
  5. #include "CommID.h"
  6. #include "Main.h"
  7. #include "Tariff.c"
  8. #include "Temperature.c"
  9. #include "Lcd.c"
  10. #include "I2C.c"
  11. #include "Comm.C"
  12. #include "Timer.C"


  15. void port_ini( void )
  16. {
  17.         P1OUT  = P1T485;
  18.         P1DIR  = TX | P1T485;
  19.         P1IES &=~P1IMPIN;
  20.         P1IES |= P1DISPLAY;
  21.         P1IE  |= P1IMPIN | P1DISPLAY;
  22.         P1IFG  = 0;
  23.         P1SEL  = 0;
  24.        
  25.         P2DIR  = 0;
  26.         P2IES |= (P2UNCOVER | P2POWERCHECK | 0x20);
  27.         P2IE  |= (P2UNCOVER | P2POWERCHECK | 0x20);
  28.        
  29.         P6DIR  = (P6E485 | P6LEDRATE2 | P6LEDRATE3 | P6LEDRATE4);
  30.         P6OUT  = (P6E485 | P6LEDRATE2 | P6LEDRATE3 | P6LEDRATE4);
  31. }

  33. void start_wdt( void )
  34. {
  35.         WDTCTL = WDT_ARST_1000;                        // Start WDT
  36.         IFG1 &=WDTIFG;
  37.         IE1  |=WDTIE;
  38. }
  39. /*
  40. void search_fee( void )
  41. {
  42.         bTmp=tar_que( &NowClk1, &TarList );
  43.         if( bTmp>3 ) bTmp=1;
  44. }
  45. */
  46. void main(void)
  47. {
  48.        
  49.         WDTCTL = WDTPW + WDTHOLD;                                // Stop watchdog timer
  50.         FLL_CTL0 |= XCAP14PF;
  51.        
  52. // 让 AD7416 进入掉电模式。
  53.         vars.tmpPtr[0] = 0x01;
  54.         w_I2C_bytes(vars.tmpPtr,0x9E,0x01,1);
  55.        
  56.         new_e2prom_ini();
  57.        
  58.         clk_ini();                        // --
  59.        
  60.         re_clk_ini();
  61.        
  62.         lcd_ini();
  63.        
  64.         port_ini();
  65.         vars.MetStatus=0;
  66.         vars.MetStatus=BATTEST(vars.MetStatus);
  67.        
  68.         TimeA_ini();
  69.         vars.cFlag=0;
  70.         vars.rt_Bit = 0;
  71.         vars.lByte = 0;
  72.         rx_cap_reseat();
  73.        
  74.         start_wdt();
  75.        
  76.         _EINT();                                                                // Enable interrupts
  77.        
  78.         while(1)
  79.         {
  80.                 if ( vars.Int_ID&ComInt )        // communication interrupt
  81.                 {
  82.                         ProcComm();
  83.                         vars.Int_ID &=~ComInt;
  84.                 }
  85.                 if ( vars.Int_ID&BtInt )                // basic timer interrupt
  86.                 {
  87.                         ProcSec();
  88.                         vars.Int_ID &=~BtInt;
  89.                 }
  90.                 if((vars.Int_ID&E2Int)&&!(vars.E2PROM_SAVE&E2BUSY))
  91.                 {
  92.                         vars.E2PROM_SAVE |= E2BUSY;
  93.                         E2_Save();
  94.                         vars.E2PROM_SAVE &=~E2BUSY;
  95.                         vars.Int_ID &=~E2Int;
  96.                 }
  97.                 _NOP();
  98.                
  99.                 LPM3;
  100.                 _NOP();
  101.         }
  102. }

  104. interrupt[BASICTIMER_VECTOR] void Basic_timer (void)
  105. {
  106.         IFG1 &=WDTIFG;
  107.        
  108.         WDTCTL = WDT_ARST_1000;                                // Clear WDT
  109.        
  110.         if ( vars.bt_int>=63 )
  111.         {
  112.                 vars.bt_int=0;
  113.         }
  114.         else vars.bt_int++;
  115.        
  116. // 以下程序为内部软件时钟温度补偿：
  117.         if(vars.Flags & Temp_F)
  118.         {
  119.                 vars.Flags &=~ Temp_F;
  120.                
  121.                 if ( vars.bt_int>=63 ) vars.bt_int=0;
  122.                 else vars.bt_int++;
  123.         }
  124. //
  125.        
  126.         if ( vars.bt_int==0 || vars.bt_int==32 ) vars.Int_ID |=BtInt;
  127.        
  128.         if(vars.Int_ID!=0) LPM3_EXIT;                                                        // wake CPU
  129. }

  131. interrupt[TIMERA0_VECTOR] void TA0_timer (void)
  132. {
  133.         if((vars.timer0status&comovertime)==comovertime)
  134.         {
  135. //                vars.rt_Bit = 0;
  136. //                vars.lByte = 0;
  137.                 rx_cap_reseat();
  138.                 vars.timer0status &=~comovertime;
  139.         }
  140.         if(vars.timer0status==0) CCTL0 &=~CCIE;
  141. }

  143. interrupt[TIMERA1_VECTOR] void TA1_timer (void)
  144. {
  145.         if ((TAIV|0x02)==0x02)
  146.         {
  147.                 if( (vars.ComFlags & rtflag)==rtflag )
  148.                 {
  149.                         ComFlagRAM |= sym_Comm;
  150.                         tx_prt(vars.rtByte[vars.lByte]);
  151.                 }
  152.                 else
  153.                 {
  154.                         switch(vars.rt_Bit)                                // 32.768k XT
  155.                         {
  156.                                 case  0:
  157.                                         CCTL0 &=~CCIE;
  158.                                         CCTL1 &= ~(CAP+CM1);
  159.                                         CCR1 =TAR+14;break;
  160.                                 case  3:CCR1=CCR1+28;break;
  161.                                 case  6:CCR1=CCR1+28;break;
  162.                                 case  9:CCR1=CCR1+28;break;
  163.                                 default:CCR1=CCR1+27;break;
  164.                         }
  165.                         vars.cFlag=0;                                                                        // 清超时计时.
  166.                        
  167.                         if (vars.rt_Bit==1)
  168.                         {
  169.                                 if ((P1IN&RX)==RX) goto looperr;                        // error return(9)
  170.                                 else
  171.                                 {
  172.                                         vars.hByte  = 0;
  173.                                         vars.csByte = 0;
  174.                                         goto loop0;
  175.                                 }
  176.                         }
  177.                         if ((vars.rt_Bit>1)&&(vars.rt_Bit<=10))                        // 7 or 8 bit: now 8 bit
  178.                         {
  179.                                 if ((P1IN&RX)==RX)
  180.                                 {
  181.                                         vars.hByte |= 0x200;                                        // 7 or 8 bit
  182.                                         vars.csByte++;
  183.                                 }
  184.                                 vars.hByte >>=1;
  185.                                 goto loop0;
  186.                         }
  187.                         if (vars.rt_Bit>10)                                                        // 7 or 8 bit
  188.                         {
  189.         //                        COMIFGS[0] |=RB_L;                                        // 字节结束，超时计时开始中。
  190.                                 vars.timer0status |= comovertime;
  191.                                 CCR0  =TAR+0x8000;
  192.                                 CCTL0 |= CCIE;
  193.                                 vars.hByte &=0xFF;                                                // 7 or 8 bit
  194.                                 if ((vars.csByte&1)==0) goto loop1;
  195.                                 else goto looperr;
  196.                         }
  197.         loop0:
  198.                         vars.rt_Bit++;
  199.                         goto loopend;
  200.         loop1:
  201.                         if((vars.lByte==0)&&(vars.hByte!=0x68)) goto looperr;
  202.                         ComFlagRAM |= sym_Comm;
  203.                         vars.rt_Bit = 0;
  204.                         vars.rtByte[vars.lByte]=vars.hByte;
  205.                         if ( vars.lByte == vars.rtByte[9]+11 )
  206.                         {
  207.                                 vars.lByte=0;
  208.                                 CCTL0 &=~CCIE;
  209.         //                        rtByte[rtByte[9]+11]=0;
  210.                                 vars.Int_ID |= ComInt;
  211.                         }
  212.                         else
  213.                         {
  214.                                 vars.lByte++;
  215.                                 if(vars.lByte>42) goto looperr;
  216.                         }
  217.                        
  218.                         rx_cap_start();                                // communication start
  219.                         goto loopend;
  220.         looperr:
  221.                         vars.rt_Bit = 0;
  222.                         vars.lByte = 0;
  223.                         rx_cap_reseat();                        // communication reseat
  224.         loopend:
  225.                         _NOP();
  226.                 }
  227.         }
  228.         if (TAIV|0x04)
  229.         {
  230.                 CCTL2 &=~CCIFG;
  231.                 CCR2  =TAR+0x8000;
  232.                 if( !(P1IN&P1DISPLAY) )
  233.                 {
  234.                         //
  235.                         if ( vars.LcdCtl.Switch==1 )
  236.                         {
  237.                                 vars.LcdCtl.Mode ^= 1;
  238.                         }
  239.                         else vars.LcdCtl.Switch++;
  240.                         //
  241.                         //LcdCtl.Mode ^= 1;
  242.                 }
  243.                 else { CCTL2 &=~CCIE; vars.LcdCtl.Switch = 0; }
  244.         }
  245. }

  247. interrupt[PORT1_VECTOR] void p1_int (void)
  248. {
  249.         if( (P1IFG&P1DISPLAY)!=0 )
  250.         {
  251.                 P1IFG &=~P1DISPLAY;
  252.                
  253.                 CCR2  =TAR+0xFFF0;
  254.                 CCTL2 |= CCIE;
  255.                
  256.                 vars.LcdCtl.SecCtr=0;
  257.                 if( vars.LcdCtl.PagePtr<23 ) vars.LcdCtl.PagePtr++;
  258.                 else vars.LcdCtl.PagePtr=0;
  259.                
  260.                 vars.Int_ID |= KeyInt;
  261.         }
  262.        
  263.         if( (P1IFG&P1REVP)!=0 )
  264.         {
  265.                 vars.CurrentRe.nTime[0]=vars.NowClk1.nMinute;
  266.                 vars.CurrentRe.nTime[1]=vars.NowClk1.nHour;
  267.                 vars.CurrentRe.nTime[2]=vars.NowClk1.nDay;
  268.                 vars.CurrentRe.nTime[3]=vars.NowClk1.nMonth;
  269.                
  270.                 vars.E2PROM_SAVE |= UnCover_S;
  271.                 vars.Int_ID |=E2Int;
  272.                
  273.                 P1IFG &=~P1REVP;
  274.         }
  275.        
  276.         if( (P1IFG&P1IMPIN)!=0 )
  277.         {
  278.                 P1IFG &=~P1IMPIN;
  279.                
  280.                 if (vars.PulseNum>=vars.MetConst)
  281.                 {
  282.                         vars.PulseNum=1;
  283.                        
  284.                         if((vars.Tariff.EC[0][0]&0x0F)>=9)                        // 电量增加 0.1，保存
  285.                         {
  286.                                 r_I2C_bytes(&vars.Tariff.EC[0][0],I2C_24CXX_P0,CuECTotal,4);
  287.                                 vars.Tariff.EC[0][0] &= 0xF0;
  288.                                 vars.Tariff.EC[0][0] += 0x09;
  289.                                 vars.E2PROM_SAVE |= EC_S;
  290.                                 vars.Int_ID |=E2Int;
  291.                         }
  292.                         if(P1IN&P1REVP) _BCD4INC((BYTE *)&vars.ECReAll[0]);
  293.                         _BCD4INC((BYTE *)&vars.Tariff.EC[0][0]);
  294.                         _BCD4INC((BYTE *)&vars.Tariff.EC[vars.bTmp+1][0]);                // [vars.bTmp+1]
  295.                 }
  296.                 else _BCD1INC((BYTE *)&vars.PulseNum);
  297.         }
  298.         P1IFG =0;
  299.         _NOP();
  300. }

  302. interrupt[PORT2_VECTOR] void p2_int (void)/////////////////////////////////////////开盖记录
  303. {
  304.         if( P2IFG&P2UNCOVER )
  305.         {
  306.                 P2IFG &=~P2UNCOVER;
  307.                 vars.UnCover.nTime[1][0]=vars.UnCover.nTime[0][0];
  308.                 vars.UnCover.nTime[1][1]=vars.UnCover.nTime[0][1];
  309.                 vars.UnCover.nTime[1][2]=vars.UnCover.nTime[0][2];
  310.                 vars.UnCover.nTime[1][3]=vars.UnCover.nTime[0][3];
  311.                 vars.UnCover.nTime[0][0]=vars.NowClk1.nMinute;
  312.                 vars.UnCover.nTime[0][1]=vars.NowClk1.nHour;
  313.                 vars.UnCover.nTime[0][2]=vars.NowClk1.nDay;
  314.                 vars.UnCover.nTime[0][3]=vars.NowClk1.nMonth;
  315.                 vars.UnCover.nTimes++;
  316.                 _NOP();
  317.                 vars.E2PROM_SAVE |= UnCover_S;
  318.                 vars.Int_ID |=E2Int;
  319.         }
  320.        
  321.         if( P2IFG&P2POWERCHECK )
  322.         {
  323.                 P2IFG &=~P2POWERCHECK;
  324.                 vars.E2PROM_SAVE |= EC_S;
  325.                 vars.E2PROM_SAVE |= PulseNum_S;
  326.                 vars.Int_ID |=E2Int;
  327.         }
  328.        
  329.         P2IFG =0;
  330.         _NOP();
  331. }
复制代码

发送
 看不清?
0条回答

一周热门 更多>

相关文章