#include "includes.h"

// *** 每个通道总共采样多次，排序以后，去掉最小和最大的几个，取中间的几个值做平均
// ADC采样次数
#define ADC_SAMPLE_COUNT  (24)
// ADC平均值次数
#define ADC_AVGVAL_COUNT (16)

// 采样通道数
#define SAMPLE_CHANNEL_COUNT 12

// ADC采样补偿
#define ADC_COMPENSATE 0

// 通过界面请求采集的标志
volatile uint8_t Config_Sample_Request = 0;
// 电容采集失败的标志
volatile uint8_t Capa_Sample_failed = 0;
// 电容采集结束的标志
volatile uint8_t Capa_Sample_finish = 0;

// 得到采集数据的通知
volatile uint8_t GPRS_semSampled = 0;

void PWM0_IRQHandler(void)
{
	if(PWM_GetCaptureIntFlag(PWM0, 3) & PWM_RISING_LATCH_INT_FLAG) // 上升沿，脉冲开始
    {
		PWM_ClearPeriodIntFlag(PWM0, 3);
        PWM_ClearCaptureIntFlag(PWM0, 3, PWM_RISING_LATCH_INT_FLAG);
    }
    if(PWM_GetCaptureIntFlag(PWM0, 3) & PWM_FALLING_LATCH_INT_FLAG) // 下降沿，脉冲结束
    {
		PWM_DisablePeriodInt(PWM0, 3);	   // 停止超时计数
		PWM_ClearPeriodIntFlag(PWM0, 3);
		// 发送消息
		Capa_Sample_finish = 1;

        PWM_ClearCaptureIntFlag(PWM0, 3, PWM_FALLING_LATCH_INT_FLAG);
    }
	if(PWM_GetPeriodIntFlag(PWM0, 3))		    // 超时（短路）
	{
		Capa_Sample_failed = 1;			    // 测电容失败
		// 发送消息
		Capa_Sample_finish = 1;

		PWM_DisablePeriodInt(PWM0, 3);
		PWM_ClearPeriodIntFlag(PWM0, 3);
	}
}

void Sample_Init()
{
    /* ADC clock source is 12MHz, set divider to 6, ADC clock is 2 MHz */
    CLK_SetModuleClock(ADC_MODULE, CLK_CLKSEL1_ADC_S_HXT, CLK_ADC_CLK_DIVIDER(6));

    /*---------------------------------------------------------------------------------------------------------*/
    /* Init I/O Multi-function                                                                                 */
    /*---------------------------------------------------------------------------------------------------------*/
    /* Configure the PA6（BAT_VAL), PA5(P), PA4(DP), PA3-2(T_2), PA1-0(T_1) analog input pins.  */
    SYS->PA_L_MFP &= ~(SYS_PA_L_MFP_PA6_MFP_Msk | SYS_PA_L_MFP_PA5_MFP_Msk | SYS_PA_L_MFP_PA4_MFP_Msk);
    SYS->PA_L_MFP |= (SYS_PA_L_MFP_PA6_MFP_ADC_CH6 | SYS_PA_L_MFP_PA5_MFP_ADC_CH5 | SYS_PA_L_MFP_PA4_MFP_ADC_CH4);
	
    SYS->PA_L_MFP &= ~(SYS_PA_L_MFP_PA3_MFP_Msk | SYS_PA_L_MFP_PA2_MFP_Msk
		| SYS_PA_L_MFP_PA1_MFP_Msk | SYS_PA_L_MFP_PA0_MFP_Msk);
    SYS->PA_L_MFP |= (SYS_PA_L_MFP_PA3_MFP_ADC_CH3 | SYS_PA_L_MFP_PA2_MFP_ADC_CH2
		| SYS_PA_L_MFP_PA1_MFP_ADC_CH1 | SYS_PA_L_MFP_PA0_MFP_ADC_CH0);
	
    /* Disable the PA6~0 digital input path to avoid the leakage current. */
    GPIO_DISABLE_DIGITAL_PATH(PA, 0x007Ful);
	
	/* Enable ADC module clock */
    CLK_EnableModuleClock(ADC_MODULE);

//	// PA.15 as CAP_CAPTURE
//    SYS->PA_H_MFP &= ~SYS_PA_H_MFP_PA15_MFP_Msk;
//    SYS->PA_H_MFP |= SYS_PA_H_MFP_PA15_MFP_PWM0_CH3;

//	// PB.8 as CAP_TRIGGER
//    SYS->PB_H_MFP &= ~SYS_PB_H_MFP_PB8_MFP_Msk;
//    SYS->PB_H_MFP |= SYS_PB_H_MFP_PB8_MFP_GPB8;
//	GPIO_SetMode(PB, BIT8, GPIO_PMD_OUTPUT);
//	
//    /* PWM clock frequency can be set equal or double to HCLK by choosing case 1 or case 2 */
//    /* case 1.PWM clock frequency is set equal to HCLK: select PWM module clock source as PCLK */
//    /* case 2.PWM clock frequency is set double to HCLK: select PWM module clock source as PLL */
//    CLK_SetModuleClock(PWM0_CH23_MODULE, CLK_CLKSEL1_PWM0_CH23_S_HCLK, NULL);

//	/* Enable PWM module clock */
//    CLK_EnableModuleClock(PWM0_CH23_MODULE);

    //Enable Timer1 clock and select Timer1 clock source
    CLK_EnableModuleClock(TMR1_MODULE);
    CLK_SetModuleClock(TMR1_MODULE, CLK_CLKSEL1_TMR1_S_HXT, 0);
}

