#include "../main/SystemInclude.h"
#if 0
__Samp_Buf_TypeDef sampleData;

//ADC0采样初始化----------------------------------------------------------
static void ADC0_Conversion_Init(ADC_BaseConfig_TypeDef* adc_config)
{
	ADC_Init(ADC_0, adc_config->SPS,  adc_config->Gain,  adc_config->PChan,  adc_config->NChan);	/* 2. 初始化ADC0 */ 
}

//ADC1采样初始化----------------------------------------------------------
static void ADC1_Conversion_Init(ADC_BaseConfig_TypeDef* adc_config)
{
	ADC_Init(ADC_1, adc_config->SPS, adc_config->Gain, adc_config->PChan, adc_config->NChan);	/* 2. 初始化ADC1 */
}

//ADC同步采样初始化----------------------------------------------------------
static void ADC0_1_SyncConversion_Init(ADC_SyncConfig_TypeDef* adc_config)
{		
	ADC_Init(ADC_0, adc_config->SPS, adc_config->Gain0, adc_config->PChan0, adc_config->NChan0);	/* 2. 初始化ADC0 */  
	ADC_Init(ADC_1, adc_config->SPS, adc_config->Gain1, adc_config->PChan1, adc_config->NChan1);	/* 3. 初始化ADC1 */
	ADC_SyncCmd(ENABLE);/* 4. ADC同步使能 */
}

//单ADC配置初始化----------------------------------------------------------
void SetSampleSiagnlForSingleADC(ADC_BaseConfig_TypeDef* adc_cfg) 
{
	ADC_REF_Init(REF_INTERNAL_2P5V, REF_INTERNAL_2P5V);
	sampleData.adcBaseCfg.Gain  = adc_cfg->Gain;	
	sampleData.adcBaseCfg.PChan = adc_cfg->PChan;
	sampleData.adcBaseCfg.NChan = adc_cfg->NChan;	
	sampleData.adcBaseCfg.SPS		= adc_cfg->SPS;
}

//双ADC配置初始化----------------------------------------------------------
void SetSampleSiagnlForSyncADC( ADC_SyncConfig_TypeDef* adc_cfg) 
{
	ADC_REF_Init(REF_INTERNAL_2P5V, REF_INTERNAL_2P5V);
	sampleData.adcSyncCfg.Gain0  = adc_cfg->Gain0;	
	sampleData.adcSyncCfg.PChan0 = adc_cfg->PChan0;
	sampleData.adcSyncCfg.NChan0 = adc_cfg->NChan0;	
	
	sampleData.adcSyncCfg.Gain1  = adc_cfg->Gain1;
	sampleData.adcSyncCfg.PChan1 = adc_cfg->PChan1;
	sampleData.adcSyncCfg.NChan1 = adc_cfg->NChan1;
	sampleData.adcSyncCfg.SPS    = adc_cfg->SPS;
}

//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);
  }
}

/* ======================================================================================================
	adc中断采样流程说明：
		1.设置：SetSampleSiagnlForSingleADC SetSampleSiagnlForSyncADC
		2.开始：StartADC0SampingData StartADC1SampingData StartADCSyncSampingData
		3.读取：IRQ ReadSamplingData  
		4.计算：ComputeSampleData
 ======================================================================================================*/
//转换完成中断
void ConversionIRQ_Callback(void)
{
	if(sampleData.SkipSampNum) {sampleData.SkipSampNum -- ; return; }
	ReadSamplingData(); //读取采样数据
}

//开始转换控制---------------------------------------------------------------
void StartADC0SampingData(void)
{
	sampleData.ADCBuffer[0]=0;
	sampleData.Counter=0;
	sampleData.SkipSampNum  = 3 ;
	ADC0_Conversion_Init(&sampleData.adcBaseCfg);
	ADC_register_irq_callback(ADC_0,ConversionIRQ_Callback);
	StartADC(ADC_0);
}

void StartADC1SampingData(void)
{
	sampleData.ADCBuffer[1]=0;
	sampleData.Counter=0;
	sampleData.SkipSampNum  = 3 ;
	ADC1_Conversion_Init(&sampleData.adcBaseCfg);
	ADC_register_irq_callback(ADC_1,ConversionIRQ_Callback);
	StartADC(ADC_1);
}

