libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[bsp][stm32]Optimize ADCs and fix some bugs

This commit is contained in:
yiyi 2024-06-26 20:26:52 +08:00 committed by GitHub
parent 14e4c45408
commit bc3afab2c9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 116 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
bsp/stm32/libraries/HAL_Drivers/drivers/drv_adc.c
View File

@ -199,18 +199,19 @@ static rt_err_t stm32_adc_enabled(struct rt_adc_device *device, rt_int8_t channe
HAL_PWREx_EnableVddA(); HAL_PWREx_EnableVddA();
#endif /* defined(SOC_SERIES_STM32U5) */ #endif /* defined(SOC_SERIES_STM32U5) */
if(HAL_ADC_ConfigChannel(stm32_adc_handler, &ADC_ChanConf) != HAL_OK) if(HAL_ADC_ConfigChannel(stm32_adc_handler, &ADC_ChanConf) != HAL_OK)
{ {
LOG_E("Failed to configure ADC channel %d", channel); LOG_E("Failed to configure ADC channel %d", channel);
} return -RT_ERROR;
}
/* perform an automatic ADC calibration to improve the conversion accuracy */ /* perform an automatic ADC calibration to improve the conversion accuracy */
#if defined(SOC_SERIES_STM32L4) || defined (SOC_SERIES_STM32WB) #if defined(SOC_SERIES_STM32L4) || defined (SOC_SERIES_STM32WB)
if (HAL_ADCEx_Calibration_Start(stm32_adc_handler, ADC_ChanConf.SingleDiff) != HAL_OK) if (HAL_ADCEx_Calibration_Start(stm32_adc_handler, ADC_ChanConf.SingleDiff) != HAL_OK)
{ {
LOG_E("ADC calibration error!\n"); LOG_E("ADC calibration error!\n");
return -RT_ERROR; return -RT_ERROR;
} }
#elif defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32U5) #elif defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32U5)
/* Run the ADC linear calibration in single-ended mode */ /* Run the ADC linear calibration in single-ended mode */
if (HAL_ADCEx_Calibration_Start(stm32_adc_handler, ADC_CALIB_OFFSET_LINEARITY, ADC_ChanConf.SingleDiff) != HAL_OK) if (HAL_ADCEx_Calibration_Start(stm32_adc_handler, ADC_CALIB_OFFSET_LINEARITY, ADC_ChanConf.SingleDiff) != HAL_OK)
@ -220,11 +221,14 @@ static rt_err_t stm32_adc_enabled(struct rt_adc_device *device, rt_int8_t channe
return -RT_ERROR; return -RT_ERROR;
} }
#endif #endif
HAL_ADC_Start(stm32_adc_handler);
} }
else else
{ {
HAL_ADC_Stop(stm32_adc_handler); if (HAL_ADC_Stop(stm32_adc_handler) != HAL_OK)
{
LOG_E("Stop ADC conversion failed!\n");
return -RT_ERROR;
}
} }
return RT_EOK; return RT_EOK;
@ -255,33 +259,62 @@ static rt_uint8_t stm32_adc_get_resolution(struct rt_adc_device *device)
return 10; return 10;
case ADC_RESOLUTION_8B: case ADC_RESOLUTION_8B:
return 8; return 8;
#if defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32U5) #if defined(SOC_SERIES_STM32H7) && (ADC_VER_V5_V90) || defined(SOC_SERIES_STM32U5)
case ADC_RESOLUTION_6B: case ADC_RESOLUTION_6B:
return 6; return 6;
#endif /* defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32U5) */ #endif /* defined(SOC_SERIES_STM32H7) && (ADC_VER_V5_V90) || defined(SOC_SERIES_STM32U5) */
default: default:
return 0; return 0;
} }
#endif /* defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F3) */ #endif /* defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F3) */
} }
static rt_err_t stm32_adc_get_value(struct rt_adc_device *device, rt_int8_t channel, rt_uint32_t *value)
{
ADC_HandleTypeDef *stm32_adc_handler;
RT_ASSERT(device != RT_NULL);
RT_ASSERT(value != RT_NULL);
stm32_adc_handler = device->parent.user_data;
if (HAL_ADC_Start(stm32_adc_handler) != HAL_OK)
{
LOG_E("Start ADC conversion error!\n");
return -RT_ERROR;
}
/* Wait for the ADC to convert */
if (HAL_ADC_PollForConversion(stm32_adc_handler, 100) != RT_EOK)
{
LOG_E("ADC conversion error!\n");
return -RT_ERROR;
}
/* get ADC value */
*value = (rt_uint32_t)HAL_ADC_GetValue(stm32_adc_handler);
return RT_EOK;
}
static rt_int16_t stm32_adc_get_vref (struct rt_adc_device *device) static rt_int16_t stm32_adc_get_vref (struct rt_adc_device *device)
{ {
if(device == RT_NULL)
return -RT_ERROR;
rt_uint16_t vref_mv; rt_uint16_t vref_mv;
#ifdef __LL_ADC_CALC_VREFANALOG_VOLTAGE #ifdef __LL_ADC_CALC_VREFANALOG_VOLTAGE
rt_err_t ret = RT_EOK; rt_err_t ret;
rt_uint32_t vref_value; rt_uint32_t vref_value;
ADC_HandleTypeDef *stm32_adc_handler = device->parent.user_data; ADC_HandleTypeDef *stm32_adc_handler = device->parent.user_data;
ret = rt_adc_enable(device, RT_ADC_INTERN_CH_VREF); ret = stm32_adc_enabled(device, RT_ADC_INTERN_CH_VREF, RT_TRUE);
if (ret != RT_EOK) return (rt_int16_t)ret; if (ret != RT_EOK)
vref_value = rt_adc_read(device, RT_ADC_INTERN_CH_VREF); return 0;
ret = rt_adc_disable(device, RT_ADC_INTERN_CH_VREF); ret = stm32_adc_get_value(device, RT_ADC_INTERN_CH_VREF, &vref_value);
if (ret != RT_EOK) return (rt_int16_t)ret; if (ret != RT_EOK)
return 0;
ret = stm32_adc_enabled(device, RT_ADC_INTERN_CH_VREF, RT_FALSE);
if (ret != RT_EOK)
return 0;
#ifdef SOC_SERIES_STM32U5 #ifdef SOC_SERIES_STM32U5
vref_mv = __LL_ADC_CALC_VREFANALOG_VOLTAGE(stm32_adc_handler->Instance, vref_value, stm32_adc_handler->Init.Resolution); vref_mv = __LL_ADC_CALC_VREFANALOG_VOLTAGE(stm32_adc_handler->Instance, vref_value, stm32_adc_handler->Init.Resolution);
@ -295,24 +328,6 @@ static rt_int16_t stm32_adc_get_vref (struct rt_adc_device *device)
return vref_mv; return vref_mv;
} }
static rt_err_t stm32_adc_get_value(struct rt_adc_device *device, rt_int8_t channel, rt_uint32_t *value)
{
ADC_HandleTypeDef *stm32_adc_handler;
RT_ASSERT(device != RT_NULL);
RT_ASSERT(value != RT_NULL);
stm32_adc_handler = device->parent.user_data;
/* Wait for the ADC to convert */
HAL_ADC_PollForConversion(stm32_adc_handler, 100);
/* get ADC value */
*value = (rt_uint32_t)HAL_ADC_GetValue(stm32_adc_handler);
return RT_EOK;
}
static const struct rt_adc_ops stm_adc_ops = static const struct rt_adc_ops stm_adc_ops =
{ {
.enabled = stm32_adc_enabled, .enabled = stm32_adc_enabled,

117
components/drivers/misc/adc.c
View File

@ -22,14 +22,14 @@
static rt_ssize_t _adc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) static rt_ssize_t _adc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{ {
rt_err_t result = RT_EOK; rt_err_t result;
rt_size_t i; rt_size_t i;
struct rt_adc_device *adc = (struct rt_adc_device *)dev; struct rt_adc_device *adc = (struct rt_adc_device *)dev;
rt_uint32_t *value = (rt_uint32_t *)buffer; rt_uint32_t *value = (rt_uint32_t *)buffer;
for (i = 0; i < size; i += sizeof(int)) for (i = 0; i < size; i++)
{ {
result = adc->ops->convert(adc, pos + i, value); result = adc->ops->convert(adc, pos, value);
if (result != RT_EOK) if (result != RT_EOK)
{ {
return 0; return 0;
@ -42,8 +42,9 @@ static rt_ssize_t _adc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size
static rt_err_t _adc_control(rt_device_t dev, int cmd, void *args) static rt_err_t _adc_control(rt_device_t dev, int cmd, void *args)
{ {
rt_err_t result = -RT_EINVAL;
rt_adc_device_t adc = (struct rt_adc_device *)dev; rt_adc_device_t adc = (struct rt_adc_device *)dev;
rt_err_t result;
if (cmd == RT_ADC_CMD_ENABLE && adc->ops->enabled) if (cmd == RT_ADC_CMD_ENABLE && adc->ops->enabled)
{ {
@ -56,9 +57,9 @@ static rt_err_t _adc_control(rt_device_t dev, int cmd, void *args)
else if (cmd == RT_ADC_CMD_GET_RESOLUTION && adc->ops->get_resolution && args) else if (cmd == RT_ADC_CMD_GET_RESOLUTION && adc->ops->get_resolution && args)
{ {
rt_uint8_t resolution = adc->ops->get_resolution(adc); rt_uint8_t resolution = adc->ops->get_resolution(adc);
if(resolution != 0) if (resolution != 0)
{ {
*((rt_uint8_t*)args) = resolution; *((rt_uint8_t *)args) = resolution;
LOG_D("resolution: %d bits", resolution); LOG_D("resolution: %d bits", resolution);
result = RT_EOK; result = RT_EOK;
} }
@ -66,10 +67,10 @@ static rt_err_t _adc_control(rt_device_t dev, int cmd, void *args)
else if (cmd == RT_ADC_CMD_GET_VREF && adc->ops->get_vref && args) else if (cmd == RT_ADC_CMD_GET_VREF && adc->ops->get_vref && args)
{ {
rt_int16_t value = adc->ops->get_vref(adc); rt_int16_t value = adc->ops->get_vref(adc);
if(value != 0) if (value != 0)
{ {
*((rt_int16_t *) args) = value; *((rt_int16_t *)args) = value;
result = RT_EOK; result = RT_EOK;
} }
} }
@ -78,36 +79,36 @@ static rt_err_t _adc_control(rt_device_t dev, int cmd, void *args)
#ifdef RT_USING_DEVICE_OPS #ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops adc_ops = const static struct rt_device_ops adc_ops =
{ {
RT_NULL, RT_NULL,
RT_NULL, RT_NULL,
RT_NULL, RT_NULL,
_adc_read, _adc_read,
RT_NULL, RT_NULL,
_adc_control, _adc_control,
}; };
#endif #endif
rt_err_t rt_hw_adc_register(rt_adc_device_t device, const char *name, const struct rt_adc_ops *ops, const void *user_data) rt_err_t rt_hw_adc_register(rt_adc_device_t device, const char *name, const struct rt_adc_ops *ops, const void *user_data)
{ {
rt_err_t result = RT_EOK;
RT_ASSERT(ops != RT_NULL && ops->convert != RT_NULL); RT_ASSERT(ops != RT_NULL && ops->convert != RT_NULL);
rt_err_t result;
device->parent.type = RT_Device_Class_ADC; device->parent.type = RT_Device_Class_ADC;
device->parent.rx_indicate = RT_NULL; device->parent.rx_indicate = RT_NULL;
device->parent.tx_complete = RT_NULL; device->parent.tx_complete = RT_NULL;
#ifdef RT_USING_DEVICE_OPS #ifdef RT_USING_DEVICE_OPS
device->parent.ops = &adc_ops; device->parent.ops = &adc_ops;
#else #else
device->parent.init = RT_NULL; device->parent.init = RT_NULL;
device->parent.open = RT_NULL; device->parent.open = RT_NULL;
device->parent.close = RT_NULL; device->parent.close = RT_NULL;
device->parent.read = _adc_read; device->parent.read = _adc_read;
device->parent.write = RT_NULL; device->parent.write = RT_NULL;
device->parent.control = _adc_control; device->parent.control = _adc_control;
#endif #endif
device->ops = ops; device->ops = ops;
device->parent.user_data = (void *)user_data; device->parent.user_data = (void *)user_data;
result = rt_device_register(&device->parent, name, RT_DEVICE_FLAG_RDWR); result = rt_device_register(&device->parent, name, RT_DEVICE_FLAG_RDWR);
@ -117,20 +118,21 @@ rt_err_t rt_hw_adc_register(rt_adc_device_t device, const char *name, const stru
rt_uint32_t rt_adc_read(rt_adc_device_t dev, rt_int8_t channel) rt_uint32_t rt_adc_read(rt_adc_device_t dev, rt_int8_t channel)
{ {
rt_uint32_t value;
RT_ASSERT(dev); RT_ASSERT(dev);
rt_uint32_t value;
rt_err_t result;
dev->ops->convert(dev, channel, &value); result = dev->ops->convert(dev, channel, &value);
if (result != RT_EOK)
return 0;
return value; return value;
} }
rt_err_t rt_adc_enable(rt_adc_device_t dev, rt_int8_t channel) rt_err_t rt_adc_enable(rt_adc_device_t dev, rt_int8_t channel)
{ {
rt_err_t result = RT_EOK;
RT_ASSERT(dev); RT_ASSERT(dev);
rt_err_t result;
if (dev->ops->enabled != RT_NULL) if (dev->ops->enabled != RT_NULL)
{ {
@ -146,9 +148,8 @@ rt_err_t rt_adc_enable(rt_adc_device_t dev, rt_int8_t channel)
rt_err_t rt_adc_disable(rt_adc_device_t dev, rt_int8_t channel) rt_err_t rt_adc_disable(rt_adc_device_t dev, rt_int8_t channel)
{ {
rt_err_t result = RT_EOK;
RT_ASSERT(dev); RT_ASSERT(dev);
rt_err_t result;
if (dev->ops->enabled != RT_NULL) if (dev->ops->enabled != RT_NULL)
{ {
@ -164,26 +165,30 @@ rt_err_t rt_adc_disable(rt_adc_device_t dev, rt_int8_t channel)
rt_int16_t rt_adc_voltage(rt_adc_device_t dev, rt_int8_t channel) rt_int16_t rt_adc_voltage(rt_adc_device_t dev, rt_int8_t channel)
{ {
rt_uint32_t value = 0;
rt_int16_t vref = 0, voltage = 0;
rt_uint8_t resolution = 0;
RT_ASSERT(dev); RT_ASSERT(dev);
/*get the resolution in bits*/ rt_uint32_t value;
if (_adc_control((rt_device_t) dev, RT_ADC_CMD_GET_RESOLUTION, &resolution) != RT_EOK) rt_int16_t vref, voltage;
{ rt_uint8_t resolution;
goto _voltage_exit; rt_err_t result;
}
/*get the resolution in bits*/
resolution = dev->ops->get_resolution(dev);
/*get the reference voltage*/ /*get the reference voltage*/
if (_adc_control((rt_device_t) dev, RT_ADC_CMD_GET_VREF, &vref) != RT_EOK) vref = dev->ops->get_vref(dev);
{ if (vref == 0)
goto _voltage_exit; goto _voltage_exit;
}
/*read the value and convert to voltage*/ /*read the value and convert to voltage*/
dev->ops->convert(dev, channel, &value); result = dev->ops->enabled(dev, channel, RT_TRUE);
if (result != RT_EOK)
goto _voltage_exit;
result = dev->ops->convert(dev, channel, &value);
if (result != RT_EOK)
goto _voltage_exit;
result = dev->ops->enabled(dev, channel, RT_FALSE);
if (result != RT_EOK)
goto _voltage_exit;
voltage = value * vref / ((1 << resolution) - 1); voltage = value * vref / ((1 << resolution) - 1);
_voltage_exit: _voltage_exit:
@ -194,11 +199,11 @@ _voltage_exit:
static int adc(int argc, char **argv) static int adc(int argc, char **argv)
{ {
int value = 0; int value = 0;
rt_int16_t voltage = 0; rt_int16_t voltage = 0;
rt_err_t result = -RT_ERROR; rt_err_t result = -RT_ERROR;
static rt_adc_device_t adc_device = RT_NULL; static rt_adc_device_t adc_device = RT_NULL;
char *result_str; char *result_str;
if (argc > 1) if (argc > 1)
{ {
@ -226,7 +231,7 @@ static int adc(int argc, char **argv)
{ {
if (argc == 3) if (argc == 3)
{ {
result = rt_adc_enable(adc_device, atoi(argv[2])); result = rt_adc_enable(adc_device, atoi(argv[2]));
result_str = (result == RT_EOK) ? "success" : "failure"; result_str = (result == RT_EOK) ? "success" : "failure";
rt_kprintf("%s channel %d enables %s \n", adc_device->parent.parent.name, (rt_base_t)atoi(argv[2]), result_str); rt_kprintf("%s channel %d enables %s \n", adc_device->parent.parent.name, (rt_base_t)atoi(argv[2]), result_str);
} }
@ -251,7 +256,7 @@ static int adc(int argc, char **argv)
{ {
if (argc == 3) if (argc == 3)
{ {
result = rt_adc_disable(adc_device, atoi(argv[2])); result = rt_adc_disable(adc_device, atoi(argv[2]));
result_str = (result == RT_EOK) ? "success" : "failure"; result_str = (result == RT_EOK) ? "success" : "failure";
rt_kprintf("%s channel %d disable %s \n", adc_device->parent.parent.name, (rt_base_t)atoi(argv[2]), result_str); rt_kprintf("%s channel %d disable %s \n", adc_device->parent.parent.name, (rt_base_t)atoi(argv[2]), result_str);
} }
@ -262,7 +267,7 @@ static int adc(int argc, char **argv)
} }
else if (!strcmp(argv[1], "voltage")) else if (!strcmp(argv[1], "voltage"))
{ {
if(argc == 3) if (argc == 3)
{ {
voltage = rt_adc_voltage(adc_device, atoi(argv[2])); voltage = rt_adc_voltage(adc_device, atoi(argv[2]));
rt_kprintf("%s channel %d voltage is %d.%03dV \n", adc_device->parent.parent.name, (rt_base_t)atoi(argv[2]), voltage / 1000, voltage % 1000); rt_kprintf("%s channel %d voltage is %d.%03dV \n", adc_device->parent.parent.name, (rt_base_t)atoi(argv[2]), voltage / 1000, voltage % 1000);