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

/**************************************************************************************/
/**
 * @brief 低功耗定时器初始化函数
 * @note  需要定义与硬件相关的函数和IO
 *        // 数据采样定时器，以ms位单位，1ms采样一次数据
 *        StartSamplingTimer(): 1ms 定时为基值
 *        StopSamplingTimer()
 *        EnableSamplingInterrupt()、 DisableSamplingInterrupt()
 *        SamplingInterruptCallBack()
 * 
 *        // 加热流程控制定时器，以ms位单位
 *        StartProcessTimer()、 StopProcessTimer()、 
 *        ProcessTimerInterruptCallBack();
 *        EnableProcessTimerInterrupt();
 */

//##############################################################################
#if(DP2201_CORE_V5000)
//##############################################################################

//__SAMPLE_STATUS_BIT_TypeDef sampleState; 
TypeSample sampleProcess;
TypeCalibOffset calibOffset;
u16 FRType;
u16 dynamicOffset,rapidOffsetGas;
u32 roughTestCounter, MEMSErrorCounter;

//ADC放大倍数值与索引转换--------------------------------------------------
u16 GetAdcGain(u16 gianX)
{
  switch(gianX)
  {
    case 1:   return GAIN1;
    case 2:   return GAIN2;
    case 4:   return GAIN4; 
    case 8:   return GAIN8;
    case 16:  return GAIN16; 
    case 32:  return GAIN32;
    case 64:  return GAIN64;
    case 128: return GAIN128;
  default: 
     return GetAdcGain(ADC_GAIN_DEFAULT);
  }
}

/******************************************************************************/
void SetNextProcess(void)
{
  if(sampleProcess.NextRun == 0) {
		StopProcessTimer();              //关闭采集时钟
		return;
	}
	
//  u32 currentTAR = ProcessTimer->CNT;  //定时器当前计数值
//  if(currentTAR >= sampleProcess.NextTime) {
//  	 sampleProcess.NextTime = currentTAR; 
// 		 FlowProcessManagement();
// 	}
	//else ResetProcessTimer(sampleProcess.NextTime);	

	StartProcessTimer(sampleProcess.NextTime);	
}

/******************************************************************************/
void AnalogCircuitInit(void)
{
  RH_CON_OUTPUT();
  TURN_ON_RH_POWER(); 

  sampleProcess.CTypeGain = GetAdcGain(adcGain);              //默认采样系数   
  SampingADCInit();
  DisableSamplingInterrupt();
}

/******************************************************************************/
void EnableRHControlByTD(void)
{
  RH_CON_OUTPUT();
  TURN_ON_RH_POWER();
  
  SELECT_TD_CON();
    
  HEATING_OUTPUT();
  TURN_OFF_HEATING(); 
}

/******************************************************************************/
void EnableRHControlByTU(void)
{
  RH_CON_OUTPUT();
  TURN_ON_RH_POWER();
  
//  SELECT_TU_CON();
    
  HEATING_OUTPUT();
  TURN_OFF_HEATING();
}

/******************************************************************************/
void TurnOffAnalogCircuit(void)
{
  TURN_OFF_HEATING(); 
  TURN_OFF_RH_POWER();

  CLR_HEATING(); 

  StopSamplingADC();  
  DisableSamplingInterrupt();
}

/******************************************************************************/
void RapidHeating(void)
{
  DisableSamplingInterrupt();  
  
  RH_CON_OUTPUT();
  TURN_ON_RH_POWER();

  SELECT_TD_CON();
	
  //----------------------------------------------------------------------------
  SELECT_VREF_CON();
//  TURN_ON_LOW_HEAT();

}

/******************************************************************************/
void FirstStageHeating(void)
{
  // RH controled by TD
  HWState.EnableTempTest  = 1;
  HWState.EnableTempInit  = 1; 
  systemProcessing.Bit.TempHandle = 1; 
	
	EnableRHControlByTD();
}

