21ic电子技术开发论坛»论坛首页 › 单片机与嵌入式系统 › 小华半导体 › 【华大测评】+串口DMA收发数据
123下一页
返回列表 发新帖我要提问

[综合信息] 【华大测评】+串口DMA收发数据

[复制链接]
 楼主| lesheng002 发表于 2020-10-15 14:36 | 显示全部楼层 |阅读模式
串口DMA, SAR, USART, ni
本帖最后由 lesheng002 于 2020-10-15 14:36 编辑

串口传输用中断实现的话，要频繁的进入中断函数，这样无疑增加MCU的负担，干扰正常程序的运行，对于一些实时性强的应用，如数字显示应用中，液晶屏显示可能受影响而不能正常显示。用DMA实现串口收发数据，进行数据收发过程中，不需要MCU的干预，由DMA独立完成数据的收发，接收或者发送完成后才进入中断做后续处理，因此MCU使用效率更高。
华大提供的例程中，对于串口DMA收发的应用比较简单，我这里结合以前的经验将串口收发用DMA实现。

使用华大免费提供的DEMO板D的基础上实现，MCU型号是HC32F460，当前例程使用的资源简单介绍
1，拥有 2 个 DMA 控制单元，共 8 个独立通道， 可以独立操作不同的 DMA 传输功能；
2，有4个串行收发器模块(USART单元)，能够灵活地与外部设备进行全双工数据交换；


实现了功能，
1，系统滴答初始化及延时，
2，串行收发数据，用DMA实现，一次收发数据最大USART_DATA_BUFF_SIZE-1个字符，
3，用接收超时中断实现一次接收数据少于(USART_DATA_BUFF_SIZE-1)个字符的传输，


有4个文件，分别如下

  Systick.c 系统滴答文件
