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


#if(DP1703COREV10)


__SAMPLE_STATUS_BIT_TypeDef sampleState;  
u16 offsetRType, offsetGCFX;


TypeSample sampleData;
u16 processNextTime, processIndex;

u16 voltageDetected[ANX], adcGain;



volatile u32 sleeptime ,flag_sleep;
//主定时器中断,程序从此进入周期--------------------------------------------------------------
void SHAL_LPTIMER0_IRQ_Callback(LPTIM_TypeDef *lptimer, uint16_t irq_type)
{
	LPTIM_ClearITPendingBit(lptimer,irq_type);//清楚中断标志位	
	
	StartNormolFlowMeasurement();//每个大周期重置全部信号的采样
	

	sleeptime++;
	if (sleeptime ==20 || sleeptime ==21){flag_sleep = 1 ;}//sleeptime = 0 ;
  if (sleeptime >40 )TOGGLE_PIN(pGPIO1, GPIO_Pin_7);
}


/*==========================================================================================
//外部传感器设备
==========================================================================================*/
void TestTemperatureInit(void)//温度测试初始化
{
  WriteWordRegister(CONFIG, CONVERSION);
  WriteByteRegister(RREG, RESULT_0_25_BIT);
	
  HWState.EnableTempInit = 0;
}

u32 tempLongInt;
void TestTemperature(void)//温度测试/测量，获取TPCB
{
  if(!HWState.EnableTempTest) return;
  if(HWState.EnableTempInit) return;
  
  
  voltageDetected[TPCB] = ReadWordRegister(TA);//获取传感器原始值
	WriteWordRegister(CONFIG, SHUT_DOWN);//温度传感器禁用
  voltageDetected[TPCB] &= 0x1fff;
  tempLongInt = (u32)(voltageDetected[TPCB] & 0xFFF);
  if(voltageDetected[TPCB] >= 0x1000) tempLongInt = 0xFFF - tempLongInt;
  tempLongInt  *= 6400;	// 0.0625*1024*100 
  tempLongInt >>= 10;	// /1024
  PCBTemperature = (u16)tempLongInt;	// Temperature*100
	voltageDetected[TPCB] =PCBTemperature;
	
 		__NOP();
}




/*==========================================================================================
//数据采样
==========================================================================================*/

/*********************************************************************/
//采样数据处理阶段
/*********************************************************************/

void FlowRateDealAndOuputSub(void)
{ 
  ComputeFlowRateIndexAndFlowRate();//计算内码 转换成流量
	  
  TestTemperature();//计算PCB温度

}

 
void ComputeFlowRateIndexAndFlowRate(void)
{ 
 
	voltageDetected[NIDX ]= (u16)sampleData.TCode[CTCode]; ///gain=32  VDU  
	voltageDetected[VRHX ]= (u16)sampleData.TCode[HTCode]; ///gain=128 VDU  
	voltageDetected[IVHDX]= (u16)sampleData.TCode[RTCode]; ///gain=1   VRH
	voltageDetected[RHVOL]= (u16)sampleData.TCode[ATCode]; ///gain=8   VRR  
	voltageDetected[VDUGX]= (u16)sampleData.TCode[BTCode]; ///gain=8   VIH 
	//voltageDetected[FRIDX]=voltageDetected[NIDX]- offsetGas;	
	
	//判断气体类型
	//1---根据VRH原始值判断
//	if(voltageDetected[IVHDX]<56000) voltageDetected[FRIDX]=voltageDetected[NIDX ]- offsetAir; //Air
//	else 														 voltageDetected[FRIDX]=voltageDetected[VRHX ]- offsetAir; //H2  														

	if(offsetAir)voltageDetected[FRIDX]=voltageDetected[NIDX ]- offsetGas; //Air
	else				 voltageDetected[FRIDX]=voltageDetected[VRHX ]- offsetGas; //H2  	

  currentFlowRate = GetFlowRate(voltageDetected[FRIDX],CURVE_1ST);
//	flowRateH
//	flowRateL
	voltageDetected[FR_H] = currentFlowRate >> 16;
	voltageDetected[FR_L] = currentFlowRate&0xFFFF;
//	voltageDetected[VDUGX]= AirflowSensor_Read();
//	voltageDetected[TPCB]= (u16)(Get_AirflowSensor_SCCM());
 
} 
u16 WordSubFunction(u16 minuend, u16 subtractor)
{
  u16 subResult;
  
  subResult  = minuend - subtractor;
  if(minuend >= subtractor) 
  {
    if(subResult < 32768) subResult += 32768;
    else                  subResult  = 65535;
  }
  else
  {
    if(subResult < 32768) subResult  = 0;
    else                  subResult -= 32768;
  }
  
  return subResult;
}



