#include "includes.h"

// 采集次数
#define SAMPLE_COUNT	(20)

// 通过界面请求采集的标志
volatile uint8_t Config_Sample_Request = 0;
volatile uint8_t Config_Vacuum_Request = 0;
// 得到采集数据的通知
volatile uint8_t GPRS_semSampled = 0;

// 通知采集的信号量
SemaphoreHandle_t Sample_Semaphore = NULL;    // 二值信号量句柄
// 通知充装匹配的信号量
SemaphoreHandle_t Match_Semaphore = NULL;    // 二值信号量句柄

uint16_t adDPress_tmp[5]= {0};
uint8_t adDPress_cnt=0;
// 当前采集阶段
volatile uint8_t Sample_phase = 0;
// 采集是否忙
uint32_t Sample_Busy()
{
    return (Sample_phase != 0);
}

// 通知采集
void Sample_Notify()
{
    if(!Sample_Busy())
    {
        // 发送消息给任务
        xSemaphoreGive(Sample_Semaphore);
    }
}

// 通知采集
void Sample_NotifyFromISR()
{
    BaseType_t xHigherPriorityTaskWoken;

    if(!Sample_Busy())
    {
        // 发送消息给任务
        xSemaphoreGiveFromISR(Sample_Semaphore, &xHigherPriorityTaskWoken);
    }
}

// 处理泄露报警唤醒
void Leak_Handler(void)
{
//	if(Wakeup_Sleeping)
//	{
//		SysTick->CTRL |= (SysTick_CTRL_ENABLE_Msk | SysTick_CTRL_TICKINT_Msk);
//		delay_ms(10);
//
//		Vcc_Enable();
//		delay_ms(40);
//		Wakeup_Sleeping = 0;

//		printf("\n\nWake up by LEAK.\n\n");
//	}

//	// 采集数据
//	Sample_NotifyFromISR();
}

// 采集一个通道：总共采集20次，取中间10次的平均值
uint32_t Sample_ChannelOne(uint32_t channel)
{
    uint32_t i;
    uint32_t adc[SAMPLE_COUNT];

    LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_1, channel);
    for(i = 0; i < SAMPLE_COUNT; i++)
    {
        LL_ADC_REG_StartConversion(ADC1);
        while(LL_ADC_REG_IsConversionOngoing(ADC1));
        adc[i] = LL_ADC_REG_ReadConversionData12(ADC1);
    }

    sort(adc, SAMPLE_COUNT);
    adc[0] = 0;
    for(i = 0; i < (SAMPLE_COUNT / 2); i++)
        adc[0] += adc[SAMPLE_COUNT / 4 + i];

    i = adc[0] / (SAMPLE_COUNT / 2);
    printf("\nchannel %d adc: %d, volt: %dmV\n", channel, i, i * 3000 / 4095);
    return i;
}

void Sample_Init()
{
    LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
// LL_EXTI_InitTypeDef EXTI_InitStruct = {0};

    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA);
    /**ADC1 GPIO Configuration
    PA0   ------> ADC1_IN5（AD5）
    PA1   ------> ADC1_IN6 (AD6)
    PA5   ------> ADC1_IN10 (AD10)
    PA6   ------> ADC1_IN11 (AD11)
    PA7   ------> ADC1_IN12 (AD12)
    */
//  PA0   ------> ADC1_IN5（AD5）
//  PA1   ------> ADC1_IN6 (AD6)
//  PA2   ------> ADC1_IN7 (AD7)
//  PA3   ------> ADC1_IN8 (AD8)
    GPIO_InitStruct.Pin = LL_GPIO_PIN_0|LL_GPIO_PIN_1
                          |LL_GPIO_PIN_2|LL_GPIO_PIN_3;
    GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

//  LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOB);
//  /**ADC1 GPIO Configuration
//  PB0   ------> ADC1_IN15（AD_BAT)
//  */
//  GPIO_InitStruct.Pin = LL_GPIO_PIN_0;
//  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
//  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
//  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);
//
//  LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOC);
//  /**ADC1 GPIO Configuration
//  PC0   ------> ADC1_IN1（AD1)
//  PC1   ------> ADC1_IN2（AD2)
//  PC2   ------> ADC1_IN3（AD3)
//  PC3   ------> ADC1_IN4（AD4)
//  */
//  GPIO_InitStruct.Pin = LL_GPIO_PIN_0|LL_GPIO_PIN_1|LL_GPIO_PIN_2|LL_GPIO_PIN_3;
//  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
//  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
//  LL_GPIO_Init(GPIOC, &GPIO_InitStruct);