复制
  1. /******************************************************************************
    

  2.  * 文件名  ：SysTick.c
    

  3.  * 描述    ：SysTick 系统滴答时钟10us中断函数库,中断时间可自由配置，
    

  4.  *           常用的有 1us 10us 1ms 中断。         
    

  5.  * 实验平台：华大HC32F460
    

  6.  * 硬件连接：-----------------
    

  7.  *          |                 |
    

  8.  *          |      无         |
    

  9.  *          |                 |
    

  10.  *           -----------------
    

  11.  * 库版本  ：
    

  12.  *
    

  13.  * 作者    ：David liu  
    

  14.  * 博客    ：https://blog.csdn.net/qq_15548761
    

  15. **********************************************************************************/
    

  16. #include "systick.h"
    

  17. #include    "usart.h"
    


  18. 

  19. volatile uint32_t TimingDelay;
    


  20. 

  21. uint16_t        mainDelayMS;
    


  22. 

  23. uint16_t        beepCnt;
    

  24. uint8_t                beepTimes;
    


  25. 

  26. uint16_t        TimerSoundON;
    

  27. uint16_t        TimerSoundOFF;
    


  28. 


  29. 

  30. /*
    

  31.  * 函数名：SysTick_Init
    

  32.  * 描述  ：启动系统滴答定时器 SysTick
    

  33.  * 输入  ：无
    

  34.  * 输出  ：无
    

  35.  * 调用  ：外部调用 
    

  36.  */
    

  37. void SysTick_Init(void)
    

  38. {
    

  39.     stc_irq_regi_conf_t stcIrqRegiCfg;
    

  40.         /* SystemFrequency / 1000    1ms中断一次
    

  41.          * SystemFrequency / 100000         10us中断一次
    

  42.          * SystemFrequency / 1000000 1us中断一次
    

  43.          */
    

  44.         TimingDelay = 0;
    

  45.         if (SysTick_Config(SystemCoreClock / 1000))
    

  46.         while(1);
    

  47.     
    

  48. //  SysTick->LOAD  = (uint32_t)((SystemCoreClock / 1000) - 1UL);                         /* set reload register */
    

  49. //  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
    

  50. //  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
    

  51. //  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
    

  52. //                   SysTick_CTRL_TICKINT_Msk   |
    

  53. //                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
    

  54.     /* Set USART RX error IRQ */
    

  55. //    stcIrqRegiCfg.enIRQn = SysTick_IRQn;
    

  56. //    stcIrqRegiCfg.pfnCallback = &SysTick_IRQHandler;
    

  57. //    stcIrqRegiCfg.enIntSrc = USART_RTO_NUM;
    

  58. //    enIrqRegistration(&stcIrqRegiCfg);
    

  59. //    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    

  60. //    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    

  61. //    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
    

  62. }
    


  63. 


  64. 

  65. /*
    

  66.  * 函数名：Delay_us
    

  67.  * 描述  ：us延时程序,1ms为一个单位
    

  68.  * 输入  ：- nTime
    

  69.  * 输出  ：无
    

  70.  * 调用  ：Delay_us( 1 ) 则实现的延时为 1 * 10us = 10us
    

  71.  *       ：外部调用 
    

  72.  */
    


  73. 

  74. void SysTickDelay_ms(__IO uint32_t nTime)
    

  75. { 
    

  76.   TimingDelay = nTime;
    


  77. 

  78.   while(TimingDelay != 0)
    

  79.   {
    

  80.       __nop();
    

  81.       usart_rxData_process();
    

  82.   }
    

  83. }
    


  84. 

  85. void        BIBI_CntDown(void);
    

  86. /*
    

  87.  * 函数名：TimingDelay_Decrement
    

  88.  * 描述  ：获取节拍程序
    

  89.  * 输入  ：无
    

  90.  * 输出  ：无
    

  91.  * 调用  ：在 SysTick 中断函数 SysTick_Handler()调用
    

  92.  */  
    

  93. void SysTick_IRQHandler(void)
    

  94. {
    

  95.     static  uint16_t  timeCnt = 0;
    

  96.     if(TimingDelay)
    

  97.         TimingDelay--;
    

  98.         if(mainDelayMS)
    

  99.                 mainDelayMS--;
    


  100. 

  101.         timeCnt++;
    

  102.         if(timeCnt >= 500)
    

  103.         {
    

  104.                 timeCnt = 0;
    

  105.         }
    

  106.         BIBI_CntDown();
    

  107.         
    

  108. }
    


  109. 


  110. 

  111. void        BIBI_CntDown(void)
    

  112. {
    

  113.         if(beepCnt)                //        蜂鸣器延时
    

  114.         {
    

  115.                 beepCnt--;
    

  116.                 if(!beepCnt)
    

  117.                 {
    

  118.                         if(!beepTimes)
    

  119.                                 BeepOut(0);
    

  120.                         else
    

  121.                         {
    

  122.                                 beepTimes--;
    

  123.                                 if(beepTimes%2)
    

  124.                                 {
    

  125.                                         beepCnt = TimerSoundOFF;
    

  126.                     BeepOut(0);
    

  127.                                 }
    

  128.                                 else
    

  129.                                 {
    

  130.                     BeepOut(1);
    

  131.                                         beepCnt = TimerSoundON;
    

  132.                                 }
    

  133.                         }
    

  134.                 }
    

  135.         }
    

  136. }
    


  137. 


  138. 

  139. void        BIBI_Start(uint8_t        bibiTimes)
    

  140. {
    

  141.         {
    

  142.                 beepTimes = bibiTimes*2-1;
    

  143.                 BeepOut(1);
    

  144.                 beepCnt = DEF_BIBI_DELAY_TIMER;
    

  145.         TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
    

  146.                 TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
    

  147.         }
    

  148. }
    


  149. 


  150. 

  151. void        BIBI_LongStart(uint8_t        bibiTimes)
    

  152. {
    

  153.         {
    

  154.                 beepTimes = bibiTimes*2-1;
    

  155.                 BeepOut(1);
    

  156.                 beepCnt = DEF_LONG_BIBI_DELAY;
    

  157.         TimerSoundON  = DEF_LONG_BIBI_DELAY ;
    

  158.                 TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
    

  159.         }
    

  160. }
    


  161. 

  162. /*****************************************************************
    

  163.       void  Buzzer(unsigned char idata  SoundType );
    

  164. *****************************************************************/
    

  165. void Buzzer(unsigned char  SoundType )
    

  166. {
    

  167. //    switch(SoundType)
    

  168. //        { 
    

  169. //        case SHORT_BI   :   TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
    

  170. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
    

  171. //                                                        beepTimes     = 1 ;          // On  1-time
    

  172. //                                                        break;
    

  173. //                case SHORT_BI_2 :   TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
    

  174. //                                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
    

  175. //                                                        beepTimes     = 3 ;          // On, Off, On
    

  176. //                                                        break;
    

  177. //                case SHORT_BI_3 :   TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
    

  178. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
    

  179. //                                                        beepTimes     = 5 ;          // On, Off, On, Off, On ( 3-times)
    

  180. //                                                        break;
    

  181. //                case LONG_BI    :   TimerSoundON  = DEF_BIBI_DELAY_TIMER*3 ;
    

  182. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
    

  183. //                                                        beepTimes     = 9;           // On  10/2=5 times
    

  184. //                                                        break;
    

  185. //                case LONG_BI_2  :   TimerSoundON  = DEF_BIBI_DELAY_TIMER*3 ;
    

  186. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
    

  187. //                                                        beepTimes     = 19;           //  On, Off, 10 times
    

  188. //                                                        break;
    

  189. //        }
    

  190.         BeepOut(1);
    

  191.         beepCnt = TimerSoundON;
    

  192. }
    


  193. 


  194. 


  195. 

  196. void Sound_KeyOK(void)
    

  197. {
    

  198. //    Buzzer(SHORT_BI);
    

  199. }
    


  200. 

  201. void Sound_KeyError(void)
    

  202. {
    

  203. //    Buzzer(SHORT_BI_2);
    

  204. }
    


  205. 

  206. void Sound_AxisError(void)
    

  207. {
    

  208. //    Buzzer(LONG_BI);
    

  209. }
    


  210. 


  211. 


  212. 

  213. /************************* *****END OF FILE***********************************/


  SysTick.h