/********************************************************************/
//采样阶段
/********************************************************************/
//采样中断
void SHAL_SamplingTime_IRQ_Callback(TIMER_TypeDef *timer, uint16_t irq_type)
{
	TIM_ClearITPendingBit(timer, irq_type);//清除中断标志	FlowProcessManagement();
	if (irq_type & TIM_IT_Update) {// 处理更新中断
	}
	if (irq_type & TIM_IT_CC1) {	// 处理比较中断
		FlowProcessManagement();
	}
}

void StartNormolFlowMeasurement(void)//开始常规流量测量
{
	
//	ManagePrimaryProcess();//主进程
	
	ADC0_1_StopSYNC_Conversion();
  HWState.SampledOver = 0;//采样结束标志重置	
	StartSamplingTimeInterval(32768); //启动比较定时器,开始从0递增计数
	SHAL_timer_register_irq_callback(SamplingTIM,SHAL_SamplingTime_IRQ_Callback );//注册中断回调函数

	
	processIndex = 0;	//
  processNextTime = 0; 
  FlowProcessManagement();//周期开始首次运行
}




void ReadSamplingData(void)//ADC中断读取采样数据 BPS
{
  sampleData.ADCBuffer[0] += ADC_ReadData(ADC0); //多重采样累计
	sampleData.ADCBuffer[1] += ADC_ReadData(ADC1); //多重采样累计
//	TOGGLE_PIN(pGPIO0, GPIO_Pin_5);//TEST PIN
  sampleData.Counter++; // 采样次数自增后判断是否采样结束
	if(sampleData.Counter < sampleData.CounterMax) return;
}


void ComputeSampleData(void) //计算样本数据
{
	ADC0_1_StopSYNC_Conversion();
 
	if(sampleData.Counter != 0)//采集数量超过设置求平均
		{
			sampleData.ADCBuffer[0] /= (u32)sampleData.Counter;
			sampleData.ADCBuffer[1] /= (u32)sampleData.Counter;
		}
}

void SetSystemForADCSample(u16 SampleSiagnl)//设置采样通道与采样次数
{
  sampleData.ADCBuffer[0] = 0;
	sampleData.ADCBuffer[1] = 0;
  sampleData.Counter   = 0; 	
 
	switch(SampleSiagnl) 
	{
		case SIGNAL0:	{
 									  ADC0_1_StartSYNC_Conversion( GAIN_32, ADC0_PCHAN_AIN0, ADC0_NCHAN_AIN1,    //CTCODE
																			GAIN_1,  ADC1_PCHAN_AIN2, ADC1_NCHAN_AVSS);   //RTCODE
									}break;
		case SIGNAL1:	{ 
 									  ADC0_1_StartSYNC_Conversion( GAIN_128, ADC0_PCHAN_AIN0, ADC0_NCHAN_AIN1,   //HTCODE
																			GAIN_1,  ADC1_PCHAN_AIN3, ADC1_NCHAN_AIN4);	  //ATCODE
									}break;
		case SIGNAL2:	{ 
 									  ADC0_1_StartSYNC_Conversion( GAIN_32, ADC0_PCHAN_AIN0, ADC0_NCHAN_AIN1,    //CTCODE
																			GAIN_8,  ADC1_PCHAN_AIN5, ADC1_NCHAN_AIN4);   //BTCODE
									}break;
		case SIGNAL3:	{ 
 									  ADC0_1_StartSYNC_Conversion( GAIN_128, ADC0_PCHAN_AIN0, ADC0_NCHAN_AIN1,   //HTCODE
																			GAIN_1,  ADC1_PCHAN_AIN2, ADC1_NCHAN_AVSS);	  //RTCODE
									}break;						
		case SIGNAL4:	{ 
 									  ADC0_1_StartSYNC_Conversion( GAIN_32, ADC0_PCHAN_AIN0, ADC0_NCHAN_AIN1,    //CTCODE
																			GAIN_1,  ADC1_PCHAN_AIN3, ADC1_NCHAN_AIN4);   //ATCODE
									}break;						
		case SIGNAL5:	{ 
 									  ADC0_1_StartSYNC_Conversion( GAIN_128, ADC0_PCHAN_AIN0, ADC0_NCHAN_AIN1,   //HTCODE
																			GAIN_8,  ADC1_PCHAN_AIN5, ADC1_NCHAN_AIN4);	  //BTCODE
									}break;			
	}
}

