Files
CHJ/user/Interface/Pulse - 副本.c

349 lines
13 KiB
C
Raw Normal View History

2026-03-20 21:16:58 +08:00
#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); // <20>رն<D8B1>ʱ<EFBFBD><CAB1>
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; // ѡ<><D1A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˿ڵĵڶ<C4B5><DAB6><EFBFBD><EFBFBD><EFBFBD>
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; // <20>رն<D8B1>ʱ<EFBFBD><CAB1>
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();
}