复制
  1. #ifndef __SYSTICK_H
    

  2. #define __SYSTICK_H
    


  3. 

  4. #include "hc32_ddl.h"
    


  5. 

  6. #define                DEF_BIBI_DELAY_TIMER                20        //80
    

  7. #define                DEF_LONG_BIBI_DELAY                        80        //300
    

  8. #define     TIME_READ_COUNTER       15
    


  9. 

  10. #define     BeepOut(x)     // x = x
    


  11. 

  12. void SysTick_Init(void);
    

  13. void Delay_10us(__IO uint32_t nTime);
    

  14. void SysTickDelay_ms(__IO uint32_t nTime);
    


  15. 

  16. void Sound_KeyOK(void);
    

  17. void Sound_KeyError(void);
    

  18. void Sound_AxisError(void);
    


  19. 


  20. 

  21. #endif /* __SYSTICK_H */
串行数据收发实现文件
usart.h
复制
  1. #ifndef __USART_H__
    

  2. #define __USART_H__
    


  3. 

  4. #include "hc32_ddl.h"
    

  5. #include <stdio.h>
    

  6. #include "hc32f46x_dmac.h"
    


  7. 

  8. #define     USART_DATA_BUFF_SIZE        100
    

  9. #define     USART_ARRAY_SIZE        3
    


  10. 

  11. #define     ENABLE_USART_DMA        1
    


  12. 

  13. /* DMAC */
    

  14. #define USART_DMA_UNIT                        (M4_DMA1)
    

  15. #define RX_DMA_CH                          (DmaCh0)
    

  16. #define RX_DMA_TRG_SEL                     (EVT_USART3_RI)
    

  17. #define TX_DMA_CH                          (DmaCh1)
    

  18. #define TX_DMA_TRG_SEL                     (EVT_USART3_TI)
    


  19. 

  20. /* DMA block transfer complete interrupt */
    

  21. #define RX_DMA_BTC_INT_NUM                 (INT_DMA1_TC0)
    

  22. #define RX_DMA_BTC_INT_IRQn                (Int002_IRQn)
    

  23. #define TX_DMA_BTC_INT_NUM                 (INT_DMA1_TC1)
    

  24. #define TX_DMA_BTC_INT_IRQn                (Int001_IRQn)
    


  25. 


  26. 

  27. /* USART channel definition */
    

  28. #define USART_CH                        (M4_USART3)
    


  29. 

  30. /* USART baudrate definition */
    

  31. #define USART_BAUDRATE                  (115200ul)
    


  32. 

  33. /* USART RX Port/Pin definition */
    

  34. #define USART_RX_PORT                   (PortE)
    

  35. #define USART_RX_PIN                    (Pin04)
    

  36. #define USART_RX_FUNC                   (Func_Usart3_Rx)
    


  37. 

  38. /* USART TX Port/Pin definition */
    

  39. #define USART_TX_PORT                   (PortE)
    

  40. #define USART_TX_PIN                    (Pin05)
    

  41. #define USART_TX_FUNC                   (Func_Usart3_Tx)
    


  42. 

  43. /* USART interrupt number  */
    

  44. #define USART_RI_NUM                    (INT_USART3_RI)
    

  45. #define USART_EI_NUM                    (INT_USART3_EI)
    

  46. #define USART_TI_NUM                    (INT_USART3_TI)
    

  47. #define USART_TCI_NUM                   (INT_USART3_TCI)
    

  48. #define USART_RI_IRQn                    (Int003_IRQn)
    

  49. #define USART_EI_IRQn                    (Int004_IRQn)
    

  50. #define USART_TI_IRQn                    (Int005_IRQn)
    

  51. #define USART_TCI_IRQn                   (Int006_IRQn)
    

  52. #define USART_RTO_NUM                    (INT_USART3_RTO)
    

  53. #define USART_RTO_IRQn                    (Int007_IRQn)
    


  54. 

  55. /* Timer0 unit definition */
    

  56. #define TMR_UNIT                        (M4_TMR02)
    

  57. #define TMR_FCG_PERIPH                  (PWC_FCG2_PERIPH_TIM02)
    


  58. 

  59. extern  uint8_t  rcvBuff[USART_ARRAY_SIZE][USART_DATA_BUFF_SIZE];
    

  60. extern  uint8_t  rcvPoint ;
    

  61. extern  uint8_t  rcvReceived ;
    

  62. extern  uint8_t  sndBuff[USART_DATA_BUFF_SIZE];
    


  63. 

  64. void USART_Config(void);
    

  65. void Usart_Rx_Tx(void);
    

  66. void UsartRxErrProcess(void);
    


  67. 

  68. void    usart_tx_start_sending(uint8_t *pbuff, uint16_t  size);
    

  69. void    usart_rxData_process(void);
    


  70. 

  71. #endif