/******************************************************************************/
void StartNormolFlowMeasurement(void)
{
//--------------------------------------------------------------------------
// 校准引脚控制（通过宏开关控制）
// 如果定义了 ENABLE_CALPIN_FOR_UPDATE_FR，则拉低校准引脚
//--------------------------------------------------------------------------
#ifndef ENABLE_CALPIN_FOR_UPDATE_FR
#pragma message("[undefined] ENABLE_CALPIN_FOR_UPDATE_FR")
#elif(ENABLE_CALPIN_FOR_UPDATE_FR)
  EXT_CALIB_OUTPUT(); // 配置引脚为输出模式
  CLR_CALIB_PIN();	// 拉低引脚
#endif
  
  //--------------------------------------------------------------------------
  HWState.SampledOver = 0;  // 清除“采样完成”标志，表示测量开始，数据尚未就绪	
  AnalogCircuitInit();// 初始化模拟电路（如运放偏置、ADC配置等）	
// 根据全局状态决定起始状态
// EnableRoughTest 为真：进入“粗检模式”（低功耗检测是否有流量）
// EnableRoughTest 为假：直接进入“正常测量模式”（第一级加热）
  if(sampleProcess.State.EnableRoughTest) sampleProcess.NextRun = START_DETECT_STAGE_HEATING;
  else                                    sampleProcess.NextRun = START_1ST_STAGE_HEATING;
  sampleProcess.NextTime = 0; // 定时器计数基准清零
      
	//--------------------------------------------------------------------------
	StartProcessTimer(64000); // 启动比较定时器,开始从0递增计数
	Timer_register_irq_callback(ProcessTimer,ProcessTimerIT, ProcessTimerInterruptCallBack );//注册中断回调函数
// 立即执行一次流程管理，处理初始状态（如进入加热阶段）
  FlowProcessManagement();
}

/******************************************************************************/
s16 ComputeOffsetCorrectValue(unsigned int offsetHigh, unsigned int offsetLow)
{ 
  tmpSLA  =  (u32)voltageDetected[TGAS];
  tmpSLA -= (u32)calibTemperature;
   
  tmpSLB  = (u32)offsetHigh;
  tmpSLB -= (u32)offsetLow;
  tmpSLA *= tmpSLB;   
   
  tmpSLB  = (u32)staticHighTemperature;
  tmpSLB -= (u32)staticLowTemperature;
  tmpSLA /= tmpSLB;
   
  return (s16)tmpSLA;
}

/******************************************************************************/
bool JudgmentFlowRate(void)
{
	u16 tempIndex;
	
  sampleProcess.NextRun = 0;
  sampleProcess.State.EnableRoughTest = 0;
  if(currentMode.Bit.CalibMode) return 0;
  
  tempIndex = abs(voltageDetected[RIDX] - rapidOffsetGas);
  rapidOffsetGas = voltageDetected[RIDX];  
  if(tempIndex > STATIC_HIGH_CODE) return 0;
  
  systemProcessing.Bit.FRHandle = 1;
  samplingInterval = factoryInterval;    
  flowRate = 0;
  
  roughTestCounter++;
  if(roughTestCounter >= 150)
  { 
    roughTestCounter  = 0; 
    sampleProcess.State.EnableRoughTest = 0;
  }
  else sampleProcess.State.EnableRoughTest = 1;
  
  Clear_WDT();
  return 1; 
}

/******************************************************************************/
void CheckATypeSensor(void)
{  
  if((voltageDetected[RHVOL] < 500) || (voltageDetected[RHVOL] > 2600)) MEMSErrorCounter += 0x10;
  else                                                                  MEMSErrorCounter &= 0x0f;
}

/******************************************************************************/
// Check sensor error 
bool CheckSensor(u16 voltageIndex)
{  
  u16 I=0;

  if((voltageIndex < 2000) || (voltageIndex > 65000)) MEMSErrorCounter += 0x01;
  else                                                MEMSErrorCounter &= 0xf0;
  
  I  = MEMSErrorCounter & 0x0f;
  I += MEMSErrorCounter >> 4;
  if(I > 4) {
    MEMSErrorCounter = 0x55;
		systemAlarm.Bit.SensorErr = 1;
    return 1;     
  }
  else {
		systemAlarm.Bit.SensorErr = 0;
    return 0;
  }   
}



