interruptservice.c

该程序用msp430单片机开发了一款单相电子式多费率电能表

/****************************************************************
*                      ESP中断服务程序                          *
****************************************************************/
#pragma vector=ESP430_VECTOR
__interrupt void ESP_ISR (void)
{
  unsigned int msg_data= MBIN1;
  unsigned int msg     = MBIN0;
  unsigned int tmp;
  if (msg == mEVENT)
  {
    if (msg_data & ENRDYFG)
    {
      *(int*)(&lActEnergy1) = ACTENERGY1_LO;
      *((int*)(&lActEnergy1)+1) = ACTENERGY1_HI;
      if(lActEnergy1<0)
      {
        lActEnergy1=-lActEnergy1;
        uESP430_STAT0 |= NEGENFG0;
      }
      else
      {
        uESP430_STAT0 &= ~NEGENFG0;
      }
      *(int*)(&lReActEnergy) = REACTENERGY_LO;
      *((int*)(&lReActEnergy)+1) = REACTENERGY_HI;
      *(int*)(&lAppEnergy) = APPENERGY_LO;
      *((int*)(&lAppEnergy)+1) = APPENERGY_HI;
      uiV1Rms = V1RMS;
      *(int*)(&ulIRms) = IRMS_LO;
      *((int*)(&ulIRms)+1) = IRMS_HI;
      if(ulIRms>Esp.ulStartCurrent)
      {
        uiPowerFct = POWERFCT;
        if(uiPowerFct>0x8000)
        {
          if(uiPowerFct>0xC000)
          {
            uiPowerFct=uiPowerFct-0xC000;
            uiPowerFct=0x4000-uiPowerFct;
          }
          else
          {
            uiPowerFct = uiPowerFct-0x8000;
          }
        }
        else
        {
          if(uiPowerFct>0x4000)
          {
            uiPowerFct=0x8000-uiPowerFct;
          }
        }
        iCapInd = CAPIND;
      }
      else
      {
        	ulIRms = 0;
			uiPowerFct = 0;
        	iCapInd = 0;
      }
#ifdef TAMPER_DETECTION
	  ulActP1=lActEnergy1*CZ_ENERGY_100000;
	  ulActP2=lActEnergy2*CZ_ENERGY_100000;
	  if(ESP430_STAT0 & TAPERFLG) //这个地方需要修改
          {
     		if(uESP430_STAT0 & I2LARGEI1)
        	{
         	 ulLastActP = ulActP2;   //暂时使用
        	}
        	else
        	{
         	ulLastActP = ulActP1;   //暂时使用
        	}                
          }
          else
          {
       	    ulLastActP = ulActP1;
          }
#else
     ulActP1 = lActEnergy1*CZ_ENERGY_100000;
     ulLastActP = ulActP1;
#endif
     ulReActP = lReActEnergy*CZ_ENERGY_100000;
     ulAppP = lAppEnergy*CZ_ENERGY_100000;

     ulMainsPeriodBak = ulMainsPeriod;
     ullMainsCntBak = uiMainsCnt;
     ulMainsPeriod=0;
     uiMainsCnt=0;
     SystemFlag |= ESP_ENRDYFG;
      _BIC_SR_IRQ(LPM0_bits);
    }

#ifdef TAMPER_DETECTION
    if (msg_data & TAMPFG)
    {
		uESP430_STAT0 |= TAPERFLG;
    }
    else
    {
		uESP430_STAT0 &= ~TAPERFLG;	
    }
#endif
    if (msg_data & ZXTRFG)
    {
      EspState |= ZXLDFG;
    }
    if ((msg_data &ZXLDFG)&& (EspState & ZXLDFG ))
    {
      EspState &= ~ZXLDFG;
      tmp=MAINSPERIOD;
      ulMainsPeriod += tmp;
      uiMainsCnt++;
    }
  }
}
#pragma vector=BASICTIMER_VECTOR
__interrupt void BT_ISR (void)
{
  if(bgbzh == 1)
    bgtimer++;
  if(bgtimer >=40)
  {
    bgbzh = 0;
    BG_OUT &= ~BG_BIT;
  }
  SystemFlag |= WatchDog_Flag;
  _BIC_SR_IRQ(LPM3_bits);
}