usart.c

复制
  1. #include "usart.h"
    


  2. 


  3. 

  4. uint8_t  rcvBuff[USART_ARRAY_SIZE][USART_DATA_BUFF_SIZE];
    

  5. uint8_t  rcvPoint = 0;
    

  6. uint8_t  rcvReceived = 0;
    

  7. uint8_t  rcvCount = 1;
    

  8. uint8_t  sndBuff[USART_DATA_BUFF_SIZE];
    


  9. 


  10. 

  11. //  DMA接收完成回调函数，或者接收超时中断函数中调用
    

  12. //  当前一组数据接收完成后的操作
    

  13. void    usart_rx_receive_finish(void)
    

  14. {
    

  15. #if     (ENABLE_USART_DMA == 1)
    

  16.     uint16_t  cnt;
    


  17. 

  18.     DMA_ChannelCmd(USART_DMA_UNIT, RX_DMA_CH,  Disable);
    

  19.     cnt = DMA_GetTransferCnt(USART_DMA_UNIT, RX_DMA_CH);
    

  20.     rcvBuff[rcvPoint][0] = USART_DATA_BUFF_SIZE - cnt ;
    

  21.     rcvReceived++;
    

  22.     rcvPoint++;
    

  23.     if(rcvPoint >= USART_ARRAY_SIZE)
    

  24.         rcvPoint = 0;
    

  25.     /* Initialize DMA. */
    

  26.     DMA_SetBlockSize(USART_DMA_UNIT, RX_DMA_CH, 1);
    

  27.     DMA_SetTransferCnt(USART_DMA_UNIT, RX_DMA_CH, USART_DATA_BUFF_SIZE-1);
    

  28.     DMA_SetDesAddress(USART_DMA_UNIT, RX_DMA_CH, (uint32_t)(&rcvBuff[rcvPoint][1]));
    

  29.     DMA_ChannelCmd(USART_DMA_UNIT, RX_DMA_CH,  Enable);
    

  30. #else
    

  31.     rcvBuff[rcvPoint][0] = rcvCount-1;
    

  32.     rcvReceived++;
    

  33.     rcvCount = 1;
    

  34.     rcvPoint++;
    

  35.     if(rcvPoint >= USART_ARRAY_SIZE)
    

  36.         rcvPoint = 0;
    

  37. #endif
    

  38. }
    


  39. 

  40. //  启动发送数据，
    

  41. void    usart_tx_start_sending(uint8_t *pbuff, uint16_t  size)
    

  42. {
    

  43.     uint16_t i;
    

  44.     for(i  = 0; i < size; i++)
    

  45.     {
    

  46.         sndBuff[i] = *pbuff++;
    

  47.     }
    

  48. #if     (ENABLE_USART_DMA == 1)
    

  49.     DMA_SetBlockSize(USART_DMA_UNIT, TX_DMA_CH, 1);
    

  50.     DMA_SetTransferCnt(USART_DMA_UNIT, TX_DMA_CH, size);
    

  51.     DMA_SetSrcAddress(USART_DMA_UNIT, TX_DMA_CH, (uint32_t)(&sndBuff[0]));
    

  52.     /* Enable the specified DMA channel. */
    

  53.     DMA_ChannelCmd(USART_DMA_UNIT, TX_DMA_CH, Enable);
    


  54. 

  55.     /* Clear DMA flag. */
    

  56.     DMA_ClearIrqFlag(USART_DMA_UNIT, TX_DMA_CH, TrnCpltIrq);
    

  57.         USART_FuncCmd(USART_CH, UsartTx, Enable);
    

  58.     USART_FuncCmd(USART_CH, UsartTxEmptyInt, Enable);
    

  59. #else
    

  60. #endif
    

  61. }
    


  62. 

  63. #if     (ENABLE_USART_DMA == 1)
    

  64. /**
    

  65.  *******************************************************************************
    

  66.  ** \brief DMA block transfer complete irq callback function.
    

  67.  **
    

  68.  ** \param [in] None
    

  69.  **
    

  70.  ** \retval None
    

  71.  **
    

  72.  ******************************************************************************/
    

  73. static void usart_rx_Dma_IrqCallback(void)
    

  74. {
    

  75.     DMA_ClearIrqFlag(USART_DMA_UNIT, RX_DMA_CH, TrnCpltIrq);
    

  76.     usart_rx_receive_finish();
    

  77. }
    


  78. 


  79. 

  80. /**
    

  81.  *******************************************************************************
    

  82.  ** \brief DMA block transfer complete irq callback function.
    

  83.  **
    

  84.  ** \param [in] None
    

  85.  **
    

  86.  ** \retval None
    

  87.  **
    

  88.  ******************************************************************************/
    

  89. static void usart_tx_Dma_IrqCallback(void)
    

  90. {
    

  91.     DMA_ClearIrqFlag(USART_DMA_UNIT, TX_DMA_CH, TrnCpltIrq);
    

  92.     /* Enable the specified DMA channel. */
    

  93.     DMA_ChannelCmd(USART_DMA_UNIT, TX_DMA_CH, Disable);
    

  94.         USART_FuncCmd(USART_CH, UsartTx, Disable);
    

  95. }
    

  96. #endif
    


  97. 


  98. 

  99. /**
    

  100.  *******************************************************************************
    

  101.  ** \brief USART RX irq callback function.
    

  102.  **
    

  103.  ** \param [in] None
    

  104.  **
    

  105.  ** \retval None
    

  106.  **
    

  107.  ******************************************************************************/
    

  108. static void UsartRxIrqCallback(void)
    

  109. {
    

  110.     rcvBuff[rcvPoint][rcvCount++] = USART_RecData(USART_CH);
    

  111. //    USART_FuncCmd(USART_CH, UsartTxAndTxEmptyInt, Enable);
    

  112.     if(rcvCount >= USART_DATA_BUFF_SIZE-1)
    

  113.     {
    

  114.         usart_rx_receive_finish();
    

  115.     }
    

  116. }
    


  117. 

  118. /**
    

  119.  *******************************************************************************
    

  120.  ** \brief USART RX error irq callback function.
    

  121.  **
    

  122.  ** \param [in] None
    

  123.  **
    

  124.  ** \retval None
    

  125.  **
    

  126.  ******************************************************************************/
    

  127. static void UsartErrIrqCallback(void)
    

  128. {
    

  129.     if (Set == USART_GetStatus(USART_CH, UsartFrameErr))
    

  130.     {
    

  131.         USART_ClearStatus(USART_CH, UsartFrameErr);
    

  132.     }
    


  133. 

  134.     if (Set == USART_GetStatus(USART_CH, UsartParityErr))
    

  135.     {
    

  136.         USART_ClearStatus(USART_CH, UsartParityErr);
    

  137.     }
    


  138. 

  139.     if (Set == USART_GetStatus(USART_CH, UsartOverrunErr))
    

  140.     {
    

  141.         USART_ClearStatus(USART_CH, UsartOverrunErr);
    

  142.     }
    

  143. }
    


  144. 


  145. 

  146. /**
    

  147.  *******************************************************************************
    

  148.  ** \brief USART RX Timer out irq callback function.
    

  149.  **
    

  150.  ** \param [in] None
    

  151.  **
    

  152.  ** \retval None
    

  153.  **
    

  154.  ******************************************************************************/
    

  155. static void usart_rx_timeOut_IrqCallback(void)
    

  156. {
    

  157.     {
    

  158.         TIMER0_Cmd(TMR_UNIT, Tim0_ChannelA,Disable);
    

  159.         USART_ClearStatus(USART_CH, UsartRxTimeOut);
    

  160.         usart_rx_receive_finish();
    

  161.     }
    

  162. }
    


  163. 


  164. 

  165. #if     (ENABLE_USART_DMA == 1)
    

  166. /**
    

  167.  *******************************************************************************
    

  168.  ** \brief Initialize DMA.
    

  169.  **
    

  170.  ** \param [in] None
    

  171.  **
    

  172.  ** \retval None
    

  173.  **
    

  174.  ******************************************************************************/
    

  175. static void DmaInit(void)
    

  176. {
    

  177.     stc_dma_config_t stcDmaInit;
    

  178.     stc_irq_regi_conf_t stcIrqRegiCfg;
    


  179. 

  180.     /* Enable peripheral clock */
    

  181.     PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_DMA1,Enable);
    


  182. 

  183.     /* Enable DMA. */
    

  184.     DMA_Cmd(USART_DMA_UNIT,Enable);
    


  185. 

  186.     /* Initialize DMA. */
    

  187.     MEM_ZERO_STRUCT(stcDmaInit);
    

  188.     stcDmaInit.u16BlockSize = 1u; /* 1 block */
    

  189.     stcDmaInit.u16TransferCnt = USART_DATA_BUFF_SIZE-1;
    

  190.     stcDmaInit.u32SrcAddr = ((uint32_t)(&USART_CH->DR)+2ul); /* Set source address. */
    

  191.     stcDmaInit.u32DesAddr = (uint32_t)(&rcvBuff[0][1]);     /* Set destination address. */
    

  192.     stcDmaInit.stcDmaChCfg.enSrcInc = AddressFix;  /* Set source address mode. */
    

  193.     stcDmaInit.stcDmaChCfg.enDesInc = AddressIncrease;  /* Set destination address mode. */
    

  194.     stcDmaInit.stcDmaChCfg.enIntEn = Enable;       /* Enable interrupt. */
    

  195.     stcDmaInit.stcDmaChCfg.enTrnWidth = Dma8Bit;   /* Set data width 8bit. */
    

  196.     DMA_InitChannel(USART_DMA_UNIT, RX_DMA_CH, &stcDmaInit);
    


  197. 

  198.     /* Enable the specified DMA channel. */
    

  199.     DMA_ChannelCmd(USART_DMA_UNIT, RX_DMA_CH, Enable);
    


  200. 

  201.     /* Clear DMA flag. */
    

  202.     DMA_ClearIrqFlag(USART_DMA_UNIT, RX_DMA_CH, TrnCpltIrq);
    


  203. 

  204.     /* Enable peripheral circuit trigger function. */
    

  205.     PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_PTDIS,Enable);
    


  206. 

  207.     /* Set DMA trigger source. */
    

  208.     DMA_SetTriggerSrc(USART_DMA_UNIT, RX_DMA_CH, RX_DMA_TRG_SEL);
    


  209. 

  210.     /* Initialize DMA. */
    

  211.     MEM_ZERO_STRUCT(stcDmaInit);
    

  212.     stcDmaInit.u16BlockSize = 1u; /* 1 block */
    

  213.     stcDmaInit.u16TransferCnt = USART_DATA_BUFF_SIZE-1;
    

  214.     stcDmaInit.u32SrcAddr = (uint32_t)(&sndBuff[1]); /* Set source address. */
    

  215.     stcDmaInit.u32DesAddr = ((uint32_t)(&USART_CH->DR));     /* Set destination address. */
    

  216.     stcDmaInit.stcDmaChCfg.enSrcInc = AddressIncrease;  /* Set source address mode. */
    

  217.     stcDmaInit.stcDmaChCfg.enDesInc = AddressFix;  /* Set destination address mode. */
    

  218.     stcDmaInit.stcDmaChCfg.enIntEn = Enable;       /* Enable interrupt. */
    

  219.     stcDmaInit.stcDmaChCfg.enTrnWidth = Dma8Bit;   /* Set data width 8bit. */
    

  220.     DMA_InitChannel(USART_DMA_UNIT, TX_DMA_CH, &stcDmaInit);
    


  221. 

  222.     /* Set DMA trigger source. */
    

  223.     DMA_SetTriggerSrc(USART_DMA_UNIT, TX_DMA_CH, TX_DMA_TRG_SEL);
    


  224. 

  225.     /* Set DMA block transfer complete IRQ */
    

  226.     stcIrqRegiCfg.enIRQn = RX_DMA_BTC_INT_IRQn;
    

  227.     stcIrqRegiCfg.pfnCallback = &usart_rx_Dma_IrqCallback;
    

  228.     stcIrqRegiCfg.enIntSrc = RX_DMA_BTC_INT_NUM;
    

  229.     enIrqRegistration(&stcIrqRegiCfg);
    

  230.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    

  231.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    

  232.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
    

  233.     
    

  234.     stcIrqRegiCfg.enIRQn = TX_DMA_BTC_INT_IRQn;
    

  235.     stcIrqRegiCfg.pfnCallback = &usart_tx_Dma_IrqCallback;
    

  236.     stcIrqRegiCfg.enIntSrc = TX_DMA_BTC_INT_NUM;
    

  237.     enIrqRegistration(&stcIrqRegiCfg);
    

  238.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    

  239.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    

  240.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
    

  241. }
    

  242. #endif
    


  243. 

  244. void Timer0Init(void);
    


  245. 

  246. //  串行数据收发器配置函数
    

  247. void USART_Config(void)
    

  248. {
    

  249.         en_result_t enRet = Ok;
    

  250.     stc_irq_regi_conf_t stcIrqRegiCfg;
    

  251.         uint32_t u32Fcg1Periph = PWC_FCG1_PERIPH_USART3;
    

  252.         const stc_usart_uart_init_t stcInitCfg = 
    

  253.         {
    

  254.         UsartIntClkCkOutput,
    

  255.         UsartClkDiv_1,
    

  256.         UsartDataBits8,
    

  257.         UsartDataLsbFirst,
    

  258.         UsartOneStopBit,
    

  259.         UsartParityNone,
    

  260.         UsartSamleBit8,
    

  261.         UsartStartBitFallEdge,
    

  262.         UsartRtsEnable,
    

  263.         };
    


  264. 

  265.         /* Enable peripheral clock */
    

  266.         PWC_Fcg1PeriphClockCmd(u32Fcg1Periph, Enable);
    


  267. 

  268.         /* Initialize USART IO */
    

  269.         PORT_SetFunc(USART_RX_PORT, USART_RX_PIN, USART_RX_FUNC, Disable);
    

  270.         PORT_SetFunc(USART_TX_PORT, USART_TX_PIN, USART_TX_FUNC, Disable);
    


  271. 

  272. #if     (ENABLE_USART_DMA == 1)
    

  273.     DmaInit();
    

  274. #endif
    

  275.     Timer0Init();
    


  276. 

  277.         /* Initialize UART */
    

  278.         enRet = USART_UART_Init(USART_CH, &stcInitCfg);
    

  279.         if (enRet != Ok)
    

  280.         {
    

  281.                 while (1)
    

  282.                 {
    

  283.                 }
    

  284.         }
    


  285. 

  286.         /* Set baudrate */
    

  287.         enRet = USART_SetBaudrate(USART_CH, USART_BAUDRATE);
    

  288.         if (enRet != Ok)
    

  289.         {
    

  290.                 while (1)
    

  291.                 {
    

  292.                 }
    

  293.         }
    

  294.     
    

  295. #if     (ENABLE_USART_DMA == 0)
    

  296.          /* Set USART RX IRQ */
    

  297.     stcIrqRegiCfg.enIRQn = USART_RI_IRQn;
    

  298.     stcIrqRegiCfg.pfnCallback = &UsartRxIrqCallback;
    

  299.     stcIrqRegiCfg.enIntSrc = USART_RI_NUM;
    

  300.     enIrqRegistration(&stcIrqRegiCfg);
    

  301.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    

  302.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    

  303.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
    

  304. #endif    
    

  305.     /* Set USART RX error IRQ */
    

  306.     stcIrqRegiCfg.enIRQn = USART_EI_IRQn;
    

  307.     stcIrqRegiCfg.pfnCallback = &UsartErrIrqCallback;
    

  308.     stcIrqRegiCfg.enIntSrc = USART_EI_NUM;
    

  309.     enIrqRegistration(&stcIrqRegiCfg);
    

  310.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    

  311.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    

  312.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
    

  313.     
    

  314.     /* Set USART RX error IRQ */
    

  315.     stcIrqRegiCfg.enIRQn = USART_RTO_IRQn;
    

  316.     stcIrqRegiCfg.pfnCallback = &usart_rx_timeOut_IrqCallback;
    

  317.     stcIrqRegiCfg.enIntSrc = USART_RTO_NUM;
    

  318.     enIrqRegistration(&stcIrqRegiCfg);
    

  319.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
    

  320.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
    

  321.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
    

  322.     
    

  323.     /*Enable TX && RX && RX interrupt function*/
    

  324.         USART_FuncCmd(USART_CH, UsartRx, Enable);
    

  325.     USART_FuncCmd(USART_CH, UsartRxInt, Enable);
    

  326.     
    

  327.     USART_FuncCmd(USART_CH, UsartTimeOut, Enable);
    

  328.     USART_FuncCmd(USART_CH, UsartTimeOutInt, Enable);
    

  329. }
    


  330. 


  331. 

  332. /**
    

  333.  *******************************************************************************
    

  334.  ** \brief Initliaze Timer0.
    

  335.  **
    

  336.  ** \param [in] None
    

  337.  **
    

  338.  ** \retval None
    

  339.  **
    

  340.  ******************************************************************************/
    

  341. void Timer0Init(void)
    

  342. {
    

  343.     stc_clk_freq_t stcClkTmp;
    

  344.     stc_tim0_base_init_t stcTimerCfg;
    

  345.     stc_tim0_trigger_init_t StcTimer0TrigInit;
    


  346. 

  347.     MEM_ZERO_STRUCT(stcClkTmp);
    

  348.     MEM_ZERO_STRUCT(stcTimerCfg);
    

  349.     MEM_ZERO_STRUCT(StcTimer0TrigInit);
    


  350. 

  351.     /* Timer0 peripheral enable */
    

  352.     PWC_Fcg2PeriphClockCmd(TMR_FCG_PERIPH, Enable);
    


  353. 

  354.     /* Clear CNTAR register for channel A */
    

  355.     TIMER0_WriteCntReg(TMR_UNIT, Tim0_ChannelA, 0u);
    

  356.     TIMER0_WriteCntReg(TMR_UNIT, Tim0_ChannelB, 0u);
    


  357. 

  358.     /* Config register for channel A */
    

  359.     stcTimerCfg.Tim0_CounterMode = Tim0_Async;
    

  360.     stcTimerCfg.Tim0_AsyncClockSource = Tim0_XTAL32;
    

  361.     stcTimerCfg.Tim0_ClockDivision = Tim0_ClkDiv8;
    

  362.     stcTimerCfg.Tim0_CmpValue = 3200u;
    

  363.     TIMER0_BaseInit(TMR_UNIT, Tim0_ChannelA, &stcTimerCfg);
    


  364. 

  365.     /* Clear compare flag */
    

  366.     TIMER0_ClearFlag(TMR_UNIT, Tim0_ChannelA);
    


  367. 

  368.     /* Config timer0 hardware trigger */
    

  369.     StcTimer0TrigInit.Tim0_InTrigEnable = false;
    

  370.     StcTimer0TrigInit.Tim0_InTrigClear = true;
    

  371.     StcTimer0TrigInit.Tim0_InTrigStart = true;
    

  372.     StcTimer0TrigInit.Tim0_InTrigStop = false;
    

  373.     TIMER0_HardTriggerInit(TMR_UNIT, Tim0_ChannelA, &StcTimer0TrigInit);
    

  374. }
    


  375. 


  376. 

  377. //  对接收到的一组数据进行分析处理
    

  378. //  该函数在延时函数中调用，以获得及时响应
    

  379. void usart_rxData_process(void)
    

  380. {
    

  381.     static uint8_t  txPoint = 0;
    

  382.     if(rcvReceived > 0)
    

  383.     {
    

  384.         rcvReceived--;
    

  385.         usart_tx_start_sending(&rcvBuff[txPoint][1], rcvBuff[txPoint][0]);
    

  386.         txPoint++;
    

  387.         if(txPoint>=USART_ARRAY_SIZE)
    

  388.             txPoint = 0;
    

  389.     }
    

  390. }
