21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › FreeRTOS-串口DMA收发不定长数据+队列
123下一页
返回列表 发新帖我要提问

[STM32F7] FreeRTOS-串口DMA收发不定长数据+队列

[复制链接]
4990|46
 楼主| zero949079783 发表于 2024-11-10 19:01 | 显示全部楼层 |阅读模式
freeRTOS, 不定长数据, 串口DMA, ar, UART, US
本帖最后由 zero949079783 于 2024-11-10 23:39 编辑

FreeRTOS-串口DMA收发不定长数据+队列
#include "Usartapp.c"
复制
  1. #include "main.h"
    


  2. 


  3. 


  4. 

  5. #define Usart1_RX_TASK_PRIO     3           /* 任务优先级 */
    

  6. #define Usart1_RX_STK_SIZE      512         /* 任务堆栈大小 */
    

  7. TaskHandle_t Usart1_RXTask_Handler;         /* 任务句柄 */
    

  8. void Usart1_RX_task(void *pvParameters);
    


  9. 

  10. #define Usart1_TX_TASK_PRIO     4           /* 任务优先级 */
    

  11. #define Usart1_TX_STK_SIZE      512                 /* 任务堆栈大小 */
    

  12. TaskHandle_t Usart1_TX_Task_Handler;         /* 任务句柄 */
    

  13. void Usart1_TX_task(void *pvParameters);
    


  14. 

  15. /*队列句柄*/
    

  16. QueueHandle_t RX_queue;                        //串口RX队列
    

  17. QueueHandle_t TX_queue;                        //串口RX队列
    


  18. 

  19. uint16_t bufflen = 0;                                //接收数据长度
    


  20. 


  21. 

  22. void Usart1_RX_Isr_FunCb(uint8_t *data,uint16_t datalen)
    

  23. {
    

  24.         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    

  25.         bufflen = datalen;        
    

  26.         xQueueSendFromISR(RX_queue,&data,&xHigherPriorityTaskWoken); //将数据放入消息队列
    

  27.         if(xHigherPriorityTaskWoken == pdTRUE)
    

  28.         {        
    

  29.                 portYIELD_FROM_ISR(xHigherPriorityTaskWoken); //如果需要就切换任务
    

  30.         }
    

  31. }
    


  32. 

  33. void Usart1_RX_task(void *pvParameters)
    

  34. {
    


  35. 

  36.                 
    

  37.         pvParameters=pvParameters;
    

  38.         Usart1_RX_FunCb(Usart1_RX_Isr_FunCb);
    

  39.         uint8_t res = 0;
    

  40.         uint8_t * rev_data ;
    

  41.         while(1)
    

  42.         {
    

  43.                 res=xQueueReceive(RX_queue,&rev_data,portMAX_DELAY);                //接收队列的数据
    

  44.                 
    

  45.                 if(res == pdPASS)
    

  46.                 {                
    

  47.                         Usart1_Txdata(rev_data,bufflen);//向队列放入数据
    

  48.                 }                
    


  49. 

  50.         }
    

  51. }
    


  52. 


  53. 

  54. void Usart1_TX_Fun(uint8_t *data,uint16_t datalen)
    

  55. {
    

  56.                 xQueueSend(TX_queue,&data,portMAX_DELAY);                                //发送队列的数据
    

  57. }
    


  58. 

  59. void Usart1_TX_task(void *pvParameters)
    

  60. {
    


  61. 


  62. 

  63.         pvParameters=pvParameters;
    

  64.         uint8_t res = 0;
    

  65.         uint8_t *tx_buff;
    

  66.         Usart1_TX_FunCb(Usart1_TX_Fun);
    

  67.         while(1)
    

  68.         {
    

  69.                 res = xQueueReceive(TX_queue,&tx_buff,portMAX_DELAY);                //接收TX队列的数据
    

  70.                 if(res == pdPASS)
    

  71.                 {
    

  72.                         Uart1_DMA_ENABLE(tx_buff,bufflen);        //启动DMA
    


  73. 

  74.                 }                        
    

  75.         }
    

  76. }
    


  77. 


  78. 

  79. void UsartAPP_Task_Init(void)
    

  80. {
    

  81.                         
    

  82.                 RX_queue = xQueueCreate(10,sizeof(uint8_t *));        //串口RX队列,接收为一桢数据        存放地址就可以
    

  83.                 
    

  84.                 if(RX_queue != NULL)
    

  85.                 {
    

  86.                         printf("\r\n串口RX队列创建成功\r\n");
    

  87.                 }        
    


  88. 

  89.                 TX_queue = xQueueCreate(10,sizeof(uint8_t *));        //串口TX队列,接收为一桢数据        存放地址就可以
    

  90.                 
    

  91.                 if(TX_queue != NULL)
    

  92.                 {
    

  93.                         printf("\r\n串口TX队列创建成功\r\n");
    

  94.                 }                        
    

  95.                 
    

  96.     /* Usart1_RX 任务 */
    

  97.     xTaskCreate((TaskFunction_t )Usart1_RX_task,                                                        /* 任务函数 */
    

  98.                 (const char*    )"Usart1_RX_task",                                                /* 任务名称 */
    

  99.                 (uint16_t       )Usart1_RX_STK_SIZE,                                        /* 任务堆栈大小 */
    

  100.                 (void*          )NULL,                                                                         /* 传递给任务函数的参数 */
    

  101.                 (UBaseType_t    )Usart1_RX_TASK_PRIO,                                        /* 任务优先级 */
    

  102.                 (TaskHandle_t*  )&Usart1_RX_task);                        /* 任务句柄 */        
    

  103.                                                                 
    

  104.     xTaskCreate((TaskFunction_t )Usart1_TX_task,                                                        /* 任务函数 */
    

  105.                 (const char*    )"Usart1_TX_task",                                                /* 任务名称 */
    

  106.                 (uint16_t       )Usart1_TX_STK_SIZE,                                        /* 任务堆栈大小 */
    

  107.                 (void*          )NULL,                                                                         /* 传递给任务函数的参数 */
    

  108.                 (UBaseType_t    )Usart1_TX_TASK_PRIO,                                        /* 任务优先级 */
    

  109.                 (TaskHandle_t*  )&Usart1_TX_task);                        /* 任务句柄 */                                                                        
    

  110. }
    


  111. 


  112. 


  113.