//  // 泄露报警引脚
//  LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOE);

//  /**/
//  LL_SYSCFG_SetEXTISource(LL_SYSCFG_EXTI_PORTE, LL_SYSCFG_EXTI_LINE8);

    // 创建信号量
    if(Sample_Semaphore == NULL)
        Sample_Semaphore = xSemaphoreCreateBinary();
    if(Match_Semaphore == NULL)
        Match_Semaphore = xSemaphoreCreateBinary();

//  /**/
//  EXTI_InitStruct.Line_0_31 = LL_EXTI_LINE_8;
//  EXTI_InitStruct.Line_32_63 = LL_EXTI_LINE_NONE;
//  EXTI_InitStruct.LineCommand = ENABLE;
//  EXTI_InitStruct.Mode = LL_EXTI_MODE_IT;
//  EXTI_InitStruct.Trigger = LL_EXTI_TRIGGER_RISING_FALLING;
//  LL_EXTI_Init(&EXTI_InitStruct);

//  /**/
//  LL_GPIO_SetPinPull(GPIOE, LL_GPIO_PIN_8, LL_GPIO_PULL_DOWN);

//  /**/
//  LL_GPIO_SetPinMode(GPIOE, LL_GPIO_PIN_8, LL_GPIO_MODE_INPUT);
}

void Sample_Open()
{
    uint32_t vrefint_cal = *((volatile uint16_t *)(0x1fff75aa));

    LL_ADC_InitTypeDef ADC_InitStruct = {0};
    LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
    LL_ADC_CommonInitTypeDef ADC_CommonInitStruct = {0};

//	// 设置传感器状态
//	dcBuff.sampleData.vacuum[0].staVacuum = VACUUM_STATUS_COMM_FAULT;
//	dcBuff.sampleData.leak.staLeak = LEAK_STATUS_COMM_FAULT;
//
//  NVIC_SetPriority(EXTI9_5_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),5, 0));
//  NVIC_EnableIRQ(EXTI9_5_IRQn);

    /* Peripheral clock enable */
    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_ADC);

    /** Common config
    */
    ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B;
    ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;
    ADC_InitStruct.LowPowerMode = LL_ADC_LP_AUTOWAIT;
    LL_ADC_Init(ADC1, &ADC_InitStruct);
    ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;
    ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_DISABLE;
    ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;
    ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;
    ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_NONE;
    ADC_REG_InitStruct.Overrun = LL_ADC_REG_OVR_DATA_PRESERVED;
    LL_ADC_REG_Init(ADC1, &ADC_REG_InitStruct);
    LL_ADC_ConfigOverSamplingRatioShift(ADC1, LL_ADC_OVS_RATIO_16, LL_ADC_OVS_SHIFT_RIGHT_4);
    LL_ADC_SetOverSamplingDiscont(ADC1, LL_ADC_OVS_REG_CONT);
    LL_ADC_DisableIT_EOC(ADC1);
    LL_ADC_DisableIT_EOS(ADC1);
    LL_ADC_DisableDeepPowerDown(ADC1);
    LL_ADC_EnableInternalRegulator(ADC1);
    ADC_CommonInitStruct.CommonClock = LL_ADC_CLOCK_SYNC_PCLK_DIV4;
    LL_ADC_CommonInit(__LL_ADC_COMMON_INSTANCE(ADC1), &ADC_CommonInitStruct);
    /** Configure Regular Channel
    */
//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_1, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_1, LL_ADC_SINGLE_ENDED);
//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_2, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_2, LL_ADC_SINGLE_ENDED);
//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_3, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_3, LL_ADC_SINGLE_ENDED);
//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_4, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_4, LL_ADC_SINGLE_ENDED);

    LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_5, LL_ADC_SAMPLINGTIME_24CYCLES_5);
    LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_5, LL_ADC_SINGLE_ENDED);
    LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_6, LL_ADC_SAMPLINGTIME_24CYCLES_5);
    LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_6, LL_ADC_SINGLE_ENDED);
    LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_7, LL_ADC_SAMPLINGTIME_24CYCLES_5);
    LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_7, LL_ADC_SINGLE_ENDED);
    LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_8, LL_ADC_SAMPLINGTIME_24CYCLES_5);
    LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_8, LL_ADC_SINGLE_ENDED);