对于经常使用串口收发数据的应用，用DMA实现提供MCU的效率，提高系统的性能。
将代码贴出来，大家一起探讨，有不妥之处，欢迎指正。

回复 赏

举报

评论

h32446975
用户手册中，USART寄存器，明确说明，TXEIE位和TE位应同时写入1. 楼主验证过，调用这个函数，可以正常发送数据吗？ // 启动发送数据，void usart_tx_start_sending(uint8_t *pbuff, uint16_t size)  发表于 2021-7-31 12:40
a1466536341
DMA_GetTransferCnt这个函数在哪，有没有可以提供  发表于 2021-7-2 14:27

相关帖子
 楼主| lesheng002 发表于 2020-10-15 20:51 | 显示全部楼层
以上代码经验证测试运行OK的
回复 赏

举报

lrzxc1 发表于 2021-4-29 15:14 | 显示全部楼层
多谢楼主分享经验
回复 赏

举报

sadicy 发表于 2021-7-16 15:02 | 显示全部楼层
这大段代码，也真是拼了
回复 赏

举报

里面有晴雨 发表于 2021-7-17 08:59 | 显示全部楼层
这个代码很长，楼主真是拼了。
回复 赏

举报

kkzz 发表于 2021-8-1 22:29 | 显示全部楼层
串口的DMA串口传输完成中断怎么理解
回复 赏