usart_drv.c
复制
  1. #include "usart_drv.h"
    


  2. 

  3. UCB uart1;        //串口1控制结构体
    


  4. 


  5. 


  6. 


  7. 

  8. uint8_t Usart1_RxBuff[U1_RX_SIZE];                 //串口1接收缓冲区
    

  9. uint8_t Usart1_TxBuff[U1_TX_SIZE];                //串口1发送缓冲区        
    


  10. 


  11. 


  12. 


  13. 

  14. static void(*USART1_TXFun)(uint8_t *data,uint16_t data_len);        //函数指针
    


  15. 

  16. void Usart1_TX_FunCb(void(*pFunc)(uint8_t *data,uint16_t datalen))
    

  17. {
    

  18.         USART1_TXFun = pFunc;
    

  19. }
    

  20. void Usart1_Txdata(uint8_t *data,uint32_t data_len)
    

  21. {
    

  22.         if(data_len == 0)        //防止发送0个数据
    

  23.         {
    

  24.                 uart1.TxState = 0;
    

  25.                 uart1.TxCounter = 0;
    

  26.                 return ;
    

  27.         }
    

  28.         
    

  29.         if((U1_TX_SIZE - uart1.TxCounter) >= data_len)
    

  30.         {
    

  31.                 USART1_TXFun(data,data_len);
    

  32.         }
    


  33. 


  34. 

  35. }
    


  36. 

  37. void Uart1_DMA_ENABLE(uint8_t *data,uint32_t data_len)
    

  38. {
    

  39.         HAL_UART_Transmit_DMA(&uart1.uart,data,data_len);
    

  40. }
    


  41. 

  42. /*************************************************************************
    

  43. *        函 数 名: UART1_Init
    

  44. *        功能说明: 串口1初始化
    

  45. *        形    参：无
    

  46. *        返 回 值: 无
    

  47. **************************************************************************/
    

  48. void UART1_Init(uint32_t baudrate)
    

  49. {        
    


  50. 

  51.         memset(&uart1.uart,0,sizeof(uart1.uart));
    

  52.         uart1.uart.Instance = USART1;
    

  53.         uart1.uart.Init.BaudRate = baudrate;
    

  54.         uart1.uart.Init.WordLength =UART_WORDLENGTH_8B;
    

  55.         uart1.uart.Init.StopBits=UART_STOPBITS_1;
    

  56.         uart1.uart.Init.Parity=UART_PARITY_NONE;
    

  57.         uart1.uart.Init.Mode=UART_MODE_TX_RX;
    

  58.         uart1.uart.Init.HwFlowCtl=UART_HWCONTROL_NONE;
    


  59. 

  60.         HAL_UART_Init(&uart1.uart);
    

  61.         
    


  62. 

  63.         __HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
    

  64.         __HAL_UART_ENABLE_IT(&uart1.uart,UART_IT_IDLE);        
    

  65.         HAL_UART_Receive_DMA(&uart1.uart,Usart1_RxBuff,U1_RX_MAX);
    

  66.         
    


  67. 

  68. }
    


  69. 

  70. uint8_t tempbuff1[256]={0};
    

  71. void Usart1_printf(char *fmt,...)
    

  72. {
    


  73. 

  74.         uint16_t i;
    

  75.         
    

  76.         va_list  ap;        
    

  77.         va_start(ap,fmt);        
    

  78.         vsprintf((char *)tempbuff1,fmt,ap);
    

  79.         va_end(ap);
    

  80.         
    

  81.         for(i=0;i<strlen((char *)tempbuff1);i++)
    

  82.         {
    

  83.                 while(!__HAL_UART_GET_FLAG(&uart1.uart,UART_FLAG_TXE))
    

  84.                 {
    

  85.                 }                
    

  86.                 uart1.uart.Instance->TDR = tempbuff1[i];                
    

  87.         }
    

  88.         
    

  89.         while(!__HAL_UART_GET_FLAG(&uart1.uart,UART_FLAG_TC))
    

  90.         {
    

  91.         
    

  92.         }                
    

  93. }
    


  94. 


  95. 


  96. 

  97. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    

  98. {
    

  99.         GPIO_InitTypeDef GPIO_InitTypeDefStructur;
    

  100.         
    

  101.         if(huart ->Instance == USART1)
    

  102.         {
    

  103.                 
    

  104.                 __HAL_RCC_DMA2_CLK_ENABLE();
    

  105.                 __HAL_RCC_GPIOA_CLK_ENABLE();
    

  106.                 __HAL_RCC_USART1_CLK_ENABLE();
    

  107.                 
    

  108.         
    

  109.                 GPIO_InitTypeDefStructur.Pin =GPIO_PIN_9;
    

  110.                 GPIO_InitTypeDefStructur.Mode = GPIO_MODE_AF_PP;
    

  111.                 GPIO_InitTypeDefStructur.Speed = GPIO_SPEED_FREQ_HIGH;
    

  112.                 GPIO_InitTypeDefStructur.Pull=GPIO_PULLUP;
    

  113.                 GPIO_InitTypeDefStructur.Alternate=GPIO_AF7_USART1;
    

  114.                 
    

  115.                 HAL_GPIO_Init(GPIOA,&GPIO_InitTypeDefStructur);                
    

  116.                 
    

  117.                 GPIO_InitTypeDefStructur.Pin =GPIO_PIN_10;
    

  118.                 GPIO_InitTypeDefStructur.Alternate=GPIO_AF7_USART1;
    

  119.                 HAL_GPIO_Init(GPIOA,&GPIO_InitTypeDefStructur);        
    

  120.                 
    

  121.                 HAL_NVIC_SetPriority(USART1_IRQn,7,0);
    

  122.                 HAL_NVIC_EnableIRQ(USART1_IRQn);
    

  123.                 
    

  124.                 //TX
    

  125.                 uart1.dmatx.Instance = DMA2_Stream7;
    

  126.                 uart1.dmatx.Init.Request= DMA_REQUEST_USART1_TX;                /* USART1发送DMA */                
    

  127.                 uart1.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;                /* 存储器到外设 */
    

  128.                 uart1.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;                                 /* 外设非增量模式 */
    

  129.                 uart1.dmatx.Init.MemInc = DMA_MINC_ENABLE;                                                /* 存储器增量模式 */
    

  130.                 uart1.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    

  131.                 uart1.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    

  132.                 uart1.dmatx.Init.Mode = DMA_NORMAL;
    

  133.                 uart1.dmatx.Init.Priority=DMA_PRIORITY_MEDIUM;
    

  134.                 uart1.dmatx.Init.FIFOThreshold=DMA_FIFOMODE_DISABLE;
    

  135.                                 HAL_DMA_Init(&uart1.dmatx);        
    

  136.                 
    

  137.                 __HAL_LINKDMA(huart,hdmatx,uart1.dmatx);                        //连接DMA通道
    

  138.         
    

  139.                 HAL_NVIC_SetPriority(DMA2_Stream7_IRQn,7,0);
    

  140.                 HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
    

  141.                 
    

  142.                 
    

  143.                 //RX
    

  144.                 uart1.dmarx.Instance = DMA2_Stream2;                        /* 数据流选择 */
    

  145.                 uart1.dmarx.Init.Request= DMA_REQUEST_USART1_RX;        /* USART1发送DMA */
    

  146.                 uart1.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    

  147.                 uart1.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
    

  148.                 uart1.dmarx.Init.MemInc = DMA_MINC_ENABLE;
    

  149.                 uart1.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    

  150.                 uart1.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    

  151.                 uart1.dmarx.Init.Mode = DMA_NORMAL;
    

  152.                 uart1.dmarx.Init.Priority=DMA_PRIORITY_MEDIUM;
    

  153.                 uart1.dmarx.Init.FIFOThreshold=DMA_FIFOMODE_DISABLE;
    

  154.                 
    

  155.                 __HAL_LINKDMA(huart,hdmarx,uart1.dmarx);                        //连接DMA通道
    

  156.                 HAL_DMA_Init(&uart1.dmarx);
    

  157.                 HAL_NVIC_SetPriority(DMA2_Stream2_IRQn,7,0);
    

  158.                 HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
    

  159.         }
    

  160.         
    

  161. }
    


  162. 


  163. 


  164. 

  165. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
    

  166. {
    

  167.         if(huart ->Instance == USART1)
    

  168.         {
    


  169. 

  170.                 uart1.TxState=0;
    


  171. 

  172.         }
    

  173.         
    

  174. }
    


  175. 


  176. 

  177. void Usart1_Send_Data(uint8_t *data,uint16_t datalen)
    

  178. {
    

  179.         uint16_t i;
    

  180.         for(i=0;i<datalen;i++)
    

  181.         {
    

  182.                 while(!__HAL_UART_GET_FLAG(&uart1.uart,UART_FLAG_TXE));        
    

  183.                 uart1.uart.Instance->TDR = data[i];                
    

  184.         }
    

  185.         
    

  186.         while(!__HAL_UART_GET_FLAG(&uart1.uart,UART_FLAG_TC));
    

  187. }
    


  188. 


  189. 

  190. static void(*USART1_RXFun)(uint8_t *data,uint16_t datalen);        //函数指针
    


  191. 

  192. void Usart1_RX_FunCb(void(*pFunc)(uint8_t *data,uint16_t datalen))
    

  193. {
    

  194.         USART1_RXFun = pFunc;
    

  195. }
    


  196. 

  197. void USART1_IRQHandler(void)
    

  198. {
    


  199. 


  200. 

  201.         HAL_UART_IRQHandler(&uart1.uart);
    

  202.         if(__HAL_UART_GET_FLAG(&uart1.uart,UART_FLAG_IDLE))
    

  203.         {
    

  204.                         
    

  205.                 __HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);        //清除空闲中断标志
    

  206.                 __HAL_DMA_DISABLE_IT(&uart1.dmarx,DMA_IT_HT);//禁止DMA传输过半中断
    

  207.                 
    

  208.                 uart1.RxCounter = ((U1_RX_MAX) - __HAL_DMA_GET_COUNTER(&uart1.dmarx));        //计算本次的接收数据量
    

  209.                 if(USART1_RXFun != NULL)
    

  210.                 {
    

  211.                         USART1_RXFun(Usart1_RxBuff,uart1.RxCounter);                
    

  212.                 }                
    

  213.         
    

  214.                 HAL_UART_DMAStop(&uart1.uart);                                        //停止DMA
    

  215.                 HAL_UART_Receive_DMA(&uart1.uart,Usart1_RxBuff,U1_RX_MAX);
    


  216. 

  217.                         
    

  218.         }
    

  219.         
    

  220. }
    


  221. 

  222. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    

  223. {
    


  224. 

  225.         if(huart ->Instance == USART1)
    

  226.         {
    

  227.                         if(__HAL_DMA_GET_FLAG(&uart1.dmarx, DMA_FLAG_TCIF2_6) == RESET)
    

  228.                         {
    

  229.                                 __HAL_DMA_CLEAR_FLAG(&uart1.dmarx, DMA_FLAG_TCIF2_6); //清除DMA2_Steam2传输完成标志
    

  230.                                 HAL_UART_DMAStop(&uart1.uart);                                        //停止DMA
    

  231.                                 HAL_UART_Receive_DMA(&uart1.uart,Usart1_RxBuff,U1_RX_MAX+1);
    

  232.                         }
    

  233.                         
    

  234.                         if(__HAL_DMA_GET_FLAG(&uart1.dmarx, DMA_FLAG_TCIF3_7) == RESET)
    

  235.                         {
    

  236.                                 __HAL_DMA_CLEAR_FLAG(&uart1.dmarx, DMA_FLAG_TCIF3_7); //清除DMA2_Steam7传输完成标志
    

  237.                         }                        
    

  238.         }
    


  239. 

  240. }
    


  241. 

  242. void DMA2_Stream2_IRQHandler(void)
    

  243. {
    

  244.         HAL_DMA_IRQHandler(&uart1.dmarx);
    

  245. }
    


  246. 

  247. void DMA2_Stream7_IRQHandler(void)
    

  248. {
    

  249.         HAL_DMA_IRQHandler(&uart1.dmatx);
    

  250. }
    


  251. 

  252. #if 1
    

  253. #if (__ARMCC_VERSION >= 6010050)            /* 使用AC6编译器时 */
    

  254. __asm(".global __use_no_semihosting\n\t");  /* 声明不使用半主机模式 */
    

  255. __asm(".global __ARM_use_no_argv \n\t");    /* AC6下需要声明main函数为无参数格式，否则部分例程可能出现半主机模式 */
    


  256. 

  257. #else
    

  258. /* 使用AC5编译器时, 要在这里定义__FILE 和 不使用半主机模式 */
    

  259. #pragma import(__use_no_semihosting)
    


  260. 

  261. struct __FILE
    

  262. {
    

  263.     int handle;
    

  264.     /* Whatever you require here. If the only file you are using is */
    

  265.     /* standard output using printf() for debugging, no file handling */
    

  266.     /* is required. */
    

  267. };
    


  268. 

  269. #endif
    


  270. 

  271. /* 不使用半主机模式，至少需要重定义_ttywrch\_sys_exit\_sys_command_string函数,以同时兼容AC6和AC5模式 */
    

  272. int _ttywrch(int ch)
    

  273. {
    

  274.     ch = ch;
    

  275.     return ch;
    

  276. }
    


  277. 

  278. /* 定义_sys_exit()以避免使用半主机模式 */
    

  279. void _sys_exit(int x)
    

  280. {
    

  281.     x = x;
    

  282. }
    


  283. 

  284. char *_sys_command_string(char *cmd, int len)
    

  285. {
    

  286.     return NULL;
    

  287. }
    


  288. 

  289. /* FILE 在 stdio.h里面定义. */
    

  290. FILE __stdout;
    


  291. 

  292. /* 重定义fputc函数, printf函数最终会通过调用fputc输出字符串到串口 */
    

  293. int fputc(int ch, FILE *f)
    

  294. {
    

  295.     while ((uart1.uart.Instance->ISR & 0X40) == 0);    /* 等待上一个字符发送完成 */
    

  296.                 
    

  297.     uart1.uart.Instance->TDR = (uint8_t)ch;            /* 将要发送的字符 ch 写入到DR寄存器 */
    

  298.     return ch;
    

  299. }
    

  300. #endif
    

  301. /******************************************************************************************/