/******************************************************************************/
u16 ComputeCTypeIndex(u16 detectIndex, u16 indexOffset)
{
  if(detectIndex > indexOffset) {
    detectIndex -= indexOffset;
  }
  else {
    detectIndex = indexOffset - detectIndex;    
    if(detectIndex > reverseScale) {
			systemAlarm.Bit.Pollution = 1; 
    }
    detectIndex = 0;  
  }
  
  return detectIndex;
}

/******************************************************************************/
void ComputeFlowRateIndexAndFlowRate(void)
{
  disable_interrupts();	
	
  //===========================================================================
  currentFlowRate = 0;
  displayUpdate   = 0;   
  FRType = CTYPE_FR; 
  GetFilterDepth(responseTimeIndex);  
  
  //============================================================================   
  rapidOffsetGas = voltageDetected[RIDX]; 
  systemAlarm.Bit.Pollution = 0; 
	systemAlarm.Bit.FRAlarm = 0;
  // Compute offset    
  //============================================================================
  if(currentMode.Bit.CalibMode) {
    calibOffset.Value[CAL_VDUX]  = offsetAir;
    calibOffset.Value[CAL_VDUGX] = offsetAirGainx;  
  }
  //----------------------------------------------------------------------------
  #ifndef ENABLE_GAS_RECOGNITION 
  #pragma message("[undefined] ENABLE_GAS_RECOGNITION")
  #elif(ENABLE_GAS_RECOGNITION)     
  else if(systemAlarm.Bit.GasChange = 1) {
    calibOffset.Value[CAL_VDUX]  = offsetGas;
    calibOffset.Value[CAL_VDUGX] = offsetGasGainx;
  }
  #endif
  //----------------------------------------------------------------------------
  else  {
    calibOffset.Value[CAL_VDUX]  = offsetGas;
    calibOffset.Value[CAL_VDUGX] = offsetGasGainx;
  }
	
  calibOffset.CalTA = calibTemperature;
  //----------------------------------------------------------------------------
  //Compute RR Parameter
  voltageDetected[VRRX] = sampleProcess.RTypeResult;
  ComputeRRParameter();
  voltageDetected[RRRES] = MovingAverage(voltageDetected[RRRES], 10, RRRES); 
  StaticTGasCompute();
  if(sampleProcess.State.AType == SAMPLE_VRH) {
     voltageDetected[VRHX] = sampleProcess.ATypeResult;
     ComputeRHParameter();
     CheckATypeSensor();           
	 }
   else {
	   voltageDetected[IVHDX] = sampleProcess.ATypeResult;
     voltageDetected[IVHDX] = MovingAverage(voltageDetected[IVHDX], 10, IVHDX);
  }

  //----------------------------------------------------------------------------
  // Compute TD-TU parameter  
  if(sampleProcess.State.CType == SAMPLE_GVDU) {
    voltageDetected[VDUGX] = sampleProcess.CTypeResult;
    voltageDetected[VDUGX] = MovingAverage(voltageDetected[VDUGX], 10, VDUGX); 
    //-------------------------------------------------------------------------
    CheckSensor(voltageDetected[VDUGX]);    

    //-------------------------------------------------------------------------
    #ifndef ENABLE_OFFSET_CORRECT 
    #pragma message("[undefined] ENABLE_OFFSET_CORRECT")
    #elif(ENABLE_OFFSET_CORRECT)
    tmpSLA  = (s32)ComputeOffsetCorrectValue(VDUGXHigh, VDUGXLow);
    voltageDetected[TVDUGX] = tmpSLA;
    tmpSLA += (u32)voltageDetected[VDUGX];
    voltageDetected[MICRO_FR] = (u16)tmpSLA;
		#else
		voltageDetected[MICRO_FR] = voltageDetected[VDUGX];
    #endif
		
    //-------------------------------------------------------------------------
		// 转换成气体识别所用的内码
    voltageDetected[MICRO_FR]  = ComputeCTypeIndex(voltageDetected[MICRO_FR], calibOffset.Value[CAL_VDUGX]);
    voltageDetected[REG_INDEX] = 128/adcGain;
    voltageDetected[REG_INDEX] = voltageDetected[MICRO_FR] / voltageDetected[REG_INDEX];
    if(voltageDetected[MICRO_FR] > CALIB_MAX_INDEX) voltageDetected[MICRO_FR] = CALIB_MAX_INDEX;  
    FRType = MICRO_FR;  
  }
  else {
    voltageDetected[VDUX] = sampleProcess.CTypeResult;
    voltageDetected[VDUX] = MovingAverage(voltageDetected[VDUX], 10, VDUX);
    //-------------------------------------------------------------------------
    CheckSensor(voltageDetected[VDUX]);    

    //-------------------------------------------------------------------------
    #ifndef ENABLE_OFFSET_CORRECT 
    #pragma message("[undefined] ENABLE_OFFSET_CORRECT")
    #elif(ENABLE_OFFSET_CORRECT)
    tmpSLA  = (signed long int)ComputeOffsetCorrectValue(OffsetHigh, OffsetLow);
    voltageDetected[TVDUX] = tmpSLA;
    tmpSLA += (u32)voltageDetected[VDUX];
    voltageDetected[CTYPE_FR] = (u16)tmpSLA;
		#else
		voltageDetected[CTYPE_FR] = voltageDetected[VDUX];
    #endif
    //-------------------------------------------------------------------------
    voltageDetected[CTYPE_FR]  = ComputeCTypeIndex(voltageDetected[CTYPE_FR], calibOffset.Value[CAL_VDUX]);
		voltageDetected[REG_INDEX] = voltageDetected[CTYPE_FR];
    FRType = CTYPE_FR;    
  }
    
  //============================================================================
  voltageDetected[NIDX] = voltageDetected[VDUX];

  //----------------------------------------------------------------------------
  //气体识别
  GasAnasisCompute();
  SaveVHHAndNRHInTempretureMode();
       
  //----------------------------------------------------------------------------
  //当前流量计算
  currentFlowRate = GetFlowRate(voltageDetected[FRType], FRType);
  
  //----------------------------------------------------------------------------
  PCBTemperature        = TestTemperature();                       // 测试环境温度
	TemperatureLowPower();                                           // 温度传感器低功耗
  voltageDetected[TPCB] = MovingAverage((u16)(TEMPRETURE_OFFSET + PCBTemperature), 100, TPCB);
  PCBTemperature        = (u16)voltageDetected[TPCB];
  PCBTemperature       -= (u16)TEMPRETURE_OFFSET;   
  TemperatureCorrection();
	
  //----------------------------------------------------------------------------
  GCFCorrection();
  
  //----------------------------------------------------------------------------
	if( systemAlarm.Bit.SensorErr | systemAlarm.Bit.Pollution ) currentFlowRate = 0;

  //----------------------------------------------------------------------------
  // JudgeflowUnit, for com and compute ACC   
  currentFlowRate = ConvertFlowrate(currentFlowRate, flowComUnit, FR_STD_UNIT);   
  FlowRateSecondaryCorrection();
  FlowRateAlarmJudgment();
	
  //----------------------------------------------------------------------------
  disable_interrupts();
	
  //----------------------------------------------------------------------------
  flowRate = currentFlowRate; 
  FlowRateMoving();
  tempL.DWord = flowRate;
  voltageDetected[FR_H] = tempL.Word[1];
  voltageDetected[FR_L] = tempL.Word[0];

  //----------------------------------------------------------------------------
  //¼ÆËã×ÜÁ÷Á¿
#ifndef REC_ACC_PER
#pragma message("[undefined] REC_ACC_PER")
#elif(REC_ACC_PER)
  ComputeFlowRateToTotal(); 
  ReleaseTotalToDisArray();
#endif
  
  //----------------------------------------------------------------------------
  //Êä³öÓû§Á÷Á¿
  #ifndef ENABLE_FLOW_GAIN
  #pragma message("[undefined] ENABLE_FLOW_GAIN")
  #elif(ENABLE_FLOW_GAIN) 
  flowRate /= calibFlowGain;
  #endif

  //---------------------------------------------------------------------------
  enable_interrupts();
  //---------------------------------------------------------------------------
  if(flowRate > 0) { 
    roughTestCounter = 0;
    return;  
  }
  else if(samplingInterval <= RESP_2000MS) return;                                                                      // Èç¹ûÁ÷Á¿Îª0£¬½øÈë×Ô¶¯Áãµã¸ú×Ù
  else if(MEMSErrorCounter > 0)            return;
  
  roughTestCounter++; 
  if(roughTestCounter >= 4) {
    roughTestCounter  = 0;
    sampleProcess.State.EnableRoughTest = 1;
  }
}
   
