wxsmart-test
/
signal_generator
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

备份

This commit is contained in:
王绪洁 2025-02-11 10:25:25 +08:00
parent aa93ff2508
commit 9e44135a34
4 changed files with 140 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Core/Src/main.c
View File

@ -122,8 +122,8 @@ int main(void)
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));
HAL_UARTEx_ReceiveToIdle_DMA(&huart2, hart2_uart2.rx_data_temp, ARRAY_LEN(hart2_uart2.rx_data_temp));
hart_ht1200m_reset(); // 夝佝HT1200M模块
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); // 坯动PWM输出，用于驱动HT1200M模块
hart_ht1200m_reset(); // 初始化HT1200M模块
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); // PWM输出，用于驱动HT1200M模块
/* USER CODE END 2 */
/* Call init function for freertos objects (in freertos.c) */
@ -139,7 +139,6 @@ int main(void)
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
// ad7124_get_analog(STOP_NC_ADC);
}
/* USER CODE END 3 */
}

37
Core/Src/usart.c
View File

@ -66,7 +66,6 @@ void MX_UART4_Init(void)
/* USER CODE BEGIN UART4_Init 2 */
//__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE); // 使能IDLE中断
/* USER CODE END UART4_Init 2 */
}
/* UART5 init function */
void MX_UART5_Init(void)
@ -92,10 +91,9 @@ void MX_UART5_Init(void)
Error_Handler();
}
/* USER CODE BEGIN UART5_Init 2 */
__HAL_UART_ENABLE_IT(&huart5, UART_IT_RXNE); // 接收中断
__HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE); // 空闲中断
// __HAL_UART_ENABLE_IT(&huart5, UART_IT_RXNE); // 接收中断
// __HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE); // 空闲中断
/* USER CODE END UART5_Init 2 */
}
/* USART2 init function */
@ -122,10 +120,9 @@ void MX_USART2_UART_Init(void)
Error_Handler();
}
/* USER CODE BEGIN USART2_Init 2 */
__HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); // 接收中断
__HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); // 使能IDLE中断
// __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); // 接收中断
// __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); // 使能IDLE中断
/* USER CODE END USART2_Init 2 */
}
/* USART3 init function */
@ -154,7 +151,6 @@ void MX_USART3_UART_Init(void)
/* USER CODE BEGIN USART3_Init 2 */
/* USER CODE END USART3_Init 2 */
}
/* USART6 init function */
@ -183,7 +179,6 @@ void MX_USART6_UART_Init(void)
/* USER CODE BEGIN USART6_Init 2 */
/* USER CODE END USART6_Init 2 */
}
void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle)
@ -648,17 +643,23 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
}
/* USER CODE BEGIN 1 */
/*
*********************************************************************************************************
* å‡? æ•? å<EFBFBD>?: dma_usart_send
* 功能说明: 串å<EFBFBD>£å<EFBFBD>‘é?<EFBFBD>功能函æ•?
* å½? å<EFBFBD>?: buf，len
* � � �: �
*********************************************************************************************************
/**
* @brief 使用DMA方式通过串口发送数据
*
* 该函数使用DMA方式通过指定的串口发送指定长度的数据。
*
* @param huart UART_HandleTypeDef结构体指针，指向需要使用的串口句柄
* @param buf 指向需要发送的数据缓冲区的指针
* @param len 需要发送的数据长度
*
* @return 无返回值
*
* @note 如果发送过程中出现错误，会调用Error_Handler函数处理错误
*/
void dma_usart_send(UART_HandleTypeDef *huart, uint8_t *buf, uint8_t len) // 串å<C2B2>£å<C2A3>‘é?<3F>å°<C3A5>è£?
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>正常，如果出现异常则进入异常中断函æ•?
if (HAL_UART_Transmit_DMA(huart, buf, len) != HAL_OK) // 判断是否发送正常，如果出现异常则进入异常中断函数
{
Error_Handler();
}

2
MDK-ARM/TEST2.uvoptx
View File

@ -308,7 +308,7 @@
<Group>
<GroupName>Application/User/Core</GroupName>
<tvExp>0</tvExp>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>

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