void Sample_Open()
{
	// 设置传感器状态
	dcBuff.sampleData.vacuum[0].staVacuum = VACUUM_STATUS_COMM_FAULT;
	dcBuff.sampleData.leak.staLeak = LEAK_STATUS_COMM_FAULT;

	/* Set the ADC internal sampling time, input mode as single-end and enable the A/D converter */
    ADC_Open(ADC, ADC_INPUT_MODE_SINGLE_END, ADC_OPERATION_MODE_SINGLE, 0);
    // Set reference voltage to VREF
    ADC_SET_REF_VOLTAGE(ADC, ADC_REFSEL_VREF);
	ADC->CALCTL &= ~0x0001;	// 关掉校准
	
//    /* Reset PWM0 module */
//    SYS_ResetModule(PWM0_RST);

//	/* set PWM0 channel 1 capture configuration：time unit is 166ns */
//	PWM_ConfigCaptureChannel(PWM0, 3, 166, 0);

//	/* Enable rising capture reload */
//	PWM0->CAPCTL &= ~PWM_CAPCTL_CAPRELOADFEN3_Msk;
//	PWM0->CAPCTL |= PWM_CAPCTL_CAPRELOADREN3_Msk;

//	/* Enable Timer for PWM0 channel 3 */
//	PWM_Start(PWM0, PWM_CH_3_MASK);

//	/* Enable Capture Function for PWM0 channel 3 */
//	PWM_EnableCapture(PWM0, PWM_CH_3_MASK);

//	NVIC_SetPriority (PWM0_IRQn, 1);
//    NVIC_EnableIRQ(PWM0_IRQn);

	// 采集任务，优先级较高
	NVIC_SetPriority (TMR1_IRQn, 2); 						  /* set Priority for Sample Interrupt */
	NVIC_EnableIRQ(TMR1_IRQn);
}