void StartADCSyncSampingData(void)
{
	sampleData.ADCBuffer[0]=0;
	sampleData.ADCBuffer[1]=0;
	sampleData.Counter=0;
	sampleData.SkipSampNum  = 3 ;
	ADC0_1_SyncConversion_Init(&sampleData.adcSyncCfg);
	ADC_register_irq_callback(ADC_0,ConversionIRQ_Callback);
	StartADC(ADC_0);//只需开启ADC_0
}


void ReadSamplingData(void)//ADC中断读取采样数据 BPS
{
  sampleData.ADCBuffer[0] += ADC_ReadData(ADC_0); //多重采样累计
	sampleData.ADCBuffer[1] += ADC_ReadData(ADC_1); //多重采样累计
  sampleData.Counter++; 													// 采样次数自增 
}

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

/* ======================================================================================================
	adc dma采样流程说明：
		1.设置： 		SetSampleSiagnlForSingleADC  SetSampleSiagnlForSyncADC
		2.开始： 		StartDMAForADC0SampingData  StartDMAForADC1SampingData  StartDMAForADCSyncSampingData
		3.传输完成: IRQ 标志位
		4.计算：	  DMA_ComputeSampleData_ADC0  DMA_ComputeSampleData_ADC1
 ======================================================================================================*/
//传输完成中断标志位
void DMAForADC0_Callback()
{
	sampleData.DMA_ADC_adcflag[0] = 1;
}

void DMAForADC1_Callback()
{
	sampleData.DMA_ADC_adcflag[1] = 1;
}

//开始转换控制---------------------------------------------------------------
//单ADC转换--------------------------
void StartDMAForADC0SampingData(void)
{	
	sampleData.SkipSampNum  = 0 ;
	sampleData.DMA_ADC_adcflag[1] = 0 ;
 
	ADC0_Conversion_Init(&sampleData.adcBaseCfg);
 	DMA_ADC_Init(ADC_0,sampleData.DMA_ADC_Buffer[0],sampleData.DMA_ADC_SampLen+sampleData.SkipSampNum);
	DMA_register_irq_callback(DMA_CHANNEL_ADC_0,NULL,DMAForADC0_Callback);
	DMA_StartADC(ADC_0);
}

//单ADC转换--------------------------
void StartDMAForADC1SampingData(void)
{ 
	sampleData.SkipSampNum  = 0 ;
	sampleData.DMA_ADC_adcflag[1] = 0 ;

	ADC0_Conversion_Init(&sampleData.adcBaseCfg);
 	DMA_ADC_Init(ADC_1, sampleData.DMA_ADC_Buffer[1],sampleData.DMA_ADC_SampLen+sampleData.SkipSampNum);
 	DMA_register_irq_callback(DMA_CHANNEL_ADC_1,NULL,DMAForADC1_Callback);
	DMA_StartADC(ADC_1);
}

//双ADC转换--------------------------
void StartDMAForADCSyncSampingData(void)
{
	sampleData.SkipSampNum  = 0 ;
	sampleData.DMA_ADC_adcflag[0] = 0 ;
	sampleData.DMA_ADC_adcflag[1] = 0 ;

	ADC0_1_SyncConversion_Init(&sampleData.adcSyncCfg);
 	DMA_ADC_Init(ADC_0,sampleData.DMA_ADC_Buffer[0],sampleData.DMA_ADC_SampLen+sampleData.SkipSampNum);
 	DMA_ADC_Init(ADC_1,sampleData.DMA_ADC_Buffer[1],sampleData.DMA_ADC_SampLen+sampleData.SkipSampNum);
 	DMA_register_irq_callback(DMA_CHANNEL_ADC_0,NULL,DMAForADC0_Callback);
 	DMA_register_irq_callback(DMA_CHANNEL_ADC_1,NULL,DMAForADC1_Callback);
	DMA_StartADC(ADC_0);
	DMA_StartADC(ADC_1);
}