//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_10, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_10, LL_ADC_SINGLE_ENDED);
//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_11, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_11, LL_ADC_SINGLE_ENDED);
//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_12, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_12, LL_ADC_SINGLE_ENDED);
//  LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_15, LL_ADC_SAMPLINGTIME_24CYCLES_5);
//  LL_ADC_SetChannelSingleDiff(ADC1, LL_ADC_CHANNEL_15, LL_ADC_SINGLE_ENDED);

    Sample_ReOpen();
}

// 休眠唤醒以后需重新执行该函数
void Sample_ReOpen()
{
    // ADC硬件校验
    VCC_SENSOR_5V_ON();
    delay_ms(50);
    LL_ADC_StartCalibration(ADC1, LL_ADC_SINGLE_ENDED);
    while(LL_ADC_IsCalibrationOnGoing(ADC1));
    VCC_SENSOR_5V_OFF();
}

void Sample_Task(void *p_arg)
{
    uint16_t adc1, adc2;
    data_dtu_t dtuSample;
    data_sample_t sample;
    uint32_t sample_time;
    // 每隔8小时测一次真空（上电第一次不测）
    uint32_t vacuum_seconds = 30, vaccuumTick = 0;
    uint8_t lastLeakWarning = 0;

    int16_t i;
    uint32_t u32Sample;
    static uint8_t charging = 0;			 // 记录充装状态
    static uint32_t lowest_Sample = 0xFFFFFFFFul; // 记录液位最低点：初值为最大（用于判断充装开始）
    static uint32_t highest_Sample = 0; 		// 记录液位最高点：初值为最小（用于判断充装结束）
    static uint8_t stopGrowCount = 0;	  		// 记录液位停止增长的次数
    static uint32_t last_SampleTime = 0; // 记录充装判别的时间（间隔时间不能过短）
    uint32_t totalSeconds;
    static uint32_t last_volumePct = 0;		 // 记录上次的液位
    static uint16_t	last_Press = 0;
    static int16_t	last_Tempr = -300;
    static uint16_t last_Vacuum = 0;
    S_RTC_TIME_DATA_T sRTC;

    // TTS协议
    static uint32_t last_spanPct[20] = {0};		// 记录上次变化量的百分比基数
    static uint32_t last_spanTime[20] = {0};	// 记录上次变化量的时间基数
    static uint8_t last_spanCount = 0;			// 记录条数
    uint32_t span;

    static uint8_t first = 1;

    // 和远气体：紧急切断阀门的输出: 电磁阀默认打开
    if(dcBuff.powerInfo.hardVer.major == 231)
        KZ_VALUE_ENABLE();

    while(1)
    {
        // 等待采集信号
        xSemaphoreTake(Sample_Semaphore, portMAX_DELAY);

        if(!IS_VCC_SENSOR_5V_ON())
        {
            VCC_SENSOR_5V_ON();
            // 延时1s以后进入采集阶段
            osDelay(1500);
        }
        // 下一阶段：采集传感器数据
        Sample_phase = 1;

        // 获取当前时间
        RTC_GetDateAndTime(&sRTC);
        // 计算自上次gps定位以来的时间
        sample_time = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
                                           sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);

        // 初始化缓冲区
        memset(&sample, 0, sizeof(sample));
        memset(&dtuSample, 0, sizeof(dtuSample));

        // 设置传感器状态
        sample.staExtPress[0].status = SENSOR_STATUS_NOCONNECT;
        sample.staExtPress[1].status = SENSOR_STATUS_NOCONNECT;
        sample.staExtPress[2].status = SENSOR_STATUS_NOCONNECT;
        sample.staExtTempr[0].status = SENSOR_STATUS_NOCONNECT;
        sample.staExtTempr[1].status = SENSOR_STATUS_NOCONNECT;
        sample.staExtTempr[2].status = SENSOR_STATUS_NOCONNECT;
        // Modbus传感器默认为沿用原来的数据
        sample.vacuum[0] = dcBuff.sampleData.vacuum[0];
        sample.leak = dcBuff.sampleData.leak;
        sample.flow = dcBuff.sampleData.flow;

        // 计算理论值
        Calculate_Theoretical_Params();

        // 用于采集真空计的延时
        vaccuumTick = GetDelayTick(15000);


        // 允许ADC
        LL_ADC_Enable(ADC1);
        while(!LL_ADC_IsActiveFlag_ADRDY(ADC1));
        osDelay(10);

        // 采集差压通道

        sample.adDPress = Sample_ChannelOne(LL_ADC_CHANNEL_5);

        sample.adPress = Sample_ChannelOne(LL_ADC_CHANNEL_6);

        sample.adWeight = Sample_ChannelOne(LL_ADC_CHANNEL_7);

        VCC_SENSOR_5V_OFF();
        // 读取电池电压
        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.configDisplay.op_USE_CAPACITY_SENSOR)
        {
            // 差压值
            sample.staDPress.status = ADC_Validate(sample.adDPress,
                                                   dcBuff.configSensor.sensorDPress.zeroValue, dcBuff.configSensor.sensorDPress.fullValue);
            if(sample.staDPress.status == SENSOR_STATUS_NORMAL)
            {
                sample.diff = ADC_Calculate(sample.adDPress,
                                            dcBuff.configSensor.sensorDPress.zeroValue, dcBuff.configSensor.sensorDPress.fullValue,
                                            dcBuff.configSensor.sensorDPress.lowRange, dcBuff.configSensor.sensorDPress.highRange);
            }
        }




        sample.staPress.status = ADC_Validate(sample.adPress,
                                              dcBuff.configSensor.sensorPress.zeroValue, dcBuff.configSensor.sensorPress.fullValue);
        if(sample.staPress.status == SENSOR_STATUS_NORMAL)
        {
            sample.pressure = ADC_Calculate(sample.adPress,
                                            dcBuff.configSensor.sensorPress.zeroValue, dcBuff.configSensor.sensorPress.fullValue,
                                            dcBuff.configSensor.sensorPress.lowRange, dcBuff.configSensor.sensorPress.highRange);
        }


        // 是否到采集时间（2秒误差）
        if(Config_Vacuum_Request || sample_time + 2 >= vacuum_seconds)
        {
            if(!Config_Vacuum_Request)
            {
                // 下次上传时再采
                vacuum_seconds = sample_time + dcBuff.configData.intervalTrans;
            }
            Config_Vacuum_Request = 0;

        }