// ADC采集、计算
void Sample_Task(data_sample_t *sample)
{
	uint8_t ch;
	uint32_t oriData[ADC_SAMPLE_COUNT];	// 原始采集数据
	uint32_t sampleData[SAMPLE_CHANNEL_COUNT][1];
	int16_t i, j;
	
	Calculate_Theoretical_Params();
	if(dcBuff.configDisplay.op_USE_PT100_SENSOR)			
		PT100_Calculate_Theoretical_Params(-200, 80);	
	
	// 采集数据
	memset(sampleData, 0, sizeof(sampleData));
	Capa_Sample_failed = 0;			   // 默认测电容成功
	for(ch = 0; ch < SAMPLE_CHANNEL_COUNT; ch++)
	{
		// 无差压
		if(ch == 0)
			continue;
		// 扩展压力23
		if(ch >= 3 && ch <= 4)
			continue;
		// 无扩展温度3（差分）
		if(ch >= 9 && ch <= 10)
			continue;
		
		memset(oriData, 0, sizeof(oriData));
		
		// 每个通道采集多次
		for(i = 0; i < ADC_SAMPLE_COUNT; i++)
		{
			// 为了避免ADC模块的使用冲突，测量电压和传感器采样在一起执行
			// 因称重传感器未用，故将电池电压的adc值存放在称重传感器的位置
			if(ch == 1)
			{
				// 连接采样模块到压力通道
				ADC_SET_INPUT_CHANNEL(ADC, ADC_CH_5_MASK);

			}
			else if(ch == 2)
			{
				// 连接采样模块到第二路压力通道（占用差压口子）
				ADC_SET_INPUT_CHANNEL(ADC, ADC_CH_4_MASK);

			}
			else if(ch == 5)
			{
				// 连接采样模块到扩展温度1上通道
				ADC_SET_INPUT_CHANNEL(ADC, ADC_CH_0_MASK);
			}
			else if(ch == 6)
			{
				// 连接采样模块到扩展温度1下通道
				ADC_SET_INPUT_CHANNEL(ADC, ADC_CH_1_MASK);
			}
			else if(ch == 7)
			{
				// 连接采样模块到扩展温度2上通道
				ADC_SET_INPUT_CHANNEL(ADC, ADC_CH_2_MASK);
			}
			else if(ch == 8)
			{
				// 连接采样模块到扩展温度2下通道
				ADC_SET_INPUT_CHANNEL(ADC, ADC_CH_3_MASK);
			}
			else // ch == 11
			{
				// 连接采样模块到电池通道
				ADC_SET_INPUT_CHANNEL(ADC, ADC_CH_6_MASK);
			}
			
			// 清除ADIF0
			ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT);

			// 允许ADIE0
			ADC_EnableInt(ADC, ADC_ADF_INT);

			// 触发采样模块,开始采样
			ADC_START_CONV(ADC);
			
			while(!(ADC_GET_INT_FLAG(ADC, ADC_ADF_INT) & ADC_ADF_INT))
				__NOP();
			ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT);
			
			if(ch == 1)
				oriData[i] = ADC_GET_CONVERSION_DATA(ADC, 5);
			else if(ch == 2)
				oriData[i] = ADC_GET_CONVERSION_DATA(ADC, 4);
			else if(ch == 5)
				oriData[i] = ADC_GET_CONVERSION_DATA(ADC, 0);
			else if(ch == 6)
				oriData[i] = ADC_GET_CONVERSION_DATA(ADC, 1);
			else if(ch == 7)
				oriData[i] = ADC_GET_CONVERSION_DATA(ADC, 2);
			else if(ch == 8)
				oriData[i] = ADC_GET_CONVERSION_DATA(ADC, 3);
			else // ch == 11
				oriData[i] = ADC_GET_CONVERSION_DATA(ADC, 6);

			if(oriData[i] + ADC_COMPENSATE > 4095)
				oriData[i] = 4095;
			else
				oriData[i] += ADC_COMPENSATE;
			// 禁止ADIE0
			ADC_DisableInt(ADC, ADC_ADF_INT);
		}
		
		// 排序
		sort(oriData, ADC_SAMPLE_COUNT);	
		
//		if(ch == 1)
//		{
//			printf("\n");
//			for(i = 0; i < ADC_SAMPLE_COUNT; i++)
//			{
//				printf("oriData[%d]: %d\n", i, oriData[i]);
//			}
//			printf("\n");
//		}

		// 去掉最小最大值，求和
		for(i = 0, j = (ADC_SAMPLE_COUNT - ADC_AVGVAL_COUNT) / 2; i < ADC_AVGVAL_COUNT; i++, j++)
		{
			if(oriData[j] != -1)
				sampleData[ch][0] += oriData[j];
			else
				sampleData[ch][0] = -1;
		}
		
		// 求平均值
		if(sampleData[ch][0] != -1)
			sampleData[ch][0] /= ADC_AVGVAL_COUNT;
	}
	
	ADC_POWER_DOWN(ADC);
	
	printf("\n");
	for(i = 0; i < SAMPLE_CHANNEL_COUNT; i++)
	{
		if(i == 0)
			continue;
		if(i >= 3 && i <= 4)
			continue;
		if(i >= 9 && i <= 10)
			continue;
		printf("sampleData[%d][0] = %d\n", i, sampleData[i][0]);
	}
	
	// 计算结果
			
	// 液位（不支持）