//转换完成判断-----------------------
inline u8 WaitADC0DMAComplete(void)
{
    if (sampleData.DMA_ADC_adcflag[0]) {
        sampleData.DMA_ADC_adcflag[0] = 0;
        return 1;  // 转换已完成
    }
    return 0;     // 转换未完成
}

inline u8 WaitADC1DMAComplete(void)
{
    if (sampleData.DMA_ADC_adcflag[1]) {
        sampleData.DMA_ADC_adcflag[1] = 0;
        return 1;  // 转换已完成
    }
    return 0;     // 转换未完成
}

inline u8 WaitSyncDMAComplete(void) //内联属性
{
    if (sampleData.DMA_ADC_adcflag[0] && sampleData.DMA_ADC_adcflag[1]) {
        sampleData.DMA_ADC_adcflag[0] = 0;
        sampleData.DMA_ADC_adcflag[1] = 0;
        return 1;  // 转换已完成
    }
    return 0;     // 转换未完成
}



//计算转换采样数据-----------------------
u16 DMA_ComputeSampleData_ADC0(void)
{
	u16 adcCode;
	u32 adcCount;
	u8 i ;
	for(i = sampleData.SkipSampNum ; i < sampleData.DMA_ADC_SampLen ;i++)
	{
		adcCode = ((((sampleData.DMA_ADC_Buffer[0][i] & 0xFFFFFF) | ((sampleData.DMA_ADC_Buffer[0][i] & 0x800000) ? 0xFF000000 : 0)) >> 8) + 32768) & 0xFFFF;//处理成16位数据
		adcCount += adcCode ;
	}
	adcCode = adcCount>>sampleData.DMA_ADC_Exponent;	
  return  adcCode;
}

u16 DMA_ComputeSampleData_ADC1(void)
{
	u16 adcCode;
	u32 adcCount;
	u8 i ;
	for(u8 i = sampleData.SkipSampNum ; i < sampleData.DMA_ADC_SampLen ;i++)
	{
		adcCode = ((((sampleData.DMA_ADC_Buffer[1][i] & 0xFFFFFF) | ((sampleData.DMA_ADC_Buffer[1][i] & 0x800000) ? 0xFF000000 : 0)) >> 8) + 32768) & 0xFFFF;//处理成16位数据
		adcCount += adcCode ;
	}	
 
	adcCode = adcCount >> sampleData.DMA_ADC_Exponent;	
  return  adcCode;
}




/*==========================================================================*/
//ADC序列采样--适合不改变采样参数的场景
//使用示例：
//设置seq_config
//StartDMA_ForADC0_SeqSample();
//u16 SeqData[4];
//if(adcFlag)ADC_ReadSeqData(SeqData,sizeof(SeqData) / sizeof(SeqData[0]));




//设置序列采样参数
typedef enum {
    seq_1, seq_2, seq_3, seq_4,/*......*/seq_Count
}__SeqIndex;
#define		SEQ_CFG   {											\
    .Gain = GAIN64,		          \
    .SPS  = SPS_12P5, 		            \
    .SeqCount = seq_Count,		            \
    .SeqChannel = {		                    \
        [seq_1] = {ADC0_AIN0, ADC0_AIN1},	\
        [seq_2] = {ADC1_AIN3, ADC1_AIN4},	\
        [seq_3] = {ADC1_AIN2, ADC1_AVSS},	\
        [seq_4] = {ADC1_AIN5, ADC1_AIN4}, \
    },		                                \
		.adcFlag = 0 ,/* DMA搬运完成标志 */   \
 }                                      

__SeqConfig_TypeDef		seq_config = SEQ_CFG;

//void SetSampleSeqConfig(u8 Gain ,u8 SPS) //应该适合不改变参数的场景的话不需要~~~要改就不用这个
//{
//	seq_config.Gain  = Gain ;
//	seq_config.SPS   = SPS  ;
//}

void seqcallback(void)
{
	seq_config.adcFlag = 1 ;
}
void StartDMA_ForADC0_SeqSample(void)
{
	DMA_ADC0_SingleChannel_SEQ_Init(&seq_config);

	seq_config.adcFlag = 0; 
	DMA_register_irq_callback(DMA_CHANNEL_ADC_CTL,NULL,seqcallback);

	StartDMA_SEQ_ADC(ADC_0);
}

 
 //读ADC数据---------------------------------------------------------------