usart_drv.h
复制
  1. #ifndef __USART_DRV_H
    

  2. #define __USART_DRV_H
    


  3. 

  4. #include "stm32h7xx_hal.h"
    


  5. 

  6. #include "string.h"
    

  7. #include "signal.h"
    

  8. #include "stdarg.h"
    

  9. #include "stdio.h"
    


  10. 

  11. #define  U1_RX_SIZE 257
    

  12. #define  U1_TX_SIZE 256
    

  13. #define  U1_RX_MAX         257
    

  14. #define  U1_TX_MAX         256
    


  15. 

  16. typedef struct{
    

  17.         uint8_t *start;
    

  18.         uint8_t *end;
    

  19. }LCB;
    


  20. 

  21. typedef struct{
    

  22.         uint32_t RxCounter;
    

  23.         uint32_t TxCounter;
    

  24.         uint32_t TxState;
    

  25.         
    

  26.         UART_HandleTypeDef uart;
    

  27.         DMA_HandleTypeDef dmatx;
    

  28.         DMA_HandleTypeDef dmarx;        
    

  29. }UCB;
    


  30. 

  31. void UART1_Init(uint32_t baudrate);
    


  32. 


  33. 

  34. void Usart1_PtrInit(void);
    

  35. void Usart1_Txdata(uint8_t *data,uint32_t data_len);
    

  36. void Uart1_DMA_ENABLE(uint8_t *data,uint32_t data_len);
    


  37. 


  38. 


  39. 

  40. void Usart1_printf(char *fmt,...);
    


  41. 


  42. 


  43. 

  44. void Usart1_Send_Data(uint8_t *data,uint16_t datalen);
    


  45. 

  46. void Usart1_RX_FunCb(void(*pFunc)(uint8_t *data,uint16_t datalen));
    

  47. void Usart1_TX_FunCb(void(*pFunc)(uint8_t *data,uint16_t datalen));
    

  48. #endif
    


  49.
















