bsp/adcs.c

@@ -2,7 +2,7 @@
  * @file adcs.c
  * @author xxx
  * @date 2023-09-04 15:59:16
- * @brief LL库ADC驱动  STM32F407
+ * @brief LL库ADC驱动
  * @copyright Copyright (c) 2023 by xxx, All Rights Reserved.
  */
 
@@ -23,7 +23,7 @@ static uint8_t adc_get_channels_count(uint32_t channnels); // 通过用户配置
  * @return {*}
  * @note TCONV(转换时间) = (采样时间 + 12.5 个周期)/(主频/ADC分频系数)
  */
-void adc_init(adcs_e num, ADC_TypeDef *adc, DMA_TypeDef *dma, uint32_t dma_stream, uint32_t dma_channel, uint16_t adc_cct, uint32_t channels)
+void adc_init(adcs_e num, ADC_TypeDef *adc, DMA_TypeDef *dma, uint32_t dma_channel, uint16_t adc_cct, uint32_t channels)
 {
     DBG_ASSERT(num < ADCS_MAX __DBG_LINE);
     DBG_ASSERT(adc != NULL __DBG_LINE);
@@ -34,7 +34,6 @@ void adc_init(adcs_e num, ADC_TypeDef *adc, DMA_TypeDef *dma, uint32_t dma_strea
     osel_memset((uint8_t *)p, 0, sizeof(adcs_t));
     p->adc = adc;
     p->dma = dma;
-    p->dma_stream = dma_stream;
     p->dma_channel = dma_channel;
     p->channels.data = channels;
     p->adc_cct = adc_cct;
@@ -50,40 +49,36 @@ void adc_init(adcs_e num, ADC_TypeDef *adc, DMA_TypeDef *dma, uint32_t dma_strea
     DBG_ASSERT(p->adc_value != NULL __DBG_LINE);
     osel_memset((uint8_t *)p->adc_value, 0, sizeof(uint16_t) * p->adc_sum);
 
-    LL_DMA_SetChannelSelection(p->dma, p->dma_stream, p->dma_channel);
+    uint32_t backup_setting_adc_dma_transfer = 0U;
-    LL_DMA_ConfigTransfer(p->dma, p->dma_stream,
+    backup_setting_adc_dma_transfer = LL_ADC_REG_GetDMATransfer(p->adc);
-                          LL_DMA_DIRECTION_PERIPH_TO_MEMORY |
+    LL_ADC_REG_SetDMATransfer(p->adc, LL_ADC_REG_DMA_TRANSFER_NONE);
-                              LL_DMA_MODE_CIRCULAR |
-                              LL_DMA_PERIPH_NOINCREMENT |
-                              LL_DMA_MEMORY_INCREMENT |
-                              LL_DMA_PDATAALIGN_HALFWORD |
-                              LL_DMA_MDATAALIGN_HALFWORD |
-                              LL_DMA_PRIORITY_HIGH);
-    LL_DMA_ConfigAddresses(p->dma, p->dma_stream,
-                           LL_ADC_DMA_GetRegAddr(p->adc, LL_ADC_DMA_REG_REGULAR_DATA),
-                           (uint32_t)p->adc_value,
-                           LL_DMA_GetDataTransferDirection(p->dma, p->dma_stream));
 
-    LL_DMA_SetDataLength(p->dma, p->dma_stream, p->adc_sum);
+    // ADC开始校准
-    LL_DMA_EnableStream(p->dma, p->dma_stream);
+    LL_ADC_StartCalibration(p->adc, LL_ADC_SINGLE_ENDED);
-
+    // 等待校准完成
-    LL_ADC_REG_SetContinuousMode(p->adc, LL_ADC_REG_CONV_CONTINUOUS);
+    while (LL_ADC_IsCalibrationOnGoing(p->adc))
-    LL_ADC_REG_SetDMATransfer(p->adc, LL_ADC_REG_DMA_TRANSFER_UNLIMITED);
+        ;
+    LL_ADC_REG_SetDMATransfer(p->adc, backup_setting_adc_dma_transfer);
+    LL_mDelay(10);
+    LL_ADC_EnableIT_OVR(p->adc);
+    LL_ADC_Enable(p->adc);
+    LL_mDelay(10);
 
     if (BIT_IS_SET(channels, INVREF))
     {
         // 使能VREFINT
         LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(p->adc), LL_ADC_PATH_INTERNAL_VREFINT);
     }
-    if (BIT_IS_SET(channels, INTEMP))
-    {
-        LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(p->adc), LL_ADC_PATH_INTERNAL_TEMPSENSOR);
-    }
 
-    LL_mDelay(10);
+    LL_DMA_SetDataLength(p->dma, p->dma_channel, p->adc_sum);
-    // 启动 ADC 转换
+    LL_DMA_SetPeriphAddress(p->dma, p->dma_channel, LL_ADC_DMA_GetRegAddr(p->adc, LL_ADC_DMA_REG_REGULAR_DATA));
-    LL_ADC_Enable(p->adc);
+    LL_DMA_SetMemoryAddress(p->dma, p->dma_channel, (uint32_t)p->adc_value);
-    LL_ADC_REG_StartConversionSWStart(p->adc);
+    LL_DMA_EnableChannel(p->dma, p->dma_channel);
+
+    if (backup_setting_adc_dma_transfer == LL_ADC_REG_DMA_TRANSFER_UNLIMITED)
+    {
+        LL_ADC_REG_StartConversion(p->adc); // 开始转换
+    }
 }
 
 /**
@@ -96,7 +91,18 @@ void adc_init(adcs_e num, ADC_TypeDef *adc, DMA_TypeDef *dma, uint32_t dma_strea
 void start_sample(adcs_e num)
 {
     DBG_ASSERT(num < ADCS_MAX __DBG_LINE);
-    // adcs_t *p = &adcs[num];
+    adcs_t *p = &adcs[num];
+    LL_DMA_SetDataLength(p->dma, p->dma_channel, p->adc_sum);
+    LL_DMA_SetPeriphAddress(p->dma, p->dma_channel, LL_ADC_DMA_GetRegAddr(p->adc, LL_ADC_DMA_REG_REGULAR_DATA));
+    LL_DMA_SetMemoryAddress(p->dma, p->dma_channel, (uint32_t)p->adc_value);
+    LL_DMA_EnableChannel(p->dma, p->dma_channel);
+
+    LL_ADC_ClearFlag_OVR(p->adc);
+    LL_ADC_ClearFlag_EOC(p->adc);
+    LL_ADC_REG_StartConversion(p->adc); // 开始转换
+
+    // ADC开始校准
+    LL_ADC_StartCalibration(p->adc, LL_ADC_SINGLE_ENDED);
 }
 
 /**
@@ -109,7 +115,14 @@ void start_sample(adcs_e num)
 void stop_sample(adcs_e num)
 {
     DBG_ASSERT(num < ADCS_MAX __DBG_LINE);
-    // adcs_t *p = &adcs[num];
+    adcs_t *p = &adcs[num];
+
+    LL_ADC_REG_StopConversion(p->adc);
+    while (LL_ADC_REG_IsConversionOngoing(p->adc) != 0)
+        ;
+    LL_DMA_DisableChannel(p->dma, p->dma_channel);
+    DMA_CLEAR_FLAG_TC_CHANNEL(p->dma, p->dma_channel);
+    DMA_CLEAR_FLAG_TE_CHANNEL(p->dma, p->dma_channel);
 }
 
 /**
@@ -134,6 +147,8 @@ void adc_dinit(adcs_e num)
 {
     DBG_ASSERT(num < ADCS_MAX __DBG_LINE);
     adcs_t *p = &adcs[num];
+    LL_ADC_REG_StopConversion(p->adc);
+    LL_DMA_DisableChannel(p->dma, p->dma_channel);
     LL_ADC_Disable(p->adc);
     if (p->adc_value != NULL)
     {
@@ -175,7 +190,7 @@ uint16_t adc_result_median_average(adcs_e num, uint8_t chan)
 
     if (p->adc_cct <= 2)
         return 0; // 如果adc_cct小于等于2，直接返回0
-
+    p->median_average_ticks.uticks = sys_get_tick();
     uint16_t adc_temp[p->adc_cct];
     uint32_t adc_sum = 0;
     uint16_t count = p->adc_cct >> 2; // 使用位移操作计算n的值
@@ -197,6 +212,13 @@ uint16_t adc_result_median_average(adcs_e num, uint8_t chan)
 
     // 计算平均值，确保不会除以0
     uint16_t res = adc_sum / (p->adc_cct - (count << 1));
+
+    p->median_average_ticks.ticks_current = sys_get_tick() - p->median_average_ticks.uticks;
+    if (p->median_average_ticks.ticks_current > p->median_average_ticks.ticks_max)
+    {
+        p->median_average_ticks.ticks_max = p->median_average_ticks.ticks_current;
+    }
+
     return res;
 }
 
@@ -214,6 +236,8 @@ uint16_t adc_result_median(adcs_e num, uint8_t chan)
     adcs_t *p = &adcs[num];
     DBG_ASSERT(p != NULL __DBG_LINE);
 
+    p->median_ticks.uticks = sys_get_tick();
+
     uint16_t adc_temp[p->adc_cct];
     // 减少重复计算，计算基础偏移量
     uint16_t *adc_values = (uint16_t *)p->adc_value + chan;
@@ -223,6 +247,12 @@ uint16_t adc_result_median(adcs_e num, uint8_t chan)
     }
     insertion_sort(adc_temp, p->adc_cct);
     res = adc_temp[p->adc_cct >> 1];
+
+    p->median_ticks.ticks_current = sys_get_tick() - p->median_ticks.uticks;
+    if (p->median_ticks.ticks_current > p->median_ticks.ticks_max)
+    {
+        p->median_ticks.ticks_max = p->median_ticks.ticks_current;
+    }
     return res;
 }
 
@@ -241,6 +271,8 @@ uint16_t adc_result_average(adcs_e num, uint8_t chan)
     adcs_t *p = &adcs[num];
     DBG_ASSERT(p != NULL __DBG_LINE);
 
+    p->average_ticks.uticks = sys_get_tick();
+
     // 减少重复计算，计算基础偏移量
     uint16_t *adc_values = (uint16_t *)p->adc_value + chan;
     for (uint16_t i = 0; i < p->adc_cct; ++i, adc_values += p->adc_chans_count)
@@ -249,6 +281,12 @@ uint16_t adc_result_average(adcs_e num, uint8_t chan)
     }
     res = adc_sum / p->adc_cct;
 
+    p->average_ticks.ticks_current = sys_get_tick() - p->average_ticks.uticks;
+    if (p->average_ticks.ticks_current > p->average_ticks.ticks_max)
+    {
+        p->average_ticks.ticks_max = p->average_ticks.ticks_current;
+    }
+
     return res;
 }
 
@@ -298,6 +336,10 @@ void adc_dma_callback(adcs_e num)
     if (LL_DMA_IsActiveFlag_TC1(p->dma) != 0)
     {
         LL_DMA_ClearFlag_TC1(p->dma);
+        // 停止ADC转换
+        LL_ADC_REG_StopConversion(p->adc);
+        // 关闭ADC,可以不关闭但是校准无法清除
+        // LL_ADC_Disable(p->adc);
     }
     // 检查DMA1的传输错误标志是否为1，如果是，则清除该标志
     if (LL_DMA_IsActiveFlag_TE1(p->dma) != 0)
@@ -319,7 +361,17 @@ void adc_env_callback(adcs_e num)
     if (LL_ADC_IsActiveFlag_OVR(p->adc) != 0)
     {
         p->ovr_count++;
+        LL_ADC_REG_StopConversion(p->adc);
+        LL_DMA_DisableChannel(p->dma, p->dma_channel);
+
+        LL_DMA_SetDataLength(p->dma, p->dma_channel, p->adc_sum);
+        LL_DMA_SetPeriphAddress(p->dma, p->dma_channel, LL_ADC_DMA_GetRegAddr(p->adc, LL_ADC_DMA_REG_REGULAR_DATA));
+        LL_DMA_SetMemoryAddress(p->dma, p->dma_channel, (uint32_t)p->adc_value);
+        LL_DMA_EnableChannel(p->dma, p->dma_channel);
+
         LL_ADC_ClearFlag_OVR(p->adc);
+        LL_ADC_ClearFlag_EOC(p->adc);
+        LL_ADC_REG_StartConversion(p->adc); // 开始转换
     }
 }
 

bsp/adcs.h

@@ -17,6 +17,9 @@
 
 #ifndef __ADCS_H__
 #define __ADCS_H__
+
+#include "lib.h"
+#include "main.h"
 #include "sys.h"
 
 #define ADC_CHANNEL_MAX 18 ///< Maximum number of ADC channels
@@ -82,7 +85,6 @@ typedef struct
 {
     ADC_TypeDef *adc;         ///< ADC peripheral
     DMA_TypeDef *dma;         ///< DMA peripheral
-    uint32_t dma_stream;      ///< DMA stream
     uint32_t dma_channel;     ///< DMA channel
     adcs_channels_u channels; ///< ADC channels
     uint32_t ovr_count;       ///< ADC overflow count
@@ -92,6 +94,9 @@ typedef struct
     uint16_t adc_sum;         ///< Channel acquisition count
     __IO uint16_t *adc_value; ///< Address to store ADC conversion results
 
+    utime_ticks_t median_average_ticks; ///< Median average filtering ticks
+    utime_ticks_t median_ticks;         ///< Median filtering ticks
+    utime_ticks_t average_ticks;        ///< Average filtering ticks
 } adcs_t;
 
 /**
@@ -106,7 +111,7 @@ typedef struct
  * @param adc_cct The ADC continuous conversion mode.
  * @param channels The number of ADC channels to be converted.
  */