void ADC_ReadSeqData(u16* SeqData ,u8 SeqNumCount) 
{
 	ADC_Data_t* tempSeqData;
	if (seq_config.adcFlag > 0)
	{
		tempSeqData = seq_config.adcBuffer;//adcBuffer变量弄成传递？
		for(u8 i = 0 ; i <  SeqNumCount ; i++)
		{
			tempSeqData[i].ADC_Data  =  ((((tempSeqData[i].ADC_Data  & 0xFFFFFF) | ((tempSeqData[i].ADC_Data  & 0x800000) ? 0xFF000000 : 0)) >> 8) + 32768) & 0xFFFF;
			SeqData[i] = tempSeqData[i].ADC_Data;//打包序列采样结果数据
		}
		seq_config.adcFlag = 0;
	}
}

/******-==============================================================================================================================================================******/
//__IntSingleSampleData_t	   sampleData1;
//__IntSyncSampleData_t		   sampleData2;
//__SingleDmaSampleData_t		 sampleData3;
//__DualSyncDmaSampleData_t  sampleData4;

////中断单ADC开始转换控制---------------------------------------------------------------
////转换完成中断
//void ADC0_SingleIRQ_Callback(void)
//{
//	if(sampleData1.skip_num) {sampleData1.skip_num -- ; return; }
//	//读取采样数据
//	sampleData1.adc_buffer+= ADC_ReadData(ADC_0); //多重采样累计
//  sampleData1.counter++; 												// 采样次数自增 
//}
//void ComputeSingleADC0SampleData(void) //计算样本数据
//{
//	StopADC(ADC_0);
//	//采集数量求平均
//	if(sampleData1.counter != 0) sampleData1.adc_buffer /= (u32)sampleData1.counter;
//}
//void StartADC0_SampingData(void)
//{
//	sampleData1.adc_buffer = 0 ;
//	sampleData1.counter =0 ;
//	sampleData1.skip_num  = 3 ;
//	ADC_REF_Init(REF_INTERNAL_2P5V,REF_INTERNAL_2P5V);/* 1. 初始化内部基准源 */ 
//	ADC_Init(ADC_0, sampleData1.adc_cfg.SPS,  sampleData1.adc_cfg.Gain,  sampleData1.adc_cfg.PChan,  sampleData1.adc_cfg.NChan);	/* 2. 初始化ADC0 */  
//	ADC_register_irq_callback(ADC_0,ADC0_SingleIRQ_Callback);
//	StartADC(ADC_0);
//}
////ADC1......


////中断双ADC同步开始转换控制---------------------------------------------------------------
////转换完成中断
//void ADC_SyncIRQ_Callback(void)
//{
//	if(sampleData2.skip_num) {sampleData2.skip_num -- ; return; }
//	//读取采样数据
//	sampleData2.adc_buffer[0] += ADC_ReadData(ADC_0); //多重采样累计
//	sampleData2.adc_buffer[1] += ADC_ReadData(ADC_1); //多重采样累计
//  sampleData2.counter++; 												// 采样次数自增 
//}
//void ComputeSyncADCSampleData(void) //计算样本数据
//{
//	StopADC(ADC_0);	
//	StopADC(ADC_1);
//	//采集数量求平均
//	if(sampleData2.counter != 0) 
//	{
//		sampleData2.adc_buffer[0] /= (u32)sampleData2.counter;
//		sampleData2.adc_buffer[1] /= (u32)sampleData2.counter;
//	}
//}
//void StartADC_Sync_SampingData(void)
//{
//	sampleData2.adc_buffer[0] = 0 ;
//	sampleData2.adc_buffer[1] = 0 ;
//	sampleData2.counter =0 ;
//	sampleData2.skip_num  = 3 ;
//	ADC_REF_Init(REF_INTERNAL_2P5V,REF_INTERNAL_2P5V);/* 1. 初始化内部基准源 */
//	ADC_Init(ADC_0, sampleData2.adc_cfg.SPS, sampleData2.adc_cfg.Gain0, sampleData2.adc_cfg.PChan0, sampleData2.adc_cfg.NChan0);	/* 2. 初始化ADC0 */  
//	ADC_Init(ADC_1, sampleData2.adc_cfg.SPS, sampleData2.adc_cfg.Gain1, sampleData2.adc_cfg.PChan1, sampleData2.adc_cfg.NChan1);	/* 3. 初始化ADC1 */
//	ADC_SyncCmd(ENABLE);/* 4. ADC同步使能 */
//	ADC_register_irq_callback(ADC_0,ADC_SyncIRQ_Callback);//只需开启ADC_0
//	StartADC(ADC_0);//只需开启ADC_0
//}