/******************************************************************************/
void FlowRateDealAndOuputSub(void)
{
// disable_interrupts();    

  //===========================================================================   
  ComputeFlowRateIndexAndFlowRate();
  ReleaseToIntAndDecimalBufForUart();  

  //---------------------------------------------------------------------------
  flowRateL = (u16)flowRate;
  flowRateH = flowRate >> 16;
	
  HWState.SampledOver = 0;
  systemProcessing.Bit.FRHandle = 0;  
  sampleProcess.NextRun = 0;
	
	Clear_WDT();
   
  enable_interrupts();
  
//----------------------------------------------------------------------------
// Update 2024/01/29
#ifndef ENABLE_CALPIN_FOR_UPDATE_FR
#pragma message("[undefined] ENABLE_CALPIN_FOR_UPDATE_FR")
#elif(ENABLE_CALPIN_FOR_UPDATE_FR)
//  EXT_CALIB_OUTPUT(); 
//  SET_CALIB_PIN();	
	
//  sampleProcess.NextRun   = FR_UPDATE;
//  sampleProcess.NextTime  = MAINTAR;
//  sampleProcess.NextTime += FR_UPDATE_PULSE_TIME;
//  SetNextProcess();
#endif
}

///******************************************************************************/
void ComputeSampleData(u16 sampleNum, u16 sampleShift)
{
	u32 I;
		
  sampleProcess.ADC0Result = 0;
  sampleProcess.ADC1Result = 0;
	// if(sampleProcess.CounterMax < sampleNum)	return;
// disable_interrupts();	
	// for(I = sampleProcess.CounterMax - sampleNum; I<sampleProcess.CounterMax; I++)
	for(I = 0; I<sampleNum; I++)
	{
    sampleProcess.ADC0Result     += ((sampleProcess.ADC0Buffer[I] >> 8) + 32768) & 0xFFFF;	
		sampleProcess.ADC1Result     += ((sampleProcess.ADC1Buffer[I] >> 8) + 32768) & 0xFFFF;	
		
	  //sampleProcess.ADC0Result += ((((sampleProcess.ADC0Buffer[I] & 0xFFFFFF) | ((sampleProcess.ADC0Buffer[I] & 0x800000) ? 0xFF000000 : 0)) >> 8) + 32768) & 0xFFFF;//处理成16位数据 //sampleProcess.ADC0Buffer[I];
	  //sampleProcess.ADC1Result += ((((sampleProcess.ADC1Buffer[I] & 0xFFFFFF) | ((sampleProcess.ADC1Buffer[I] & 0x800000) ? 0xFF000000 : 0)) >> 8) + 32768) & 0xFFFF;//处理成16位数据 //sampleProcess.ADC1Buffer[I];
	} 

  sampleProcess.ADC0Result >>= sampleShift;
  sampleProcess.ADC1Result >>= sampleShift;	
	
//	enable_interrupts();	
}