串口DMA队列操作.rar

8.48 MB, 下载次数: 17
回复

收藏 举报

相关帖子
mnynt121 发表于 2024-11-11 15:36 | 显示全部楼层
当接收到一帧完整的数据后，如果一段时间内没有新的数据到来，会触发串口空闲中断。这个中断用于通知处理器已经接收到完整的数据帧。
回复

收藏 举报

AdaMaYun 发表于 2024-11-11 16:05 | 显示全部楼层
接收到完整数据帧之后进行中断处理
回复

收藏 举报

dspmana 发表于 2024-11-11 16:34 | 显示全部楼层
在某些情况下，可以使用DMA的循环模式，这样当指定长度的串口数据通过DMA接收完成后，DMA硬件会自动重新设置传输长度，并开启下一个接收过程。但需要注意，在循环模式下，必须确保数据处理能够及时完成，以避免新接收的数据覆盖正在处理的数据。
回复

收藏 举报

 楼主| zero949079783 发表于 2024-11-11 19:27 | 显示全部楼层
mnynt121 发表于 2024-11-11 15:36
当接收到一帧完整的数据后，如果一段时间内没有新的数据到来，会触发串口空闲中断。这个中断用于通知处理器 ...

有数据，都会接收到乱码，这时候就需要做CRC了，这个只是使用DMA+环形队列的操作而已
回复