#if 0
//	sampleData[0][0] = dcBuff.configSensor.sensorDPress.zeroValue
//			+ (dcBuff.configSensor.sensorDPress.fullValue - dcBuff.configSensor.sensorDPress.zeroValue) / (1 + rand() % 10);
	sample->adDPress = sampleData[0][0];
	sample->staDPress.status = ADC_Validate(sampleData[0][0], 
				dcBuff.configSensor.sensorDPress.zeroValue, dcBuff.configSensor.sensorDPress.fullValue);
	if(sample->staDPress.status == SENSOR_STATUS_NORMAL)
	{
		sample->diff = ADC_Calculate(sampleData[0][0], 
				dcBuff.configSensor.sensorDPress.zeroValue, dcBuff.configSensor.sensorDPress.fullValue,
				dcBuff.configSensor.sensorDPress.lowRange, dcBuff.configSensor.sensorDPress.highRange);
	}
#endif
	
	// 压力
//	sampleData[1][0] = dcBuff.configSensor.sensorPress.zeroValue 
//			+ (dcBuff.configSensor.sensorPress.fullValue - dcBuff.configSensor.sensorPress.zeroValue) / (1 + rand() % 10);
	sample->adPress = sampleData[1][0];		
	sample->staPress.status = ADC_Validate(sampleData[1][0], 
				dcBuff.configSensor.sensorPress.zeroValue, dcBuff.configSensor.sensorPress.fullValue);		
	if(sample->staPress.status == SENSOR_STATUS_NORMAL)
	{
		sample->pressure = ADC_Calculate(sampleData[1][0], 
				dcBuff.configSensor.sensorPress.zeroValue, dcBuff.configSensor.sensorPress.fullValue,
				dcBuff.configSensor.sensorPress.lowRange, dcBuff.configSensor.sensorPress.highRange);
	}
	
	// 扩展压力1
	for(i = 0; i < 1; i++)
	{
//		sampleData[2 + i][0] = dcBuff.configSensor.sensorEPress[i].zeroValue 
//			+ (dcBuff.configSensor.sensorEPress[i].fullValue - dcBuff.configSensor.sensorEPress[i].zeroValue) / (1 + rand() % 10);
		sample->adExtPress[i] = sampleData[2 + i][0];	
		sample->staExtPress[i].status = ADC_Validate(sampleData[2 + i][0], 
					dcBuff.configSensor.sensorEPress[i].zeroValue, dcBuff.configSensor.sensorEPress[i].fullValue);
		if(sample->staExtPress[i].status == SENSOR_STATUS_NORMAL)
		{
			sample->extPressure[i] = ADC_Calculate(sampleData[2 + i][0], 
					dcBuff.configSensor.sensorEPress[i].zeroValue, dcBuff.configSensor.sensorEPress[i].fullValue,
					dcBuff.configSensor.sensorEPress[i].lowRange, dcBuff.configSensor.sensorEPress[i].highRange);
		}
	}

	if(dcBuff.configDisplay.op_DIFF_RESIST)
	{		
		// 扩展温度（2路）
		for(i = 0; i < 2; i++)
		{
			sample->adExtTempr[i] = PT100_CalResit(sampleData[5 + i * 2][0], sampleData[5 + i * 2 + 1][0]);
			sample->staExtTempr[i].status = ADC_Validate(sample->adExtTempr[i], 
					PT100_Resis[0] * dcBuff.configDisplay.op_PT100_MULTI, PT100_Resis[sizeof(PT100_Resis) / sizeof(float) - 1] * dcBuff.configDisplay.op_PT100_MULTI);
			if(sample->staExtTempr[i].status == SENSOR_STATUS_NORMAL)
			{
				sample->extTempr[i] = PT100_CalTempr(sampleData[5 + i * 2][0], sampleData[5 + i * 2 + 1][0],
					dcBuff.configSensor.sensorPTempr[i].calibrateT, dcBuff.configSensor.sensorPTempr[i].calibrateR);
			}
		}
	}
	else
	{
		// 扩展温度（2路）
		for(i = 0; i < 2; i++)
		{
	//		sampleData[5 + i * 2][0] = dcBuff.configSensor.sensorMTempr[i].zeroValue 
	//			+ (dcBuff.configSensor.sensorMTempr[i].fullValue - dcBuff.configSensor.sensorMTempr[i].zeroValue) / (1 + rand() % 10);
			sample->adExtTempr[i] = sampleData[5 + i * 2][0];
			sample->staExtTempr[i].status = ADC_Validate(sampleData[5 + i * 2][0], 
					dcBuff.configSensor.sensorMTempr[i].zeroValue, dcBuff.configSensor.sensorMTempr[i].fullValue);

			if(sample->staExtTempr[i].status == SENSOR_STATUS_NORMAL)
			{
				if(!dcBuff.configDisplay.op_USE_PT100_SENSOR)					
					sample->extTempr[i] = ADC_Calculate(sampleData[5 + i * 2][0], 
							dcBuff.configSensor.sensorMTempr[i].zeroValue, dcBuff.configSensor.sensorMTempr[i].fullValue,
							dcBuff.configSensor.sensorMTempr[i].lowRange, dcBuff.configSensor.sensorMTempr[i].highRange);
				else
					sample->extTempr[i] = PT100_CalTempr(sampleData[5 + i * 2][0], 0,
							dcBuff.configSensor.sensorPTempr[i].calibrateT, dcBuff.configSensor.sensorPTempr[i].calibrateR);
			}
		}
	}

	// 为了避免ADC模块的使用冲突，测量电压和传感器采样在一起执行
	// 因称重传感器未用，故将电池电压的adc值存放在称重传感器的位置
	sample->adWeight = sampleData[SAMPLE_CHANNEL_COUNT - 1][0];
			
	// 总容积
	sample->volumeTotal = Theoretical_Param.v;
	
	// 计算标方容积，不考虑压缩因子
	if(sample->staPress.status == SENSOR_STATUS_NORMAL && sample->staExtTempr[0].status == SENSOR_STATUS_NORMAL)
		sample->volume = Theoretical_Param.v * (sample->pressure / 101.325) * (273.15 / (sample->extTempr[0] + 273.15));
	else
		sample->volume = 0;
}