举报

hudi008 发表于 2021-8-1 22:29 | 显示全部楼层
串口使用dma方式 是什么配置
回复 赏

举报

lzmm 发表于 2021-8-1 22:30 | 显示全部楼层
可以发用dma，收用普通中断吗
回复 赏

举报

minzisc 发表于 2021-8-1 22:30 | 显示全部楼层
串口dma怎么接受数据
回复 赏

举报

selongli 发表于 2021-8-1 22:30 | 显示全部楼层
只采用查询用此函数还可以？
回复 赏

举报

fentianyou 发表于 2021-8-1 22:30 | 显示全部楼层
串口dma缓冲区是先进先出吗  
回复 赏

举报

xiaoyaodz 发表于 2021-8-1 22:30 | 显示全部楼层
循环模式如何设置发送周期？
回复 赏

举报

febgxu 发表于 2021-8-1 22:30 | 显示全部楼层
串口dma最多发送多少个
回复 赏

举报

sdlls 发表于 2021-8-1 22:30 | 显示全部楼层
串口中断和DMA中断一起使用行么
回复 赏

举报

pixhw 发表于 2021-8-1 22:31 | 显示全部楼层

开启串口DMA空闲中断接收不定长度数据  
回复 赏

举报

 楼主| lesheng002 发表于 2021-8-5 10:19 | 显示全部楼层
