新葡京娱乐场官方: [综合信息] 【华大测评】+串口DMA收发数据

云顶之星 马尼拉网上娱乐场
61|1
楼主
 楼主 | 2020-10-15 14:36 | 只看该作者 |退出气泡模式 |倒序浏览 |阅读模式
本帖最后由 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. * 博客    :http://www.524.ib737.com/qq_15548761
  15. **********************************************************************************/
  16. #include "systick.h"
  17. #include    "usart.h"

  18. volatile uint32_t TimingDelay;

  19. uint16_t        mainDelayMS;

  20. uint16_t        beepCnt;
  21. uint8_t                beepTimes;

  22. uint16_t        TimerSoundON;
  23. uint16_t        TimerSoundOFF;


  24. /*
  25. * 函数名:SysTick_Init
  26. * 描述  :启动系统滴答定时器 SysTick
  27. * 输入  :无
  28. * 输出  :无
  29. * 调用  :外部调用
  30. */
  31. void SysTick_Init(void)
  32. {
  33.     stc_irq_regi_conf_t stcIrqRegiCfg;
  34.         /* SystemFrequency / 1000    1ms中断一次
  35.          * SystemFrequency / 100000         10us中断一次
  36.          * SystemFrequency / 1000000 1us中断一次
  37.          */
  38.         TimingDelay = 0;
  39.         if (SysTick_Config(SystemCoreClock / 1000))
  40.         while(1);
  41.    
  42. //  SysTick->LOAD  = (uint32_t)((SystemCoreClock / 1000) - 1UL);                         /* set reload register */
  43. //  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
  44. //  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
  45. //  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
  46. //                   SysTick_CTRL_TICKINT_Msk   |
  47. //                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
  48.     /* Set USART RX error IRQ */
  49. //    stcIrqRegiCfg.enIRQn = SysTick_IRQn;
  50. //    stcIrqRegiCfg.pfnCallback = &SysTick_IRQHandler;
  51. //    stcIrqRegiCfg.enIntSrc = USART_RTO_NUM;
  52. //    enIrqRegistration(&stcIrqRegiCfg);
  53. //    NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
  54. //    NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
  55. //    NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
  56. }


  57. /*
  58. * 函数名:Delay_us
  59. * 描述  :us延时程序,1ms为一个单位
  60. * 输入  :- nTime
  61. * 输出  :无
  62. * 调用  :Delay_us( 1 ) 则实现的延时为 1 * 10us = 10us
  63. *       :外部调用
  64. */

  65. void SysTickDelay_ms(__IO uint32_t nTime)
  66. {
  67.   TimingDelay = nTime;

  68.   while(TimingDelay != 0)
  69.   {
  70.       __nop();
  71.       usart_rxData_process();
  72.   }
  73. }

  74. void        BIBI_CntDown(void);
  75. /*
  76. * 函数名:TimingDelay_Decrement
  77. * 描述  :获取节拍程序
  78. * 输入  :无
  79. * 输出  :无
  80. * 调用  :在 SysTick 中断函数 SysTick_Handler()调用
  81. */  
  82. void SysTick_IRQHandler(void)
  83. {
  84.     static  uint16_t  timeCnt = 0;
  85.     if(TimingDelay)
  86.         TimingDelay--;
  87.         if(mainDelayMS)
  88.                 mainDelayMS--;

  89.         timeCnt++;
  90.         if(timeCnt >= 500)
  91.         {
  92.                 timeCnt = 0;
  93.         }
  94.         BIBI_CntDown();
  95.        
  96. }


  97. void        BIBI_CntDown(void)
  98. {
  99.         if(beepCnt)                //        蜂鸣器延时
  100.         {
  101.                 beepCnt--;
  102.                 if(!beepCnt)
  103.                 {
  104.                         if(!beepTimes)
  105.                                 BeepOut(0);
  106.                         else
  107.                         {
  108.                                 beepTimes--;
  109.                                 if(beepTimes%2)
  110.                                 {
  111.                                         beepCnt = TimerSoundOFF;
  112.                     BeepOut(0);
  113.                                 }
  114.                                 else
  115.                                 {
  116.                     BeepOut(1);
  117.                                         beepCnt = TimerSoundON;
  118.                                 }
  119.                         }
  120.                 }
  121.         }
  122. }


  123. void        BIBI_Start(uint8_t        bibiTimes)
  124. {
  125.         {
  126.                 beepTimes = bibiTimes*2-1;
  127.                 BeepOut(1);
  128.                 beepCnt = DEF_BIBI_DELAY_TIMER;
  129.         TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
  130.                 TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
  131.         }
  132. }


  133. void        BIBI_LongStart(uint8_t        bibiTimes)
  134. {
  135.         {
  136.                 beepTimes = bibiTimes*2-1;
  137.                 BeepOut(1);
  138.                 beepCnt = DEF_LONG_BIBI_DELAY;
  139.         TimerSoundON  = DEF_LONG_BIBI_DELAY ;
  140.                 TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
  141.         }
  142. }

  143. /*****************************************************************
  144.       void  Buzzer(unsigned char idata  SoundType );
  145. *****************************************************************/
  146. void Buzzer(unsigned char  SoundType )
  147. {
  148. //    switch(SoundType)
  149. //        {
  150. //        case SHORT_BI   :   TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
  151. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
  152. //                                                        beepTimes     = 1 ;          // On  1-time
  153. //                                                        break;
  154. //                case SHORT_BI_2 :   TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
  155. //                                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
  156. //                                                        beepTimes     = 3 ;          // On, Off, On
  157. //                                                        break;
  158. //                case SHORT_BI_3 :   TimerSoundON  = DEF_BIBI_DELAY_TIMER ;
  159. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
  160. //                                                        beepTimes     = 5 ;          // On, Off, On, Off, On ( 3-times)
  161. //                                                        break;
  162. //                case LONG_BI    :   TimerSoundON  = DEF_BIBI_DELAY_TIMER*3 ;
  163. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
  164. //                                                        beepTimes     = 9;           // On  10/2=5 times
  165. //                                                        break;
  166. //                case LONG_BI_2  :   TimerSoundON  = DEF_BIBI_DELAY_TIMER*3 ;
  167. //                                        TimerSoundOFF = DEF_BIBI_DELAY_TIMER ;
  168. //                                                        beepTimes     = 19;           //  On, Off, 10 times
  169. //                                                        break;
  170. //        }
  171.         BeepOut(1);
  172.         beepCnt = TimerSoundON;
  173. }



  174. void Sound_KeyOK(void)
  175. {
  176. //    Buzzer(SHORT_BI);
  177. }

  178. void Sound_KeyError(void)
  179. {
  180. //    Buzzer(SHORT_BI_2);
  181. }

  182. void Sound_AxisError(void)
  183. {
  184. //    Buzzer(LONG_BI);
  185. }



  186. /************************* *****END OF FILE***********************************/
