ADC通道检测功能-单片机通用模板

使用ADC外设的流程：
先初始化ADC外设的时钟；
选择ADC的参考电压 以及需要采集的通道；
ADSOC=1 开始转换，死循环等待转换完成ADSOC=0；
从ADCDH、ADCDL数据寄存器取出ADC转换数值；
进行中位值平均滤波 、限幅平均滤波 、限幅消抖滤波 、滑动平均滤波 、加权递推平均滤波 、一阶互补滤波等滤波处理。
c 复制代码
//=============================================================================
//函数名称:ADCInit
//输	入:无
//输	出:无
//功	能:系统ADC外设初始化
//=============================================================================
void ADCInit(void)
{
	OPTION = (OPTION&ADCKS_Mask)|ADCKS_sys_4;	//ADC 时钟频率选择FSys/32
}

//=============================================================================
//函数名称:getChannelVal
//输	入:channel 通道
//输	出:无
//功	能:中位值平均滤波获取channel通道ADC值
//=============================================================================
u16 getChannelVal(u8 channel)
{
	u8 i=0;
	u16 adcValMin=0xffff,adcValMax=0;
	u16 adcValue=0,adcValueSum=0;
	ADCHS = (ADCHS & ~ADCHS_MASK)|channel;
	SET_ADVREFS_00;
	for(i=0;i<4;i++)
	{
		ADSOC = 1;
		while(ADSOC);
		adcValue = (ADCDH<<4)|(ADCDL>>4);
		adcValueSum += adcValue;
		if(adcValMin>adcValue)
			adcValMin=adcValue;
		if(adcValMax<adcValue)
			adcValMax=adcValue;
	}
	return	(adcValueSum-adcValMin-adcValMax)/2;
	//return	(adcValueSum-adcValMin-adcValMax)>>2;		//移位
}

//=============================================================================
//函数名称:setAdv_getChannelVal
//输	入:adv 参考电压 channel 通道
//输	出:adcValue 12bit的Adc数据
//功	能:设置参考电压ADV和通道channel获取ADC
//=============================================================================
u16 setAdv_getChannelVal(ADV adv,u8 channel)
{
	u16 adcValue=0;
	ADCHS = channel;
	switch(adv)
	{
		case ADV_VCC:
			SET_ADVREFS_00;
			break;
		case ADV_25:
			SET_ADVREFS_01;
			break;
		case ADV_4:
			SET_ADVREFS_02;
			break;
		case ADV_5:
			SET_ADVREFS_03;
			break;
	}
	
	ADSOC = 1;
	while(ADSOC);
	adcValue = (ADCDH<<4)|(ADCDL>>4);
	return	adcValue;
}

//=============================================================================
//函数名称:Lim_filter
//输	入:new_Adcdata 最新采集ADC limmit 限幅范围
//输	出:无
//功	能:限幅滤波,超出限定范围内波动取上一次的值
//=============================================================================
/*u16 Lim_filter(u16 new_Adcdata,u16 limmit)
{
	static u16 old_Adcdata;
	int deta;
	deta = (int)(new_Adcdata- old_Adcdata);
	if(deta < limmit && deta >-limmit)
	{
		old_Adcdata= new_Adcdata;
		return new_Adcdata;
	}
	else
	{
		old_Adcdata= new_Adcdata;
		return old_Adcdata;
	}
}
*/

//=============================================================================
//函数名称:Lim_filter
//输	入:new_Adcdata 最新采集ADC limmit 限幅范围 aveCnt 平均的总数
//输	出:无
//功	能:限幅平均滤波,限定范围内波动取最新值，达到aveCnt 后取平均
//=============================================================================
/*u16 Lim_ave_filter(u16 new_Adcdata,u16 limmit,u8 aveCnt)
{
 static u16 old_Adcdata=0,filterCnt=0;
 u16 new_value,adcValueSum =0;
 int deta=0;
 deta = (int)(new_Adcdata- old_Adcdata);
 if(deta < limmit && deta >-limmit)
  filter_v[filterCnt++]=new_value;
 if(filterCnt==aveCnt) filterCnt=0;
 for(count =0 ;count<aveCnt;count++)
  adcValueSum +=filter_v[count];
 return (adcValueSum /aveCnt);
*/
//=============================================================================
//函数名称:sort
//输	入:buf 数据 len 数据长度
//输	出:无
//功	能:排序  小到大（冒泡排序）
//=============================================================================
/*static void sort(u16 *buf, u8 len)
{
	u8 i,j;
	u16 temp;

	for (j = 0; j < len - 1; j++) //排序  小到大
	{
		for (i = j + 1; i < len; i++)
		{
			if (buf[j] > buf[i])
			{
				temp = buf[i];
				buf[i] = buf[j];
				buf[j] = temp;
			}
		}
	}
}
*/
//=============================================================================
//函数名称:Glide_ave_filter
//输	入:new_Adcdata 最新采集ADC aveCnt 平均的总数
//输	出:无
//功	能:滑动平均滤波,更新最新的值取平均
//=============================================================================
/*u16 Glide_ave_filter(u16 new_Adcdata, u8 aveCnt)
{
	u8 i;
	u16 adcValueSum = 0;
	u16 temp_buf[ADC_FILTER_CNT];
	
		for(i = 0; i < ADC_FILTER_CNT - 1; i++)  //去掉最旧
		{
			filter_v[i] = filter_v[i + 1];
		}
		filter_v[ADC_FILTER_CNT - 1] = new_Adcdata;  //最新值
		memcpy(temp_buf, filter_v, ADC_FILTER_CNT);
		
	sort(temp_buf, ADC_FILTER_CNT);  //排序  小到大


	for(i = aveCnt; i < ADC_FILTER_CNT - aveCnt; i++)
	{
		adcValueSum += temp_buf[i];
	}

	return (u16)(adcValueSum / (ADC_FILTER_CNT - aveCnt * 2));
}
*/