wxsmart
/
controller-pcba
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat(usart): 添加 HART1 通信功能

This commit is contained in:
qiuxin 2025-05-23 13:30:14 +08:00
parent 250abb4bda
commit 2135af95bb
14 changed files with 373 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.vscode/settings.json vendored
View File

@ -5,6 +5,8 @@
"user_spi.h": "c",
"spi.h": "c",
"ad7124.h": "c",
"freertos.h": "c"
"freertos.h": "c",
"usart.h": "c",
"stm32f4xx_it.h": "c"
}
}

22
Core/Inc/main.h
View File

@ -96,7 +96,7 @@ extern "C"
/* USER CODE BEGIN EFP */
#define ENCODE_TIM8 1
#define BLE2_USART6 0
#define HART1_USART6 0
/* USER CODE END EFP */
@ -148,8 +148,6 @@ extern "C"
#define DI_CH1_GPIO_Port GPIOC
#define DI_CH2_Pin GPIO_PIN_9
#define DI_CH2_GPIO_Port GPIOC
#define HART1_RST_Pin GPIO_PIN_8
#define HART1_RST_GPIO_Port GPIOA
#define USB_TX_Pin GPIO_PIN_9
#define USB_TX_GPIO_Port GPIOA
#define USB_RX_Pin GPIO_PIN_10
@ -158,21 +156,29 @@ extern "C"
#define DI_CH3_GPIO_Port GPIOA
#define DI_CH4_Pin GPIO_PIN_12
#define DI_CH4_GPIO_Port GPIOA
#define HART_CLK_Pin GPIO_PIN_15
#define HART_CLK_GPIO_Port GPIOA
//LCD串口引脚
#define LCD_TX_Pin GPIO_PIN_10
#define LCD_TX_GPIO_Port GPIOC
#define LCD_RX_Pin GPIO_PIN_11
#define LCD_RX_GPIO_Port GPIOC
//hart1发送引脚
//HART1复位引脚
//HART1时钟引脚
#define HART_CLK_Pin GPIO_PIN_15
#define HART_CLK_GPIO_Port GPIOA
#define HART1_RST_Pin GPIO_PIN_8
#define HART1_RST_GPIO_Port GPIOC
#define HART1_TX_Pin GPIO_PIN_12
#define HART1_TX_GPIO_Port GPIOC
#define HART1_RTS_Pin GPIO_PIN_0
#define HART1_RTS_GPIO_Port GPIOD
#define HART1_OCD_Pin GPIO_PIN_1
#define HART_RTS_Pin GPIO_PIN_1
#define HART_RTS_GPIO_Port GPIOD
#define HART1_OCD_Pin GPIO_PIN_0
#define HART1_OCD_GPIO_Port GPIOD
#define HART1_OCD_EXTI_IRQn EXTI1_IRQn
#define HART1_RX_Pin GPIO_PIN_2
#define HART1_RX_GPIO_Port GPIOD
#define HART2_OCD_Pin GPIO_PIN_3
#define HART2_OCD_GPIO_Port GPIOD
#define HART2_OCD_EXTI_IRQn EXTI3_IRQn

6
Core/Inc/usart.h
View File