-extern void adc_init(adcs_e num, ADC_TypeDef *adc, DMA_TypeDef *dma, uint32_t dma_stream, uint32_t dma_channel, uint16_t adc_cct, uint32_t channels);
+extern void adc_init(adcs_e num, ADC_TypeDef *adc, DMA_TypeDef *dma, uint32_t dma_channel, uint16_t adc_cct, uint32_t channels);
 
 /**
  * @brief Starts the ADC conversion.

bsp/bsp.h

@@ -13,12 +13,12 @@
 #define __BSP_H__
 
 #include "gpios.h"
-// #include "dmas.h"
+#include "dmas.h"
 // #include "adcs.h"
 // #include "dacs.h"
 // #include "tims.h"
 // #include "pwms.h"
-// #include "uarts.h"
+#include "uarts.h"
 // #include "eeprom.h"
 // #include "spis.h"
 // #include "i2cs.h"
@@ -29,5 +29,4 @@ typedef void (*pvd_irq_handle_cb)(void);
 extern void pvd_configuration(uint32_t pwr_level, pvd_irq_handle_cb call); ///< Configures the Programmable Voltage Detector (PVD) module
 extern void pvd_irq_handle(void);                                          ///< Handles the PVD interrupt
 extern void disable_debug_interface(void);                                 ///< Disables the debug interface
-
 #endif                                                                     ///< __BSP_H__

delay.c

@@ -10,12 +10,6 @@
 
 #include "delay.h"
 
-#if USE_OS == 1
-#include "os.h"
-// 确保包含了 vPortSetupTimerInterrupt 函数的声明
-extern void vPortSetupTimerInterrupt(void);
-#endif
-
 // static uint16_t g_fac_ms = 0; // ms延时倍乘数,在os下,代表每个节拍的ms数
 static uint32_t g_fac_us = 0; /* us延时倍乘数 */
 