////DMA单ADC开始转换控制---------------------------------------------------------------
//void DMAForSingleADC0_Callback()
//{
//	sampleData3.adcflag = 1;
//}
//void StartDMAForSingleADC0SampingData(void)
//{	
//	sampleData3.skip_num = 3;
//	ADC_REF_Init(REF_INTERNAL_2P5V,REF_INTERNAL_2P5V);/* 1. 初始化内部基准源 */ 
//	ADC_Init(ADC_0, sampleData3.adc_cfg.SPS,  sampleData3.adc_cfg.Gain,  sampleData3.adc_cfg.PChan,  sampleData3.adc_cfg.NChan);	/* 2. 初始化ADC0 */  
////	ADC_DMA_Init(ADC_0,sampleData3.dma_buffer,sampleData3.samp_len+sampleData3.skip_num);
//	DMA_register_irq_callback(DMA_CHANNEL_ADC_0,NULL,DMAForSingleADC0_Callback);
//	DMA_StartADC(ADC_0);
//}
//u16 DMA_ComputeSingleSampleData_ADC0(void)
//{
//	u16 adcCode;
//	u32 adcCount;
//	u8 i ;
//	for(i = sampleData3.skip_num ; i < sampleData3.samp_len  ;i++)
//	{
//		adcCode = ((((sampleData3.dma_buffer[i] & 0xFFFFFF) | ((sampleData3.dma_buffer[i] & 0x800000) ? 0xFF000000 : 0)) >> 8) + 32768) & 0xFFFF;//处理成16位数据
//		adcCount += adcCode ;
//	}
//	adcCode = adcCount>>sampleData3.exponent;	
//  return  adcCode;
//}

////ADC1......

////DMA双ADC开始转换控制---------------------------------------------------------------
//void DMAForSyncADC0_Callback()
//{
//	sampleData4.adcflag[0] = 1;
//}
//void DMAForSyncADC1_Callback()
//{
//	sampleData4.adcflag[1] = 1;
//}
//void StartDMA_ForADCSyncSampingData(void)
//{
//	sampleData3.skip_num = 3;
//	ADC_REF_Init(REF_INTERNAL_2P5V,REF_INTERNAL_2P5V);/* 1. 初始化内部基准源 */
//	ADC_Init(ADC_0, sampleData4.adc_cfg.SPS, sampleData4.adc_cfg.Gain0, sampleData4.adc_cfg.PChan0, sampleData4.adc_cfg.NChan0);	/* 2. 初始化ADC0 */  
//	ADC_Init(ADC_1, sampleData4.adc_cfg.SPS, sampleData4.adc_cfg.Gain1, sampleData4.adc_cfg.PChan1, sampleData4.adc_cfg.NChan1);	/* 3. 初始化ADC1 */
//	
////	ADC_DMA_Init(ADC_0,sampleData4.dma_buffer[0],sampleData4.samp_len+sampleData4.skip_num);
////	ADC_DMA_Init(ADC_1,sampleData4.dma_buffer[1],sampleData4.samp_len+sampleData4.skip_num);
// 	DMA_register_irq_callback(DMA_CHANNEL_ADC_0,NULL,DMAForSyncADC0_Callback);
// 	DMA_register_irq_callback(DMA_CHANNEL_ADC_1,NULL,DMAForSyncADC1_Callback);

//	DMA_StartADC(ADC_0);
//	DMA_StartADC(ADC_1);
//}


#endif