收藏 举报

 楼主| zero949079783 发表于 2024-11-11 19:29 | 显示全部楼层
AdaMaYun 发表于 2024-11-11 16:05
接收到完整数据帧之后进行中断处理

数据接收后，在任务中处理数据。数据先放进队列
回复

收藏 举报

 楼主| zero949079783 发表于 2024-11-11 19:30 | 显示全部楼层
dspmana 发表于 2024-11-11 16:34
在某些情况下，可以使用DMA的循环模式，这样当指定长度的串口数据通过DMA接收完成后，DMA硬件会自动重新设 ...

队列就是一个环形接收的，FIFO数据结构
回复

收藏 举报

sesefadou 发表于 2024-11-12 15:50 | 显示全部楼层
如果长时间没有接收到新的数据帧，可能需要进行超时检测，以确保系统稳定运行。
回复

收藏 举报

pentruman 发表于 2024-11-13 11:42 | 显示全部楼层
在空闲中断处理函数中，将DMA接收缓冲区中的数据拷贝到队列中，实现数据的入队操作。
在应用程序需要处理数据时，从队列中取出数据进行处理，实现数据的出队操作。
回复

收藏 举报

sdlls 发表于 2024-11-13 13:30 | 显示全部楼层
定义一个循环队列用于存储接收到的串口数据。循环队列是一种将数组的首位在逻辑上连接起来的环形结构，可以高效地利用存储空间。
初始化队列的头指针和尾指针，以及队列的长度等参数。
回复