复制代码


  SysTick.h
  1. #ifndef __SYSTICK_H
  2. #define __SYSTICK_H

  3. #include "hc32_ddl.h"

  4. #define                DEF_BIBI_DELAY_TIMER                20        //80
  5. #define                DEF_LONG_BIBI_DELAY                        80        //300
  6. #define     TIME_READ_COUNTER       15

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

  8. void SysTick_Init(void);
  9. void Delay_10us(__IO uint32_t nTime);
  10. void SysTickDelay_ms(__IO uint32_t nTime);

  11. void Sound_KeyOK(void);
  12. void Sound_KeyError(void);
  13. void Sound_AxisError(void);


  14. #endif /* __SYSTICK_H */
复制代码
串行数据收发实现文件
usart.h
  1. #ifndef __USART_H__
  2. #define __USART_H__

  3. #include "hc32_ddl.h"
  4. #include <stdio.h>
  5. #include "hc32f46x_dmac.h"

  6. #define     USART_DATA_BUFF_SIZE        100
  7. #define     USART_ARRAY_SIZE        3

  8. #define     ENABLE_USART_DMA        1

  9. /* DMAC */
  10. #define USART_DMA_UNIT                        (M4_DMA1)
  11. #define RX_DMA_CH                          (DmaCh0)
  12. #define RX_DMA_TRG_SEL                     (EVT_USART3_RI)
  13. #define TX_DMA_CH                          (DmaCh1)
  14. #define TX_DMA_TRG_SEL                     (EVT_USART3_TI)

  15. /* DMA block transfer complete interrupt */
  16. #define RX_DMA_BTC_INT_NUM                 (INT_DMA1_TC0)
  17. #define RX_DMA_BTC_INT_IRQn                (Int002_IRQn)
  18. #define TX_DMA_BTC_INT_NUM                 (INT_DMA1_TC1)
  19. #define TX_DMA_BTC_INT_IRQn                (Int001_IRQn)


  20. /* USART channel definition */
  21. #define USART_CH                        (M4_USART3)

  22. /* USART baudrate definition */
  23. #define USART_BAUDRATE                  (115200ul)

  24. /* USART RX Port/Pin definition */
  25. #define USART_RX_PORT                   (PortE)
  26. #define USART_RX_PIN                    (Pin04)
  27. #define USART_RX_FUNC                   (Func_Usart3_Rx)

  28. /* USART TX Port/Pin definition */
  29. #define USART_TX_PORT                   (PortE)
  30. #define USART_TX_PIN                    (Pin05)
  31. #define USART_TX_FUNC                   (Func_Usart3_Tx)

  32. /* USART interrupt number  */
  33. #define USART_RI_NUM                    (INT_USART3_RI)
  34. #define USART_EI_NUM                    (INT_USART3_EI)
  35. #define USART_TI_NUM                    (INT_USART3_TI)
  36. #define USART_TCI_NUM                   (INT_USART3_TCI)
  37. #define USART_RI_IRQn                    (Int003_IRQn)
  38. #define USART_EI_IRQn                    (Int004_IRQn)
  39. #define USART_TI_IRQn                    (Int005_IRQn)
  40. #define USART_TCI_IRQn                   (Int006_IRQn)
  41. #define USART_RTO_NUM                    (INT_USART3_RTO)
  42. #define USART_RTO_IRQn                    (Int007_IRQn)

  43. /* Timer0 unit definition */
  44. #define TMR_UNIT                        (M4_TMR02)
  45. #define TMR_FCG_PERIPH                  (PWC_FCG2_PERIPH_TIM02)

  46. extern  uint8_t  rcvBuff[USART_ARRAY_SIZE][USART_DATA_BUFF_SIZE];
  47. extern  uint8_t  rcvPoint ;
  48. extern  uint8_t  rcvReceived ;
  49. extern  uint8_t  sndBuff[USART_DATA_BUFF_SIZE];

  50. void USART_Config(void);
  51. void Usart_Rx_Tx(void);
  52. void UsartRxErrProcess(void);

  53. void    usart_tx_start_sending(uint8_t *pbuff, uint16_t  size);
  54. void    usart_rxData_process(void);

  55. #endif