#pragma vector=TIMERA0_VECTOR
__interrupt void TA0_ISR (void)
{
  TACCR0 = TAR + TIMERA_PULSE_PERIOD;
  ullAccKwhPp += ulLastActP;
  if(ullAccKwhPp >= ENERGY_PULSE_THRESHOLD_100000)
  {
    ullAccKwhPp -= ENERGY_PULSE_THRESHOLD_100000;
    LED_YG_OUT |= LED_YG_BIT;
    ucActPulseCycle = REACT_PULSE_CYCLE;
    //TACCR1 = TAR + ENERGY_PULSE_PERIOD;
    //TACCTL1 = CCIE;
    pulse1 ++;
    ygzip++;
    ucChkFlg |= BIT0;
    if(ygzip >= O_O1KWH_PULS)
    {
      ygzip = 0x00;
      ucChkFlg |= BIT1;
      BCD1INC(&YgKwhZXS);
      if(YgKwhZXS ==0x00)
      {
         BCD3INC(&YgKwhZ[0]);
         ucChkFlg |= BIT2;
      }
    }
    if(flbzh == Jian)
    {
      ygjip++;
      if(ygjip >= O_O1KWH_PULS)
      {
        ygjip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&YgKwhJXS);
        if(YgKwhJXS == 0x00)
        {
          BCD3INC(&YgKwhJ[0]);
          ucChkFlg |= BIT2;
        }
      }
    }
    else if(flbzh == Feng)
    {
      ygfip++;
      if(ygfip >= O_O1KWH_PULS)
      {
        ygfip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&YgKwhFXS);
        if(YgKwhFXS == 0x00)
        {
          BCD3INC(&YgKwhF[0]);
          ucChkFlg |= BIT2;
        }
      }
    }
    else if(flbzh == Ping)
    {
      ygpip++;
      if(ygpip >= O_O1KWH_PULS)
      {
        ygpip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&YgKwhPXS);
        if(YgKwhPXS == 0x00)
        {
          BCD3INC(&YgKwhP[0]);
          ucChkFlg |= BIT2;
        }
      }
    }
    else 
    {
      yggip++;
      if(yggip >= O_O1KWH_PULS)
      {
        yggip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&YgKwhGXS);
        if(YgKwhGXS == 0x00)
        {
          BCD3INC(&YgKwhG[0]);
          ucChkFlg |= BIT2;
        }
      }
    }
  }
  ullAccKwhQp += ulReActP;
  if(ullAccKwhQp >= ENERGY_PULSE_THRESHOLD_100000)
  {
    ullAccKwhQp -= ENERGY_PULSE_THRESHOLD_100000;
    LED_WG_OUT |= LED_WG_BIT;
    ucReActPulseCycle = REACT_PULSE_CYCLE;
    wgzip++;
    ucChkFlg |= BIT0;
    if(wgzip >= O_O1KWH_PULS)
    {
      wgzip = 0x00 ;
      ucChkFlg |= BIT1;
      BCD1INC(&WgKwhZXS);
      if(WgKwhZXS == 0x00)
      {
        BCD3INC(&WgKwhZ[0]);
        ucChkFlg |= BIT3;
      }
    }
/*    if(flbzh == Jian)
    {
      wgjip++;
      if(wgjip > O_O1KWH_PULS)
      {
        wgjip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&WgKwhJXS);
        if(WgKwhJXS == 0x00)
        {
          BCD3INC(&WgKwhJ[0]);
          ucChkFlg |= BIT3;
        }
      }

    }
    else if(flbzh == Feng)
    {
      wgfip++;
      if(wgfip > O_O1KWH_PULS)
      {
        wgjip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&WgKwhFXS);
        if(WgKwhFXS == 0x00)
        {
          BCD3INC(&WgKwhF[0]);
          ucChkFlg |= BIT3;
        }
      }
    }
    else if(flbzh == Ping)
    {
      wgpip++;
      if(wgpip > O_O1KWH_PULS)
      {
        wgpip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&WgKwhPXS);
        if(WgKwhPXS == 0x00)
        {
          BCD4INC(&WgKwhP[0]);
          ucChkFlg |= BIT3;
        }
      }
    }
    else 
    {
      wggip++;
      if(wggip > O_O1KWH_PULS)
      {
        wggip = 0x00;
        ucChkFlg |= BIT1;
        BCD1INC(&WgKwhGXS);
        if(WgKwhGXS == 0x00)
        {
          BCD3INC(&WgKwhG[0]);
          ucChkFlg |= BIT3;
        }
      }
    }*/
  }
  if(ucChkFlg & BIT0)
  {
    ucChkFlg &= ~BIT0;
    chkip = ChkSum(&ygzip,10);
  }
  if(ucChkFlg&BIT1)
  {
    ucChkFlg &= ~BIT1;
    ChkXS = ChkSum(&YgKwhZXS,10);
  }
  if(ucChkFlg & BIT2)
  {
    ucChkFlg &= ~BIT2;
    ChkYg = ChkSum(&YgKwhZ[0],15);
  }
  if(ucChkFlg&BIT3)
  {
    ucChkFlg &= ~BIT3;
    ChkWg = ChkSum(&WgKwhZ[0],15);
  }

  if(ucActPulseCycle>0)
  {
    ucActPulseCycle--;
    if(ucActPulseCycle==0)
    {
      LED_YG_OUT &= ~LED_YG_BIT;
    }
  } if(ucReActPulseCycle>0)
  {
    ucReActPulseCycle--;
    if(ucReActPulseCycle==0)
    {
      LED_WG_OUT &= ~LED_WG_BIT;
    }
  }
}

#pragma vector=TIMERA1_VECTOR
__interrupt void TA1_ISR (void)
{
  //switch(TAIV)
  switch(__even_in_range(TAIV, 10))
  {
  case 0:{}break;
  case 2:
    {
      LED_YG_OUT &= ~LED_YG_BIT;
      TACCTL1 = 0x00;
    }break;

  }
}