@ -19,14 +19,14 @@ extern uint8_t tcp_echo_flags_hart1;
extern uint8_t tcp_echo_flags_hart2;
extern uint8_t tcp_echo_flags_ble1;
extern uint8_t tcp_echo_flags_ble2;
/*接收回调函数*/
/*接收回调函数*/
static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
tcp_echo_flags_hart1 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_hart1, &tpcb, sizeof(struct tcp_pcb *));
#if 0
memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
@ -39,23 +39,11 @@ static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
HART1_RTS_SEND;
dma_usart_send(&huart5, hart1_uart5.tx_data, p->tot_len);
// HART1_RTS_RECEIVE;
#endif
#if 0
memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart6, ble1_uart6.tx_data, p->tot_len);
#endif
#if 0
memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart3, ble2_uart3.tx_data, p->tot_len);
#endif
#if 0
memcpy(lcd_uart4.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart4, lcd_uart4.tx_data, p->tot_len);
#endif
memset(p->payload, 0, p->tot_len);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
return tcp_close(tpcb);
}
@ -63,12 +51,12 @@ static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
tcp_echo_flags_hart2 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_hart2, &tpcb, sizeof(struct tcp_pcb *));
#if 1
memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
@ -81,22 +69,11 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
HAL_UART_Transmit(&huart5, hart1_uart5.tx_data, p->tot_len, 100);
HART1_RTS_RECEIVE;
#endif
#if 0
memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart6, ble1_uart6.tx_data, p->tot_len);
#endif
#if 0
memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart3, ble2_uart3.tx_data, p->tot_len);
#endif
#if 0
memcpy(lcd_uart4.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart4, lcd_uart4.tx_data, p->tot_len);
#endif
memset(p->payload, 0, p->tot_len);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
return tcp_close(tpcb);
}
@ -104,12 +81,12 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
tcp_echo_flags_ble1 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_ble1, &tpcb, sizeof(struct tcp_pcb *));
memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
@ -118,7 +95,7 @@ static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
memset(p->payload, 0, p->tot_len);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
return tcp_close(tpcb);
}
@ -126,12 +103,12 @@ static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
}
static err_t tcpecho_recv_ble2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
tcp_echo_flags_ble2 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_ble2, &tpcb, sizeof(struct tcp_pcb *));
memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
@ -140,36 +117,36 @@ static err_t tcpecho_recv_ble2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
memset(p->payload, 0, p->tot_len);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
return tcp_close(tpcb);
}
return ERR_OK;
}
static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
// 形参的数量和类型必须一致
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
tcp_recv(newpcb, tcpecho_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK;
}
static err_t tcpecho_accept_hart2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
static err_t tcpecho_accept_hart2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_hart2); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_recv(newpcb, tcpecho_recv_hart2); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK;
}
static err_t tcpecho_accept_ble1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
static err_t tcpecho_accept_ble1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_ble1); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_recv(newpcb, tcpecho_recv_ble1); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK;
}
static err_t tcpecho_accept_ble2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
static err_t tcpecho_accept_ble2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{
tcp_recv(newpcb, tcpecho_recv_ble2); // 当收到数据时，回调用户自己写的tcpecho_recv
tcp_recv(newpcb, tcpecho_recv_ble2); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK;
}
@ -180,53 +157,53 @@ void tcp_echo_init(void)
struct tcp_pcb *server_ble1 = NULL;
struct tcp_pcb *server_ble2 = NULL;
/* 创建一个TCP控制块 */
/* 创建一个TCP控制块 */
server_hart1 = tcp_new();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_hart1, IP_ADDR_ANY, TCP_PORT_HART1);
/* 进入监听状态 */
/* 进入监听状态 */
server_hart1 = tcp_listen(server_hart1);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_hart1, tcpecho_accept_hart1); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_hart1, tcpecho_accept_hart1); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 创建一个TCP控制块 */
/* 创建一个TCP控制块 */
server_hart2 = tcp_new();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_hart2, IP_ADDR_ANY, TCP_PORT_HART2);
/* 进入监听状态 */
/* 进入监听状态 */
server_hart2 = tcp_listen(server_hart2);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 创建一个TCP控制块 */
/* 创建一个TCP控制块 */
server_ble1 = tcp_new();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_ble1, IP_ADDR_ANY, TCP_PORT_BLE1);
/* 进入监听状态 */
/* 进入监听状态 */
server_ble1 = tcp_listen(server_ble1);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_ble1, tcpecho_accept_ble1); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_ble1, tcpecho_accept_ble1); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 创建一个TCP控制块 */
/* 创建一个TCP控制块 */
server_ble2 = tcp_new();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_ble2, IP_ADDR_ANY, TCP_PORT_BLE2);
/* 进入监听状态 */
/* 进入监听状态 */
server_ble2 = tcp_listen(server_ble2);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_ble2, tcpecho_accept_ble2); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_ble2, tcpecho_accept_ble2); // 侦听到连接后，回调用户编写的tcpecho_accept
}
void user_send_data_hart1(uint8_t *data, uint16_t len)