@ -35,6 +35,7 @@ extern "C" {
extern UART_HandleTypeDef huart4;
extern UART_HandleTypeDef huart5;
extern UART_HandleTypeDef huart6;
extern UART_HandleTypeDef huart1;
@ -45,8 +46,8 @@ extern UART_HandleTypeDef huart3;
/* USER CODE BEGIN Private defines */
// #define BUFFER_SIZE 100
// extern volatile uint8_t rx_len; // 接收ä¸?帧数æ<C2B0>®çš„长度
// extern volatile uint8_t recv_end_flag; // ä¸?帧数æ<C2B0>®æŽ¥æ”¶å®Œæˆ<C3A6>æ ‡å¿?
// extern volatile uint8_t rx_len; // 接收<EFBFBD>?帧数据的长度
// extern volatile uint8_t recv_end_flag; // <EFBFBD>?帧数据接收完成标<E68890>?
// extern uint8_t rx_buffer[BUFFER_SIZE]; // 接收数据缓存数组
/* USER CODE END Private defines */
@ -56,6 +57,7 @@ void MX_UART5_Init(void);
void MX_USART1_UART_Init(void);
void MX_USART2_UART_Init(void);
void MX_USART3_UART_Init(void);
void MX_USART6_UART_Init(void);
/* USER CODE BEGIN Prototypes */
void dma_usart_send(UART_HandleTypeDef *huart, uint8_t *buf, uint8_t len); // DMA??

6
Core/Src/dma.c
View File

@ -71,6 +71,12 @@ void MX_DMA_Init(void)
/* DMA2_Stream2_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
/* DMA2_Stream1_IRQn interrupt configuration */
// HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 5, 0);
// HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);
// /* DMA2_Stream6_IRQn interrupt configuration */
// HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 5, 0);
// HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
/* DMA2_Stream7_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);

246
Core/Src/freertos.c
View File

@ -38,6 +38,8 @@
#include "linear_encoder.h"
#include "lan8742.h"
#include "ad7124_test.h"
#include <string.h> // 添加string.h用于字符串操作
#include "ht1200m.h"
// 声明外部变量
extern ad7124_analog_t ad7124_analog[AD7124_CHANNEL_EN_MAX];
@ -60,8 +62,6 @@ extern ad7124_analog_t ad7124_analog[AD7124_CHANNEL_EN_MAX];
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */
/* USER CODE END Variables */
osThreadId lwip_taskHandle;
osThreadId led_taskHandle;
osThreadId dac_taskHandle;
@ -69,6 +69,17 @@ osThreadId adc_taskHandle;
osThreadId gpio_di_do_taskHandle;
osThreadId ec11_taskHandle;
osThreadId ad7124_test_taskHandle;
osThreadId usart6_test_taskHandle; // 添加USART6测试任务句柄
// 添加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引脚复用功能
/* USER CODE END Variables */
/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */
@ -83,6 +94,7 @@ 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测试任务函数声明
/* USER CODE END FunctionPrototypes */
void start_tcp_task(void const *argument);
@ -162,8 +174,8 @@ void MX_FREERTOS_Init(void)
// adc_taskHandle = osThreadCreate(osThread(adc_task), NULL);
/* definition and creation of gpio_di_do_task */
// osThreadDef(gpio_di_do_task, start_gpio_di_do_task, osPriorityNormal, 0, 128);
// gpio_di_do_taskHandle = osThreadCreate(osThread(gpio_di_do_task), NULL);
//osThreadDef(gpio_di_do_task, start_gpio_di_do_task, osPriorityNormal, 0, 128);
//gpio_di_do_taskHandle = osThreadCreate(osThread(gpio_di_do_task), NULL);
/* definition and creation of ec11_task */
// osThreadDef(ec11_task, start_ec11_task, osPriorityNormal, 0, 512);
@ -173,6 +185,10 @@ void MX_FREERTOS_Init(void)
// osThreadDef(ad7124_test_task, start_ad7124_test_task, osPriorityNormal, 0, 512);
// ad7124_test_taskHandle = osThreadCreate(osThread(ad7124_test_task), NULL);
/* definition and creation of usart6_test_task */
osThreadDef(usart6_test_task, start_usart6_test_task, osPriorityNormal, 0, 128);
usart6_test_taskHandle = osThreadCreate(osThread(usart6_test_task), NULL);
/* USER CODE BEGIN RTOS_THREADS */
/* add threads, ... */
/* USER CODE END RTOS_THREADS */
@ -361,167 +377,14 @@ void start_ec11_task(void const *argument)
/* USER CODE END start_ec11_task */
}
/* USER CODE BEGIN Header_start_ad7124_test_task */
/**
* @brief Function implementing the ad7124_test_task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_start_ad7124_test_task */
// 添加全局变量用于Watch窗口观察
volatile int32_t g_adc_data = 0;
volatile int32_t g_adc_error = 0;
volatile uint8_t g_adc_state = 0; // 0:初始化 1:配置通道 2:等待转换 3:读取数据 4:组包 5:发送
volatile uint16_t g_channel_config = 0; // 用于观察通道配置值
volatile uint16_t g_channel_status = 0; // 用于观察通道状态
volatile uint16_t g_adc_control = 0; // 用于观察ADC控制寄存器
volatile uint16_t g_config_0 = 0; // 用于观察配置寄存器0
volatile uint32_t g_filter_0 = 0; // 用于观察滤波器配置
extern int32_t g_ad7124_id;
// void start_ad7124_test_task(const void *argument)
// {
// vTaskDelay(1000);
// // 初始化AD7124
// ad7124_setup();
// vTaskDelay(100);
// while(1)
// {
// // 遍历所有启用的通道
// for(uint8_t ch = STOP_NC_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++)
// {
// // 1. 将ADC设置为掉电模式
// ad7124_regs[AD7124_ADC_CONTROL].value = 0x0600; // Power-down mode
// ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]);
// vTaskDelay(1);
// // 2. 配置当前通道
// ad7124_regs[AD7124_CHANNEL_0].value = ad7124_channel_regs[ch].value;
// ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]);
// // 3. 读取并保存通道配置状态
// ad7124_read_register(&ad7124_regs[AD7124_CHANNEL_0]);
// g_channel_config = ad7124_regs[AD7124_CHANNEL_0].value;
// // 4. 设置为单次转换模式并启动转换
// ad7124_regs[AD7124_ADC_CONTROL].value = 0x0684; // Single conversion mode
// ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]);
// // 5. 立即读取状态寄存器确认转换开始
// ad7124_read_register(&ad7124_regs[AD7124_STATUS]);
// g_channel_status = ad7124_regs[AD7124_STATUS].value;
// // 6. 等待转换完成
// uint16_t timeout = 1000;
// while(timeout--) {
// int32_t ret = ad7124_read_register(&ad7124_regs[AD7124_STATUS]);
// if(ret >= 0) {
// g_channel_status = ad7124_regs[AD7124_STATUS].value;
// if(!(g_channel_status & AD7124_STATUS_REG_RDY)) {
// // 转换完成，立即读取数据
// g_adc_data = ad7124_read_data();
// break;
// }
// }
// vTaskDelay(1);
// }
// // 7. 读取错误寄存器检查是否有错误
// ad7124_read_register(&ad7124_regs[AD7124_ERROR]);
// g_adc_error = ad7124_regs[AD7124_ERROR].value;
// // 8. 保存最终的控制寄存器状态
// ad7124_read_register(&ad7124_regs[AD7124_ADC_CONTROL]);
// g_adc_control = ad7124_regs[AD7124_ADC_CONTROL].value;
// // 9. 如果发生错误，重置ADC
// if(g_adc_error != 0) {
// ad7124_reset();
// vTaskDelay(100);
// ad7124_setup();
// vTaskDelay(10);
// }
// // 10. 如果超时或出错，增加延时方便调试
// if(timeout == 0 || g_adc_error != 0) {
// vTaskDelay(100);
// }
// }
// vTaskDelay(pdMS_TO_TICKS(10));
// }
// }
/**
* @brief Initialize AD7124 with multiple channels
* @param sample_rate: Sample rate selection (2Hz to 1kHz)
* @retval None
*/
// void ad7124_multi_channel_init(uint8_t sample_rate)
// {
// // Reset AD7124
// ad7124_reset();
// vTaskDelay(pdMS_TO_TICKS(100)); // 复位后延时
// // 配置ADC控制寄存器
// ad7124_regs[AD7124_ADC_CONTROL].value =
// AD7124_ADC_CTRL_REG_DATA_STATUS | // Enable status register
// AD7124_ADC_CTRL_REG_CS_EN | // Enable chip select
// AD7124_ADC_CTRL_REG_REF_EN | // Enable internal reference
// AD7124_ADC_CTRL_REG_POWER_MODE(3); // Full power mode
// ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]);
// // 配置Setup 0
// ad7124_regs[AD7124_CONFIG_0].value =
// AD7124_CFG_REG_BIPOLAR | // Bipolar mode
// AD7124_CFG_REG_BURNOUT(0) | // Burnout current source off
// AD7124_CFG_REG_REF_BUFP | // Reference buffer positive enabled
// AD7124_CFG_REG_REF_BUFM | // Reference buffer negative enabled
// AD7124_CFG_REG_AIN_BUFP | // Enable positive input buffer
// AD7124_CFG_REG_AINN_BUFM | // Enable negative input buffer
// AD7124_CFG_REG_REF_SEL(2) | // Use internal reference
// AD7124_CFG_REG_PGA(0); // Gain = 1
// ad7124_write_register(&ad7124_regs[AD7124_CONFIG_0]);
// // 初始禁用所有通道
// for(uint8_t ch = 0; ch < AD7124_CHANNEL_EN_MAX; ch++) {
// ad7124_regs[AD7124_CHANNEL_0 + ch].value = 0;
// ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0 + ch]);
// }
// // 配置滤波器
// ad7124_regs[AD7124_FILTER_0].value =
// AD7124_FILT_REG_FILTER(0) | // SINC4 filter
// AD7124_FILT_REG_REJ60 | // Enable 60Hz rejection
// AD7124_FILT_REG_POST_FILTER(3) | // Post filter enabled
// AD7124_FILT_REG_FS(1); // Output data rate
// ad7124_write_register(&ad7124_regs[AD7124_FILTER_0]);
// }
/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */
// void start_adc_task(void const *argument)
// {
// /* USER CODE BEGIN start_adc_task */
// ad7124_setup();
// /* Infinite loop */
// for (;;)
// {
// osThreadSuspend(dac_taskHandle); // 暂停DAC任务，防止ADC采集时产生干<E7949F>????????,因为ADC和DAC采用的是同一路SPI，但是时序不<E5BA8F>????????
// uint8_t ch = 0;
// for (ch = STOP_NC_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++)
// {
// ad7124_get_analog(ch);
// }
// communication_reset_hart();
// osThreadResume(dac_taskHandle);
// vTaskDelay(10);
// }
// /* USER CODE END start_adc_task */
// }
/* USER CODE END Application */
/**
* @brief 测试CS引脚的功能
@ -545,3 +408,72 @@ void test_cs_pin(void)
HAL_Delay(100);
}
}
/* USER CODE BEGIN Header_start_usart6_test_task */
/**
* @brief Function implementing the usart6_test_task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_start_usart6_test_task */
void start_usart6_test_task(void const *argument)
{
/* USER CODE BEGIN start_usart6_test_task */
// 使用简单的测试模式：0x55 (01010101) 和 0xAA (10101010)
uint8_t test_data[] = {0xFF,0x55, 0xAA, 0x85, 0x8A, 0x57, 0xAB}; // 6字节交替的0和1，便于观察
uint8_t counter = 0;
// 重置HART模块
hart_ht1200m_reset();
// 重新配置USART6
huart6.Instance = USART6;
huart6.Init.BaudRate = 1200;
huart6.Init.WordLength = UART_WORDLENGTH_9B;//9位数据
huart6.Init.StopBits = UART_STOPBITS_1;//1位停止位
huart6.Init.Parity = UART_PARITY_ODD;//奇校验
huart6.Init.Mode = UART_MODE_TX_RX;//收发模式
huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;//无硬件流控
huart6.Init.OverSampling = UART_OVERSAMPLING_16;//16倍过采样
if (HAL_UART_Init(&huart6) != HAL_OK)
{
Error_Handler();
}
//MX_GPIO_Init();
/* Infinite loop */
for(;;)
{
if (huart6.gState == HAL_UART_STATE_READY)
{
HART1_RTS_SEND;
vTaskDelay(8);
if (HAL_UART_Transmit(&huart6, test_data, sizeof(test_data), 100) != HAL_OK)
{
Error_Handler();
}
counter++;
vTaskDelay(5);
HART1_RTS_RECEIVE;
vTaskDelay(500); // 500ms延时
}
else
{
// 如果UART不就绪，等待一段时间后重试
vTaskDelay(100);
}
}
/* USER CODE END start_usart6_test_task */
}
void start_usart6_dma_test_task(void const *argument)
{
}