///******************************************************************************/
void ComputeSampleDataForSingle(u16 sampleNum, u16 sampleShift)
{
	u32 I;
		
  sampleProcess.ADC0Result = 0;
	for(I = 0; I<sampleNum; I++)
	{
    sampleProcess.ADC0Result     += ((sampleProcess.ADC0Buffer[I] >> 8) + 32768) & 0xFFFF;	
	  //sampleProcess.ADC0Result += ((((sampleProcess.ADC0Buffer[I] & 0xFFFFFF) | ((sampleProcess.ADC0Buffer[I] & 0x800000) ? 0xFF000000 : 0)) >> 8) + 32768) & 0xFFFF;//处理成16位数据 //sampleProcess.ADC0Buffer[I];
	} 
  sampleProcess.ADC0Result >>= sampleShift;
}

/******************************************************************************/
void SetSystemForADCSample(u16 sampleNum)
{ 
  sampleProcess.Counter = 0;  
  sampleProcess.CounterMax = sampleNum;
  
  StartSamplingADC();  
}

/******************************************************************************/
void FlowProcessManagement(void)
{
  // 进入流程
  switch(sampleProcess.NextRun)
  {  
  //-------
	  //-------------------------------------------------------------------------
    // 状态 1: 粗检阶段 - 加热
    // 场景：低功耗模式，快速判断管道内是否有流体流动
    //-------------------------------------------------------------------------------------------------------------------------------------------
  // In low power consumption mode, judge whether there is flow?
  case START_DETECT_STAGE_HEATING:
    RapidHeating();  // 快速加热传感器	
    SetupCTypeChannle(sampleProcess.CTypeGain);  // 配置测量通道  	
    SetSystemForADCSample(SAMPLING_TIMES_IN_DETECT_STAGE);// 配置ADC采样次数
    // 状态流转：设定下一步要做什么，以及多久后做
    sampleProcess.NextRun  = START_DETECT_STAGE_PROCESSING; // 下一状态：处理粗检数据
    sampleProcess.NextTime += SET_UP_TIME_OF_DETECT_STAGE;// 累加时间：加热稳定时间
    break;

//-------------------------------------------------------------------------
// 状态 2: 粗检阶段 - 数据处理与判断
// 场景：读取ADC值，判断是否有流量
//-------------------------------------------------------------------------
  case START_DETECT_STAGE_PROCESSING:
    TurnOffAnalogCircuit(); // 省电：关闭模拟电路电源
  // 计算粗检阶段的采样数据
    ComputeSampleData(SAMPLING_TIMES_IN_DETECT_STAGE, SHIFT_IN_DETECT_STAGE);
    voltageDetected[RIDX] = sampleCTypeValue;// 保存检测值
  // 核心逻辑：判断是否有流量
        // JudgmentFlowRate() 返回 1 表示检测到有流量，直接 break，等待后续正常测量
    if(JudgmentFlowRate()) break;
     // 若无流量，则需要进入正常测量流程（或是误触发）
    AnalogCircuitInit();    
    HWState.SampledOver  = 0;   
    sampleProcess.NextTime = 1638;                     // TimeVaule[0];
    sampleProcess.NextRun  = START_1ST_STAGE_HEATING;
    FlowProcessManagement();
    return;
    
  //-------------------------------------------------------------------------
  // normal check flowrate 
  // start First stage heating 
  case START_1ST_STAGE_HEATING:
    FirstStageHeating();  	

		// 如果不是检定模式，则启动预采样
    if(currentMode.Bit.IntCalibMode) sampleProcess.State.PreSampling = 0;
    else                             sampleProcess.State.PreSampling = 1;
	
    SetupCTypeChannle(sampleProcess.CTypeGain);                 //设置VDU
    SetupRTypeChannle();                                        //设置VRR
    SetSystemForADCSample(PRESAMPLING_TIMES_IN_1ST_STAGE);      //(PRESAMPLING_TIMES_MAX_IN_1ST_STAGE);
	
    TestTemperatureInit(TEMP_SENSOR_RESULT);                    // 温度传感器初始化
	
    // sampleProcess.NextTime += SET_UP_TIME_OF_1ST_STAGE;
	  sampleProcess.NextTime  = SET_UP_TIME_OF_1ST_STAGE;
    sampleProcess.NextRun   = START_1ST_STAGE_SAMPLING;  	
    break;    
   
  //------------------------------------------------------------------------
  // 1ST: normal SAMPLING
  // start sampling data       
  case START_1ST_STAGE_SAMPLING:
    ComputeSampleData(PRESAMPLING_TIMES_IN_1ST_STAGE, SHIFT_IN_PRESAMPLING_1ST_STAGE);
	  sampleProcess.RTypeResult = sampleRTypeValue;   //VRR 8304  sampleProcess.ADC1Result   

    // 通过预采样，确定CTYPE放大倍数
	  // Setup CType Channel -----------------------------------------------------
    if(sampleProcess.State.PreSampling) {
	    tmpIA = ComputeCTypeIndex((u16)sampleCTypeValue,  calibOffset.Value[CAL_VDUX]);        // |采样内码-零点内码|   预采样内码值结果
      if(sampleSwitchThreshold < 500)              sampleProcess.State.CType = SAMPLE_VDU;   // 小于500，禁止使用变增益功能
      else if(tmpIA > sampleSwitchThreshold + 500) sampleProcess.State.CType = SAMPLE_VDU;   // 
      else if(tmpIA < sampleSwitchThreshold)       sampleProcess.State.CType = SAMPLE_GVDU;
    }
		else sampleProcess.State.CType++;                                                        // 该值为一个 1 位宽的无符号位域，++操作会在0 1之间切换
		if(sampleProcess.State.CType == SAMPLE_VDU) SetupCTypeChannle(sampleProcess.CTypeGain);  // Gain=32 128
    else              		                      SetupCTypeChannle( GIDX_GAIN );              // GAIN = 128
		
		// Setup AType Channel -------------------------------------------------------- 
		if(sampleProcess.State.AType == SAMPLE_VRH) {
      sampleProcess.State.AType = SAMPLE_IRH;
      SetupIRHChannle();
		}
	  else {
			sampleProcess.State.AType = SAMPLE_VRH;
      SetupVRHChannle();
		}
		
		// Start ADC -------------------------------------------------------- 
    SetSystemForADCSample(SAMPLING_TIMES_IN_1ST_STAGE);
    // sampleProcess.NextTime += SAMPLING_TIME_OF_1ST_STAGE;
    sampleProcess.NextTime = SAMPLING_TIME_OF_1ST_STAGE;
    sampleProcess.NextRun  = START_1ST_STAGE_PROCESSING;
//CLR_TEST_PIN();
    break;
    
  //------------------------------------------------------------------------
  case START_1ST_STAGE_PROCESSING: 
CLR_TEST_PIN();
    if(samplingInterval > RESP_125MS) TurnOffAnalogCircuit(); 

    ComputeSampleData(SAMPLING_TIMES_IN_1ST_STAGE, SHIFT_IN_1ST_STAGE);
	  sampleProcess.CTypeResult = sampleCTypeValue; 
    sampleProcess.ATypeResult = sampleATypeValue; 
	
	  //End Sampling
    sampleProcess.NextRun = 0; 	
    HWState.SampledOver   = 1;		
    systemProcessing.Bit.FRHandle = 1;  
    break;
	
  //------------------------------------------------------------------------  
  // Update 2024/01/29
  case FR_UPDATE: 
    EXT_CALIB_OUTPUT();
    CLR_CALIB_PIN();
    sampleProcess.NextRun = 0;
    break;
    
  //------------------------------------------------------------------------
  default: 
    TurnOffAnalogCircuit();                                                     // into lowpower mode
    sampleProcess.NextRun = 0;
    systemProcessing.Bit.FRHandle = 0;
    break;
  }
	
	// 设置下一个流程定时  
  SetNextProcess();

//  if(sampleProcess.NextRun == 0) {
//		StopProcessTimer();//关闭采集时钟
//		return;
//	}
//	else {	
//    u32 currentTAR = SamplingTimer->CNT;   //定时器当前计数值
//    if(currentTAR >= sampleProcess.NextTime) {
//			 sampleProcess.NextTime = currentTAR; 
//			 FlowProcessManagement();
//		}
//		else ResetSamplingTimer(sampleProcess.NextTime);	
//}
}

