#include "../main/SystemInclude.h"

//******************************************************************************
unsigned int PulsePeriod[3];
//unsigned int PulsePeriod, PulseDuty, PulseDiv, PulseCapture;
unsigned long int pulseCounter;
  signed int targetPulse;
  bool isPulseUpdaed;  
//******************************************************************************
  
//0.25s, 0.5s, 1s, 2s, 4s       
//const unsigned char PulseGain[] = {4, 2, 1, 1, 1};                            // 0.25s *4, 0.5S*4,
const unsigned char PulseGain[] = {16, 8, 4, 2, 1};          
//const unsigned int UpdateTimeVaule[] = {3768, 7372, 7372, 7372, 7372};        // 0.23s, 0.45s
const unsigned int UpdateTimeVaule[] = {3768, 7372, 8192, 16384, 32768};        // 0.23s, 0.45s, 0.5s,  1s, 2s
const unsigned int MaxPulseOutput[]={
  MAX_TIMER_PULSE>>2, MAX_TIMER_PULSE>>1, MAX_TIMER_PULSE*1 , MAX_TIMER_PULSE*2,
  MAX_TIMER_PULSE*4                                                             }; // 0.25s, 0.5s, 1s, 2s, 4s
//******************************************************************************
// USER PULSE ( MAX FR = 3600 NM3)
const unsigned int UserHighPulsePeriod[]={1022, 511, 341, 255, 204, 170, 146, 128, 114,  102, 93,  85,  79,  73,  68, 64, 60}; //> 32Hz < 512Hz  
const unsigned int UserLowPulsePeriod[]={8192, 4096, 2730, 2048, 1638, 1365, 1170, 1024};                                      // {4088, 2044, 1363, 1022};          //<32Hz 
//******************************************************************************
//for 125KHz
const unsigned int PULSE_TABLE[]={
  0,62501,31250,20834,15626,12501,10417,8929,7813,6945,6251,5682,5209,4808,
  4465,4167,3907,3677,3473,3290,3126,2977,2841,2718,2605,2501,2404,2315,2233,
  2156,2084,2017,1954,1894,1839,1786,1737,1690,1645,1603,1563,1525,1489,1454,
  1421,1389,1359,1330,1303,1276,1251,1226,1202,1180,1158,1137,1117,1097,1078,
  1060,1042,1025,1009,993,977,962,947,933,920,906,893,881,869,857,845,834,823,
  812,802,792,782,772,763,754,745,736,727,719,711,703,695,687,680,673,665,658,
  652,645,638,632,626,619,613,607,601,596,590,585,579,574,569,564,559,554,549,
  544,539,535,530,526,521,517,513,509,505,501,497,493,489,485,481,478,474,470,
  467,463,460,457,453,450,447,444,441,438,435,432,429,426,423,420,417,414,412,
  409,406,404,401,399,396,394,391,389,386,384,382,379,377,375,373,370,368,366,
  364,362,360,358,356,354,352,350,348,346,344,342,340,338,337,335,333,331,329,
  328,326,324,323,321,319,318,316,315,313,311,310,308,307,305,304,302,301,300,
  298,297,295,294,293,291,290,289,287,286,285,283,282,281,280,278,277,276,275,
  273,272,271,270,269,268,266,265,264,263,262,261,260,259,258,257,256,255,254,
  253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,
  235,234,233,232,231,230,229,229,228,227,226,225,225,224,223,222,221,221,220,
  219,218,218,217,216,215,215,214,213,212,212,211,210,210,209,208,207,207,206,
  205,205,204,203,203,202,201,201,200,200,199,198,198,197,196,196,195,195,194,
  193,193,192,192,191,190,190,189,189,188,188,187,187,186,185,185,184,184,183,
  183,182,182,181,181,180,180,179,179,178,178,177,177,176,176,175,175,174,174,
  173,173,172,172,171,171,170,170,169,169,169,168,168,167,167,166,166,165,165,
  165,164,164,163,163,162,162,162,161,161,160,160,160,159,159,158,158,158,157,
  157,156,156,156,155,155,154,154,154,153,153,153,152,152,151,151,151,150,150,
  150,149,149,149,148,148,148,147,147,147,146,146,146,145,145,145,144,144,144,
  143,143,143,142,142,142,141,141,141,140,140,140,139,139,139,138,138,138,138,
  137,137,137,136,136,136,135,135,135,135,134,134,134,133,133,133,133,132,132,
  132,132,131,131,131,130,130,130,130,129,129,129,129,128,128,128,128,127,127,
  127,127,126,126,126,126,125,125,125,125,124,124,124,124,123,123,123,123,122,
  122,122,122,121,121,121,121 };

