社区导航

 

搜索
查看: 2116|回复: 2

[经验分享] GD32F350双串口非阻塞高速收发机制及其驱动

[复制链接]

671

TA的帖子

3

TA的资源

版主

Rank: 6Rank: 6

发表于 2018-10-13 16:32 | 显示全部楼层 |阅读模式
GD32F350上有两个串口,其中,第二个还有点小坑。

在本应用中,一个串口用于USB CDC,需要的设计速率越高越好,另一个用于SWO,速率也低不了,所以串口驱动需要好好折腾一下。GD32的串口硬件上不带FIFO(指可降低中断频率的那种),需配合DMA使用。收发机制如下:
一、发送:
给每路发送通道准备64字节的专用FIFO,发送前根据DMA通道传输字节,获得FIFO剩余空间大小。发送时先关闭DMA通道,将FIFO内残余数据和新数据合并,再开启DMA通道。另需试能DMA传输完成中断。
二、接收:
给每路接收通道准备64字节 * 2的专用FIFO,两块FIFO用于乒乓操作,响应接收中断后(包括DMA完成和超时,高优先级响应),依次关闭通道,读取通道传输字节,切换FIFO,开启通道,向串口流发送接收事件,退出中断响应。
注意,GD32串口上有一个5帧的接收fifo,所以没必要使用DMA传输半完成中断。
小坑如下:
2.jpg
这就是你们卖0.3美金的理由吗?
好吧,只能人为进行超时检查了,在system_tick 一毫秒中断中加一个usart1_poll,大功告成。