void Sample_CheckWarning(data_sample_t *sample)
{
	static uint16_t	last_Press = 0;
	static int16_t	last_Tempr = -300;
	static uint16_t last_Vacuum = 0;
	
	// 判断是否压力报警
	if(sample->staPress.status == SENSOR_STATUS_NORMAL)
	{
		if(dcBuff.configBottle.warnPress > 0 && last_Press > dcBuff.configBottle.warnPress && sample->pressure <= dcBuff.configBottle.warnPress)
			sample->warnning = 1;
		if(dcBuff.configBottle.warnPressH > 0 && last_Press < dcBuff.configBottle.warnPressH && sample->pressure >= dcBuff.configBottle.warnPressH)
			sample->warnning = 1;

		if(sample->warnning)
			printf("\n*** Pressure warnning ***\n");
		
		// 记录采集值
		last_Press = sample->pressure;
	}
	
	// 判断是否温度报警
	if(dcBuff.configBottle.serverVer != 3 && !dcBuff.configDisplay.op_LEVEL_SENSOR_ONLY)
	{
		if(sample->staExtTempr[0].status == SENSOR_STATUS_NORMAL)
		{
			if(dcBuff.configBottle.warnTempr > -300 && last_Tempr > dcBuff.configBottle.warnTempr && sample->extTempr[0] <= dcBuff.configBottle.warnTempr)
				sample->warnning = 1;
			if(dcBuff.configBottle.warnTemprH > -300 && last_Tempr < dcBuff.configBottle.warnTemprH && sample->extTempr[0] >= dcBuff.configBottle.warnTemprH)
				sample->warnning = 1;
			
			// 记录采集值
			last_Tempr = sample->extTempr[0];
		}
	}

	// 判断是否真空度报警
	if(dcBuff.configBottle.serverVer != 3 && sample->vacuum[0].staVacuum == VACUUM_STATUS_OK)
	{
		if(dcBuff.configBottle.warnVacuumH > 0 && last_Vacuum < dcBuff.configBottle.warnVacuumH * 0.01 && sample->vacuum[0].vacuum >= dcBuff.configBottle.warnVacuumH * 0.01)
			sample->warnning = 1;
		
		// 记录采集值
		last_Vacuum = sample->vacuum[0].vacuum;
	}
}