/******************************************************************************/
void CapturePulseStart(unsigned int timerCLK)
{   
   P3SEL |= BIT2; 
   P3DIR &= ~BIT2; 
   CAPTURECTL  &= ~(MC0+MC1);               // 关闭定时器 
   CAPTURECCTL0 = COMPARE;
   CAPTURECCR0  = targetPulse; 
   
   CAPTURECTL = CONTINUOUS + DIV_1 + timerCLK + TIMER_CLR;  
}

/******************************************************************************/
void DisableCapturePulse(void)
{
   CAPTURECTL   = TIMER_CLR;  
   CAPTURECCTL0 = COMPARE;                  // start timer A 
   CAPTUREEX0   = 0;
   CAPTURECCR0  = 0;  

   DISABLE_CAPTURE_INTERRUPT; 
   P3SEL |= BIT2; 
   P3DIR &= ~BIT2; 
}

/******************************************************************************/
void CloseFloawRatePulse(void)
{
   P3SEL &= ~BIT1;	                   // 选择输出端口的第二功能
   P3DIR |=  BIT1;
   
   // HIGH Effective: IO=LOW,  PULSE OUT = HIGH;
   // LOW  Effective: IO=HIGH, PULSE OUT = LOW;
   if(PulseLevel == (unsigned int)LOW)  P3OUT |=  BIT1;  
   else                                 P3OUT &= ~BIT1;  
   
   PULSECTL   = TIMER_CLR;                 // 关闭定时器
   PULSECCR1  = 0;
   PULSECCR0  = 0;
   
   DISABLE_PULSE_INTERRUPT;
   DISABLE_CAPTURE_INTERRUPT;
   isPulseUpdaed = 1;
   
   CAPTURECTL   = TIMER_CLR;  
   CAPTURECCTL0 = COMPARE;                  // start timer A 
   CAPTUREEX0   = 0;
   CAPTURECCR0  = 0;  
   
   DMADisableInterrupt(2);
   DMADisableAndStop(2);
} 

/******************************************************************************/
void CompareLossCount(void)
{
   unsigned int countTemp;
   
   // stop pulse output capture timer
   //CAPTURECTL  &= ~(MC0+MC1);    
   //PULSECTL    &= ~(MC0+MC1);  
   
   alarmState  &= ~PULSE_ALARM;
   // compute lose pulse
   countTemp    = CAPTURETAR;
   targetPulse  = CAPTURECCR0;
   
   if(countTemp >= (targetPulse >> 1))
   {
      targetPulse -= countTemp;
      if(targetPulse > 50) targetPulse = 50;
   }
   else if(targetPulse == 0) isPulseUpdaed = 1;
   else
   { 
      targetPulse  = 0; 
      alarmState  |= PULSE_ALARM; 
      isPulseUpdaed = 1;
   }
}