lzmm 发表于 2021-8-1 22:30
可以发用dma，收用普通中断吗

肯定可以
回复 赏

举报

 楼主| lesheng002 发表于 2021-8-8 15:38 | 显示全部楼层
sdlls 发表于 2021-8-1 22:30
串口中断和DMA中断一起使用行么

可以的，你怎么用可以自己选择，并没有严格要求
回复 赏

举报

 楼主| lesheng002 发表于 2021-8-8 15:46 | 显示全部楼层
febgxu 发表于 2021-8-1 22:30
串口dma最多发送多少个

查看用户手册15章，可知有2个参数，一是数据块，二是传输次数，传输次数最大65535个，你说的最多发送多少个，那么如果一个块的数据为1字节，那么最大可以发送65535个数据
回复 赏

举报

 楼主| lesheng002 发表于 2021-8-8 15:50 | 显示全部楼层
xiaoyaodz 发表于 2021-8-1 22:30
循环模式如何设置发送周期？

发送周期完全是你自己来控制，如果数据准备好了，发送完成立即启动下一次发送周期，如果你的数据没有准备好，可以延迟发送或者你可以用定时器设置定时发送
回复 赏

举报

 楼主| lesheng002 发表于 2021-8-8 15:55 | 显示全部楼层
fentianyou 发表于 2021-8-1 22:30
串口dma缓冲区是先进先出吗

好像没有这个说法，DMA设置中，目标地址或源地址可以指定为固定，递增，递减，重载或者不连续跳转，因而没有固定规律，由你自己定义
回复 赏

举报

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

本版积分规则

lesheng002

7

主题

93

帖子

0

粉丝
快速回复 返回顶部 返回列表