void SetNextProcess(void)//设置采样定时器的下一个进程
{
  if(processIndex == 0){
		StopSamplingTimeInterval();//关闭采集时钟
		return;
	}
  u32 currentTAR;
  currentTAR = (u32)GetSamplingTimeCounter();//定时器当前计数值 
  if(currentTAR > processNextTime) processNextTime = currentTAR + 5; 
	
  ResetSamplingTimeInterval(processNextTime);
}

void FlowProcessManagement(void)//采样过程管理
{
  switch(processIndex)
  {
		case 0: 
		{
			HWState.SampledOver = 0;//采样开始
			SetSystemForADCSample(SIGNAL0);//开始采集SIGNAL0
			processNextTime += 655;  //20ms 计数值=65535/4000*t = 
			processIndex     = 1;
  		}break;
		
		case 1: 
		{
			ComputeSampleData();	//计算样本数据
			sampleData.TCode[CTCode] = sampleData.ADCBuffer[0];//放入缓存
			sampleData.TCode[RTCode] = sampleData.ADCBuffer[1];//放入缓存
			SetSystemForADCSample(SIGNAL1);//开始采集SIGNAL1
			processNextTime += 655;//20ms
			processIndex     = 2; 
  		}break;
		
		case 2: 
		{
			ComputeSampleData();	//计算样本数据
			sampleData.TCode[HTCode] = sampleData.ADCBuffer[0];//放入缓存
			sampleData.TCode[ATCode] = sampleData.ADCBuffer[1];//放入缓存
			SetSystemForADCSample(SIGNAL2);//开始采集SIGNAL1
			processNextTime += 655;//20ms
			processIndex     = 3; 
  		}break;
		case 3: 
		{
			ComputeSampleData();	//计算样本数据
			sampleData.TCode[CTCode] += sampleData.ADCBuffer[0];//放入缓存
			sampleData.TCode[BTCode] = sampleData.ADCBuffer[1];//放入缓存
			SetSystemForADCSample(SIGNAL3);//开始采集SIGNAL1
			processNextTime += 655;//20ms
			processIndex     = 4; 
  		}break;
		case 4: 
		{
			ComputeSampleData();	//计算样本数据
			sampleData.TCode[HTCode] += sampleData.ADCBuffer[0];//放入缓存
			sampleData.TCode[RTCode] += sampleData.ADCBuffer[1];//放入缓存
			SetSystemForADCSample(SIGNAL4);//开始采集SIGNAL1
			processNextTime += 655;//20ms
			processIndex     = 5; 
  		}break;		
		
		case 5: 
		{

			ComputeSampleData();	//计算样本数据
			sampleData.TCode[CTCode] += sampleData.ADCBuffer[0];//放入缓存
			sampleData.TCode[ATCode] += sampleData.ADCBuffer[1];//放入缓存
			SetSystemForADCSample(SIGNAL5);//开始采集SIGNAL1
			processNextTime += 655;//20ms
			processIndex     = 6; 
  		}break;				
			
		case 6: 
		{

			ComputeSampleData();	//计算样本数据
			sampleData.TCode[HTCode] += sampleData.ADCBuffer[0];//放入缓存
			sampleData.TCode[BTCode] += sampleData.ADCBuffer[1];//放入缓存
			
			sampleData.TCode[CTCode] /= 3 ;//gain=32  VDU 
			sampleData.TCode[HTCode] /= 3 ;//gain=128 VDU 
			sampleData.TCode[RTCode] /= 2 ;//gain=1   VRH
			sampleData.TCode[ATCode] /= 2 ;//gain=8   VRR 
			sampleData.TCode[BTCode] /= 2 ;//gain=8   VIH
			
 			HWState.SampledOver = 1;   //采样结束
			StopSamplingTimeInterval();//关闭采集时钟
			processIndex	= 7;
		}break;
		default :	processIndex	= 0; break;
	}
	SetNextProcess();
}

#endif