void Sample_Print(data_sample_t *sample)
{	
	int16_t i, j;
	
	/* Get the conversion result */
//	printf("\nConversion result of diff: \t\t%02X, %.1f kPa", sample->staDPress.status, sample->diff);
//	printf("\nConversion result of press: \t\t%02X, %.2f MPa", sample->staPress.status, (float) sample->pressure / 1000);
	for(i = 0; i < 0; i++)
		printf("\nConversion result of extPress[%d]: \t%02X, %.2f MPa", i, sample->staExtPress[i].status, (float) sample->extPressure[i] / 1000);
//	for(i = 0; i < 2; i++)
//		printf("\nConversion result of extTempr[%d]: \t%02X, %d ℃", i, sample->staExtTempr[i].status, sample->extTempr[i]);
			
//	printf("\nConversion result of height: \t\t%.0f mm", sample->height);
//	printf("\nConversion result of volTol: \t\t%u L", sample->volumeTotal);
//	printf("\nConversion result of volume: \t\t%u L", sample->volume);
//	printf("\nConversion result of volPct: \t\t%.2f %%", (float) sample->volumePct / 100);
//	printf("\nConversion result of charging: \t\t%d", sample->charging);
//	
//	printf("\nConversion result of staVacuum: \t%u", sample->vacuum[0].staVacuum);
//	printf("\nConversion result of lifeVacuum: \t%u Months", sample->vacuum[0].lifeVacuum);
//	printf("\nConversion result of vacuum: \t\t%.2f Pa", sample->vacuum[0].vacuum);
//	printf("\nConversion result of rateVacuum: \t%.2f Pa.M3/s", sample->vacuum[0].rateVacuum);
//	printf("\nConversion result of typeLeak: \t\t%u", sample->leak.typeLeak);
//	printf("\nConversion result of staLeak: \t\t%u", sample->leak.staLeak);
//	printf("\nConversion result of concentrations: \t%u %%", sample->leak.concentrations);
	printf("\n");
}

// 以毫秒为单位设置定时器时间
// 预分频比为8，CMP为24位
// 按12M主频计算，最大可延时11秒
void TIMER_MyOpen(TIMER_T *timer, uint32_t u32Mode, uint32_t u32Ms)
{
    uint32_t u32Clk = TIMER_GetModuleClock(timer);
    uint32_t u32Cmpr = 0, u32Prescale = 0;

	// 先对定时器软件复位
	timer->CTL = 2;

	u32Prescale = 7;    // real prescaler value is 
	u32Clk >>= 3;

	u32Cmpr = u32Clk / 1000 * u32Ms;

    timer->CMPR = u32Cmpr;
    timer->PRECNT = u32Prescale;
    timer->CTL = u32Mode;
}

void Sample_StartTimer(TIMER_T *timer, uint16_t ms)
{
	// 设置定时器的周期
	TIMER_MyOpen(timer, TIMER_ONESHOT_MODE, ms);
	// 启动定时器
	TIMER_EnableInt(timer);
	TIMER_Start(timer);
}

// 当前采集阶段
volatile uint8_t Sample_phase = 0;

// 采集是否忙
uint32_t Sample_Busy()
{
	return (Sample_phase != 0);
}