完整驱动代码如下,测试很少,仅供参考:
  1. #include "vsf.h"
  2. #include "core.h"

  3. // usart + dma + HTFIE + FTFIE + 64byte buffer

  4. #define DMA_BUFF_SIZE                        64
  5. static uint8_t tx_dma_buff[VSFHAL_USART_NUM][DMA_BUFF_SIZE];

  6. static uint8_t rx_dma_buf_sel[VSFHAL_USART_NUM];
  7. static uint8_t rx_dma_buff_pos[VSFHAL_USART_NUM][2];
  8. static uint8_t rx_dma_buff[VSFHAL_USART_NUM][2][DMA_BUFF_SIZE];

  9. static void (*vsfhal_usart_ontx[VSFHAL_USART_NUM])(void *);
  10. static void (*vsfhal_usart_onrx[VSFHAL_USART_NUM])(void *);
  11. static void *vsfhal_usart_callback_param[VSFHAL_USART_NUM];

  12. vsf_err_t vsfhal_usart_init(vsfhal_usart_t index)
  13. {
  14.         if (index >= VSFHAL_USART_NUM)
  15.                 return VSFERR_BUG;
  16.         
  17.         switch (index)
  18.         {
  19. #if VSFHAL_USART0_ENABLE
  20.         case 0:
  21. #if VSFHAL_USART0_TXD_PA9_EN
  22.                 RCU_AHBEN |= RCU_AHBEN_PAEN;
  23.                 IO_AF_SELECT(0, 9, 1);
  24.                 IO_CFG_AF(0, 9);
  25. #endif
  26. #if VSFHAL_USART0_RXD_PA10_EN
  27.                 RCU_AHBEN |= RCU_AHBEN_PAEN;
  28.                 IO_AF_SELECT(0, 10, 1);
  29.                 IO_CFG_AF(0, 10);
  30. #endif
  31. #if VSFHAL_USART0_TXD_PB6_EN
  32.                 RCU_AHBEN |= RCU_AHBEN_PBEN;
  33.                 IO_AF_SELECT(1, 6, 0);
  34.                 IO_CFG_AF(1, 6);
  35. #endif
  36. #if VSFHAL_USART0_RXD_PB7_EN
  37.                 RCU_AHBEN |= RCU_AHBEN_PBEN;
  38.                 IO_AF_SELECT(1, 7, 0);
  39.                 IO_CFG_AF(1, 7);
  40. #endif
  41.                 RCU_AHBEN |= RCU_AHBEN_DMAEN;
  42.                 RCU_APB2EN |= RCU_APB2EN_USART0EN;
  43.                 break;
  44. #endif
  45. #if VSFHAL_USART1_ENABLE
  46.         case 1:
  47. #if VSFHAL_USART1_TXD_PA2_EN
  48.                 RCU_AHBEN |= RCU_AHBEN_PAEN;
  49.                 IO_AF_SELECT(0, 2, 1);
  50.                 IO_CFG_AF(0, 2);
  51. #endif
  52. #if VSFHAL_USART1_RXD_PA3_EN
  53.                 RCU_AHBEN |= RCU_AHBEN_PAEN;
  54.                 IO_AF_SELECT(0, 3, 1);
  55.                 IO_CFG_AF(0, 3);
  56. #endif
  57. #if VSFHAL_USART1_TXD_PA8_EN
  58.                 RCU_AHBEN |= RCU_AHBEN_PAEN;
  59.                 IO_AF_SELECT(0, 8, 4);
  60.                 IO_CFG_AF(0, 8);
  61. #endif
  62. #if VSFHAL_USART1_RXD_PB0_EN
  63.                 RCU_AHBEN |= RCU_AHBEN_PBEN;
  64.                 IO_AF_SELECT(1, 0, 4);
  65.                 IO_CFG_AF(1, 0);
  66. #endif
  67. #if VSFHAL_USART1_TXD_PA14_EN
  68.                 RCU_AHBEN |= RCU_AHBEN_PAEN;
  69.                 IO_AF_SELECT(0, 14, 1);
  70.                 IO_CFG_AF(0, 14);
  71. #endif
  72. #if VSFHAL_USART1_RXD_PA15_EN
  73.                 RCU_AHBEN |= RCU_AHBEN_PAEN;
  74.                 IO_AF_SELECT(0, 15, 1);
  75.                 IO_CFG_AF(0, 15);
  76. #endif
  77.                 RCU_AHBEN |= RCU_AHBEN_DMAEN;
  78.                 RCU_APB1EN |= RCU_APB1EN_USART1EN;
  79.                 break;
  80. #endif
  81.         }
  82.         
  83.         return VSFERR_NONE;
  84. }

  85. vsf_err_t vsfhal_usart_fini(vsfhal_usart_t index)
  86. {
  87.         if (index >= VSFHAL_USART_NUM)
  88.                 return VSFERR_BUG;

  89.         return VSFERR_NONE;
  90. }

  91. vsf_err_t vsfhal_usart_config(vsfhal_usart_t index, uint32_t baudrate, uint32_t mode)
  92. {
  93.         uint32_t temp;
  94.         uint32_t usartx;
  95.         struct vsfhal_info_t *info;

  96.         if (index >= VSFHAL_USART_NUM)
  97.                 return VSFERR_BUG;

  98.         if (vsfhal_core_get_info(&info) || (NULL == info))
  99.                 return VSFERR_BUG;
  100.         
  101.         switch (index)
  102.         {
  103.         case 0:
  104.                 usartx = USART0;
  105.                 temp = info->apb2_freq_hz;
  106.                 break;
  107.         case 1:
  108.                 usartx = USART1;
  109.                 temp = info->apb1_freq_hz;
  110.                 break;
  111.         }

  112.         if (index == 0)
  113.         {
  114.                 DMA_CH1CTL = 0;
  115.                 DMA_CH2CTL = 0;
  116.                 USART_CTL0(usartx) = USART_CTL0_RTIE | USART_CTL0_OVSMOD |
  117.                                 (mode & 0x1600) | USART_CTL0_TEN | USART_CTL0_REN;
  118.                 USART_CTL1(usartx) = USART_CTL1_RTEN | ((mode >> 16) & 0x3000);
  119.                 USART_CTL2(usartx) = USART_CTL2_DENR | USART_CTL2_DENT;
  120.                 USART_RT(usartx) = 30;
  121.                
  122.                 // dma tx
  123.                 DMA_CH1CTL = DMA_CHXCTL_MNAGA | DMA_CHXCTL_DIR | DMA_CHXCTL_FTFIE;
  124.                 DMA_CH1PADDR = (uint32_t)(usartx + 0x28U);

  125.                 // dma rx
  126.                 rx_dma_buf_sel[0] = 0;
  127.                 DMA_CH2PADDR = (uint32_t)(usartx + 0x24U);
  128.                 DMA_CH2MADDR = (uint32_t)rx_dma_buff[0][0];
  129.                 DMA_CH2CNT = DMA_BUFF_SIZE;
  130.                 DMA_CH2CTL = DMA_CHXCTL_MNAGA | DMA_CHXCTL_FTFIE | DMA_CHXCTL_CHEN;
  131.         }
  132.         else
  133.         {
  134.                 DMA_CH3CTL = 0;
  135.                 DMA_CH4CTL = 0;
  136.                 USART_CTL0(usartx) = USART_CTL0_OVSMOD |
  137.                                 (mode & 0x1000) | USART_CTL0_TEN | USART_CTL0_REN;
  138.                 USART_CTL1(usartx) = 0;
  139.                 USART_CTL2(usartx) = USART_CTL2_DENR | USART_CTL2_DENT;
  140.                
  141.                 // dma tx
  142.                 DMA_CH3CTL = DMA_CHXCTL_MNAGA | DMA_CHXCTL_DIR | DMA_CHXCTL_FTFIE;
  143.                 DMA_CH3PADDR = (uint32_t)(usartx + 0x28U);

  144.                 // dma rx
  145.                 rx_dma_buf_sel[1] = 0;
  146.                 DMA_CH4PADDR = (uint32_t)(usartx + 0x24U);
  147.                 DMA_CH4MADDR = (uint32_t)rx_dma_buff[1][0];
  148.                 DMA_CH4CNT = DMA_BUFF_SIZE;
  149.                 DMA_CH4CTL = DMA_CHXCTL_MNAGA | DMA_CHXCTL_FTFIE | DMA_CHXCTL_CHEN;
  150.         
  151.         }
  152.         USART_BAUD(usartx) = (temp / baudrate) << 1;        // ovsmod = 1
  153.         USART_CMD(usartx) = 0x1f;
  154.         USART_RFCS(usartx) |= USART_RFCS_RFEN;
  155.         USART_CTL0(usartx) |= USART_CTL0_UEN;

  156.         return VSFERR_NONE;
  157. }

  158. vsf_err_t vsfhal_usart_config_cb(vsfhal_usart_t index, int32_t int_priority, void *p,
  159.                 void (*ontx)(void *), void (*onrx)(void *))
  160. {
  161.         if (index >= VSFHAL_USART_NUM)
  162.                 return VSFERR_BUG;

  163.         vsfhal_usart_ontx[index] = ontx;
  164.         vsfhal_usart_onrx[index] = onrx;
  165.         vsfhal_usart_callback_param[index] = p;
  166.         
  167.         if (int_priority >= 0)
  168.         {
  169.                 switch (index)
  170.                 {
  171.                 #if VSFHAL_USART0_ENABLE
  172.                 case 0:
  173.                         NVIC_EnableIRQ(USART0_IRQn);
  174.                         NVIC_SetPriority(USART0_IRQn, int_priority);
  175.                         NVIC_EnableIRQ(DMA_Channel1_2_IRQn);
  176.                         NVIC_SetPriority(DMA_Channel1_2_IRQn, int_priority);
  177.                         break;
  178.                 #endif
  179.                 #if VSFHAL_USART1_ENABLE
  180.                 case 1:
  181.                         //NVIC_EnableIRQ(USART1_IRQn);
  182.                         //NVIC_SetPriority(USART1_IRQn, int_priority);
  183.                         NVIC_EnableIRQ(DMA_Channel3_4_IRQn);
  184.                         NVIC_SetPriority(DMA_Channel3_4_IRQn, int_priority);
  185.                         break;
  186.                 #endif
  187.                 }
  188.         }
  189.         return VSFERR_NONE;
  190. }

  191. uint16_t vsfhal_usart_tx_bytes(vsfhal_usart_t index, uint8_t *data, uint16_t size)
  192. {
  193.         uint8_t buf[DMA_BUFF_SIZE], last;

  194.         if ((index >= VSFHAL_USART_NUM) || !size)
  195.                 return 0;

  196.         switch (index)
  197.         {
  198.         case 0:
  199.                 DMA_CH1CTL &= ~DMA_CHXCTL_CHEN;
  200.                 last = DMA_CH1CNT;
  201.                 if (last)
  202.                         memcpy(buf, (void *)DMA_CH1MADDR, last);
  203.                 size = min(sizeof(buf) - last, size);
  204.                 if (size)
  205.                         memcpy(buf + last, data, size);
  206.                 memcpy(tx_dma_buff[index], buf, size + last);
  207.                 DMA_CH1MADDR = (uint32_t)tx_dma_buff[index];
  208.                 DMA_CH1CNT = size + last;
  209.                 DMA_CH1CTL |= DMA_CHXCTL_CHEN;
  210.                 return size;
  211.         case 1:
  212.                 DMA_CH3CTL &= ~DMA_CHXCTL_CHEN;
  213.                 last = DMA_CH3CNT;
  214.                 if (last)
  215.                         memcpy(buf, (void *)DMA_CH3MADDR, last);
  216.                 size = min(sizeof(buf) - last, size);
  217.                 if (size)
  218.                         memcpy(buf + last, data, size);
  219.                 memcpy(tx_dma_buff[index], buf, size + last);
  220.                 DMA_CH3MADDR = (uint32_t)tx_dma_buff[index];
  221.                 DMA_CH3CNT = size + last;
  222.                 DMA_CH3CTL |= DMA_CHXCTL_CHEN;
  223.                 return size;
  224.         default:
  225.                 return 0;
  226.         }
  227. }

  228. uint16_t vsfhal_usart_tx_get_data_size(vsfhal_usart_t index)
  229. {
  230.         switch (index)
  231.         {
  232.         case 0:
  233.                 if (DMA_CH1CTL & DMA_CHXCTL_CHEN)
  234.                         return DMA_CH1CNT;
  235.                 else
  236.                         return 0;
  237.         case 1:
  238.                 if (DMA_CH3CTL & DMA_CHXCTL_CHEN)
  239.                         return DMA_CH3CNT;
  240.                 else
  241.                         return 0;
  242.         default:
  243.                 return 0;
  244.         }
  245. }

  246. uint16_t vsfhal_usart_tx_get_free_size(vsfhal_usart_t index)
  247. {
  248.         return DMA_BUFF_SIZE -  vsfhal_usart_tx_get_data_size(index);
  249. }

  250. vsf_err_t vsfhal_usart_tx_int_config(vsfhal_usart_t index, bool enable)
  251. {
  252.         switch (index)
  253.         {
  254.         case 0:
  255.                 if (enable)
  256.                         DMA_CH1CTL |= DMA_CHXCTL_FTFIE;
  257.                 else
  258.                         DMA_CH1CTL &= ~DMA_CHXCTL_FTFIE;
  259.                 break;
  260.         case 1:
  261.                 if (enable)
  262.                         DMA_CH3CTL |= DMA_CHXCTL_FTFIE;
  263.                 else
  264.                         DMA_CH3CTL &= ~DMA_CHXCTL_FTFIE;
  265.                 break;
  266.         default:
  267.                 return VSFERR_BUG;
  268.         }

  269.         return VSFERR_NONE;
  270. }

  271. uint16_t vsfhal_usart_rx_bytes(vsfhal_usart_t index, uint8_t *data, uint16_t size)
  272. {
  273.         uint8_t buf[DMA_BUFF_SIZE];

  274.         switch (index)
  275.         {
  276.         case 0:
  277.                 if (DMA_CH2CTL & DMA_CHXCTL_CHEN)
  278.                 {
  279.                         if (rx_dma_buf_sel[0] == 0)
  280.                         {
  281.                                 if (rx_dma_buff_pos[0][1])
  282.                                 {
  283.                                         if (size >= rx_dma_buff_pos[0][1])
  284.                                         {
  285.                                                 size = rx_dma_buff_pos[0][1];
  286.                                                 memcpy(data, rx_dma_buff[0][1], size);
  287.                                                 rx_dma_buff_pos[0][1] = 0;
  288.                                                 return size;
  289.                                         }
  290.                                         else
  291.                                         {
  292.                                                 memcpy(data, rx_dma_buff[0][1], size);
  293.                                                 memcpy(buf, rx_dma_buff[0][1] + size, rx_dma_buff_pos[0][1] - size);
  294.                                                 memcpy(rx_dma_buff[0][1], buf, rx_dma_buff_pos[0][1] - size);
  295.                                                 rx_dma_buff_pos[0][1] -= size;
  296.                                                 return size;
  297.                                         }
  298.                                 }
  299.                         }
  300.                         else
  301.                         {
  302.                                 if (rx_dma_buff_pos[0][0])
  303.                                 {
  304.                                         if (size >= rx_dma_buff_pos[0][0])
  305.                                         {
  306.                                                 size = rx_dma_buff_pos[0][0];
  307.                                                 memcpy(data, rx_dma_buff[0][0], size);
  308.                                                 rx_dma_buff_pos[0][0] = 0;
  309.                                                 return size;
  310.                                         }
  311.                                         else
  312.                                         {
  313.                                                 memcpy(data, rx_dma_buff[0][0], size);
  314.                                                 memcpy(buf, rx_dma_buff[0][0] + size, rx_dma_buff_pos[0][0] - size);
  315.                                                 memcpy(rx_dma_buff[0][0], buf, rx_dma_buff_pos[0][0] - size);
  316.                                                 rx_dma_buff_pos[0][0] -= size;
  317.                                                 return size;
  318.                                         }
  319.                                 }
  320.                         }
  321.                 }
  322.                 break;
  323.         case 1:
  324.                 if (DMA_CH4CTL & DMA_CHXCTL_CHEN)
  325.                 {
  326.                         if (rx_dma_buf_sel[1] == 0)
  327.                         {
  328.                                 if (rx_dma_buff_pos[1][1])
  329.                                 {
  330.                                         if (size >= rx_dma_buff_pos[1][1])
  331.                                         {
  332.                                                 size = rx_dma_buff_pos[1][1];
  333.                                                 memcpy(data, rx_dma_buff[1][1], size);
  334.                                                 rx_dma_buff_pos[1][1] = 0;
  335.                                                 return size;
  336.                                         }
  337.                                         else
  338.                                         {
  339.                                                 memcpy(data, rx_dma_buff[1][1], size);
  340.                                                 memcpy(buf, rx_dma_buff[1][1] + size, rx_dma_buff_pos[1][1] - size);
  341.                                                 memcpy(rx_dma_buff[1][1], buf, rx_dma_buff_pos[1][1] - size);
  342.                                                 rx_dma_buff_pos[1][1] -= size;
  343.                                                 return size;
  344.                                         }
  345.                                 }
  346.                         }
  347.                         else
  348.                         {
  349.                                 if (rx_dma_buff_pos[1][0])
  350.                                 {
  351.                                         if (size >= rx_dma_buff_pos[1][0])
  352.                                         {
  353.                                                 size = rx_dma_buff_pos[1][0];
  354.                                                 memcpy(data, rx_dma_buff[1][0], size);
  355.                                                 rx_dma_buff_pos[1][0] = 0;
  356.                                                 return size;
  357.                                         }
  358.                                         else
  359.                                         {
  360.                                                 memcpy(data, rx_dma_buff[1][0], size);
  361.                                                 memcpy(buf, rx_dma_buff[1][0] + size, rx_dma_buff_pos[1][0] - size);
  362.                                                 memcpy(rx_dma_buff[1][0], buf, rx_dma_buff_pos[1][0] - size);
  363.                                                 rx_dma_buff_pos[1][0] -= size;
  364.                                                 return size;
  365.                                         }
  366.                                 }
  367.                         }
  368.                 }
  369.                 break;
  370.         }
  371.         return 0;
  372. }

  373. uint16_t vsfhal_usart_rx_get_data_size(vsfhal_usart_t index)
  374. {
  375.         switch (index)
  376.         {
  377.         case 0:
  378.                 if (DMA_CH2CTL & DMA_CHXCTL_CHEN)
  379.                 {
  380.                         if (rx_dma_buf_sel[0] == 0)
  381.                                 return rx_dma_buff_pos[0][1];
  382.                         else
  383.                                 return rx_dma_buff_pos[0][0];
  384.                 }
  385.                 break;
  386.         case 1:
  387.                 if (DMA_CH4CTL & DMA_CHXCTL_CHEN)
  388.                 {
  389.                         if (rx_dma_buf_sel[1] == 0)
  390.                                 return rx_dma_buff_pos[1][1];
  391.                         else
  392.                                 return rx_dma_buff_pos[1][0];
  393.                 }
  394.                 break;
  395.         }
  396.         return 0;
  397. }

  398. uint16_t vsfhal_usart_rx_get_free_size(vsfhal_usart_t index)
  399. {
  400.         return DMA_BUFF_SIZE - vsfhal_usart_rx_get_data_size(index);
  401. }

  402. vsf_err_t vsfhal_usart_rx_int_config(vsfhal_usart_t index, bool enable)
  403. {
  404.         switch (index)
  405.         {
  406.         case 0:
  407.                 if (enable)
  408.                         DMA_CH2CTL |= DMA_CHXCTL_FTFIE;
  409.                 else
  410.                         DMA_CH2CTL &= ~DMA_CHXCTL_FTFIE;
  411.                 break;
  412.         case 1:
  413.                 if (enable)
  414.                         DMA_CH4CTL |= DMA_CHXCTL_FTFIE;
  415.                 else
  416.                         DMA_CH4CTL &= ~DMA_CHXCTL_FTFIE;
  417.                 break;
  418.         default:
  419.                 return VSFERR_BUG;
  420.         }

  421.         return VSFERR_NONE;
  422. }

  423. static uint8_t rx_dma_buf_sel[VSFHAL_USART_NUM];
  424. static uint8_t rx_dma_buff_pos[VSFHAL_USART_NUM][2];
  425. static uint8_t rx_dma_buff[VSFHAL_USART_NUM][2][DMA_BUFF_SIZE];

  426. static void (*vsfhal_usart_ontx[VSFHAL_USART_NUM])(void *);
  427. static void (*vsfhal_usart_onrx[VSFHAL_USART_NUM])(void *);
  428. static void *vsfhal_usart_callback_param[VSFHAL_USART_NUM];

  429. static void usart0_dma_handler(void)
  430. {
  431.         // rx dma
  432.         if ((DMA_CH2CTL & DMA_CHXCTL_CHEN) && (DMA_CH2CNT != DMA_BUFF_SIZE))
  433.         {
  434.                 if (rx_dma_buf_sel[0] == 0)
  435.                 {
  436.                         DMA_CH2CTL &= ~DMA_CHXCTL_CHEN;
  437.                         rx_dma_buff_pos[0][0] = DMA_BUFF_SIZE - DMA_CH2CNT;
  438.                         DMA_CH2MADDR = (uint32_t)rx_dma_buff[0][1];
  439.                         DMA_CH2CNT = DMA_BUFF_SIZE;
  440.                         DMA_CH2CTL |= DMA_CHXCTL_CHEN;
  441.                         rx_dma_buf_sel[0] = 1;
  442.                         if (vsfhal_usart_onrx[0])
  443.                                 vsfhal_usart_onrx[0](vsfhal_usart_callback_param[0]);
  444.                 }
  445.                 else
  446.                 {
  447.                         DMA_CH2CTL &= ~DMA_CHXCTL_CHEN;
  448.                         rx_dma_buff_pos[0][1] = DMA_BUFF_SIZE - DMA_CH2CNT;
  449.                         DMA_CH2MADDR = (uint32_t)rx_dma_buff[0][0];
  450.                         DMA_CH2CNT = DMA_BUFF_SIZE;
  451.                         DMA_CH2CTL |= DMA_CHXCTL_CHEN;
  452.                         rx_dma_buf_sel[0] = 0;
  453.                         if (vsfhal_usart_onrx[0])
  454.                                 vsfhal_usart_onrx[0](vsfhal_usart_callback_param[0]);
  455.                 }
  456.         }
  457.         // tx dma
  458.         if ((DMA_CH1CTL & DMA_CHXCTL_CHEN) && (DMA_CH1CNT == 0))
  459.         {
  460.                 if (vsfhal_usart_ontx[0])
  461.                         vsfhal_usart_ontx[0](vsfhal_usart_callback_param[0]);
  462.         }
  463. }

  464. static void usart1_dma_handler(void)
  465. {
  466.         // rx dma
  467.         if ((DMA_CH4CTL & DMA_CHXCTL_CHEN) && (DMA_CH4CNT != DMA_BUFF_SIZE))
  468.         {
  469.                 if (rx_dma_buf_sel[1] == 0)
  470.                 {
  471.                         DMA_CH4CTL &= ~DMA_CHXCTL_CHEN;
  472.                         rx_dma_buff_pos[1][0] = DMA_BUFF_SIZE - DMA_CH4CNT;
  473.                         DMA_CH4MADDR = (uint32_t)rx_dma_buff[1][1];
  474.                         DMA_CH4CNT = DMA_BUFF_SIZE;
  475.                         DMA_CH4CTL |= DMA_CHXCTL_CHEN;
  476.                         rx_dma_buf_sel[1] = 1;
  477.                         if (vsfhal_usart_onrx[1])
  478.                                 vsfhal_usart_onrx[1](vsfhal_usart_callback_param[1]);
  479.                 }
  480.                 else
  481.                 {
  482.                         DMA_CH4CTL &= ~DMA_CHXCTL_CHEN;
  483.                         rx_dma_buff_pos[1][1] = DMA_BUFF_SIZE - DMA_CH4CNT;
  484.                         DMA_CH4MADDR = (uint32_t)rx_dma_buff[1][0];
  485.                         DMA_CH4CNT = DMA_BUFF_SIZE;
  486.                         DMA_CH4CTL |= DMA_CHXCTL_CHEN;
  487.                         rx_dma_buf_sel[1] = 0;
  488.                         if (vsfhal_usart_onrx[1])
  489.                                 vsfhal_usart_onrx[1](vsfhal_usart_callback_param[1]);
  490.                 }
  491.         }
  492.         // tx dma
  493.         if ((DMA_CH3CTL & DMA_CHXCTL_CHEN) && (DMA_CH3CNT == 0))
  494.         {
  495.                 if (vsfhal_usart_ontx[1])
  496.                         vsfhal_usart_ontx[1](vsfhal_usart_callback_param[1]);
  497.         }
  498. }

  499. #if VSFHAL_USART0_ENABLE
  500. // used for usart0 tx/rx
  501. ROOTFUNC void USART0_IRQHandler(void)
  502. {
  503.         if (USART_STAT(USART0) & USART_STAT_RTF)
  504.         {
  505.                 USART_INTC(USART0) = USART_INTC_RTC;
  506.                 usart0_dma_handler();
  507.         }
  508. }

  509. ROOTFUNC void DMA_Channel1_2_IRQHandler(void)
  510. {
  511.         DMA_INTC = (DMA_INTC_GIFC << (1 * 4)) | (DMA_INTC_GIFC << (2 * 4));
  512.         usart0_dma_handler();
  513. }
  514. #endif
  515. #if VSFHAL_USART1_ENABLE
  516. // used for usart1 tx/rx
  517. ROOTFUNC void DMA_Channel3_4_IRQHandler(void)
  518. {
  519.         DMA_INTC = (DMA_INTC_GIFC << (3 * 4)) | (DMA_INTC_GIFC << (4 * 4));
  520.         usart1_dma_handler();
  521. }
  522. void gd32f3x0_usart1_poll(void)
  523. {
  524.         if ((DMA_CH4CTL & DMA_CHXCTL_CHEN) && (DMA_CH4CNT != DMA_BUFF_SIZE))
  525.                 usart1_dma_handler();
  526. }
  527. #endif