收藏 举报

iyoum 发表于 2024-11-13 17:15 | 显示全部楼层
通过合理设置DMA传输长度和双缓冲机制，可以减少中断次数，提高系统响应速度。
回复

收藏 举报

febgxu 发表于 2024-11-13 20:47 | 显示全部楼层
DMA缓冲区足够大以容纳可能的最大数据包。如果数据包长度不固定，可能需要动态调整缓冲区大小或使用多个缓冲区。
回复

收藏 举报

mmbs 发表于 2024-11-14 17:12 | 显示全部楼层
使用环形队列（Circular Buffer）来管理接收到的数据，可以有效提高数据处理的效率。
回复

收藏 举报

robertesth 发表于 2024-11-14 21:25 | 显示全部楼层
为接收队列分配足够的内存空间，并定期清理不再使用的内存，防止内存溢出。
回复

收藏 举报

yorkbarney 发表于 2024-11-17 18:29 | 显示全部楼层
在接收过程中，可能会遇到各种错误情况，如接收超时、数据溢出等。
回复

收藏 举报

claretttt 发表于 2024-11-17 22:47 | 显示全部楼层
通过空闲中断，可以实现接收不定长数据的功能。无论串口接收了多少字节的数据，只要接收停止并产生空闲中断，就意味着有一组完整的数据已经接收完成。
回复

收藏 举报

gygp 发表于 2024-11-18 09:30 | 显示全部楼层
接收的是不定长数据，需要在数据处理过程中加入适当的完整性校验机制
回复

收藏 举报

gygp 发表于 2024-11-20 09:22 | 显示全部楼层
合理设置DMA中断和其他相关中断的优先级，确保关键任务能够及时得到处理。
回复

收藏 举报

uiint 发表于 2024-11-20 10:38 | 显示全部楼层
实施数据校验机制（如CRC校验），确保接收到的数据完整无误。
回复

收藏 举报

jackcat 发表于 2024-11-20 16:15 | 显示全部楼层
优化DMA的配置和缓冲区大小，以提高数据传输效率。
回复

收藏 举报

下一页 »
123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

zero949079783

33

主题

91

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部