@@ -50,49 +44,6 @@ void delay_init(uint16_t sysclk)
 #endif
 }
 
-#if USE_OS == 1
-void delay_us(uint32_t nus)
-{
-    uint32_t ticks;
-    uint32_t told, tnow, reload, tcnt = 0;
-
-    if ((0x0001 & (SysTick->CTRL)) == 0)
-    {
-        // 定时器未工作，初始化定时器
-        vPortSetupTimerInterrupt();
-    }
-
-    reload = SysTick->LOAD; // 获取重装载寄存器值
-    ticks = nus * g_fac_us; // 计算延时所需的SysTick计数
-
-    vTaskSuspendAll();   // 阻止OS调度，防止打断us延时
-    told = SysTick->VAL; // 获取当前数值寄存器值（开始时数值）
-
-    while (1)
-    {
-        tnow = SysTick->VAL; // 获取当前数值寄存器值
-        if (tnow != told)
-        { // 当前值不等于开始值说明已在计数
-            if (tnow < told)
-            {
-                tcnt += told - tnow; // 计数值 = 开始值 - 当前值
-            }
-            else
-            {
-                tcnt += reload - tnow + told; // 计数值 = 重装载值 - 当前值 + 开始值
-            }
-            told = tnow; // 更新开始值
-            if (tcnt >= ticks)
-            {
-                break; // 时间超过/等于要延迟的时间,则退出
-            }
-        }
-    }
-
-    xTaskResumeAll(); // 恢复OS调度
-}
-
-#else
 /**
  * @brief       延时nus
  * @param       nus: 要延时的us数.
@@ -128,7 +79,6 @@ void delay_us(uint32_t nus)
         }
     }
 }
-#endif
 
 /**
  * @brief 对指定的硬件定时器进行微秒级延时

delay.h

@@ -14,8 +14,6 @@
 #include "sys.h"
 #include "tims.h"
 
-#define USE_OS 0
-
 void delay_init(uint16_t sysclk);                           /* 初始化延迟函数 */
 void delay_ms(uint16_t nms);                                /* 延时nms */
 void delay_us(uint32_t nus);                                /* 延时nus */