42
Core/Src/gpio.c
View File

@ -56,21 +56,21 @@ void MX_GPIO_Init(void)
HAL_GPIO_WritePin(ETH_RESET_GPIO_Port, ETH_RESET_Pin, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, LED3_R_Pin|LED3_G_Pin|DAC1_CS_Pin|DAC2_CS_Pin, GPIO_PIN_SET);
//HAL_GPIO_WritePin(GPIOB, LED3_R_Pin|LED3_G_Pin|DAC1_CS_Pin|DAC2_CS_Pin, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOE, LED3_Y_Pin|LED2_R_Pin|LED2_G_Pin|LED2_Y_Pin
|ADC_CS_Pin|AD7124_SYNC_Pin, GPIO_PIN_SET);
//HAL_GPIO_WritePin(GPIOE, LED3_Y_Pin|LED2_R_Pin|LED2_G_Pin|LED2_Y_Pin
//|ADC_CS_Pin|AD7124_SYNC_Pin, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOD, DO_CH4_Pin|DO_CH3_Pin|DO_CH1_Pin|DO_CH2_Pin
|HART2_RST_Pin, GPIO_PIN_RESET);
//HAL_GPIO_WritePin(GPIOD, DO_CH4_Pin|DO_CH3_Pin|DO_CH1_Pin|DO_CH2_Pin
//|HART2_RST_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOD, DO_EN_Pin|HART1_RTS_Pin|HART2_RTS_Pin, GPIO_PIN_SET);
//HAL_GPIO_WritePin(GPIOD, DO_EN_Pin|HART_RTS_Pin|HART2_RTS_Pin, GPIO_PIN_RESET);//修改
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(HART1_RST_GPIO_Port, HART1_RST_Pin, GPIO_PIN_SET);
//HAL_GPIO_WritePin(HART1_RST_GPIO_Port, HART1_RST_Pin, GPIO_PIN_SET);
/*Configure GPIO pins : PEPin PEPin */
GPIO_InitStruct.Pin = DI_CH5_Pin|DI_CH6_Pin;
@ -118,12 +118,7 @@ void MX_GPIO_Init(void)
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pins : PDPin PDPin PDPin PDPin */
GPIO_InitStruct.Pin = DO_EN_Pin|HART1_RTS_Pin|HART2_RTS_Pin|HART2_RST_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/* Configure SPI2 pins */
// SCK (PB10)
@ -163,12 +158,6 @@ void MX_GPIO_Init(void)
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pin : PtPin */
GPIO_InitStruct.Pin = HART1_RST_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(HART1_RST_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pins : PAPin PAPin */
GPIO_InitStruct.Pin = DI_CH3_Pin|DI_CH4_Pin;
@ -203,6 +192,20 @@ void MX_GPIO_Init(void)
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(AD7124_SYNC_GPIO_Port, &GPIO_InitStruct);
/*HART复位 */
GPIO_InitStruct.Pin = HART1_RST_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(HART1_RST_GPIO_Port, &GPIO_InitStruct);
/*HART RTS */
GPIO_InitStruct.Pin = HART_RTS_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(HART_RTS_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_WritePin(HART_RTS_GPIO_Port, HART_RTS_Pin, GPIO_PIN_RESET);
/* EXTI interrupt init*/
HAL_NVIC_SetPriority(EXTI1_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(EXTI1_IRQn);
@ -212,6 +215,7 @@ void MX_GPIO_Init(void)
HAL_NVIC_SetPriority(EXTI9_5_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
HAL_GPIO_WritePin(HART_RTS_GPIO_Port, HART_RTS_Pin, GPIO_PIN_SET);
}

29
Core/Src/main.c
View File

@ -69,7 +69,7 @@ void MX_FREERTOS_Init(void);
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uart_t lcd_uart4 = {0};
uart_t ble1_uart6 = {0};
uart_t hart1_uart6 = {0};
uart_t ble2_uart3 = {0};
uart_t hart2_uart2 = {0};
uart_t hart1_uart5 = {0};
@ -125,24 +125,25 @@ int main(void)
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_TIM3_Init();
MX_SPI1_Init();
MX_UART4_Init();
//MX_DMA_Init();
//MX_TIM3_Init();
//MX_SPI1_Init();
MX_USART6_UART_Init();
MX_TIM2_Init();
MX_UART5_Init();
MX_USART2_UART_Init();
MX_USART3_UART_Init();
MX_TIM1_Init();
MX_USART1_UART_Init();
MX_TIM8_Init();
//MX_UART5_Init();
//MX_USART2_UART_Init();
//MX_USART3_UART_Init();
//MX_TIM1_Init();
//MX_USART1_UART_Init();
//MX_TIM8_Init();
/* USER CODE BEGIN 2 */
//board_spi_init(AD7124); // Initialize SPI2 for AD7124 using the unified initialization function
/*DMA INIT*/
// start
HAL_UARTEx_ReceiveToIdle_DMA(&huart4, lcd_uart4.rx_data_temp, ARRAY_LEN(lcd_uart4.rx_data_temp));
#if (BLE2_USART6 == 1)
HAL_UARTEx_ReceiveToIdle_DMA(&huart6, ble1_uart6.rx_data_temp, ARRAY_LEN(ble1_uart6.rx_data_temp));
#if (HART1_USART6 == 1)
HAL_UARTEx_ReceiveToIdle_DMA(&huart6, hart1_uart6.rx_data_temp, ARRAY_LEN(hart1_uart6.rx_data_temp));
#endif
HAL_UARTEx_ReceiveToIdle_DMA(&huart3, ble2_uart3.rx_data_temp, ARRAY_LEN(ble2_uart3.rx_data_temp));
HAL_UARTEx_ReceiveToIdle_DMA(&huart5, hart1_uart5.rx_data_temp, ARRAY_LEN(hart1_uart5.rx_data_temp));
@ -331,7 +332,7 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
}
if (huart == &huart2)
{
HART2_RTS_RECEIVE;
//HART2_RTS_RECEIVE;
}
}

30
Core/Src/stm32f4xx_it.c
View File

@ -74,6 +74,8 @@ extern DMA_HandleTypeDef hdma_usart2_rx;
extern DMA_HandleTypeDef hdma_usart2_tx;
extern DMA_HandleTypeDef hdma_usart3_rx;
extern DMA_HandleTypeDef hdma_usart3_tx;
extern DMA_HandleTypeDef hdma_usart6_rx;
extern DMA_HandleTypeDef hdma_usart6_tx;
extern UART_HandleTypeDef huart4;
extern UART_HandleTypeDef huart5;
extern UART_HandleTypeDef huart1;
@ -469,6 +471,34 @@ void DMA2_Stream7_IRQHandler(void)
/* USER CODE END DMA2_Stream7_IRQn 1 */
}
/**
* @brief This function handles DMA2 stream1 global interrupt.
*/
void DMA2_Stream1_IRQHandler(void)
{
/* USER CODE BEGIN DMA2_Stream1_IRQn 0 */
/* USER CODE END DMA2_Stream1_IRQn 0 */
HAL_DMA_IRQHandler(&hdma_usart6_rx);
/* USER CODE BEGIN DMA2_Stream1_IRQn 1 */
/* USER CODE END DMA2_Stream1_IRQn 1 */
}
/**
* @brief This function handles DMA2 stream6 global interrupt.
*/
void DMA2_Stream6_IRQHandler(void)
{
/* USER CODE BEGIN DMA2_Stream6_IRQn 0 */
/* USER CODE END DMA2_Stream6_IRQn 0 */
HAL_DMA_IRQHandler(&hdma_usart6_tx);
/* USER CODE BEGIN DMA2_Stream6_IRQn 1 */
/* USER CODE END DMA2_Stream6_IRQn 1 */
}
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */

