/* USER CODE BEGIN Header */ /** ****************************************************************************** * File Name : freertos.c * Description : Code for freertos applications ****************************************************************************** * @attention * * Copyright (c) 2025 STMicroelectronics. * All rights reserved. * * This software is licensed under terms that can be found in the LICENSE file * in the root directory of this software component. * @file freertos.c * ****************************************************************************** */ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "FreeRTOS.h" #include "task.h" #include "main.h" #include "cmsis_os.h" #include "event_groups.h" // 添加事件组支持 /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ #include // 添加标准整型定义 #include "stm32f4xx_hal.h" // 添加HAL库定义 #include "dac161s997.h" #include "ad7124.h" #include "usart.h" #include "communication_protocol.h" #include "tim.h" #include "gpio.h" #include "tcpserverc.h" #include "lwip.h" #include "lwip/tcp.h" // 添加TCP相关定义 #include "uart_lcd.h" #include "user_gpio.h" #include "linear_encoder.h" #include "lan8742.h" #include "ad7124_test.h" #include // 添加string.h用于字符串操作 #include "ht1200m.h" #include "TCA6416.h" // 添加TCA6416头文件 #include "DAC8568.h" #include "dma.h" // 添加DMA头文件 // 声明外部变量 extern ad7124_analog_t ad7124_analog[AD7124_CHANNEL_EN_MAX]; extern ad7124_analog_t ad7124_analog2[AD7124_CHANNEL_EN_MAX]; // 添加第二个AD7124的采样数据结构体 /* USER CODE END Includes */ /* Private typedef -----------------------------------------------------------*/ /* USER CODE BEGIN PTD */ /* USER CODE END PTD */ /* Private define ------------------------------------------------------------*/ /* USER CODE BEGIN PD */ /* USER CODE END PD */ /* Private macro -------------------------------------------------------------*/ /* USER CODE BEGIN PM */ /* USER CODE END PM */ /* Private variables ---------------------------------------------------------*/ /* USER CODE BEGIN Variables */ osThreadId lwip_taskHandle; osThreadId led_taskHandle; osThreadId adc_taskHandle; osThreadId io_control_taskHandle; // 合并后的IO控制任务 osThreadId dac_control_taskHandle; // 合并后的DAC控制任务 osThreadId usart6_test_taskHandle; osThreadId dma_test_taskHandle; // 添加DMA测试任务句柄 // 添加调试变量 static volatile uint32_t uart6_dr_raw = 0; // UART数据寄存器的原始值 static volatile uint8_t uart6_data_bits = 0; // 数据位（8位） static volatile uint8_t uart6_parity_bit = 0; // 校验位 static volatile uint8_t uart6_stop_bits = 0; // 停止位 static volatile uint8_t uart6_error_flags = 0; // 错误标志 // 添加RTS引脚监控变量 volatile GPIO_PinState rts_pin_state = GPIO_PIN_RESET; // RTS引脚当前状态 volatile GPIO_PinState rst_pin_state = GPIO_PIN_RESET; // RTS引脚当前状态 volatile uint32_t rts_pin_pull = 0; // RTS引脚上下拉配置 volatile uint32_t rts_pin_mode = 0; // RTS引脚模式 volatile uint32_t rts_pin_speed = 0; // RTS引脚速度 volatile uint32_t rts_pin_alternate = 0; // RTS引脚复用功能 // 添加全局变量用于存储TCA6416引脚状态 volatile uint8_t tca6416_port0_status = 0; // 第一个TCA6416的Port0状态 volatile uint8_t tca6416_port1_status = 0; // 第一个TCA6416的Port1状态 volatile uint8_t tca6416_port2_status = 0; // 第二个TCA6416的Port0状态 volatile uint8_t tca6416_port3_status = 0; // 第二个TCA6416的Port1状态 volatile uint8_t tca6416_port4_status = 0; // 第三个TCA6416的Port0状态 volatile uint8_t tca6416_port5_status = 0; // 第三个TCA6416的Port1状态 // 添加TCA6416测试相关的调试变量 volatile uint8_t tca6416_test_step = 0; // 当前测试步骤 volatile uint8_t tca6416_init_result = 0xFF; // 初始化结果 volatile uint8_t tca6416_init2_result = 0xFF; // 第二个芯片初始化结果 volatile uint8_t tca6416_init3_result = 0xFF; // 第三个芯片初始化结果 volatile uint8_t tca6416_write_data = 0; // 写入的数据 volatile uint8_t tca6416_read_data = 0; // 读取的数据 volatile uint8_t tca6416_error_count = 0; // 错误计数 volatile uint8_t tca6416_test_pattern = 0; // 测试模式 volatile uint8_t tca6416_port0_dir = 0; // Port0方向寄存器值 volatile uint8_t tca6416_port1_dir = 0; // Port1方向寄存器值 volatile uint8_t tca6416_i2c_ack_status = 0; // I2C应答状态 // 添加接收缓冲区 static uint8_t uart6_rx_buffer[1]; static volatile uint8_t uart6_rx_data = 0; static volatile uint8_t uart6_rx_flag = 0; // 添加数据缓冲相关变量 #define UART6_BUFFER_SIZE 128 #define UART6_TIMEOUT_MS 50 // 50ms超时，认为数据包结束 static uint8_t uart6_data_buffer[UART6_BUFFER_SIZE]; static volatile uint16_t uart6_buffer_index = 0; static volatile uint32_t uart6_last_rx_time = 0; // 添加任务同步对象 osSemaphoreId adc_semaphoreHandle; osSemaphoreId uart6_semaphoreHandle; osSemaphoreId io_semaphoreHandle; // IO控制任务信号量 osSemaphoreId dac_semaphoreHandle; // DAC控制任务信号量 // DMA测试相关变量 #define DMA_UART_RX_BUFFER_SIZE 256 #define DMA_UART_TX_BUFFER_SIZE 256 #define DMA_ADC_BUFFER_SIZE 32 #define DMA_DAC_BUFFER_SIZE 32 static uint8_t dma_uart_rx_buffer[DMA_UART_RX_BUFFER_SIZE]; static uint8_t dma_uart_tx_buffer[DMA_UART_TX_BUFFER_SIZE]; static uint16_t dma_adc_buffer[DMA_ADC_BUFFER_SIZE]; static uint16_t dma_dac_buffer[DMA_DAC_BUFFER_SIZE]; // DMA传输状态标志 volatile uint8_t dma_uart_rx_complete = 0; volatile uint8_t dma_uart_tx_complete = 0; volatile uint8_t dma_adc_complete = 0; volatile uint8_t dma_dac_complete = 0; volatile uint16_t dma_uart_rx_count = 0; volatile uint16_t dma_uart_tx_count = 0; volatile uint16_t dma_adc_count = 0; volatile uint16_t dma_dac_count = 0; // DMA错误计数 volatile uint32_t dma_uart_rx_errors = 0; volatile uint32_t dma_uart_tx_errors = 0; volatile uint32_t dma_adc_errors = 0; volatile uint32_t dma_dac_errors = 0; // 添加信号量句柄 osSemaphoreId tca6416_semaphoreHandle; // 添加TCA6416信号量句柄 // 添加DMA句柄 DMA_HandleTypeDef hdma_uart6_rx; // UART6接收DMA句柄 DMA_HandleTypeDef hdma_uart6_tx; // UART6发送DMA句柄 // ADC滤波相关定义 #define ADC_FILTER_COUNT 2 // 保持2点滤波 #define ADC_CHANNEL_MAX AD7124_CHANNEL_EN_MAX // 通道数量 #define ADC_STARTUP_SAMPLES 20 // 启动时的快速采样次数 #define ADC_STARTUP_INTERVAL 1 // 启动时的采样间隔(ms) #define ADC_NORMAL_INTERVAL 2 // 正常采样间隔(ms) #define ADC_NOISE_THRESHOLD 100 // 噪声阈值 #define ADC_CALIBRATION_SAMPLES 20 // 零点校准采样次数 #define ADC_MAX_VALID_VALUE 0x7FFFFF // 最大有效值 #define ADC_MIN_VALID_VALUE -0x7FFFFF // 最小有效值 #define ADC_MAX_DIFF 0x400000 // 最大允许差值 #define ADC_INVALID_COUNT_MAX 10 // 最大连续无效值计数 #define ADC_HIGH_CHANNEL_START 22 // 高值通道起始编号 #define ADC_HIGH_CHANNEL_THRESHOLD 0x00A00000 // 高值通道的预期最小值 #define ADC_HIGH_CHANNEL_MAX_DIFF 0x00200000 // 高值通道的最大允许差值 // 添加通道分组定义 #define ADC_LOW_CHANNEL_MAX_DIFF 0x100000 // 低值通道的最大允许差值 #define ADC_LOW_CHANNEL_THRESHOLD 0x100000 // 低值通道的噪声阈值 // 添加信号检测相关定义 #define ADC_SIGNAL_LOST_THRESHOLD 0x1000 // 信号消失阈值 #define ADC_SIGNAL_LOST_COUNT_MAX 5 // 信号消失计数阈值 #define ADC_ZERO_THRESHOLD 0x1000 // 零点阈值 // 添加信号状态跟踪变量 static uint8_t adc1_signal_lost_count[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的信号消失计数 static uint8_t adc2_signal_lost_count[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的信号消失计数 static uint8_t adc1_signal_valid[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的信号有效标志 static uint8_t adc2_signal_valid[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的信号有效标志 // 为每个ADC设备创建缓冲区 static int32_t adc1_buffer[ADC_CHANNEL_MAX][ADC_FILTER_COUNT]; // 第一个AD7124的缓冲区 static int32_t adc2_buffer[ADC_CHANNEL_MAX][ADC_FILTER_COUNT]; // 第二个AD7124的缓冲区 static uint8_t adc1_buffer_index[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的缓冲区索引 static uint8_t adc2_buffer_index[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的缓冲区索引 static int32_t adc1_filtered_data[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的滤波后数据 static int32_t adc2_filtered_data[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的滤波后数据 static int32_t adc1_zero_offset[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的零点偏移 static int32_t adc2_zero_offset[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的零点偏移 static int32_t adc1_last_valid[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的上次有效值 static int32_t adc2_last_valid[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的上次有效值 static uint8_t adc1_invalid_count[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的连续无效值计数 static uint8_t adc2_invalid_count[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的连续无效值计数 static uint8_t adc_startup_count = 0; // 启动采样计数器 static uint8_t adc_calibration_count = 0; // 校准计数器 static uint8_t adc_calibration_done = 0; // 校准完成标志 // 添加芯片状态检测相关定义 #define ADC_CHIP_ERROR_COUNT_MAX 5 // 芯片错误计数阈值 #define ADC_CHIP_RESET_INTERVAL 1000 // 芯片复位间隔(ms) #define ADC_CHIP_CHECK_INTERVAL 100 // 芯片状态检查间隔(ms) #define ADC_ABNORMAL_VALUE_THRESHOLD 0x100000 // 异常值阈值 // 添加芯片状态跟踪变量 static uint8_t adc1_error_count = 0; // 第一个AD7124的错误计数 static uint8_t adc2_error_count = 0; // 第二个AD7124的错误计数 static uint32_t adc1_last_reset_time = 0; // 第一个AD7124的最后复位时间 static uint32_t adc2_last_reset_time = 0; // 第二个AD7124的最后复位时间 static uint8_t adc1_chip_valid = 1; // 第一个AD7124的有效标志 static uint8_t adc2_chip_valid = 1; // 第二个AD7124的有效标志 // 添加异常值检测变量 static int32_t adc1_abnormal_values[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的异常值记录 static int32_t adc2_abnormal_values[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的异常值记录 static uint8_t adc1_abnormal_count[ADC_CHANNEL_MAX] = {0}; // 第一个AD7124的异常值计数 static uint8_t adc2_abnormal_count[ADC_CHANNEL_MAX] = {0}; // 第二个AD7124的异常值计数 // 芯片复位函数 static void reset_adc_chip(uint8_t device_num) { if (device_num == 1) { ad7124_setup(1); // 重新初始化第一个AD7124 adc1_error_count = 0; adc1_last_reset_time = HAL_GetTick(); adc1_chip_valid = 1; // 清除异常值记录 memset(adc1_abnormal_values, 0, sizeof(adc1_abnormal_values)); memset(adc1_abnormal_count, 0, sizeof(adc1_abnormal_count)); } else if (device_num == 2) { ad7124_setup(2); // 重新初始化第二个AD7124 adc2_error_count = 0; adc2_last_reset_time = HAL_GetTick(); adc2_chip_valid = 1; // 清除异常值记录 memset(adc2_abnormal_values, 0, sizeof(adc2_abnormal_values)); memset(adc2_abnormal_count, 0, sizeof(adc2_abnormal_count)); } } // 检查异常值 static int32_t check_abnormal_value(int32_t new_value, int32_t *abnormal_value, uint8_t *abnormal_count, uint8_t channel) { // 如果新值与记录的异常值相同 if (new_value == *abnormal_value && new_value != 0) { (*abnormal_count)++; if (*abnormal_count >= ADC_INVALID_COUNT_MAX) { // 连续多次出现相同的异常值，认为是有效值 return new_value; } return 0; // 返回0，表示这是异常值 } // 如果新值与记录的异常值不同 if (abs(new_value - *abnormal_value) < ADC_ABNORMAL_VALUE_THRESHOLD) { // 新值接近异常值，更新异常值记录 *abnormal_value = new_value; *abnormal_count = 1; return 0; // 返回0，表示这是异常值 } // 新值正常，清除异常值记录 *abnormal_value = 0; *abnormal_count = 0; return new_value; } /* USER CODE END Variables */ /* Private function prototypes -----------------------------------------------*/ /* USER CODE BEGIN FunctionPrototypes */ extern float current_buff[2]; extern uint8_t TCA6416_WritePort_buff[2]; extern struct netif gnetif; extern ETH_HandleTypeDef heth; extern struct tcp_pcb *server_pcb_hart1; extern struct tcp_pcb *server_pcb_hart2; extern struct tcp_pcb *server_pcb_ble1; extern struct tcp_pcb *server_pcb_ble2; extern struct tcp_pcb *server_pcb_control; extern void tcp_abort(struct tcp_pcb *pcb); void start_usart6_test_task(void const *argument); // 添加USART6测试任务函数声明 void start_io_control_task(void const *argument); // 添加IO控制任务函数声明 void start_dac_control_task(void const *argument); // 添加DAC控制任务函数声明 void start_dma_test_task(void const *argument); // 添加DMA测试任务函数声明 // 声明外部回调函数 extern void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); extern void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); extern void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart); /* USER CODE END FunctionPrototypes */ void start_tcp_task(void const *argument); void start_led_toggle_task(void const *argument); void start_adc_task(void const *argument); void start_io_control_task(void const *argument); void start_dac_control_task(void const *argument); void start_dac8568_test_task(void const *argument); extern void MX_LWIP_Init(void); void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */ /* GetIdleTaskMemory prototype (linked to static allocation support) */ void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize); /* USER CODE BEGIN GET_IDLE_TASK_MEMORY */ static StaticTask_t xIdleTaskTCBBuffer; static StackType_t xIdleStack[configMINIMAL_STACK_SIZE]; void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize) { *ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer; *ppxIdleTaskStackBuffer = &xIdleStack[0]; *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; /* place for user code */ } /* USER CODE END GET_IDLE_TASK_MEMORY */ /** * @brief FreeRTOS initialization * @param None * @retval None */ void MX_FREERTOS_Init(void) { /* USER CODE BEGIN Init */ // 创建同步对象 osSemaphoreDef(adc_semaphore); adc_semaphoreHandle = osSemaphoreCreate(osSemaphore(adc_semaphore), 1); osSemaphoreDef(uart6_semaphore); uart6_semaphoreHandle = osSemaphoreCreate(osSemaphore(uart6_semaphore), 1); osSemaphoreDef(io_semaphore); io_semaphoreHandle = osSemaphoreCreate(osSemaphore(io_semaphore), 1); osSemaphoreDef(dac_semaphore); dac_semaphoreHandle = osSemaphoreCreate(osSemaphore(dac_semaphore), 1); // 创建TCA6416信号量 osSemaphoreDef(tca6416_semaphore); tca6416_semaphoreHandle = osSemaphoreCreate(osSemaphore(tca6416_semaphore), 1); /* Create the thread(s) */ /* definition and creation of lwip_task */ osThreadDef(lwip_task, start_tcp_task, osPriorityRealtime, 0, 512); lwip_taskHandle = osThreadCreate(osThread(lwip_task), NULL); /* HART测试任务 */ osThreadDef(usart6_test_task, start_usart6_test_task, osPriorityLow, 0, 256); usart6_test_taskHandle = osThreadCreate(osThread(usart6_test_task), NULL); /* ADC任务 */ osThreadDef(adc_task, start_adc_task, osPriorityNormal, 0, 256); adc_taskHandle = osThreadCreate(osThread(adc_task), NULL); /* IO监听控制任务 */ osThreadDef(io_control_task, start_io_control_task, osPriorityNormal, 0, 256); io_control_taskHandle = osThreadCreate(osThread(io_control_task), NULL); /* 合并后的DAC控制任务 - 使用较低优先级 */ osThreadDef(dac_control_task, start_dac_control_task, osPriorityBelowNormal, 0, 512); // 增加堆栈大小 dac_control_taskHandle = osThreadCreate(osThread(dac_control_task), NULL); /* USER CODE END RTOS_THREADS */ } /* USER CODE BEGIN Header_start_tcp_task */ /** * @brief Function implementing the lwip_task thread. * @param argument: Not used * @retval None */ /* USER CODE END Header_start_tcp_task */ void start_tcp_task(void const *argument) { /* init code for LWIP */ MX_LWIP_Init(); /* USER CODE BEGIN start_tcp_task */ // 等待网络初始化完成 osDelay(1000); // 初始化TCP服务器 tcp_echo_init(); uart_lcd_draw_ipaddr(); // 初始化显示IP地址信息 // 添加网络状态变量 static uint8_t last_network_state = 0; static uint32_t network_down_time = 0; /* Infinite loop */ for (;;) { uint32_t phyreg = 0; HAL_ETH_ReadPHYRegister(&heth, 0x00, PHY_BSR, &phyreg); uint8_t current_network_state = ((phyreg >> 2) & 0x1); // 网络状态发生变化 if (current_network_state != last_network_state) { if (current_network_state == 0) // 网络断开 { /* When the netif link is down this function must be called */ netif_set_link_down(&gnetif); netif_set_down(&gnetif); network_down_time = HAL_GetTick(); // 关闭所有TCP连接 if (tcp_echo_flags_hart1 == 1) { tcp_abort(server_pcb_hart1); tcp_echo_flags_hart1 = 0; } if (tcp_echo_flags_hart2 == 1) { tcp_abort(server_pcb_hart2); tcp_echo_flags_hart2 = 0; } #if (BLE2_USART6 == 1) if (tcp_echo_flags_ble1 == 1) { tcp_abort(server_pcb_ble1); tcp_echo_flags_ble1 = 0; } #endif if (tcp_echo_flags_ble2 == 1) { tcp_abort(server_pcb_ble2); tcp_echo_flags_ble2 = 0; } if (tcp_echo_flags_control == 1) { tcp_abort(server_pcb_control); tcp_echo_flags_control = 0; } } else // 网络恢复 { /* When the netif is fully configured this function must be called */ netif_set_link_up(&gnetif); netif_set_up(&gnetif); // 等待网络稳定 osDelay(1000); // 重新初始化TCP服务器 tcp_echo_init(); uart_lcd_draw_ipaddr(); } last_network_state = current_network_state; } // 网络断开超过5秒，尝试重新初始化 else if (current_network_state == 0 && (HAL_GetTick() - network_down_time) > 5000) { // 尝试重新初始化网络 MX_LWIP_Init(); osDelay(1000); // 重新检查网络状态 HAL_ETH_ReadPHYRegister(&heth, 0x00, PHY_BSR, &phyreg); if (((phyreg >> 2) & 0x1) == 1) { netif_set_link_up(&gnetif); netif_set_up(&gnetif); tcp_echo_init(); uart_lcd_draw_ipaddr(); last_network_state = 1; } else { network_down_time = HAL_GetTick(); } } vTaskDelay(5); } /* USER CODE END start_tcp_task */ } /* USER CODE BEGIN Header_start_led_toggle_task */ /** * @brief Function implementing the led_task thread. * @param argument: Not used * @retval None */ /* USER CODE END Header_start_led_toggle_task */ void start_led_toggle_task(void const *argument) { /* USER CODE BEGIN start_led_toggle_task */ /* Infinite loop */ for (;;) { HAL_GPIO_TogglePin(LED3_G_GPIO_Port, LED3_G_Pin); uart_lcd_ecll_control_current_out(); vTaskDelay(500); } /* USER CODE END start_led_toggle_task */ } /* USER CODE BEGIN Header_start_adc_task */ /** * @brief ADC任务函数实现 * @param argument: 未使用 * @retval None */ /* USER CODE END Header_start_adc_task */ void start_adc_task(void const *argument) { /* USER CODE BEGIN start_adc_task */ // 初始化两个AD7124设备 ad7124_setup(1); // 初始化第一个AD7124设备 ad7124_setup(2); // 初始化第二个AD7124设备 // 初始化缓冲区 memset(adc1_buffer, 0, sizeof(adc1_buffer)); memset(adc2_buffer, 0, sizeof(adc2_buffer)); memset(adc1_buffer_index, 0, sizeof(adc1_buffer_index)); memset(adc2_buffer_index, 0, sizeof(adc2_buffer_index)); memset(adc1_filtered_data, 0, sizeof(adc1_filtered_data)); memset(adc2_filtered_data, 0, sizeof(adc2_filtered_data)); memset(adc1_zero_offset, 0, sizeof(adc1_zero_offset)); memset(adc2_zero_offset, 0, sizeof(adc2_zero_offset)); memset(adc1_last_valid, 0, sizeof(adc1_last_valid)); memset(adc2_last_valid, 0, sizeof(adc2_last_valid)); memset(adc1_invalid_count, 0, sizeof(adc1_invalid_count)); memset(adc2_invalid_count, 0, sizeof(adc2_invalid_count)); adc_startup_count = 0; adc_calibration_count = 0; adc_calibration_done = 0; // 初始化信号状态跟踪变量 memset(adc1_signal_lost_count, 0, sizeof(adc1_signal_lost_count)); memset(adc2_signal_lost_count, 0, sizeof(adc2_signal_lost_count)); memset(adc1_signal_valid, 0, sizeof(adc1_signal_valid)); memset(adc2_signal_valid, 0, sizeof(adc2_signal_valid)); // 初始化芯片状态跟踪变量 adc1_error_count = 0; adc2_error_count = 0; adc1_last_reset_time = 0; adc2_last_reset_time = 0; adc1_chip_valid = 1; adc2_chip_valid = 1; memset(adc1_abnormal_values, 0, sizeof(adc1_abnormal_values)); memset(adc2_abnormal_values, 0, sizeof(adc2_abnormal_values)); memset(adc1_abnormal_count, 0, sizeof(adc1_abnormal_count)); memset(adc2_abnormal_count, 0, sizeof(adc2_abnormal_count)); /* Infinite loop */ for (;;) { uint32_t current_time = HAL_GetTick(); // 检查芯片状态 if (current_time - adc1_last_reset_time > ADC_CHIP_RESET_INTERVAL) { if (adc1_error_count >= ADC_CHIP_ERROR_COUNT_MAX) { reset_adc_chip(1); // 复位第一个AD7124 } } if (current_time - adc2_last_reset_time > ADC_CHIP_RESET_INTERVAL) { if (adc2_error_count >= ADC_CHIP_ERROR_COUNT_MAX) { reset_adc_chip(2); // 复位第二个AD7124 } } // 正常采样模式 for (uint8_t ch = AD7124_AIN0; ch < AD7124_CHANNEL_EN_MAX; ch++) { // 第一个AD7124 if (adc1_chip_valid) { int32_t raw_data = ad7124_get_analog(ch, 1); if (raw_data < 0) { // 读取失败 adc1_error_count++; if (adc1_error_count >= ADC_CHIP_ERROR_COUNT_MAX) { adc1_chip_valid = 0; // 标记芯片无效 ad7124_analog[ch].base.data = 0; // 输出0值 continue; } } else { adc1_error_count = 0; // 重置错误计数 // 检查异常值 int32_t valid_value = check_abnormal_value(raw_data, &adc1_abnormal_values[ch], &adc1_abnormal_count[ch], ch); if (valid_value != 0) { // 不是异常值 // 检查信号是否消失 if (abs(valid_value - adc1_zero_offset[ch]) < ADC_SIGNAL_LOST_THRESHOLD) { adc1_signal_lost_count[ch]++; if (adc1_signal_lost_count[ch] >= ADC_SIGNAL_LOST_COUNT_MAX) { adc1_signal_valid[ch] = 0; adc1_filtered_data[ch] = 0; ad7124_analog[ch].base.data = 0; continue; } } else { adc1_signal_lost_count[ch] = 0; adc1_signal_valid[ch] = 1; } // 正常数据处理 if (adc1_signal_valid[ch]) { int32_t max_diff = (ch >= ADC_HIGH_CHANNEL_START) ? ADC_HIGH_CHANNEL_MAX_DIFF : ADC_LOW_CHANNEL_MAX_DIFF; if (abs(valid_value - adc1_last_valid[ch]) > max_diff) { if (adc1_last_valid[ch] == 0) { adc1_last_valid[ch] = valid_value; } else { valid_value = adc1_last_valid[ch]; } } else { adc1_last_valid[ch] = valid_value; } adc1_buffer[ch][adc1_buffer_index[ch]] = valid_value; adc1_buffer_index[ch] = (adc1_buffer_index[ch] + 1) % ADC_FILTER_COUNT; adc1_filtered_data[ch] = (adc1_buffer[ch][0] + adc1_buffer[ch][1]) / 2; ad7124_analog[ch].base.data = adc1_filtered_data[ch]; } } else { ad7124_analog[ch].base.data = 0; // 异常值输出0 } } } // 第二个AD7124 if (adc2_chip_valid) { int32_t raw_data = ad7124_get_analog(ch, 2); if (raw_data < 0) { // 读取失败 adc2_error_count++; if (adc2_error_count >= ADC_CHIP_ERROR_COUNT_MAX) { adc2_chip_valid = 0; // 标记芯片无效 ad7124_analog2[ch].base.data = 0; // 输出0值 continue; } } else { adc2_error_count = 0; // 重置错误计数 // 检查异常值 int32_t valid_value = check_abnormal_value(raw_data, &adc2_abnormal_values[ch], &adc2_abnormal_count[ch], ch); if (valid_value != 0) { // 不是异常值 // 检查信号是否消失 if (abs(valid_value - adc2_zero_offset[ch]) < ADC_SIGNAL_LOST_THRESHOLD) { adc2_signal_lost_count[ch]++; if (adc2_signal_lost_count[ch] >= ADC_SIGNAL_LOST_COUNT_MAX) { adc2_signal_valid[ch] = 0; adc2_filtered_data[ch] = 0; ad7124_analog2[ch].base.data = 0; continue; } } else { adc2_signal_lost_count[ch] = 0; adc2_signal_valid[ch] = 1; } // 正常数据处理 if (adc2_signal_valid[ch]) { int32_t max_diff = (ch >= ADC_HIGH_CHANNEL_START) ? ADC_HIGH_CHANNEL_MAX_DIFF : ADC_LOW_CHANNEL_MAX_DIFF; if (abs(valid_value - adc2_last_valid[ch]) > max_diff) { if (adc2_last_valid[ch] == 0) { adc2_last_valid[ch] = valid_value; } else { valid_value = adc2_last_valid[ch]; } } else { adc2_last_valid[ch] = valid_value; } adc2_buffer[ch][adc2_buffer_index[ch]] = valid_value; adc2_buffer_index[ch] = (adc2_buffer_index[ch] + 1) % ADC_FILTER_COUNT; adc2_filtered_data[ch] = (adc2_buffer[ch][0] + adc2_buffer[ch][1]) / 2; ad7124_analog2[ch].base.data = adc2_filtered_data[ch]; } } else { ad7124_analog2[ch].base.data = 0; // 异常值输出0 } } } } vTaskDelay(ADC_NORMAL_INTERVAL); } /* USER CODE END start_adc_task */ } /* USER CODE BEGIN Header_start_io_control_task */ /** * @brief Function implementing the io_control_task thread. * @param argument: Not used * @retval None */ /* USER CODE END Header_start_io_control_task */ void start_io_control_task(void const *argument) { /* USER CODE BEGIN start_io_control_task */ uint8_t ret = 0; uint8_t addr_scan_result[8] = {0}; static uint32_t last_scan_time = 0; const uint32_t SCAN_INTERVAL = 20; // 20ms扫描间隔 // 等待系统稳定 osDelay(50); // 初始化TCA6416 tca6416_test_step = 0; for(uint8_t addr = 0x20; addr <= 0x27; addr++) { I2C_Start(); ret = I2C_SendByte(addr << 1); I2C_Stop(); addr_scan_result[addr - 0x20] = ret; osDelay(1); } // 初始化三个TCA6416芯片 tca6416_init_result = TCA6416_Init(); tca6416_init2_result = TCA6416_Init2(); tca6416_init3_result = TCA6416_Init3(); // 配置第一个TCA6416芯片的端口方向和输出状态 if(tca6416_init_result == 0) { TCA6416_SetPortDirection(0, 0x00); TCA6416_SetPortDirection(1, 0x00); osDelay(1); } // 配置其他两个芯片的端口方向 if(tca6416_init2_result == 0) { TCA6416_SetPortDirection2(0, 0xFF); TCA6416_SetPortDirection2(1, 0xFF); } if(tca6416_init3_result == 0) { TCA6416_SetPortDirection3(0, 0xFF); TCA6416_SetPortDirection3(1, 0xFF); } /* Infinite loop */ for(;;) { uint32_t current_time = HAL_GetTick(); // 使用时间间隔控制扫描频率 if(current_time - last_scan_time >= SCAN_INTERVAL) { // 获取信号量，但设置较短的超时时间 if(osSemaphoreWait(io_semaphoreHandle, 5) == osOK) { // 写入第一块 TCA6416_WritePort(0, TCA6416_WritePort_buff[1]); TCA6416_WritePort(1, TCA6416_WritePort_buff[0]); // 读取其他芯片状态 if(tca6416_init2_result == 0) { TCA6416_ReadPort2(0, &tca6416_read_data); tca6416_port2_status = tca6416_read_data; TCA6416_ReadPort2(1, &tca6416_read_data); tca6416_port3_status = tca6416_read_data; } if(tca6416_init3_result == 0) { TCA6416_ReadPort3(0, &tca6416_read_data); tca6416_port4_status = tca6416_read_data; TCA6416_ReadPort3(1, &tca6416_read_data); tca6416_port5_status = tca6416_read_data; } osSemaphoreRelease(io_semaphoreHandle); } last_scan_time = current_time; } // 使用较短的延时，让出CPU时间 osDelay(100); } /* USER CODE END start_io_control_task */ } /* USER CODE BEGIN Header_start_dac_control_task */ /** * @brief Function implementing the dac_control_task thread. * @param argument: Not used * @retval None */ /* USER CODE END Header_start_dac_control_task */ void start_dac_control_task(void const *argument) { /* USER CODE BEGIN start_dac_control_task */ // 等待系统稳定 osDelay(1000); // 初始化DAC161S997 dac161s997_init(); // 初始化DAC8568 DAC8568_Init(&hspi3); HAL_Delay(10); DAC8568_EnableStaticInternalRef(); /* Infinite loop */ for(;;) { // 获取信号量 if(osSemaphoreWait(dac_semaphoreHandle, 100) == osOK) { // 处理DAC161S997输出 - 必须脉冲输出 dac161s997_output(DAC161S997, current_buff[0]); // 处理DAC8568输出 // uint16_t dac_value = 32768; // 示例值 // DAC8568_WriteAndUpdate(BROADCAST, dac_value); // 释放信号量 osSemaphoreRelease(dac_semaphoreHandle); } // 使用较短的延时，因为DAC161S997需要脉冲输出 osDelay(100); // 100ms更新周期，与原来的DAC161S997任务保持一致 } /* USER CODE END start_dac_control_task */ } // UART接收完成回调函数 static void UART6_RxCpltCallback(void) { uart6_rx_data = uart6_rx_buffer[0]; uart6_rx_flag = 1; // 重新启动接收 HAL_UART_Receive_IT(&huart6, uart6_rx_buffer, 1); } //HART1 串口测试任务 void start_usart6_test_task(void const *argument) { /* USER CODE BEGIN start_usart6_test_task */ err_t err; uint32_t current_time; // 确保UART6已正确初始化 if (huart6.Instance == NULL) { Error_Handler(); } // 重新初始化UART6 HAL_UART_DeInit(&huart6); huart6.Init.BaudRate = 1200; huart6.Init.WordLength = UART_WORDLENGTH_8B; huart6.Init.StopBits = UART_STOPBITS_1; huart6.Init.Parity = UART_PARITY_NONE; huart6.Init.Mode = UART_MODE_TX_RX; huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart6.Init.OverSampling = UART_OVERSAMPLING_16; // 清除所有标志位 __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_RXNE); __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_PE); __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_FE); __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_ORE); if (HAL_UART_Init(&huart6) != HAL_OK) { Error_Handler(); } // 初始化缓冲区 uart6_buffer_index = 0; uart6_last_rx_time = 0; /* Infinite loop */ for(;;) { current_time = HAL_GetTick(); // 直接检查接收标志 if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_RXNE)) { // 读取数据寄存器的原始值 uart6_dr_raw = huart6.Instance->DR; // 解析数据寄存器的各个位 uart6_data_bits = (uint8_t)(uart6_dr_raw & 0xFF); // 低8位是数据位 uart6_parity_bit = (uint8_t)((uart6_dr_raw >> 8) & 0x1); // 第9位是校验位 uart6_stop_bits = (uint8_t)((uart6_dr_raw >> 9) & 0x3); // 第10-11位是停止位 // 存储错误标志 uart6_error_flags = 0; if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_PE)) uart6_error_flags |= 0x01; if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_FE)) uart6_error_flags |= 0x02; if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_ORE)) uart6_error_flags |= 0x04; // 检查是否有接收错误 if (uart6_error_flags == 0) { // 将数据添加到缓冲区 if (uart6_buffer_index < UART6_BUFFER_SIZE) { uart6_data_buffer[uart6_buffer_index++] = uart6_data_bits; uart6_last_rx_time = current_time; // 更新最后接收时间 } else { // 缓冲区满，强制发送 if (server_pcb_control != NULL && tcp_echo_flags_control == 1 && uart6_buffer_index > 0) { err = tcp_write(server_pcb_control, uart6_data_buffer, uart6_buffer_index, 1); if (err == ERR_OK) { tcp_output(server_pcb_control); } } // 重置缓冲区 uart6_buffer_index = 0; uart6_data_buffer[uart6_buffer_index++] = uart6_data_bits; uart6_last_rx_time = current_time; } } else { // 清除错误标志 __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_PE); __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_FE); __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_ORE); } } // 检查超时，如果超时且有数据则发送 if (uart6_buffer_index > 0 && uart6_last_rx_time > 0 && (current_time - uart6_last_rx_time) >= UART6_TIMEOUT_MS) { // 检查TCP连接状态并发送缓冲区数据 if (server_pcb_control != NULL && tcp_echo_flags_control == 1) { err = tcp_write(server_pcb_control, uart6_data_buffer, uart6_buffer_index, 1); if (err == ERR_OK) { err = tcp_output(server_pcb_control); if (err != ERR_OK) { // TCP输出失败，关闭连接 tcp_abort(server_pcb_control); server_pcb_control = NULL; tcp_echo_flags_control = 0; } } else if (err == ERR_MEM) { // 内存不足，等待一段时间后重试 vTaskDelay(10); continue; // 不清除缓冲区，下次重试 } else { // 其他错误（如连接已关闭），关闭连接 tcp_abort(server_pcb_control); server_pcb_control = NULL; tcp_echo_flags_control = 0; } } // 重置缓冲区 uart6_buffer_index = 0; uart6_last_rx_time = 0; } vTaskDelay(500); // 给其他任务执行的机会 } /* USER CODE END start_usart6_test_task */ } void test_tca6416_task(void const *argument) { /* USER CODE BEGIN test_tca6416_task */ uint8_t ret = 0; uint8_t addr_scan_result[8] = {0}; // 等待系统稳定 osDelay(100); // 步骤0: I2C地址扫描 tca6416_test_step = 0; for(uint8_t addr = 0x20; addr <= 0x27; addr++) { I2C_Start(); ret = I2C_SendByte(addr << 1); I2C_Stop(); addr_scan_result[addr - 0x20] = ret; // 0=ACK, 1=NACK osDelay(10); } // 步骤1: 初始化第一个TCA6416芯片 tca6416_test_step = 1; tca6416_init_result = TCA6416_Init(); // 步骤2: 初始化第二个TCA6416芯片（地址0x21） tca6416_test_step = 2; tca6416_init2_result = TCA6416_Init2(); // 步骤3: 初始化第三个TCA6416芯片（地址0x20，第二条总线） tca6416_test_step = 3; tca6416_init3_result = TCA6416_Init3(); // 设置第一个芯片Port0和Port1为输出（0=输出，1=输入） // 注意：输出状态由tcpecho_recv_control控制，这里只设置方向 ret = TCA6416_SetPortDirection(0, 0x00); // Port0全部设为输出 osDelay(10); ret = TCA6416_SetPortDirection(1, 0x00); // Port1全部设为输出 osDelay(10); // 步骤5: 配置第二、三个芯片所有IO为输入模式 tca6416_test_step = 5; // 第二个芯片设为输入 if(tca6416_init2_result == 0) { TCA6416_SetPortDirection2(0, 0xFF); // Port0全部设为输入 osDelay(10); TCA6416_SetPortDirection2(1, 0xFF); // Port1全部设为输入 osDelay(10); } // 第三个芯片设为输入 if(tca6416_init3_result == 0) { TCA6416_SetPortDirection3(0, 0xFF); // Port0全部设为输入 osDelay(10); TCA6416_SetPortDirection3(1, 0xFF); // Port1全部设为输入 osDelay(10); } // 步骤6: 循环检测所有芯片状态 - 优化扫描周期 tca6416_test_step = 6; for(;;) { // 获取信号量 if(osSemaphoreWait(tca6416_semaphoreHandle, 100) == osOK) { // 读取第一个芯片状态 if(TCA6416_ReadPort(0, &tca6416_read_data) == 0) { tca6416_port0_status = tca6416_read_data; } if(TCA6416_ReadPort(1, &tca6416_read_data) == 0) { tca6416_port1_status = tca6416_read_data; } // 读取第二个芯片状态 if(tca6416_init2_result == 0) { if(TCA6416_ReadPort2(0, &tca6416_read_data) == 0) { tca6416_port2_status = tca6416_read_data; } if(TCA6416_ReadPort2(1, &tca6416_read_data) == 0) { tca6416_port3_status = tca6416_read_data; } } // 读取第三个芯片状态 if(tca6416_init3_result == 0) { if(TCA6416_ReadPort3(0, &tca6416_read_data) == 0) { tca6416_port4_status = tca6416_read_data; } if(TCA6416_ReadPort3(1, &tca6416_read_data) == 0) { tca6416_port5_status = tca6416_read_data; } } // 释放信号量 osSemaphoreRelease(tca6416_semaphoreHandle); } // 缩短扫描周期到200ms osDelay(200); } /* USER CODE END test_tca6416_task */ } /* USER CODE BEGIN Header_start_dac8568_test_task */ /** * @brief Function implementing the dac8568_test_task thread. * @param argument: Not used * @retval None */ /* USER CODE END Header_start_dac8568_test_task */ void start_dac8568_test_task(void const *argument) { // 初始化DAC8568 DAC8568_Init(&hspi3); // 使用SPI3 HAL_Delay(10); // 启用静态内部参考(2.5V) DAC8568_EnableStaticInternalRef(); while(1) { //uint16_t i = 65535; //DAC8568_WriteAndUpdate(CHANNEL_A, (uint16_t)i); //DAC8568_WriteAndUpdate(CHANNEL_B, (uint16_t)i); //DAC8568_WriteAndUpdate(CHANNEL_C, (uint16_t)i); //DAC8568_WriteAndUpdate(CHANNEL_D, (uint16_t)i); //DAC8568_WriteAndUpdate(CHANNEL_E, (uint16_t)i); //DAC8568_WriteAndUpdate(CHANNEL_F, (uint16_t)i); //DAC8568_WriteAndUpdate(CHANNEL_G, (uint16_t)i); //DAC8568_WriteAndUpdate(CHANNEL_H, (uint16_t)i); // for (int i = 65535; i >= 0; i = i - 4096) // 从65535到0，步长4096 // { // // 写入并更新所有通道的值 // DAC8568_WriteAndUpdate(BROADCAST, (uint16_t)i); // // 计算电压值 (假设Vref=2.5V，16位分辨率，2倍增益) // float voltage = 2.5f * 2.0f * i / 65536.0f; // 延时2秒 osDelay(1000); //} } } /* USER CODE BEGIN Header_start_dma_test_task */ /** * @brief Function implementing the dma_test_task thread. * @param argument: Not used * @retval None */ /* USER CODE END Header_start_dma_test_task */ void start_dma_test_task(void const *argument) { /* USER CODE BEGIN start_dma_test_task */ HAL_StatusTypeDef status; // 等待系统稳定 osDelay(1000); // 初始化DMA // 1. 配置UART6 DMA __HAL_RCC_DMA2_CLK_ENABLE(); // 使能DMA2时钟 // 配置UART6接收DMA hdma_uart6_rx.Instance = DMA2_Stream1; hdma_uart6_rx.Init.Channel = DMA_CHANNEL_5; hdma_uart6_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_uart6_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_uart6_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_uart6_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_uart6_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_uart6_rx.Init.Mode = DMA_CIRCULAR; // 循环模式 hdma_uart6_rx.Init.Priority = DMA_PRIORITY_HIGH; hdma_uart6_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; status = HAL_DMA_Init(&hdma_uart6_rx); if (status != HAL_OK) { dma_uart_rx_errors++; Error_Handler(); } // 配置UART6发送DMA hdma_uart6_tx.Instance = DMA2_Stream6; hdma_uart6_tx.Init.Channel = DMA_CHANNEL_5; hdma_uart6_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_uart6_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_uart6_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_uart6_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_uart6_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_uart6_tx.Init.Mode = DMA_NORMAL; // 正常模式 hdma_uart6_tx.Init.Priority = DMA_PRIORITY_HIGH; hdma_uart6_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; status = HAL_DMA_Init(&hdma_uart6_tx); if (status != HAL_OK) { dma_uart_tx_errors++; Error_Handler(); } // 关联DMA到UART6 __HAL_LINKDMA(&huart6, hdmarx, hdma_uart6_rx); __HAL_LINKDMA(&huart6, hdmatx, hdma_uart6_tx); // 启动UART6 DMA接收 status = HAL_UART_Receive_DMA(&huart6, dma_uart_rx_buffer, DMA_UART_RX_BUFFER_SIZE); if (status != HAL_OK) { dma_uart_rx_errors++; Error_Handler(); } /* Infinite loop */ for(;;) { // 检查DMA传输状态 if (dma_uart_rx_complete) { // 处理接收到的数据 dma_uart_rx_count++; dma_uart_rx_complete = 0; // 这里可以添加数据处理逻辑 // 例如：将接收到的数据通过TCP发送出去 if (server_pcb_control != NULL && tcp_echo_flags_control == 1) { err_t err = tcp_write(server_pcb_control, dma_uart_rx_buffer, DMA_UART_RX_BUFFER_SIZE, 1); if (err == ERR_OK) { tcp_output(server_pcb_control); } } } // 测试DMA发送 if (dma_uart_tx_complete) { dma_uart_tx_count++; dma_uart_tx_complete = 0; // 准备新的测试数据 for (int i = 0; i < DMA_UART_TX_BUFFER_SIZE; i++) { dma_uart_tx_buffer[i] = 'A' + (i % 26); // 简单的测试数据 } // 启动新的DMA发送 status = HAL_UART_Transmit_DMA(&huart6, dma_uart_tx_buffer, DMA_UART_TX_BUFFER_SIZE); if (status != HAL_OK) { dma_uart_tx_errors++; } } // 每100ms检查一次状态 osDelay(100); } /* USER CODE END start_dma_test_task */ }