复制代码



此帖出自GD32 MCU论坛

i.MX RT1010 真香


回复

使用道具 举报

1383

TA的帖子

6

TA的资源

版主

Rank: 6Rank: 6

发表于 2018-10-14 18:33 | 显示全部楼层
不错,厉害,加油!CDC可以好好搞一下,USB的协议还是比较多的,能多搞一些就多搞一些,把USB协议都搞通了,以后其它数据传输类传输协议,你会很快搞定,加油!我最近也在搞CDC与USB AUDIO,还有HID的复合设备,搞的蛋疼^_^

点评

我用的vsf框架,usb很多协议都是现成的,只要开发一个底层驱动就行。  详情 回复 发表于 2018-10-14 19:13

回复

使用道具 举报

671

TA的帖子

3

TA的资源

版主

Rank: 6Rank: 6

 楼主| 发表于 2018-10-14 19:13 | 显示全部楼层
懒猫爱飞 发表于 2018-10-14 18:33
不错,厉害,加油!CDC可以好好搞一下,USB的协议还是比较多的,能多搞一些就多搞一些,把USB协议都搞通了 ...

我用的vsf框架,usb很多协议都是现成的,只要开发一个底层驱动就行。

i.MX RT1010 真香


回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

关闭

站长推荐上一条 1/4 下一条

  • 论坛活动 E手掌握

    扫码关注
    EEWORLD 官方微信

  • EE福利  唾手可得

    扫码关注
    EE福利 唾手可得

Archiver|手机版|小黑屋|电子工程世界 ( 京ICP证 060456 )

GMT+8, 2020-6-7 16:35 , Processed in 0.155554 second(s), 25 queries , Gzip On, MemCache On.

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