void TMR1_IRQHandler(void)
{
	static data_sample_t sample;
	static data_dtu_t dtuSample;
	static uint8_t lastLeakWarning = 0;
	
	// 每隔8小时测一次真空（上电第一次不测）
	static uint32_t vacuum_seconds = 30;
	uint32_t sample_time;
    S_RTC_TIME_DATA_T sRTC;
	
	// 清除中断，复位定时器
	TIMER_Close(TIMER1);
    NVIC_ClearPendingIRQ(TMR1_IRQn);
	TIMER_ClearIntFlag(TIMER1);
	
	if(Sample_phase == 0)
	{
		// 下一阶段：采集数据（为避免重复进入采集任务，尽快设置下一阶段）
		Sample_phase = 1;

		// 初始化准备
		memset(&sample, 0, sizeof(data_sample_t));	
		
		// Modbus传感器默认为沿用原来的数据
		sample.vacuum[0] = dcBuff.sampleData.vacuum[0];
		sample.leak = dcBuff.sampleData.leak;
		sample.flow = dcBuff.sampleData.flow;
		
		// TODO: 打开电源
		ADC_POWER_ON(ADC);
		VCC_SENSOR_5V_ON();
	
		// 延时600ms以后进入采集阶段
		Sample_StartTimer(TIMER1, 600);
	}
	else if(Sample_phase == 1)
	{
		// TODO: 采集数据
		Sample_Task(&sample);

		// Modbus采集真空计
		Sample_phase = 2;

		// 直接触发下一阶段
		NVIC_SetPendingIRQ(TMR1_IRQn);
	}
	else if(Sample_phase == 2)
	{
		// 获取当前时间
		RTC_GetDateAndTime(&sRTC);
		// 计算自上次gps定位以来的时间
		sample_time = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
				sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
		
		// 是否到采集时间（3秒误差）
		if(sample_time + 3 < vacuum_seconds)
		{
			// 下一阶段：采集泄露计
			Sample_phase = 5;
			// 直接触发下一阶段
			NVIC_SetPendingIRQ(TMR1_IRQn);
		}
		else
		{
			// 下次上传时再采
			vacuum_seconds = sample_time + dcBuff.configData.intervalTrans;			
			// 下一阶段：采集真空计，需要额外延时
			Sample_phase = 3;			
			// 等待8s以后进入下一阶段
			Sample_StartTimer(TIMER1, 10000);
		}
	}
	else if(Sample_phase == 3)
	{
		// 下一阶段：采集真空计，需要额外延时
		Sample_phase = 4;			
		// 采集真空计需要上电5秒
		Sample_StartTimer(TIMER1, 5000);
	}
	else if(Sample_phase == 4)
	{
		printf("\n*** Read vacuum ***\n");
		// TODO: Modbus采集真空计1
		Sensor_ReadVacuum(0, &sample);
		// 下一阶段：采集泄露计
		Sample_phase = 5;
		// 最多等待500ms以后进入下一阶段
		Sample_StartTimer(TIMER1, 500);
	}
	else if(Sample_phase == 5)
	{
		// 下一阶段：打印信息
		Sample_phase = 6;
		
		if(!VCC_POWER_STATUS())
		{
			// 无外接电源，直接触发下一阶段
			NVIC_SetPendingIRQ(TMR1_IRQn);
		}
		else
		{
			// 有外接电源，Modbus采集泄露计
			Sensor_ReadLeak(&sample);
			// 最多等待500ms以后进入下一阶段
			Sample_StartTimer(TIMER1, 500);
		}
	}
	else
	{
		VCC_SENSOR_5V_OFF();

		// TODO: 打印信息
		Sample_Print(&sample);

		// 检查充装、报警等
		Sample_CheckWarning(&sample);

		// 如果没有扩展温度，且有真空计温度，用真空计温度代替扩展温度（显示和上传）
		if(sample.staExtTempr[0].status == SENSOR_STATUS_NOCONNECT)
		{
			if(sample.vacuum[0].staVacuum != VACUUM_STATUS_COMM_FAULT && sample.vacuum[0].staVacuum != VACUUM_STATUS_FAULT)
			{
				sample.extTempr[0] = sample.vacuum[0].tempr;
				sample.staExtTempr[0].status = SENSOR_STATUS_NORMAL;
			}
		}
				
		// 写入全局缓冲（保持报警标志，直到发送任务处理）
		if(dcBuff.sampleData.warnning)
			sample.warnning = 1;
		dcBuff.sampleData = sample;

		// 检测电量
		if(DS2788_ReadBattery(&dtuSample))
		{
			// 写入全局缓冲
			dcBuff.dtuData.batLow = dtuSample.batLow;
			dcBuff.dtuData.batCurrent = dtuSample.batCurrent;
			dcBuff.dtuData.batPct = dtuSample.batPct;
			dcBuff.dtuData.batCapa = dtuSample.batCapa;
			dcBuff.dtuData.batMaxCapa = dtuSample.batMaxCapa;
			dcBuff.dtuData.batTempr = dtuSample.batTempr;
			dcBuff.dtuData.batVoltage = dtuSample.batVoltage;			
		}
		
		// 首次检测到泄露或停止泄露，立即发送数据
		if((dcBuff.sampleData.leak.staLeak == LEAK_STATUS_A2_ALARM) != lastLeakWarning)
		{
			printf("\n*** Leak warnning: %d ***\n", (dcBuff.sampleData.leak.staLeak == LEAK_STATUS_A2_ALARM));
			dcBuff.sampleData.warnning = 1;
			DTU_semGPRS = 1;
		}
		lastLeakWarning = (dcBuff.sampleData.leak.staLeak == LEAK_STATUS_A2_ALARM);

		// 通知发送任务采集完成
		GPRS_semSampled = 1;
		// 通知显示板采集完成
		Config_Sample_Request = 0;
		// 通知显示屏: 刷新
		Form_Refresh();
		
		// 采集结束
		Sample_phase = 0;
	}
}