复制代码
usart.c

  1. #include "usart.h"


  2. uint8_t  rcvBuff[USART_ARRAY_SIZE][USART_DATA_BUFF_SIZE];
  3. uint8_t  rcvPoint = 0;
  4. uint8_t  rcvReceived = 0;
  5. uint8_t  rcvCount = 1;
  6. uint8_t  sndBuff[USART_DATA_BUFF_SIZE];


  7. //  DMA接收完成回调函数,或者接收超时中断函数中调用
  8. //  当前一组数据接收完成后的操作
  9. void    usart_rx_receive_finish(void)
  10. {
  11. #if     (ENABLE_USART_DMA == 1)
  12.     uint16_t  cnt;

  13.     DMA_ChannelCmd(USART_DMA_UNIT, RX_DMA_CH,  Disable);
  14.     cnt = DMA_GetTransferCnt(USART_DMA_UNIT, RX_DMA_CH);
  15.     rcvBuff[rcvPoint][0] = USART_DATA_BUFF_SIZE - cnt ;
  16.     rcvReceived++;
  17.     rcvPoint++;
  18.     if(rcvPoint >= USART_ARRAY_SIZE)
  19.         rcvPoint = 0;
  20.     /* Initialize DMA. */
  21.     DMA_SetBlockSize(USART_DMA_UNIT, RX_DMA_CH, 1);
  22.     DMA_SetTransferCnt(USART_DMA_UNIT, RX_DMA_CH, USART_DATA_BUFF_SIZE-1);
  23.     DMA_SetDesAddress(USART_DMA_UNIT, RX_DMA_CH, (uint32_t)(&rcvBuff[rcvPoint][1]));
  24.     DMA_ChannelCmd(USART_DMA_UNIT, RX_DMA_CH,  Enable);
  25. #else
  26.     rcvBuff[rcvPoint][0] = rcvCount-1;
  27.     rcvReceived++;
  28.     rcvCount = 1;
  29.     rcvPoint++;
  30.     if(rcvPoint >= USART_ARRAY_SIZE)
  31.         rcvPoint = 0;
  32. #endif
  33. }

  34. //  启动发送数据,
  35. void    usart_tx_start_sending(uint8_t *pbuff, uint16_t  size)
  36. {
  37.     uint16_t i;
  38.     for(i  = 0; i < size; i++)
  39.     {
  40.         sndBuff[i] = *pbuff++;
  41.     }
  42. #if     (ENABLE_USART_DMA == 1)
  43.     DMA_SetBlockSize(USART_DMA_UNIT, TX_DMA_CH, 1);
  44.     DMA_SetTransferCnt(USART_DMA_UNIT, TX_DMA_CH, size);
  45.     DMA_SetSrcAddress(USART_DMA_UNIT, TX_DMA_CH, (uint32_t)(&sndBuff[0]));
  46.     /* Enable the specified DMA channel. */
  47.     DMA_ChannelCmd(USART_DMA_UNIT, TX_DMA_CH, Enable);

  48.     /* Clear DMA flag. */
  49.     DMA_ClearIrqFlag(USART_DMA_UNIT, TX_DMA_CH, TrnCpltIrq);
  50.         USART_FuncCmd(USART_CH, UsartTx, Enable);
  51.     USART_FuncCmd(USART_CH, UsartTxEmptyInt, Enable);
  52. #else
  53. #endif
  54. }

  55. #if     (ENABLE_USART_DMA == 1)
  56. /**
  57. *******************************************************************************
  58. ** \brief DMA block transfer complete irq callback function.
  59. **
  60. ** \param [in] None
  61. **
  62. ** \retval None
  63. **
  64. ******************************************************************************/
  65. static void usart_rx_Dma_IrqCallback(void)
  66. {
  67.     DMA_ClearIrqFlag(USART_DMA_UNIT, RX_DMA_CH, TrnCpltIrq);
  68.     usart_rx_receive_finish();
  69. }


  70. /**
  71. *******************************************************************************
  72. ** \brief DMA block transfer complete irq callback function.
  73. **
  74. ** \param [in] None
  75. **
  76. ** \retval None
  77. **
  78. ******************************************************************************/
  79. static void usart_tx_Dma_IrqCallback(void)
  80. {
  81.     DMA_ClearIrqFlag(USART_DMA_UNIT, TX_DMA_CH, TrnCpltIrq);
  82.     /* Enable the specified DMA channel. */
  83.     DMA_ChannelCmd(USART_DMA_UNIT, TX_DMA_CH, Disable);
  84.         USART_FuncCmd(USART_CH, UsartTx, Disable);
  85. }
  86. #endif


  87. /**
  88. *******************************************************************************
  89. ** \brief USART RX irq callback function.
  90. **
  91. ** \param [in] None
  92. **
  93. ** \retval None
  94. **
  95. ******************************************************************************/
  96. static void UsartRxIrqCallback(void)
  97. {
  98.     rcvBuff[rcvPoint][rcvCount++] = USART_RecData(USART_CH);
  99. //    USART_FuncCmd(USART_CH, UsartTxAndTxEmptyInt, Enable);
  100.     if(rcvCount >= USART_DATA_BUFF_SIZE-1)
  101.     {
  102.         usart_rx_receive_finish();
  103.     }
  104. }

  105. /**
  106. *******************************************************************************
  107. ** \brief USART RX error irq callback function.
  108. **
  109. ** \param [in] None
  110. **
  111. ** \retval None
  112. **
  113. ******************************************************************************/
  114. static void UsartErrIrqCallback(void)
  115. {
  116.     if (Set == USART_GetStatus(USART_CH, UsartFrameErr))
  117.     {
  118.         USART_ClearStatus(USART_CH, UsartFrameErr);
  119.     }

  120.     if (Set == USART_GetStatus(USART_CH, UsartParityErr))
  121.     {
  122.         USART_ClearStatus(USART_CH, UsartParityErr);
  123.     }

  124.     if (Set == USART_GetStatus(USART_CH, UsartOverrunErr))
  125.     {
  126.         USART_ClearStatus(USART_CH, UsartOverrunErr);
  127.     }
  128. }


  129. /**
  130. *******************************************************************************
  131. ** \brief USART RX Timer out irq callback function.
  132. **
  133. ** \param [in] None
  134. **
  135. ** \retval None
  136. **
  137. ******************************************************************************/
  138. static void usart_rx_timeOut_IrqCallback(void)
  139. {
  140.     {
  141.         TIMER0_Cmd(TMR_UNIT, Tim0_ChannelA,Disable);
  142.         USART_ClearStatus(USART_CH, UsartRxTimeOut);
  143.         usart_rx_receive_finish();
  144.     }
  145. }


  146. #if     (ENABLE_USART_DMA == 1)
  147. /**
  148. *******************************************************************************
  149. ** \brief Initialize DMA.
  150. **
  151. ** \param [in] None
  152. **
  153. ** \retval None
  154. **
  155. ******************************************************************************/
  156. static void DmaInit(void)
  157. {
  158.     stc_dma_config_t stcDmaInit;
  159.     stc_irq_regi_conf_t stcIrqRegiCfg;

  160.     /* Enable peripheral clock */
  161.     PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_DMA1,Enable);

  162.     /* Enable DMA. */
  163.     DMA_Cmd(USART_DMA_UNIT,Enable);

  164.     /* Initialize DMA. */
  165.     MEM_ZERO_STRUCT(stcDmaInit);
  166.     stcDmaInit.u16BlockSize = 1u; /* 1 block */
  167.     stcDmaInit.u16TransferCnt = USART_DATA_BUFF_SIZE-1;
  168.     stcDmaInit.u32SrcAddr = ((uint32_t)(&USART_CH->DR)+2ul); /* Set source address. */
  169.     stcDmaInit.u32DesAddr = (uint32_t)(&rcvBuff[0][1]);     /* Set destination address. */
  170.     stcDmaInit.stcDmaChCfg.enSrcInc = AddressFix;  /* Set source address mode. */
  171.     stcDmaInit.stcDmaChCfg.enDesInc = AddressIncrease;  /* Set destination address mode. */
  172.     stcDmaInit.stcDmaChCfg.enIntEn = Enable;       /* Enable interrupt. */
  173.     stcDmaInit.stcDmaChCfg.enTrnWidth = Dma8Bit;   /* Set data width 8bit. */
  174.     DMA_InitChannel(USART_DMA_UNIT, RX_DMA_CH, &stcDmaInit);

  175.     /* Enable the specified DMA channel. */
  176.     DMA_ChannelCmd(USART_DMA_UNIT, RX_DMA_CH, Enable);

  177.     /* Clear DMA flag. */
  178.     DMA_ClearIrqFlag(USART_DMA_UNIT, RX_DMA_CH, TrnCpltIrq);

  179.     /* Enable peripheral circuit trigger function. */
  180.     PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_PTDIS,Enable);

  181.     /* Set DMA trigger source. */
  182.     DMA_SetTriggerSrc(USART_DMA_UNIT, RX_DMA_CH, RX_DMA_TRG_SEL);

  183.     /* Initialize DMA. */
  184.     MEM_ZERO_STRUCT(stcDmaInit);
  185.     stcDmaInit.u16BlockSize = 1u; /* 1 block */
  186.     stcDmaInit.u16TransferCnt = USART_DATA_BUFF_SIZE-1;
  187.     stcDmaInit.u32SrcAddr = (uint32_t)(&sndBuff[1]); /* Set source address. */
  188.     stcDmaInit.u32DesAddr = ((uint32_t)(&USART_CH->DR));     /* Set destination address. */
  189.     stcDmaInit.stcDmaChCfg.enSrcInc = AddressIncrease;  /* Set source address mode. */
  190.     stcDmaInit.stcDmaChCfg.enDesInc = AddressFix;  /* Set destination address mode. */
  191.     stcDmaInit.stcDmaChCfg.enIntEn = Enable;       /* Enable interrupt. */
  192.     stcDmaInit.stcDmaChCfg.enTrnWidth = Dma8Bit;   /* Set data width 8bit. */
  193.     DMA_InitChannel(USART_DMA_UNIT, TX_DMA_CH, &stcDmaInit);

  194.     /* Set DMA trigger source. */
  195.     DMA_SetTriggerSrc(USART_DMA_UNIT, TX_DMA_CH, TX_DMA_TRG_SEL);

  196.     /* Set DMA block transfer complete IRQ */
  197.     stcIrqRegiCfg.enIRQn = RX_DMA_BTC_INT_IRQn;
  198.     stcIrqRegiCfg.pfnCallback = &usart_rx_Dma_IrqCallback;
  199.     stcIrqRegiCfg.enIntSrc = RX_DMA_BTC_INT_NUM;
  200.     enIrqRegistration(&stcIrqRegiCfg);
  201.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
  202.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
  203.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
  204.    
  205.     stcIrqRegiCfg.enIRQn = TX_DMA_BTC_INT_IRQn;
  206.     stcIrqRegiCfg.pfnCallback = &usart_tx_Dma_IrqCallback;
  207.     stcIrqRegiCfg.enIntSrc = TX_DMA_BTC_INT_NUM;
  208.     enIrqRegistration(&stcIrqRegiCfg);
  209.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
  210.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
  211.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
  212. }
  213. #endif

  214. void Timer0Init(void);

  215. //  串行数据收发器配置函数
  216. void USART_Config(void)
  217. {
  218.         en_result_t enRet = Ok;
  219.     stc_irq_regi_conf_t stcIrqRegiCfg;
  220.         uint32_t u32Fcg1Periph = PWC_FCG1_PERIPH_USART3;
  221.         const stc_usart_uart_init_t stcInitCfg =
  222.         {
  223.         UsartIntClkCkOutput,
  224.         UsartClkDiv_1,
  225.         UsartDataBits8,
  226.         UsartDataLsbFirst,
  227.         UsartOneStopBit,
  228.         UsartParityNone,
  229.         UsartSamleBit8,
  230.         UsartStartBitFallEdge,
  231.         UsartRtsEnable,
  232.         };

  233.         /* Enable peripheral clock */
  234.         PWC_Fcg1PeriphClockCmd(u32Fcg1Periph, Enable);

  235.         /* Initialize USART IO */
  236.         PORT_SetFunc(USART_RX_PORT, USART_RX_PIN, USART_RX_FUNC, Disable);
  237.         PORT_SetFunc(USART_TX_PORT, USART_TX_PIN, USART_TX_FUNC, Disable);

  238. #if     (ENABLE_USART_DMA == 1)
  239.     DmaInit();
  240. #endif
  241.     Timer0Init();

  242.         /* Initialize UART */
  243.         enRet = USART_UART_Init(USART_CH, &stcInitCfg);
  244.         if (enRet != Ok)
  245.         {
  246.                 while (1)
  247.                 {
  248.                 }
  249.         }

  250.         /* Set baudrate */
  251.         enRet = USART_SetBaudrate(USART_CH, USART_BAUDRATE);
  252.         if (enRet != Ok)
  253.         {
  254.                 while (1)
  255.                 {
  256.                 }
  257.         }
  258.    
  259. #if     (ENABLE_USART_DMA == 0)
  260.          /* Set USART RX IRQ */
  261.     stcIrqRegiCfg.enIRQn = USART_RI_IRQn;
  262.     stcIrqRegiCfg.pfnCallback = &UsartRxIrqCallback;
  263.     stcIrqRegiCfg.enIntSrc = USART_RI_NUM;
  264.     enIrqRegistration(&stcIrqRegiCfg);
  265.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
  266.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
  267.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
  268. #endif   
  269.     /* Set USART RX error IRQ */
  270.     stcIrqRegiCfg.enIRQn = USART_EI_IRQn;
  271.     stcIrqRegiCfg.pfnCallback = &UsartErrIrqCallback;
  272.     stcIrqRegiCfg.enIntSrc = USART_EI_NUM;
  273.     enIrqRegistration(&stcIrqRegiCfg);
  274.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
  275.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
  276.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
  277.    
  278.     /* Set USART RX error IRQ */
  279.     stcIrqRegiCfg.enIRQn = USART_RTO_IRQn;
  280.     stcIrqRegiCfg.pfnCallback = &usart_rx_timeOut_IrqCallback;
  281.     stcIrqRegiCfg.enIntSrc = USART_RTO_NUM;
  282.     enIrqRegistration(&stcIrqRegiCfg);
  283.     NVIC_SetPriority(stcIrqRegiCfg.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
  284.     NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
  285.     NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
  286.    
  287.     /*Enable TX && RX && RX interrupt function*/
  288.         USART_FuncCmd(USART_CH, UsartRx, Enable);
  289.     USART_FuncCmd(USART_CH, UsartRxInt, Enable);
  290.    
  291.     USART_FuncCmd(USART_CH, UsartTimeOut, Enable);
  292.     USART_FuncCmd(USART_CH, UsartTimeOutInt, Enable);
  293. }


  294. /**
  295. *******************************************************************************
  296. ** \brief Initliaze Timer0.
  297. **
  298. ** \param [in] None
  299. **
  300. ** \retval None
  301. **
  302. ******************************************************************************/
  303. void Timer0Init(void)
  304. {
  305.     stc_clk_freq_t stcClkTmp;
  306.     stc_tim0_base_init_t stcTimerCfg;
  307.     stc_tim0_trigger_init_t StcTimer0TrigInit;

  308.     MEM_ZERO_STRUCT(stcClkTmp);
  309.     MEM_ZERO_STRUCT(stcTimerCfg);
  310.     MEM_ZERO_STRUCT(StcTimer0TrigInit);

  311.     /* Timer0 peripheral enable */
  312.     PWC_Fcg2PeriphClockCmd(TMR_FCG_PERIPH, Enable);

  313.     /* Clear CNTAR register for channel A */
  314.     TIMER0_WriteCntReg(TMR_UNIT, Tim0_ChannelA, 0u);
  315.     TIMER0_WriteCntReg(TMR_UNIT, Tim0_ChannelB, 0u);

  316.     /* Config register for channel A */
  317.     stcTimerCfg.Tim0_CounterMode = Tim0_Async;
  318.     stcTimerCfg.Tim0_AsyncClockSource = Tim0_XTAL32;
  319.     stcTimerCfg.Tim0_ClockDivision = Tim0_ClkDiv8;
  320.     stcTimerCfg.Tim0_CmpValue = 3200u;
  321.     TIMER0_BaseInit(TMR_UNIT, Tim0_ChannelA, &stcTimerCfg);

  322.     /* Clear compare flag */
  323.     TIMER0_ClearFlag(TMR_UNIT, Tim0_ChannelA);

  324.     /* Config timer0 hardware trigger */
  325.     StcTimer0TrigInit.Tim0_InTrigEnable = false;
  326.     StcTimer0TrigInit.Tim0_InTrigClear = true;
  327.     StcTimer0TrigInit.Tim0_InTrigStart = true;
  328.     StcTimer0TrigInit.Tim0_InTrigStop = false;
  329.     TIMER0_HardTriggerInit(TMR_UNIT, Tim0_ChannelA, &StcTimer0TrigInit);
  330. }


  331. //  对接收到的一组数据进行分析处理
  332. //  该函数在延时函数中调用,以获得及时响应
  333. void usart_rxData_process(void)
  334. {
  335.     static uint8_t  txPoint = 0;
  336.     if(rcvReceived > 0)
  337.     {
  338.         rcvReceived--;
  339.         usart_tx_start_sending(&rcvBuff[txPoint][1], rcvBuff[txPoint][0]);
  340.         txPoint++;
  341.         if(txPoint>=USART_ARRAY_SIZE)
  342.             txPoint = 0;
  343.     }
  344. }
复制代码
对于经常使用串口收发数据的应用,用DMA实现提供MCU的效率,提高系统的性能。
将代码贴出来,大家一起探讨,有不妥之处,欢迎指正。

沙发
 楼主 | 2020-10-15 20:51 | 只看该作者
以上代码经验证测试运行OK的
扫描二维码,随时随地手机跟帖
您需要登录后才可以回帖 登录 | 注册

本版积分规则

我要发帖 投诉建议 创建版块 申请版主

快速回复

您需要登录后才可以回帖
登录 | 注册
高级模式

论坛热帖

云顶之星 马尼拉网上娱乐场 永利游戏开户直营 返回顶部 返回列表
手机版游戏赌博 菲律宾太阳网站游戏 88彩票集团 9亿娱乐注册最高返水 美高梅官网开户最高占成
足球开户 bbin高速卡车 富豪网 澳门官方赌场赌桌 威斯汀广西快乐十分开奖记录
加拿大幸运28开奖查询 菲律宾申博博彩登入 澳门新葡京网上娱乐 英皇宫殿娱乐平台 磨丁赌场网
电子游戏娱乐平台 菲律宾申博太阳城现金网游戏网官网 永利网上娱乐登入 伯爵娱乐彩票官方网 互博国际球彩客户端