//******************************************************************************/
void CoreInit(void)
{
  SystemGPIOInit();
  // ExternCalibratinInput();
  TurnOffAnalogCircuit();
}

//******************************************************************************/
void CoreColdStartProcessing(void)
{
  //----------------------------------------------------------------------------  
  // check cold start
  if(systmeState != 0xAA55)
  {     
//    if(CodeCRC == 0) alarmState &= ~BL_CRC_ERROR;
//    else             alarmState |=  BL_CRC_ERROR; 

////    CodeCheckCRC();
//    if(CodeCRC == 0) alarmState &= ~AP_CRC_ERROR;
//    else             alarmState |= AP_CRC_ERROR;

    SystemHardWareAutoCheck(); 
		
		#ifndef ENABLE_ZERO_CALIB_CMD 
		#pragma message("[undefined] ENABLE_ZERO_CALIB_CMD")
		#elif(ENABLE_ZERO_CALIB_CMD)
		tempL.Word[0]  = ReadShortParameterFromMemory(SYS_COMMAND, 0);  
    currentMode.Word = tempL.Word[0];
		if(currentMode.Bit.ZeroCalib) EnterZeroCalibMode();
		else                          EnterUserMode();
		#else
		EnterUserMode();
		#endif
  }
  
  //----------------------------------------------------------------------------  
  Clear_WDT();
  
  //----------------------------------------------------------------------------  
  // Interface Init
  SystemInterfaceInit(); 
  
  //---------------------------------------------------------------------------- 
  enable_interrupts();  
}

  //---------------------------------------------------------------------------- 
