322 lines
5.7 KiB
C
322 lines
5.7 KiB
C
|
|
#include "adcctrl.h"
|
|
|
|
#if (MAX_ADC1_CHANNEL_NUM != 0 || MAX_ADC2_CHANNEL_NUM != 0 || MAX_ADC3_CHANNEL_NUM != 0)
|
|
|
|
#include "adc.h"
|
|
|
|
|
|
#include "filter.h"
|
|
|
|
#if (MAX_ADC1_CHANNEL_NUM > 0)
|
|
|
|
//-------------------------------------------------------------------------------
|
|
|
|
// ad 的滤波等级
|
|
#ifndef ADC1_FILTER_NUM
|
|
#define ADC1_FILTER_NUM (20) // 滤波次数
|
|
#endif
|
|
|
|
#ifndef HADC1
|
|
#define HADC1 hadc1
|
|
#endif
|
|
|
|
#define ADC1VALBUFSIZE (ADC1_FILTER_NUM * MAX_ADC1_CHANNEL_NUM)
|
|
|
|
u16 g_adc1valuebuf[ADC1VALBUFSIZE];
|
|
|
|
LPF1stData g_adc1lpf1st[MAX_ADC1_CHANNEL_NUM];
|
|
LPF2ndData g_adc1lpf2nd[MAX_ADC1_CHANNEL_NUM];
|
|
static int g_adc1Inited = 0;
|
|
|
|
void InitADC1(void)
|
|
{
|
|
int i;
|
|
|
|
if (g_adc1Inited == 0)
|
|
{
|
|
g_adc1Inited = 1;
|
|
memset(g_adc1valuebuf, 0, ADC1VALBUFSIZE*sizeof(u16));
|
|
|
|
// 初始化滤波器
|
|
for (i = 0; i < MAX_ADC1_CHANNEL_NUM; i++)
|
|
{
|
|
memcpy(&g_adc1lpf1st[i], &defaultLPF1st, sizeof(LPF1stData));
|
|
memcpy(&g_adc1lpf2nd[i], &defaultLPF2nd, sizeof(LPF2ndData));
|
|
}
|
|
HAL_ADC_Start_DMA(&HADC1, (u32*)(&g_adc1valuebuf[0]), ADC1VALBUFSIZE);
|
|
HAL_ADC_Start(&HADC1);
|
|
}
|
|
}
|
|
|
|
void ADC1IntProc(void)
|
|
{
|
|
/*
|
|
if(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == SET)
|
|
{
|
|
ADC_ClearFlag(ADC1,ADC_FLAG_EOC);
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*
|
|
* HAL_ADC_PollForConversion(&HADC1, 0); // 等待转换完成
|
|
* if (HAL_IS_BIT_SET(HAL_ADC_GetState(&HADC1), HAL_ADC_STATE_REG_EOC))
|
|
* ADC中断模式只支持单通道
|
|
* ADC中断回调函数
|
|
*/
|
|
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
|
|
{
|
|
static int i = 0;
|
|
|
|
g_adc1valuebuf[i] = HAL_ADC_GetValue(hadc);
|
|
i++;
|
|
if (i >= ADC1VALBUFSIZE)
|
|
{
|
|
i = 0;
|
|
}
|
|
}
|
|
|
|
s32 GetADC1Value(int channelIdx, int flev)
|
|
{
|
|
int i;
|
|
s32 value = 0;
|
|
int buff[ADC1_FILTER_NUM];
|
|
int * pTBuf;
|
|
u16 * pSBuf;
|
|
|
|
if (g_adc1Inited == 0 || channelIdx < 0 || channelIdx >= MAX_ADC1_CHANNEL_NUM)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// 拷贝当前通道的采集数据
|
|
pSBuf = &(g_adc1valuebuf[channelIdx]);
|
|
pTBuf = &(buff[0]);
|
|
for (i = 0; i < ADC1_FILTER_NUM; i++)
|
|
{
|
|
*pTBuf = (int)(*pSBuf);
|
|
pTBuf++;
|
|
pSBuf += MAX_ADC1_CHANNEL_NUM;
|
|
}
|
|
|
|
// 默认为中位值平均滤波法
|
|
value = MAFilter(buff, ADC1_FILTER_NUM);
|
|
|
|
// 一阶滤波
|
|
if (flev >= 1)
|
|
{
|
|
value = LPF1st(&g_adc1lpf1st[channelIdx], value);
|
|
}
|
|
|
|
// 二阶滤波
|
|
if (flev >= 2)
|
|
{
|
|
value = LPF2nd(&g_adc1lpf2nd[channelIdx], value);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
#endif
|
|
|
|
//----------------------------------------------
|
|
|
|
#if (MAX_ADC2_CHANNEL_NUM > 0)
|
|
|
|
// ad 的滤波等级
|
|
#ifndef ADC2_FILTER_NUM
|
|
#define ADC2_FILTER_NUM (10) // 滤波次数
|
|
#endif
|
|
|
|
#ifndef HADC2
|
|
#define HADC2 hadc2
|
|
#endif
|
|
|
|
#define ADC2VALBUFSIZE (ADC2_FILTER_NUM * MAX_ADC2_CHANNEL_NUM)
|
|
|
|
u16 g_adc2valuebuf[ADC2VALBUFSIZE];
|
|
|
|
LPF1stData g_adc2lpf1st[MAX_ADC2_CHANNEL_NUM];
|
|
LPF2ndData g_adc2lpf2nd[MAX_ADC2_CHANNEL_NUM];
|
|
static int g_adc2Inited = 0;
|
|
|
|
void InitADC2(void)
|
|
{
|
|
int i;
|
|
|
|
if (g_adc2Inited == 0)
|
|
{
|
|
g_adc2Inited = 1;
|
|
memset(g_adc2valuebuf, 0, ADC2VALBUFSIZE*sizeof(u16));
|
|
|
|
// 初始化滤波器
|
|
for (i = 0; i < MAX_ADC2_CHANNEL_NUM; i++)
|
|
{
|
|
memcpy(&g_adc2lpf1st[i], &defaultLPF1st, sizeof(LPF1stData));
|
|
memcpy(&g_adc2lpf2nd[i], &defaultLPF2nd, sizeof(LPF2ndData));
|
|
}
|
|
|
|
HAL_ADC_Start_DMA(&HADC2, (u32*)(&g_adc2valuebuf[0]), ADC2VALBUFSIZE);
|
|
HAL_ADC_Start(&HADC2);
|
|
}
|
|
}
|
|
|
|
void ADC2IntProc(void)
|
|
{
|
|
/*
|
|
if(ADC_GetFlagStatus(ADC2, ADC_FLAG_EOC) == SET)
|
|
{
|
|
ADC_ClearFlag(ADC2,ADC_FLAG_EOC);
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
s32 GetADC2Value(int channelIdx, int flev)
|
|
{
|
|
int i;
|
|
s32 value = 0;
|
|
int buff[ADC2_FILTER_NUM];
|
|
int * pTBuf;
|
|
u16 * pSBuf;
|
|
|
|
if (g_adc2Inited == 0 || channelIdx < 0 || channelIdx >= MAX_ADC2_CHANNEL_NUM)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// 拷贝当前通道的采集数据
|
|
pSBuf = &(g_adc2valuebuf[channelIdx]);
|
|
pTBuf = &(buff[0]);
|
|
for (i = 0; i < ADC2_FILTER_NUM; i++)
|
|
{
|
|
*pTBuf = (int)(*pSBuf);
|
|
pTBuf++;
|
|
pSBuf += MAX_ADC2_CHANNEL_NUM;
|
|
}
|
|
|
|
// 默认为中位值平均滤波法
|
|
value = MAFilter(buff, ADC2_FILTER_NUM);
|
|
|
|
// 一阶滤波
|
|
if (flev >= 1)
|
|
{
|
|
value = LPF1st(&g_adc2lpf1st[channelIdx], value);
|
|
}
|
|
|
|
// 二阶滤波
|
|
if (flev >= 2)
|
|
{
|
|
value = LPF2nd(&g_adc2lpf2nd[channelIdx], value);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
#endif
|
|
|
|
//-------------------------------------------------------------------------------
|
|
|
|
#if (MAX_ADC3_CHANNEL_NUM > 0)
|
|
// ad 的滤波等级
|
|
#ifndef ADC3_FILTER_NUM
|
|
#define ADC3_FILTER_NUM 5
|
|
#endif
|
|
|
|
#ifndef HADC3
|
|
#define HADC3 hadc3
|
|
#endif
|
|
|
|
#define ADC3VALBUFSIZE (ADC3_FILTER_NUM * MAX_ADC3_CHANNEL_NUM)
|
|
|
|
u16 g_adc3valuebuf[ADC3VALBUFSIZE];
|
|
|
|
LPF1stData g_adc3lpf1st[MAX_ADC3_CHANNEL_NUM];
|
|
LPF2ndData g_adc3lpf2nd[MAX_ADC3_CHANNEL_NUM];
|
|
static int g_adc3Inited = 0;
|
|
|
|
|
|
void InitADC3(void)
|
|
{
|
|
int i;
|
|
|
|
if (g_adc3Inited == 0)
|
|
{
|
|
g_adc3Inited = 1;
|
|
memset(g_adc3valuebuf, 0, ADC3VALBUFSIZE*sizeof(u16));
|
|
|
|
// 初始化滤波器
|
|
for (i = 0; i < MAX_ADC3_CHANNEL_NUM; i++)
|
|
{
|
|
memcpy(&g_adc3lpf1st[i], &defaultLPF1st, sizeof(LPF1stData));
|
|
memcpy(&g_adc3lpf2nd[i], &defaultLPF2nd, sizeof(LPF2ndData));
|
|
}
|
|
|
|
HAL_ADC_Start_DMA(&HADC3, (u32*)(&g_adc3valuebuf[0]), ADC3VALBUFSIZE);
|
|
HAL_ADC_Start(&HADC3);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void ADC3IntProc(void)
|
|
{
|
|
/*
|
|
if(ADC_GetFlagStatus(ADC3, ADC_FLAG_EOC) == SET)
|
|
{
|
|
ADC_ClearFlag(ADC3,ADC_FLAG_EOC);
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
s32 GetADC3Value(int channelIdx, int flev)
|
|
{
|
|
int i;
|
|
s32 value = 0;
|
|
int buff[ADC3_FILTER_NUM];
|
|
int * pTBuf;
|
|
u16 * pSBuf;
|
|
|
|
if (g_adc3Inited == 0 || channelIdx < 0 || channelIdx >= MAX_ADC3_CHANNEL_NUM)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// 拷贝当前通道的采集数据
|
|
pSBuf = &(g_adc3valuebuf[channelIdx]);
|
|
pTBuf = &(buff[0]);
|
|
for (i = 0; i < ADC3_FILTER_NUM; i++)
|
|
{
|
|
*pTBuf = (int)(*pSBuf);
|
|
pTBuf++;
|
|
pSBuf += MAX_ADC3_CHANNEL_NUM;
|
|
}
|
|
|
|
// 默认为中位值平均滤波法
|
|
value = MAFilter(buff, ADC3_FILTER_NUM);
|
|
|
|
// 一阶滤波
|
|
if (flev >= 1)
|
|
{
|
|
value = LPF1st(&g_adc3lpf1st[channelIdx], value);
|
|
}
|
|
|
|
// 二阶滤波
|
|
if (flev >= 2)
|
|
{
|
|
value = LPF2nd(&g_adc3lpf2nd[channelIdx], value);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
//-------------------------------------------------------------------------------
|
|
|
|
#endif
|
|
|