//        // 电容传感器
//        if(dcBuff.configDisplay.op_USE_CAPACITY_SENSOR && sample.staDPress.status != SENSOR_STATUS_NOCONNECT)
//        {
//            if(sample.adDPress == 0xFFFF) // 短路
//                sample.staDPress.status = SENSOR_STATUS_OVERFLOW;
//            else
//            {
//                // 根据底电容、增长电容判断状态
//                sample.staDPress.status = ADC_Validate(sample.diff * 10,
//                                                       dcBuff.configSensor.sensorCap.baseC, dcBuff.configSensor.sensorCap.baseC + dcBuff.configSensor.sensorCap.refC);
//            }
//        }

        // 总容积
//        sample.volumeTotal = Theoretical_Param.v;

//        if(dcBuff.configBottle.measureType == MEASURE_DPRESS && sample.staDPress.status == SENSOR_STATUS_NORMAL)
//        {
//            if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR)
//            {
//                // 液位
//                if(!dcBuff.configDisplay.op_USE_HEIGHT_LEVEL && !dcBuff.configDisplay.op_USE_PCT_LEVEL)
//                    sample.height = Diff2Level(sample.diff); // 单位mm
//                else if(!dcBuff.configDisplay.op_USE_PCT_LEVEL)
//                    sample.height = sample.diff;			   // 直接测量液位高度，单位mm
//                else
//                    sample.height = sample.diff * 100;	  // 直接测量液位百分比：单位0.01%
//            }
//            else
//            {
//                // 根据底电容、增长电容计算液位高度
//                sample.height = Cap_Calculate(sample.diff * 10,
//                                              dcBuff.configSensor.sensorCap.baseC, dcBuff.configSensor.sensorCap.refC);
//            }