freertos/inc/FreeRTOSConfig.h

@@ -26,7 +26,7 @@
 
 #ifndef FREERTOS_CONFIG_H
 #define FREERTOS_CONFIG_H
-#include "main.h"
+
 /*-----------------------------------------------------------
  * Application specific definitions.
  *
@@ -42,7 +42,7 @@
 #define configUSE_PREEMPTION 1
 #define configUSE_IDLE_HOOK 0
 #define configUSE_TICK_HOOK 0
-#define configCPU_CLOCK_HZ ((unsigned long)SystemCoreClock)
+#define configCPU_CLOCK_HZ ((unsigned long)72000000)
 #define configTICK_RATE_HZ ((TickType_t)1000)
 #define configMAX_PRIORITIES (5)
 #define configMINIMAL_STACK_SIZE ((unsigned short)128)

freertos/os.h

@@ -1,34 +1,7 @@
 #ifndef __OS_H__
 #define __OS_H__
-#include "FreeRTOSConfig.h"
+
 #include "FreeRTOS.h"
 #include "task.h"
-#include "semphr.h"
-
-typedef struct
-{
-    uint32_t free_heap_size;      ///< 空闲堆大小
-    uint32_t min_free_heap_size;  ///< 最小空闲堆大小
-    uint32_t min_free_stack_size; ///< 最小空闲栈大小
-} os_t;
-
-static inline void os_read(os_t *os)
-{
-    os->free_heap_size = xPortGetFreeHeapSize();
-    os->min_free_heap_size = xPortGetMinimumEverFreeHeapSize();
-    os->min_free_stack_size = uxTaskGetStackHighWaterMark(NULL);
-}
-
-// 禁止任务抢占
-static inline void os_task_preemption_disable(void)
-{
-    taskENTER_CRITICAL();
-}
-
-// 允许任务抢占
-static inline void os_task_preemption_enable(void)
-{
-    taskEXIT_CRITICAL();
-}
 
 #endif // __OS_H__

freertos/readme.md

@@ -1,33 +1,3 @@
-## 移植
+# 移植
 
 https://blog.csdn.net/ctt15703065585/article/details/139291183
-
-## 创建任务
-
-```c
-static TaskHandle_t xxx_task_handle = NULL; // 定义任务句柄
-static void xxx_task(void *pvParameters)
-{
-    for (;;)
-    {
-        vTaskDelay(1000);
-    }
-}
-
-void task_init()
-{
-    // 创建任务
-    xTaskCreate((TaskFunction_t)xxx_task,
-                (const char *)"xxx_task",
-                (uint16_t)configMINIMAL_STACK_SIZE,
-                (void *)NULL,
-                (UBaseType_t)1,
-                (TaskHandle_t *)&xxx_task_handle);
-}
-```
-
-## 信号量
-
-```c
-
-```

lib/inc/storage.h

@@ -7,7 +7,7 @@
  */
 #ifndef __STORAGE_H__
 #define __STORAGE_H__
-#include "sys.h"
+
 #include "lib.h"
 
 typedef struct
@@ -34,7 +34,7 @@ typedef struct
         BOOL(*read)
         (uint32_t addr, uint8_t *buf, uint16_t size);
         BOOL(*write)
-        (uint32_t addr, uint8_t *buf, uint16_t size);
+        (uint32_t addr,  uint8_t * buf, uint16_t size);
         BOOL(*erase_page)
         (uint32_t page);
     } ops;

lib/src/debug.c

@@ -26,6 +26,7 @@ BOOL DBG_ASSERT(uint8_t cond _DBG_LINE_)
 #else
 #include "board.h"
 #include "sys.h"
+
 BOOL DBG_ASSERT(uint8_t cond _DBG_LINE_)
 {
     do

sys.h

@@ -18,15 +18,6 @@
 #define LOCK() __disable_irq()    ///< 系统关全局中断
 #define UNLOCK() __enable_irq()   ///< 系统开全局中断
 
-#ifndef __NOP
-
-/**
-  \brief   No Operation
-  \details No Operation does nothing. This instruction can be used for code alignment purposes.
- */
-#define __NOP() __ASM volatile("nop")
-#endif
-
 typedef struct
 {
     uint32_t pll_source;