/******************************************************************************/
void ReadyForCalibrationPulseOutput(void)
{
   //select timer clock   
   // for flowRate output pulse
   // set timer A0
   //(DCO clk(FREQ) = 2000000)  
   //2000000/16 = 125000

   CompareLossCount();  
   targetPulse += (signed int)totalPulse;
   
   if(targetPulse <= 0)
   {
      CloseFloawRatePulse();
      DisableCapturePulse();
      return;
   }
   //else if(targetPulse >= MAX_TIMER_PULSE) targetPulse = MAX_TIMER_PULSE;
   else if(targetPulse >= MaxPulseOutput[samplingInterval]) targetPulse = MaxPulseOutput[samplingInterval];
   
   if(PulseLevel == (unsigned int)LOW) CapturePulseStart(TIMER_TACLK);
   else                                CapturePulseStart(TIMER_INVTACLK);
   DISABLE_CAPTURE_INTERRUPT;   
   
   //---------------------------------------------------------------------------
   targetPulse *= (unsigned int)PulseGain[samplingInterval];
   targetPulse >>= 2;
   //---------------------------------------------------------------------------
   PulsePeriod[1] = PULSE_TABLE[targetPulse];
   PulsePeriod[2] = PulsePeriod[1] >> 1;
   //---------------------------------------------------------------------------
   PULSECCTL0 &= ~CCIFG;   
   if(isPulseUpdaed == 1)
   {  
      DMADisableInterrupt(2);
      DMAInit(2, DMA_TA2CCR0, BURST_BLOCK+DMASA_INC+DMADA_INC, (unsigned int)&PulsePeriod, (unsigned int)&PULSETAR, 3);
     
      // HIGH Effective: IO=LOW,  PULSE OUT = HIGH;
      // LOW  Effective: IO=HIGH, PULSE OUT = LOW;
      if(PulseLevel == (unsigned int)LOW) PULSECCTL1 = OUT_RESET_SET;
      else                                PULSECCTL1 = OUT_SET_RESET;
      
      P3SEL |= BIT1; 
      P3DIR |= BIT1; 
   
      PulsePeriod[0] = 0; 
      PULSECTL = 0;
      PULSECCR0 = PulsePeriod[1];
      PULSECCR1 = PulsePeriod[2];
      PULSEEX0  = TAIDEX_7;
      //PULSECTL  = UP_CCR0_0 + DIV_2 + TIMER_SMCLK;
      PULSECTL  = UP_CCR0 + DIV_4 + TIMER_SMCLK;
      isPulseUpdaed = 0;   
   }   
   DMA2CTL |= DMAREQ + DMAEN; 
}

//******************************************************************************
void ReadyForUserPulseOutput(void)
{
   //select timer clock   
   // for flowRate output pulse
   // stop pulse output capture timer
   // for 32768Hz

   targetPulse = totalPulse;
   if(targetPulse == 0)
   {
      CloseFloawRatePulse();
      return;
   }

   //---------------------------------------------------------------------------
   totalPulse *= (unsigned int)PulseGain[samplingInterval];
   totalPulse >>= 2;
   //---------------------------------------------------------------------------   
   if(totalPulse < 32) PULSECCR0 = UserLowPulsePeriod[totalPulse>>2];
   else
   {
      totalPulse >>= 5;
      if(totalPulse > 16) totalPulse = 16;     
      PULSECCR0 = UserHighPulsePeriod[totalPulse];
   }
   
   PULSECTL |= TIMER_CLR;  
   P3SEL |= BIT1; 
   P3DIR |= BIT1; 
   PULSECCR1  = PULSECCR0 >> 1; 
   
   // HIGH Effective: IO=LOW,  PULSE OUT = HIGH;
   // LOW  Effective: IO=HIGH, PULSE OUT = LOW;
   if(PulseLevel == (unsigned int)LOW)
   {
      PULSECCTL1 = OUT_RESET_SET;
      CapturePulseStart(TIMER_TACLK); 
   }
   else 
   {
      PULSECCTL1 = OUT_SET_RESET;
      CapturePulseStart(TIMER_INVTACLK); 
   }
   
   PulsePeriod[0] = (unsigned int)TIMER_CLR;   
   CAPTURECCTL0 &= ~CCIFG;   
   DMADisableInterrupt(2);
   DMAInit(2, DMA_TA1CCR0, SINGLE_TRAN+DMASA_UNCHANGED+DMADA_UNCHANGED, (unsigned int)&PulsePeriod, (unsigned int)&PULSECTL, 1);
   DMA2CTL  |= DMAREQ + DMAEN; 
   //DMAEnableInterrupt(2);
   
   PULSEEX0   = 0;
   PULSECTL   = UP_CCR0 + DIV_1 + TIMER_ACLK + TIMER_CLR; 
   isPulseUpdaed = 1;
         
//   ENABLE_CAPTURE_INTERRUPT;
//   PULSEEX0   = 0;
//   PULSECTL   = UP_CCR0 + DIV_1 + TIMER_ACLK + TIMER_CLR;  
//   
//   isPulseUpdaed = 1;
//   DMADisableAndStop(2); 
}