//            if(!dcBuff.configDisplay.op_USE_PCT_LEVEL && dcBuff.configSensor.levelOutMMWC == 0)
//            {
//                // 体积
//                sample.volume = Level2Vol(sample.height);
//                // 质量
//                sample.weight = Vol2Quantity(sample.volume);
//                // 充装比
//                if(sample.volume >= Theoretical_Param.ve)
//                    sample.volumePct = dcBuff.configBottle.chargePct * 100;
//                else
//                    sample.volumePct = (float) sample.volume / sample.volumeTotal * 10000;
//            }
//            else
//            {
//                if(dcBuff.configSensor.levelOutMMWC > 0)
//                {
//                    // 充装比
//                    if(KPa2mmH2O(sample.diff) >= dcBuff.configSensor.levelOutMMWC)
//                        sample.volumePct = dcBuff.configBottle.chargePct * 100;
//                    else
//                        sample.volumePct = KPa2mmH2O(sample.diff) / dcBuff.configSensor.levelOutMMWC * 10000;
//                }
//                else
//                {
//                    // 充装比
//                    if(sample.diff >= dcBuff.configBottle.chargePct)
//                        sample.volumePct = dcBuff.configBottle.chargePct * 100;
//                    else
//                        sample.volumePct = sample.diff * 100;
//                }
//                // 体积
//                sample.volume = Theoretical_Param.ve * (sample.volumePct / 10000.0);
//                // 质量
//                sample.weight = Vol2Quantity(sample.volume);
//            }
//        }






        // 无外供电，不输出声光报警，恢复到初始状态
        if(!VCC_POWER_STATUS() || (dcBuff.configDisplay.op_USE_SOLAR && dcBuff.dtuData.batVoltage <= 4500))
        {
            KZ_ALARM_OFF();
            KZ_LOW_ALARM_OFF();

            Alarm_Output = 0;
            Low_Alarm_Output = 0;
            Leak_Alarm_Output = 0;
            Press_Alarm_Output = 0;
            Low_Press_Alarm_Output = 0;
            ExtPress_Alarm_Output = 0;
            Low_ExtPress_Alarm_Output = 0;

            Alarm_Enabled = 1;
            Low_Alarm_Enabled = 1;
            Leak_Alarm_Enabled = 1;
            Press_Alarm_Enabled = 1;
            Low_Press_Alarm_Enabled = 1;
            ExtPress_Alarm_Enabled = 1;
            Low_ExtPress_Alarm_Enabled = 1;
        }





        if(dcBuff.configBottle.fullPct > dcBuff.configBottle.emptyPct)
        {

            if( sample.diff>dcBuff.configBottle.fullPct)
            {
                sample.warnning |= 0x01;
                printf("\n*** fullPct warnning ***\n");
            }
            else
            {
                sample.warnning &= 0x0e;
            }
            if( sample.diff<dcBuff.configBottle.emptyPct)
            {
                sample.warnning |= 0x02;

                printf("\n*** emptyPct warnning ***\n");
            }
            else
            {
                sample.warnning &= 0x0d;
            }
        }
        else
        {
            sample.warnning &= 0x0c;
        }
        if((sample.staPress.status == SENSOR_STATUS_NORMAL)&&(dcBuff.configBottle.warnPressH > dcBuff.configBottle.warnPress))
        {
            if(dcBuff.configBottle.warnPress > 0 && sample.pressure < dcBuff.configBottle.warnPress)
            {

                sample.warnning |= 0x04;
                printf("\n*** warnPress warnning ***\n");
            }
            else
            {
                sample.warnning &= 0x0b;
            }
            if(dcBuff.configBottle.warnPressH > 0 &&  sample.pressure > dcBuff.configBottle.warnPressH)
            {
                sample.warnning |= 0x08;
                printf("\n*** warnPressH warnning ***\n");
            }
            else {
                sample.warnning &= 0x07;
            }

        }
        else
        {
            sample.warnning &= 0x03;
        }


//        // 判断是否温度报警
//        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.sampleData.warnning)
//            sample.warnning = 1;
       dcBuff.sampleData = sample;

        // 禁止ADC
        LL_ADC_Disable(ADC1);

        // 通知发送任务采集完成
        GPRS_semSampled = 1;
        // 通知显示板采集完成
        Config_Sample_Request = 0;
        // 通知显示屏: 刷新
        xSemaphoreGive(Key_Semaphore); //Form_Refresh(); //这个函数未做互斥，有可能冲突
        // 刷新电流输出
       // DAC7311_Refresh();

        /* Get the conversion result */
        if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR)
            printf("\nConversion result of diff: \t\t%02X, %.1f kPa", sample.staDPress.status, sample.diff);
        else
            printf("\nConversion result of capa: \t\t%02X, %.1f pF", 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%.1f 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");

        if(first)
        {
            first = 0;

            // 马上采集真空数据
            Config_Vacuum_Request = 1;
            // 发送消息给任务
            xSemaphoreGive(Sample_Semaphore);
        }

        // 采集结束
        Sample_phase = 0;
        osDelay(1000);
    }
}