152
Core/Src/usart.c
View File

@ -29,6 +29,7 @@ UART_HandleTypeDef huart5;
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
UART_HandleTypeDef huart3;
UART_HandleTypeDef huart6;
DMA_HandleTypeDef hdma_uart4_rx;
DMA_HandleTypeDef hdma_uart4_tx;
DMA_HandleTypeDef hdma_uart5_tx;
@ -39,6 +40,8 @@ DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;
DMA_HandleTypeDef hdma_usart3_rx;
DMA_HandleTypeDef hdma_usart3_tx;
DMA_HandleTypeDef hdma_usart6_rx;
DMA_HandleTypeDef hdma_usart6_tx;
/* UART4 init function */
void MX_UART4_Init(void)
@ -186,6 +189,34 @@ void MX_USART3_UART_Init(void)
}
/* USART6 init function */
void MX_USART6_UART_Init(void)
{
/* USER CODE BEGIN USART6_Init 0 */
/* USER CODE END USART6_Init 0 */
/* USER CODE BEGIN USART6_Init 1 */
/* USER CODE END USART6_Init 1 */
huart6.Instance = USART6;
huart6.Init.BaudRate = 1200;
huart6.Init.WordLength = UART_WORDLENGTH_9B;
huart6.Init.StopBits = UART_STOPBITS_1;
huart6.Init.Parity = UART_PARITY_ODD;
huart6.Init.Mode = UART_MODE_TX_RX;
huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart6.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart6) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART6_Init 2 */
// __HAL_UART_ENABLE_IT(&huart6, UART_IT_RXNE); // 接收中断
// __HAL_UART_ENABLE_IT(&huart6, UART_IT_IDLE); // 空闲中断
/* USER CODE END USART6_Init 2 */
}
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{
@ -518,6 +549,70 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END USART3_MspInit 1 */
}
else if(uartHandle->Instance==USART6)
{
/* USER CODE BEGIN USART6_MspInit 0 */
/* USER CODE END USART6_MspInit 0 */
/* USART6 clock enable */
__HAL_RCC_USART6_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
/**USART6 GPIO Configuration
PC6 ------> USART6_TX
PC7 ------> USART6_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_USART6;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/* USART6 DMA Init */
/* USART6_RX Init */
hdma_usart6_rx.Instance = DMA2_Stream1;
hdma_usart6_rx.Init.Channel = DMA_CHANNEL_5;
hdma_usart6_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_usart6_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart6_rx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart6_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart6_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart6_rx.Init.Mode = DMA_NORMAL;
hdma_usart6_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
hdma_usart6_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
if (HAL_DMA_Init(&hdma_usart6_rx) != HAL_OK)
{
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmarx,hdma_usart6_rx);
/* USART6_TX Init */
hdma_usart6_tx.Instance = DMA2_Stream6;
hdma_usart6_tx.Init.Channel = DMA_CHANNEL_5;
hdma_usart6_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_usart6_tx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart6_tx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart6_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart6_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart6_tx.Init.Mode = DMA_NORMAL;
hdma_usart6_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
hdma_usart6_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
if (HAL_DMA_Init(&hdma_usart6_tx) != HAL_OK)
{
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmatx,hdma_usart6_tx);
/* USART6 interrupt Init */
HAL_NVIC_SetPriority(USART6_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(USART6_IRQn);
/* USER CODE BEGIN USART6_MspInit 1 */
/* USER CODE END USART6_MspInit 1 */
}
}
void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
@ -645,22 +740,67 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END USART3_MspDeInit 1 */
}
else if(uartHandle->Instance==USART6)
{
/* USER CODE BEGIN USART6_MspDeInit 0 */
/* USER CODE END USART6_MspDeInit 0 */
/* Peripheral clock disable */
__HAL_RCC_USART6_CLK_DISABLE();
/**USART6 GPIO Configuration
PC6 ------> USART6_TX
PC7 ------> USART6_RX
*/
HAL_GPIO_DeInit(GPIOC, GPIO_PIN_6|GPIO_PIN_7);
/* USART6 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx);
HAL_DMA_DeInit(uartHandle->hdmatx);
/* USART6 interrupt Deinit */
HAL_NVIC_DisableIRQ(USART6_IRQn);
/* USER CODE BEGIN USART6_MspDeInit 1 */
/* USER CODE END USART6_MspDeInit 1 */
}
}
/* USER CODE BEGIN 1 */
/**
* @brief ??DMA????USART????
* @brief DMA传输完成回调函数
* @param hdma DMA句柄
*/
void HAL_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
{
if(hdma->Instance == DMA2_Stream6)
{
/* 清除UART发送完成标志 */
__HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_TC);
/* 更新UART状态为就绪 */
huart6.gState = HAL_UART_STATE_READY;
}
}
/**
* @brief 使用DMA发送USART数据
*
* ?????USART????DMA???????
* 通过USART使用DMA发送数据
*
* @param huart USART?????UART_HandleTypeDef??????
* @param buf ???????????
* @param len ????????
* @param huart USART句柄，类型为UART_HandleTypeDef结构体指针
* @param buf 要发送的数据缓冲区指针
* @param len 要发送的数据长度
*/
void dma_usart_send(UART_HandleTypeDef *huart, uint8_t *buf, uint8_t len)
{
if (HAL_UART_Transmit_DMA(huart, buf, len) != HAL_OK) // 判断是å<C2AF>¦å<C2A6>‘é?<3F>正常，如果出现异常则进入异常中断函æ•?
/* 等待上一次传输完成 */
while(huart->gState == HAL_UART_STATE_BUSY_TX)
{
osDelay(1);
}
if (HAL_UART_Transmit_DMA(huart, buf, len) != HAL_OK)
{
Error_Handler();
}

15
MDK-ARM/controller_pcba.uvoptx
View File

@ -220,6 +220,21 @@
<WinNumber>1</WinNumber>
<ItemText>ad7124_analog[channel_nr].voltage</ItemText>
</Ww>
<Ww>
<count>14</count>
<WinNumber>1</WinNumber>
<ItemText>huart6.gState</ItemText>
</Ww>
<Ww>
<count>15</count>
<WinNumber>1</WinNumber>
<ItemText>rts_pin_state</ItemText>
</Ww>
<Ww>
<count>16</count>
<WinNumber>1</WinNumber>
<ItemText>rst_pin_state</ItemText>
</Ww>
</WatchWindow1>
<Tracepoint>
<THDelay>0</THDelay>

49
User/application/src/tcpserverc.c
View File

@ -87,48 +87,7 @@ uint8_t adc_set_data[22] = {
0x0D,0xF0,// 比例阀1输出高字节, 比例阀1输出低字节,
0x0D,0xF0,// 比例阀2输出高字节, 比例阀2输出低字节
};
// 假设数据按高字节到低字节排列
// 定义数组存放数据，总字节数根据表格计算为：2 + 4×18 = 74 字节
uint8_t test_adc_read_data[74] = {
// IO扩展1高字节, IO扩展1低字节
0x12, 0x34,
// ADC(通道1)高字节1, ADC(通道1)高字节2, ADC(通道1)低字节1, ADC(通道1)低字节2
0x01, 0x02, 0x03, 0x04,
// ADC(通道2)高字节1, ADC(通道2)高字节2, ADC(通道2)低字节1, ADC(通道2)低字节2
0x05, 0x06, 0x07, 0x08,
// ADC(通道3)高字节1, ADC(通道3)高字节2, ADC(通道3)低字节1, ADC(通道3)低字节2
0x09, 0x0A, 0x0B, 0x0C,
// ADC(通道4)高字节1, ADC(通道4)高字节2, ADC(通道4)低字节1, ADC(通道4)低字节2
0x0D, 0x0E, 0x0F, 0x10,
// ADC(通道5)高字节1, ADC(通道5)高字节2, ADC(通道5)低字节1, ADC(通道5)低字节2
0x11, 0x12, 0x13, 0x14,
// ADC(通道6)高字节1, ADC(通道6)高字节2, ADC(通道6)低字节1, ADC(通道6)低字节2
0x15, 0x16, 0x17, 0x18,
// ADC(通道7)高字节1, ADC(通道7)高字节2, ADC(通道7)低字节1, ADC(通道7)低字节2
0x19, 0x1A, 0x1B, 0x1C,
// ADC(通道8)高字节1, ADC(通道8)高字节2, ADC(通道8)低字节1, ADC(通道8)低字节2
0x1D, 0x1E, 0x1F, 0x20,
// ADC(通道9)高字节1, ADC(通道9)高字节2, ADC(通道9)低字节1, ADC(通道9)低字节2
0x21, 0x22, 0x23, 0x24,
// ADC(通道10)高字节1, ADC(通道10)高字节2, ADC(通道10)低字节1, ADC(通道10)低字节2
0x25, 0x26, 0x27, 0x28,
// ADC(通道11)高字节1, ADC(通道11)高字节2, ADC(通道11)低字节1, ADC(通道11)低字节2
0x29, 0x2A, 0x2B, 0x2C,
// ADC(通道12)高字节1, ADC(通道12)高字节2, ADC(通道12)低字节1, ADC(通道12)低字节2
0x2D, 0x2E, 0x2F, 0x30,
// ADC(通道13)高字节1, ADC(通道13)高字节2, ADC(通道13)低字节1, ADC(通道13)低字节2
0x31, 0x32, 0x33, 0x34,
// ADC(通道14)高字节1, ADC(通道14)高字节2, ADC(通道14)低字节1, ADC(通道14)低字节2
0x35, 0x36, 0x37, 0x38,
// ADC(通道15)高字节1, ADC(通道15)高字节2, ADC(通道15)低字节1, ADC(通道15)低字节2
0x39, 0x3A, 0x3B, 0x3C,
// ADC(通道16)高字节1, ADC(通道16)高字节2, ADC(通道16)低字节1, ADC(通道16)低字节2
0x3D, 0x3E, 0x3F, 0x40,
// 比例阀1输入高字节1, 比例阀1输入高字节2, 比例阀1输入低字节1, 比例阀1输入低字节2
0x41, 0x42, 0x43, 0x44,
// 比例阀2输入高字节1, 比例阀2输入高字节2, 比例阀2输入低字节1, 比例阀2输入低字节2
0x45, 0x46, 0x47, 0x48
};
// 校验和函数
uint8_t calc_checksum(const uint8_t *data, uint8_t start, uint8_t end) {
uint8_t checksum = 0;
@ -498,7 +457,7 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
if (huart2.gState == HAL_UART_STATE_READY)
{
HART2_RTS_SEND;
//HART2_RTS_SEND;
dma_usart_send(&huart2, hart2_uart2.tx_data, p->tot_len);
}
@ -648,7 +607,7 @@ static err_t tcpecho_recv_control(void *arg, struct tcp_pcb *tpcb, struct pbuf *
{
uint16_t body_len = 74; //22个字节表示的是设置的参数
reply_type = tcp_rx_data[8];
tx_data_len = handle_type_87(test_adc_read_data, body_len, tcp_tx_data);
//tx_data_len = handle_type_87(test_adc_read_data, body_len, tcp_tx_data);
}
break;
case 0x88://透传数据
@ -686,7 +645,7 @@ static err_t tcpecho_recv_control(void *arg, struct tcp_pcb *tpcb, struct pbuf *
static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的，形参的数量和类型必须一致
{
tcp_recv(newpcb, tcpecho_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv
HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_3); // 停止蜂鸣器PWM输出，用于关闭蜂鸣器发声
//HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_3); // 停止蜂鸣器PWM输出，用于关闭蜂鸣器发声
return ERR_OK;
}

4
User/driver/ht1200m.c
View File

@ -14,10 +14,8 @@
extern void hart_ht1200m_reset(void)
{
HART1_RESET_ON;
HART2_RESET_ON;
HAL_Delay(10);
HART1_RESET_OFF;
HART2_RESET_OFF;
HART1_RTS_RECEIVE;
HART2_RTS_RECEIVE;
HAL_Delay(10);
}

14
User/driver/ht1200m.h
View File

@ -4,16 +4,16 @@
#include "main.h"
#define HART1_RESET_ON HAL_GPIO_WritePin(HART1_RST_GPIO_Port, HART1_RST_Pin, GPIO_PIN_RESET) // 拉低引脚复位模块
#define HART1_RESET_OFF HAL_GPIO_WritePin(HART1_RST_GPIO_Port, HART1_RST_Pin, GPIO_PIN_SET)
#define HART1_RESET_OFF HAL_GPIO_WritePin(HART1_RST_GPIO_Port, HART1_RST_Pin, GPIO_PIN_SET)//拉高引脚启动模块
#define HART2_RESET_ON HAL_GPIO_WritePin(HART2_RST_GPIO_Port, HART2_RST_Pin, GPIO_PIN_RESET) // 拉低引脚复位模块
#define HART2_RESET_OFF HAL_GPIO_WritePin(HART2_RST_GPIO_Port, HART2_RST_Pin, GPIO_PIN_SET)
// #define HART2_RESET_ON HAL_GPIO_WritePin(HART2_RST_GPIO_Port, HART2_RST_Pin, GPIO_PIN_RESET) // 拉低引脚复位模块
// #define HART2_RESET_OFF HAL_GPIO_WritePin(HART2_RST_GPIO_Port, HART2_RST_Pin, GPIO_PIN_SET)
#define HART1_RTS_RECEIVE HAL_GPIO_WritePin(HART1_RTS_GPIO_Port, HART1_RTS_Pin, GPIO_PIN_SET)
#define HART1_RTS_SEND HAL_GPIO_WritePin(HART1_RTS_GPIO_Port, HART1_RTS_Pin, GPIO_PIN_RESET) // 拉低引脚发送
#define HART1_RTS_RECEIVE HAL_GPIO_WritePin(HART_RTS_GPIO_Port, HART_RTS_Pin, GPIO_PIN_SET)
#define HART1_RTS_SEND HAL_GPIO_WritePin(HART_RTS_GPIO_Port, HART_RTS_Pin, GPIO_PIN_RESET) // 拉低引脚发送
#define HART2_RTS_RECEIVE HAL_GPIO_WritePin(HART2_RTS_GPIO_Port, HART2_RTS_Pin, GPIO_PIN_SET)
#define HART2_RTS_SEND HAL_GPIO_WritePin(HART2_RTS_GPIO_Port, HART2_RTS_Pin, GPIO_PIN_RESET) // 拉低引脚发送
// #define HART2_RTS_RECEIVE HAL_GPIO_WritePin(HART2_RTS_GPIO_Port, HART2_RTS_Pin, GPIO_PIN_SET)
// #define HART2_RTS_SEND HAL_GPIO_WritePin(HART2_RTS_GPIO_Port, HART2_RTS_Pin, GPIO_PIN_RESET) // 拉低引脚发送
extern void hart_ht1200m_reset(void);
#endif

13
User/system/user_gpio.c
View File

@ -40,6 +40,13 @@ void user_read_gpio(communication_di_t *di_data, uint8_t *tx_data, const uint8_t
tx_data[6 + length] = FRAME_TAIL; // 帧尾
}
/**
* @brief 用户GPIO触发函数
*
* 该函数用于检测用户GPIO状态变化，并将状态信息发送给控制端。
*
* @return 无返回值
*/
void user_gpio_trigger(void)
{
uint8_t di_ch = 0;
@ -62,11 +69,11 @@ void user_gpio_trigger(void)
}
if ((send_data_flag_cmd != 0) && (1 == tcp_echo_flags_control))
{
tx_data[5 + DI_MAX] = xor_compute(tx_data + 1, tx_data_len - 3); // 寮傛垨鏍￠獙
tx_data[6 + DI_MAX] = FRAME_TAIL; // 甯у熬
tx_data[5 + DI_MAX] = xor_compute(tx_data + 1, tx_data_len - 3); // 异或校验
tx_data[6 + DI_MAX] = FRAME_TAIL; // 帧尾
user_send_data_control(tx_data, tx_data_len);
send_data_flag_cmd++;
if (send_data_flag_cmd > 3) // 杩炵画涓夋涓婁綅鏈烘病鏈夊洖搴旓紝鍒欏仠姝㈠彂閫佹暟鎹寘
if (send_data_flag_cmd > 3) // 如果连续发送3次，则清零
{
send_data_flag_cmd = 0;
}