/******************************************************************************/
//#pragma vector = PULSE_PERIOD_VECTOR
//__interrupt void Pulse_isr(void)
//{
//   disable_interrupts();
//   CloseFloawRatePulse();   
//   DisableCapturePulse();
//   
//   enable_interrupts();
//}

/******************************************************************************/
//#pragma vector = DMA2_VECTOR
//__interrupt void ClosePulse_isr(void)
//{ 
//   intVector = DMAIV;
//   if(intVector != DMA2_VECTOR) return;
//   disable_interrupts();
//  
//   CloseFloawRatePulse();   
//   DisableCapturePulse();
//   DMAEnableInterrupt(2);
//   enable_interrupts();
//}

/******************************************************************************/
//#pragma vector = CAPTURETACCP0_VECTOR
//__interrupt void CloseCapture_isr(void)
//{ 
//   disable_interrupts();
//  
//   CloseFloawRatePulse();   
//   DisableCapturePulse();
//   
//   enable_interrupts();
//}

/******************************************************************************/
//set up flowRate PULSE OUTPUT 
void UpdateAccPulse(void)
{   
   if(isCalibMode) ReadyForCalibrationPulseOutput();
   else
   {
     pulseCounter += (unsigned long int)totalPulse;
     if(unitPerPulse < 51) ReadyForCalibrationPulseOutput();
     else                  ReadyForUserPulseOutput();
   }

   totalPulse = 0;
   targetPulse = 0;
}

/******************************************************************************/
void SetPulseUpdateTime(void)
{
   MAINTACCTL2  = COMPARE;
   MAINTACCR2   = UpdateTimeVaule[samplingInterval];
   MAINTACCTL2 &= ~CCIFG;
   MAINTACCTL2 |= CCIE;
}

/******************************************************************************/
void DisablePulseTimerInterrupt(void)
{
   MAINTACCTL2 = 0;
}

/******************************************************************************/
void PulseParameterInit(void)
{
   // for pulse output unit
   ReadMultiByteFromEEPROM(PULSE_UNIT, tempL.Byte, PULSE_UNIT_WIDTH, PARA_EEPROM);
   if(tempL.Byte[PULSE_UNIT_CRC] != CRC8(tempL.Byte, PULSE_UNIT_CRC)) factoryUnitPerPulse = PULSE_UNIT_DEFAULT;
   else    factoryUnitPerPulse = tempL.Word[0];
   
   // for pulse output cunter
   // ReadMultiByteFromEEPROM(PULSE_COUNTER, tempL.Byte, PULSE_COUNTER_WIDTH, PARA_EEPROM);
   // if(tempL.Byte[PULSE_COUNTER_CRC] != CRC8(tempL.Byte, PULSE_COUNTER_CRC)) pulseCounter = 0;
   // else                                                                     pulseCounter = tempL.Word[0];
   
   ReadMultiByteFromEEPROM(PULSE_LEVEL, tempL.Byte, PULSE_LEVEL_WIDTH, PARA_EEPROM);
   if(tempL.Byte[PULSE_LEVEL_CRC] != CRC8(tempL.Byte, PULSE_LEVEL_CRC)) PulseLevel = (unsigned int)HIGH;
   else                                                                 PulseLevel = (unsigned int)tempL.Byte[0];
   // HIGH Effective: IO=LOW,  PULSE OUT = HIGH;
   // LOW  Effective: IO=HIGH, PULSE OUT = LOW;
 
   DisableCapturePulse();
   CloseFloawRatePulse();
}