void ProcessTimerInterruptCallBack(void)
{
  DisableProcessTimerInterrupt();
	HWState.ProcessTimerOut = 1;
  //FlowProcessManagement();
  //enable_interrupts();
}  

//采样中断--------------------------------------------------------------------
//void SamplingTimer_IRQ_Callback(void)
//{
//	FlowProcessManagement();
////	LHL_GPIO_TogglePin(pGPIO1, GPIO_PIN_7);  MEMSErrorCounter
//}

//主程序中断------------------------------------------------------------
void PrimaryTimer_IRQ_Callback()
{
	SET_TEST_PIN();
	//TEST_PIN_TOGGLE();
	HWState.MainTimerOut = 1; 
}

//系统轮询----------------------------------------------------------------------
void SystemPolling(void)
{
	while(1) {
    //-------------------------------------------------------------------------- 
		//test flowrate
	  if(HWState.MainTimerOut == 1 ) {
      ManagePrimaryTimeInterval();         // 判断下阶段的工作模式   
      ModeExitCount();                     // 判断各种模式退出 
      Clear_WDT();
		  StartNormolFlowMeasurement();
	    HWState.MainTimerOut = 0;
	  }
		else if(HWState.ProcessTimerOut == 1 ) {
		  FlowProcessManagement();
      HWState.ProcessTimerOut = 0;
	  }
		
    if(HWState.SampledOver) {
			FlowRateDealAndOuputSub();
			//------------------------------------------------------------------------
		  #if ENABLE_USE_AVANT_PROTOCOL
			if(urrentMode.Bit.DigitOutput)	AvantGardeAutoUploadData();
			#endif
		}
		
	  //---------------------------------------------------------------------------- 
	  #ifndef ENABLE_USER_UART 
	  #pragma message("[undefined] ENABLE_USER_UART")
	  #elif(ENABLE_USER_UART)
	  if(comState.state.ReceivedData ) {
			ReceivedDataProcessing();
			continue;
		}
	  #endif
	
	  //-------------------------------------------------------------------------- 
	  #ifndef ENABLE_USER_I2C 
	  #pragma message("[undefined] ENABLE_USER_I2C")
	  #elif(ENABLE_USER_I2C)
		if(comState.I2CReceivedData) {
   		DoneI2CComm();   
			continue;
		}		
	  #endif
		
	  //-------------------------------------------------------------------------- 
    if(HWState.EnableSaveData) DataStorageManagement();  

    alarmState = systemAlarm.Word;
	//-------------------------------------------------------------------------- 
  }
}


/* File end *****************************************************************/
#endif 
/****************************************************************************/