zhangcheng2
/
PLSR
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
12 Revize
4 Větve
4.4 MiB
 
 
 
 
Strom: 85b6075f9b
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „85b6075f9b“
${ noResults }
PLSR/TrainCamp_zhangcheng_PLSR/system/src/usart.c

637 řádky
18 KiB
Surový Blame Historie 

  1. #include "../inc/system.h"

  2. 

  3. #include "./USART.h"

  4. 

  5. //////////////////////////////////////////////////////////////////

  6. //加入以下代码,支持printf函数,而不需要选择use MicroLIB	  

  7. #if 1

  8. #pragma import(__use_no_semihosting)             

  9. //标准库需要的支持函数                 

  10. struct __FILE 

  11. { 

  12. 	int handle; 

  13. }; 

  14. 

  15. FILE __stdout;       

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

  17. void _sys_exit(int x) 

  18. { 

  19. 	x = x; 

  20. } 

  21. //重定义fputc函数 

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

  23. { 	

  24. 	while((USART1->SR&0X80)==0);//循环发送,直到发送完毕   

  25. 	USART1->DR = (u8) ch;      

  26. 	return ch;

  27. }

  28. #endif

  29. 

  30. #ifndef USE_STM32F103_Cxxx

  31. define USE_STM32F103_Cxxx 1 //默认使用STM32F103Cxxxx三个串口

  32. #endif

  33. 

  34. #define Send_Buffer 1024 //设置发送缓冲区最大长度

  35. 

  36. #define Receive_Queue_Max_Length    1030 //设置接收队列缓冲区最大长度

  37. #define Receive_Queue_ItemSize      1   //设置接收队列缓冲区单个数据大小

  38. static uint8_t Receive_Queue_Buffer[Receive_Queue_Max_Length]; //设置接收队列缓冲区

  39. static uint16_t Receive_Queue_Buffer_Count = 0;

  40. static void *Receive_Queue[Receive_Queue_Max_Length];

  41. 

  42. /* 串口私有数据结构体类型 */

  43. typedef struct USART_PRIV_DATA {

  44.     USART_TypeDef *USARTx; //串口号

  45.     OS_EVENT *xSemphr_Send; //发送完成信号量句柄

  46.     OS_EVENT *xSemphr_Receive; //接收数据帧信号量句柄

  47.     OS_EVENT *xQueue_Receive; //接收队列句柄

  48.     char SendBuffer[Send_Buffer]; //发送缓冲区

  49.     char *pSendBuffer; //指向发送缓冲区指针

  50. } usart_priv_obj_t;

  51. 

  52. /* 串口相关操作函数声明 */

  53. static int usart_init(usart_obj_t *pDev, uint32_t BaudRate, uint16_t DataBit, float StopBit, uint16_t Parity);

  54. static void usart_deinit(usart_obj_t *pDev);

  55. static void usart_send(usart_obj_t *pDev, uint8_t *data, uint16_t dataLenght);

  56. static int usart_print(usart_obj_t *pDev, INT32U timeout_ms, char *format, ...);

  57. static int usart_receive(usart_obj_t *pDev, uint8_t *data, uint16_t data_len, uint16_t *rec_br, INT32U timeout_ms);

  58. static uint32_t usart_wait_message_count(usart_obj_t *pDev);

  59. static void usart_irq_handle(usart_obj_t *pDev);

  60. 

  61. /* 串口1私有数据 */

  62. static usart_priv_obj_t g_usart1_priv_data = {

  63.     USART1,

  64. };

  65. 

  66. /* 串口1结构体对象 */

  67. static usart_obj_t g_usart1 = {

  68.     "usart1",

  69.     usart_init,

  70.     usart_deinit,

  71.     usart_send,

  72.     usart_print,

  73.     usart_receive,

  74.     usart_wait_message_count,

  75.     &g_usart1_priv_data

  76. };

  77. 

  78. /* 串口2私有数据 */

  79. static usart_priv_obj_t g_usart2_priv_data = {

  80.     USART2,

  81. };

  82. 

  83. /* 串口2结构体对象 */

  84. static usart_obj_t g_usart2 = {

  85.     "usart2",

  86.     usart_init,

  87.     usart_deinit,

  88.     usart_send,

  89.     usart_print,

  90.     usart_receive,

  91.     usart_wait_message_count,

  92.     &g_usart2_priv_data

  93. };

  94. 

  95. /* 串口3私有数据 */

  96. static usart_priv_obj_t g_usart3_priv_data = {

  97.     USART3,

  98. };

  99. 

  100. /* 串口3结构体对象 */

  101. static usart_obj_t g_usart3 = {

  102.     "usart3",

  103.     usart_init,

  104.     usart_deinit,

  105.     usart_send,

  106.     usart_print,

  107.     usart_receive,

  108.     usart_wait_message_count,

  109.     &g_usart3_priv_data

  110. };

  111. 

  112. #if (USE_STM32F103_Cxxx != 1)

  113. 

  114. /* 串口4私有数据 */

  115. static usart_priv_obj_t g_usart4_priv_data = {

  116.     UART4,

  117. };

  118. 

  119. /* 串口4结构体对象 */

  120. static usart_obj_t g_uart4 = {

  121.     "usart4",

  122.     usart_init,

  123.     usart_deinit,

  124.     usart_send,

  125.     usart_print,

  126.     usart_receive,

  127.     usart_wait_message_count,

  128.     &g_usart4_priv_data

  129. };

  130. 

  131. /* 串口5私有数据 */

  132. static  usart_priv_obj_t g_usart5_priv_data = {

  133.     UART5,

  134. };

  135. 

  136. /* 串口5结构体对象 */

  137. static usart_obj_t g_uart5 = {

  138.     "uart5",

  139.     usart_init,

  140.     usart_deinit,

  141.     usart_send,

  142.     usart_print,

  143.     usart_receive,

  144.     usart_wait_message_count,

  145.     &g_usart5_priv_data

  146. };

  147. #endif

  148. 

  149. /* 串口设备列表 */

  150. static usart_obj_t *g_usart_devs[] = {

  151.     &g_usart1,

  152.     &g_usart2,

  153.     &g_usart3,

  154.     #if(USE_STM32F103_Cxxx != 1)

  155.         &g_uart4,

  156.         &g_uart5,

  157.     #endif

  158. };

  159. 

  160. static void USART_DMA_Config(void);

  161. 

  162. /*

  163.  *@函数名：usart_init

  164.  *@函数功能：初始化指定串口

  165.  *@参数：

  166.  *    @pDev：指定串口句柄

  167.  *    @BautRate：串口波特率

  168.  *        value：9600、 14400、 19200、 38400、 115200、 256000、 921600

  169.  *    @DataBit：串口数据位

  170.  *        value：8、 9

  171.  *    @StopBit：串口停止位

  172.  *        value：0.5、 1、 1.5、 2

  173.  *    @Parity：串口校验位

  174.  *        value：0：无校验、 1：奇校验、 2：偶校验

  175.  *@返回值

  176.  *    0：串口初始化成功

  177.  *    -1：串口初始化失败

  178.  */

  179. static int usart_init(usart_obj_t *pDev, uint32_t BaudRate, uint16_t DataBit, float StopBit, uint16_t Parity)

  180. {

  181.     usart_priv_obj_t *usart_priv_obj = pDev->usart_priv_data;

  182. 

  183.     /* 创建串口发送信号量和接收队列 */

  184.     usart_priv_obj->xQueue_Receive = OSQCreate(Receive_Queue,

  185.                     Receive_Queue_Max_Length);

  186.     if (usart_priv_obj->xQueue_Receive == NULL)

  187.     {

  188.         printf("usart init fail %s %d\r\n", __FILE__, __LINE__);

  189.     }

  190. 

  191.     usart_priv_obj->xSemphr_Send = OSSemCreate(0);

  192.     if (usart_priv_obj->xSemphr_Send == NULL)

  193.     {

  194.         printf("usart init fail %s %d\r\n", __FILE__, __LINE__);

  195.     }

  196. 

  197.     usart_priv_obj->xSemphr_Receive = OSSemCreate(0);

  198.     if (usart_priv_obj->xSemphr_Receive == NULL)

  199.     {

  200.         printf("usart init fail %s %d\r\n", __FILE__, __LINE__);

  201.     }

  202. 

  203.     /* 初始化不同串口不同的参数部分 */

  204.     uint32_t RCC_APBxPeriph_UARTx = NULL;

  205.     uint32_t RCC_AHB1Periph_GPIOx = NULL;

  206.     GPIO_TypeDef *GPIOx = NULL;

  207.     uint16_t GPIO_PinSource_Tx;

  208.     uint16_t GPIO_PinSource_Rx;

  209.     uint8_t AF_Type;

  210.     GPIO_InitTypeDef GPIO_InitStructure_Tx;

  211.     GPIO_InitTypeDef GPIO_InitStructure_Rx;

  212.     USART_InitTypeDef USART_InitStructure;

  213.     NVIC_InitTypeDef NVIC_InitStructure;

  214.     if(USART1 == usart_priv_obj->USARTx)

  215.     {

  216.         RCC_APBxPeriph_UARTx = RCC_APB2Periph_USART1;

  217.         RCC_AHB1Periph_GPIOx = RCC_AHB1Periph_GPIOA;

  218.         GPIOx = GPIOA;

  219.         GPIO_PinSource_Tx = GPIO_PinSource9;

  220.         GPIO_PinSource_Rx = GPIO_PinSource10;

  221.         AF_Type = GPIO_AF_USART1;

  222.         GPIO_InitStructure_Tx.GPIO_Pin = GPIO_Pin_9;

  223.         GPIO_InitStructure_Rx.GPIO_Pin = GPIO_Pin_10;

  224.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

  225.     }

  226.     else if(USART2 == usart_priv_obj->USARTx)

  227.     {

  228.         RCC_APBxPeriph_UARTx = RCC_APB1Periph_USART2;

  229.         RCC_AHB1Periph_GPIOx = RCC_AHB1Periph_GPIOA;

  230.         GPIOx = GPIOA;

  231.         GPIO_PinSource_Tx = GPIO_PinSource2;

  232.         GPIO_PinSource_Rx = GPIO_PinSource3;

  233.         AF_Type = GPIO_AF_USART2;

  234.         GPIO_InitStructure_Tx.GPIO_Pin = GPIO_Pin_2;

  235.         GPIO_InitStructure_Rx.GPIO_Pin = GPIO_Pin_3;

  236.         NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;

  237.     }

  238.     else if(USART3 == usart_priv_obj->USARTx)

  239.     {

  240.         RCC_APBxPeriph_UARTx = RCC_APB1Periph_USART3;

  241.         RCC_AHB1Periph_GPIOx = RCC_AHB1Periph_GPIOB;

  242.         GPIOx = GPIOB;

  243.         GPIO_PinSource_Tx = GPIO_PinSource10;

  244.         GPIO_PinSource_Rx = GPIO_PinSource11;

  245.         AF_Type = GPIO_AF_USART3;

  246.         GPIO_InitStructure_Tx.GPIO_Pin = GPIO_Pin_10;

  247.         GPIO_InitStructure_Rx.GPIO_Pin = GPIO_Pin_11;

  248.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;

  249.     }

  250.     /*   else if (UART4 == usart_priv_obj->USARTx)

  251.        {

  252.        }*/

  253.        //    else{}

  254. 

  255.     /* 初始化串口数据位、停止位、校验位 */

  256.     switch(DataBit)

  257.     {

  258.     case 8:USART_InitStructure.USART_WordLength = USART_WordLength_8b; break;

  259.     case 9:USART_InitStructure.USART_WordLength = USART_WordLength_9b; break;

  260.     default:return -1;

  261.     }

  262.     if(0.5f == StopBit)

  263.         USART_InitStructure.USART_StopBits = USART_StopBits_0_5;

  264.     else if(1.0f == StopBit)

  265.         USART_InitStructure.USART_StopBits = USART_StopBits_1;

  266.     else if(1.5f == StopBit)

  267.         USART_InitStructure.USART_StopBits = USART_StopBits_1_5;

  268.     else if(2.0f == StopBit)

  269.         USART_InitStructure.USART_StopBits = USART_StopBits_2;

  270.     else

  271.         return -1;

  272.     switch(Parity)

  273.     {

  274.     case 0:USART_InitStructure.USART_Parity = USART_Parity_No; break;

  275.     case 1:USART_InitStructure.USART_Parity = USART_Parity_Odd; break;

  276.     case 2:USART_InitStructure.USART_Parity = USART_Parity_Even; break;

  277.     default:return -1;

  278.     }

  279. 

  280.     /* 初始化串口时钟、GPIO、NVIC */

  281.     if(USART1 == usart_priv_obj->USARTx)

  282.         RCC_APB2PeriphClockCmd(RCC_APBxPeriph_UARTx, ENABLE);

  283.     else

  284.         RCC_APB1PeriphClockCmd(RCC_APBxPeriph_UARTx, ENABLE);

  285.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOx, ENABLE);

  286.     

  287.     GPIO_PinAFConfig(GPIOx, GPIO_PinSource_Tx, AF_Type);

  288.     GPIO_PinAFConfig(GPIOx, GPIO_PinSource_Rx, AF_Type);

  289.     

  290.     GPIO_InitStructure_Tx.GPIO_Mode = GPIO_Mode_AF;

  291.     GPIO_InitStructure_Tx.GPIO_OType = GPIO_OType_PP;

  292.     GPIO_InitStructure_Rx.GPIO_PuPd = GPIO_PuPd_UP;

  293.     GPIO_InitStructure_Tx.GPIO_Speed = GPIO_Speed_100MHz;

  294.     GPIO_Init(GPIOx, &GPIO_InitStructure_Tx);

  295.     GPIO_InitStructure_Rx.GPIO_Mode = GPIO_Mode_AF;

  296.     GPIO_InitStructure_Rx.GPIO_OType = GPIO_OType_PP;

  297.     GPIO_InitStructure_Rx.GPIO_PuPd = GPIO_PuPd_UP;

  298.     GPIO_InitStructure_Rx.GPIO_Speed = GPIO_Speed_100MHz;

  299.     GPIO_Init(GPIOx, &GPIO_InitStructure_Rx);

  300.     

  301.     USART_InitStructure.USART_BaudRate = BaudRate;

  302.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

  303.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  304.     USART_Init(usart_priv_obj->USARTx, &USART_InitStructure);

  305. 

  306.     USART_DMA_Config();

  307.     

  308.     USART_ClearITPendingBit(usart_priv_obj->USARTx, USART_IT_TC);//清除传输完成

  309.     USART_ITConfig(usart_priv_obj->USARTx, USART_IT_TC, ENABLE);

  310.     USART_ITConfig(usart_priv_obj->USARTx, USART_IT_IDLE, ENABLE);

  311. 

  312.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  313.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 6;

  314.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

  315.     NVIC_Init(&NVIC_InitStructure);

  316.   

  317.     USART_Cmd(usart_priv_obj->USARTx, ENABLE);

  318. 

  319.     

  320. 

  321.     return 0;

  322. }

  323. 

  324. 

  325. /*

  326.  *@函数名：usart_deinit

  327.  *@函数功能：重置指定串口

  328.  *@参数：

  329.  *    @pDev：指定串口句柄

  330.  *@返回值：无

  331.  */

  332. static void usart_deinit(usart_obj_t *pDev)

  333. {

  334.     usart_priv_obj_t *usart_priv_obj = pDev->usart_priv_data;

  335.     USART_DeInit(usart_priv_obj->USARTx);

  336. }

  337. 

  338. /*

  339.  *@函数名：usart_print

  340.  *@函数功能：串口格式化发送数据

  341.  *@参数：

  342.  *    @pDev：指定串口句柄

  343.  *    @timeout_ms：等待超时时间

  344.  *        参数值：0~portMAX_DELAY；

  345.  *    @format：待发送字符串

  346.  *    @...：可变参数

  347.  *@返回值

  348.  *    0：串口发送成功

  349.  *    -1：串口发送失败

  350.  */

  351. static int usart_print(usart_obj_t *pDev, INT32U timeout_ms, char *format, ...)

  352. {

  353.     OS_ERR err;

  354. 

  355.     usart_priv_obj_t *usart_priv_obj = pDev->usart_priv_data;

  356. 

  357.     /* 格式化字符串复制到缓冲区 */

  358.     va_list arg;

  359.     va_start(arg, format);

  360.     vsprintf(usart_priv_obj->SendBuffer, format, arg);

  361.     va_end(arg);

  362.     usart_priv_obj->pSendBuffer = usart_priv_obj->SendBuffer;

  363. 

  364.     /* 开启发送中断，在中断中发送数据 */

  365.     USART_ITConfig(usart_priv_obj->USARTx, USART_IT_TXE, ENABLE);

  366. 

  367.     /* 等待中断发送完成释放信号量 */

  368.     OSSemPend(usart_priv_obj->xSemphr_Send, timeout_ms, &err);

  369.     if (err != OS_ERR_NONE)

  370.     {

  371.         return 0;

  372.     }

  373.     else

  374.     {

  375.         return -1;

  376.     }

  377. }

  378. 

  379. 

  380. /*

  381.  *@函数名：usart_send

  382.  *@函数功能：串口发送数据

  383.  *@参数：

  384.  *    @pDev：指定串口句柄

  385.  *    @data：待发送数据

  386.  *@返回值

  387.  *    0：串口发送成功

  388.  *    -1：串口发送失败

  389.  */

  390. static void usart_send(usart_obj_t *pDev, uint8_t *data, uint16_t dataLenght)

  391. {

  392.     OS_ERR err;

  393.     usart_priv_obj_t *usart_priv_obj = pDev->usart_priv_data;

  394. 

  395.     OSSemPend(usart_priv_obj->xSemphr_Send, 0, &err);

  396. 

  397.     DMA_Cmd(USART_TX_DMA_STREAM, DISABLE);

  398.     USART_TX_DMA_STREAM->M0AR = (uint32_t)data;

  399.     DMA_SetCurrDataCounter(USART_TX_DMA_STREAM, dataLenght);//设置需要发送的量

  400.     DMA_Cmd(USART_TX_DMA_STREAM, ENABLE);

  401. }

  402. 

  403. 

  404. /*

  405.  *@函数名：usart_receive

  406.  *@函数功能：从串口接收队列中读取一个数据

  407.  *@参数：

  408.  *    @pDev：指定串口句柄

  409.  *    @data：保存接收到的数据

  410.  *    @timeout_ms：等待超时时间

  411.  *        参数值：0~portMAX_DELAY；

  412.  *@返回值

  413.  *    0：读取串口队列成功

  414.  *   -1：读取串口超时

  415.  */

  416. static int usart_receive(struct USART *pDev, uint8_t *data, uint16_t data_len, uint16_t *rec_br, INT32U timeout_ms)

  417. {

  418.     OS_ERR err;

  419. 

  420.     usart_priv_obj_t *usart_priv_obj = pDev->usart_priv_data;

  421. 

  422.     /* 读取串口接收队列 */

  423.     OSSemPend(usart_priv_obj->xSemphr_Receive, timeout_ms, &err);

  424.     if (err == OS_ERR_NONE)

  425.     {

  426.         *rec_br = Receive_Queue_Buffer_Count;

  427.         Receive_Queue_Buffer_Count = 0;

  428.         

  429.         if(data_len > *rec_br)

  430.         {

  431.             data_len = (*rec_br);

  432.         }

  433. 

  434.         memcpy(data, Receive_Queue_Buffer, data_len);

  435.         

  436.         return 0;

  437.     }

  438.     else

  439.     {

  440.         return -1;

  441.     }

  442. }

  443. 

  444. 

  445. /*

  446.  *@函数名：usart_wait_message_count

  447.  *@函数功能：获取串口接收队列剩余数据量

  448.  *@参数：

  449.  *    @pDev：指定串口句柄

  450.  *@返回值：串口接收队列剩余数据量

  451.  */

  452. static uint32_t usart_wait_message_count(usart_obj_t *pDev)

  453. {

  454.     usart_priv_obj_t *usart_priv_obj = pDev->usart_priv_data;

  455.     return ((OS_Q *)(usart_priv_obj->xQueue_Receive->OSEventPtr))->OSQEntries;

  456. }

  457. 

  458. 

  459. /*

  460.  *@函数名：usart_irq_handle

  461.  *@函数功能：处理串口发送和接收中断

  462.  *@参数：

  463.  *    @pDev：待处理中断的串口句柄

  464.  *@返回值：无

  465.  */

  466. //UBaseType_t semaphore;

  467. static void usart_irq_handle(usart_obj_t *pDev)

  468. {

  469.     OS_CPU_SR cpu_sr;

  470.     OS_ENTER_CRITICAL();

  471.     OSIntEnter();                                               /* Tell uC/OS-III that we are starting an ISR           */

  472.     OS_EXIT_CRITICAL();

  473.  

  474.     usart_priv_obj_t *usart_priv_obj = pDev->usart_priv_data;

  475.     

  476.     /* 发送寄存器为空，填入数据到发送寄存器开始发送 */

  477.     if(SET == USART_GetITStatus(usart_priv_obj->USARTx, USART_IT_TC))

  478.     {

  479.         OSSemPost(usart_priv_obj->xSemphr_Send);

  480. 

  481.         DMA_ClearFlag(USART_TX_DMA_STREAM, DMA_FLAG_TCIF7); //清除DMA传输完成标志

  482.         DMA_ClearFlag(USART_TX_DMA_STREAM, DMA_FLAG_HTIF7); //清除DMA传输完成标志

  483. 	USART_ClearITPendingBit(usart_priv_obj->USARTx, USART_IT_TC);	 //清除传输完成

  484.     }

  485.     

  486.     /* 空闲中断接收到完整的数据帧 */

  487.     if(SET == USART_GetITStatus(usart_priv_obj->USARTx, USART_IT_IDLE))

  488.     {

  489.         OSSemPost(usart_priv_obj->xSemphr_Receive);

  490. 

  491.         /* 清除计数器和空闲中断标志位 */

  492.         USART_GetITStatus(usart_priv_obj->USARTx, USART_IT_IDLE);

  493.         USART_ReceiveData(usart_priv_obj->USARTx);

  494. 		

  495.         Receive_Queue_Buffer_Count = Receive_Queue_Max_Length

  496.                       - DMA_GetCurrDataCounter(USART_RX_DMA_STREAM);

  497.         

  498.         DMA_ClearFlag(USART_RX_DMA_STREAM, DMA_FLAG_TCIF5); //清除DMA传输完成标志

  499.         DMA_ClearFlag(USART_RX_DMA_STREAM, DMA_FLAG_HTIF5); //清除DMA传输完成标志

  500.         DMA_Cmd(USART_RX_DMA_STREAM, DISABLE);

  501.         DMA_SetCurrDataCounter(USART_RX_DMA_STREAM, Receive_Queue_Max_Length);//设置需要接收的量

  502. 	DMA_Cmd(USART_RX_DMA_STREAM, ENABLE);

  503.     }

  504. 

  505.     OSIntExit();

  506. }

  507. 

  508. 

  509. /*

  510.  *@函数名：USART1_IRQHandler

  511.  *@函数功能：处理串口1发送和接收中断

  512.  *@参数：无

  513.  *@返回值：无

  514.  */

  515. void USART1_IRQHandler(void)

  516. {

  517.     usart_irq_handle(&g_usart1);

  518. }

  519. 

  520. 

  521. /*

  522.  *@函数名：USART2_IRQHandler

  523.  *@函数功能：处理串口2发送和接收中断

  524.  *@参数：无

  525.  *@返回值：无

  526.  */

  527. void USART2_IRQHandler(void)

  528. {

  529.     usart_irq_handle(&g_usart2);

  530. }

  531. 

  532. 

  533. /*

  534.  *@函数名：USART3_IRQHandler

  535.  *@函数功能：处理串口3发送和接收中断

  536.  *@参数：无

  537.  *@返回值：无

  538.  */

  539. void USART3_IRQHandler(void)

  540. {

  541.     usart_irq_handle(&g_usart3);

  542. }

  543. 

  544. 

  545. #if (USE_STM32F103_Cxxx != 1)

  546. /*

  547.  *@函数名：UART4_IRQHandler

  548.  *@函数功能：处理串口4发送和接收中断

  549.  *@参数：无

  550.  *@返回值：无

  551.  */

  552. void UART4_IRQHandler(void)

  553. {

  554.     usart_irq_handle(&g_uart4);

  555. }

  556. 

  557. 

  558. /*

  559.  *@函数名：UART5_IRQHandler

  560.  *@函数功能：处理串口5发送和接收中断

  561.  *@参数：无

  562.  *@返回值：无

  563.  */

  564. void UART5_IRQHandler(void)

  565. {

  566.     usart_irq_handle(&g_uart5);

  567. }

  568. #endif

  569. 

  570. /*

  571.  *@函数名：Get_USART_Handle

  572.  *@函数功能：获取指定串口句柄

  573.  *@参数：

  574.  *    @name：串口名称

  575.  *@返回值：串口句柄

  576.  */

  577. usart_obj_t *get_usart_obj(char *name) {

  578.     uint8_t usart_dev_num = sizeof(g_usart_devs) / sizeof(g_usart_devs[0]);

  579.     for(uint8_t i = 0; i < usart_dev_num; i++)

  580.     {

  581.         if(0 == strcmp(name, g_usart_devs[i]->name))

  582.         {

  583.             return g_usart_devs[i];

  584.         }

  585.     }

  586.     return NULL;

  587. }

  588. 

  589. 

  590. 

  591. static void USART_DMA_Config(void)

  592. {

  593.     DMA_InitTypeDef DMA_InitStructure;

  594. 	

  595.     RCC_AHB1PeriphClockCmd(USART_TX_DMA_CLK | USART_RX_DMA_CLK, ENABLE);//使能DMA2时钟

  596. 	

  597.     /* 配置发送 */

  598.     DMA_InitStructure.DMA_BufferSize = 0;//随便配置，因为在接收到数据后我们会重新给这值赋值

  599.     DMA_InitStructure.DMA_Channel = USART_TX_DMA_CHANNEL;//串口发送通道

  600.     DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;//DMA搬运方向：存储器到外设

  601. 	

  602.     DMA_InitStructure.DMA_Memory0BaseAddr = 0;//存储器地址

  603.     DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;//存储器突发模式选择：单次模式

  604.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;//存储器数据宽度：字节

  605.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable ;//使能存储器地址自动递增功能

  606.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;//DMA 传输模式选择：一次传输

  607.     DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;//外设地址

  608.     DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;//外设突发模式选择：单次模式

  609.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;//外设数据宽度：字节

  610.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//禁止外设地址自动递增功能

  611.     DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;//软件设置数据流的优先级：中等

  612.     /* FIFO不用随便配置 */

  613.     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;

  614.     DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;

  615. 	

  616.     DMA_Init(USART_TX_DMA_STREAM, &DMA_InitStructure);

  617.     DMA_Cmd(USART_TX_DMA_STREAM, DISABLE);//发送先失能

  618. 	

  619.     /* 配置接收 */

  620.     DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)Receive_Queue_Buffer;//存储器地址

  621.     DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;//外设地址

  622.     DMA_InitStructure.DMA_BufferSize = Receive_Queue_Max_Length;//接收数据的长度

  623.     DMA_InitStructure.DMA_Channel = USART_RX_DMA_CHANNEL;//串口接收通道

  624.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;//DMA搬运方向：外设到存储器

  625.     DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;//DMA 传输模式选择：循环接收

  626. 	

  627.     /* 其余配置与上面一样 */

  628.     DMA_Init(USART_RX_DMA_STREAM, &DMA_InitStructure);

  629.     DMA_ClearFlag(USART_RX_DMA_STREAM, DMA_FLAG_TCIF5); //清除DMA传输完成标志

  630.     DMA_ClearFlag(USART_RX_DMA_STREAM, DMA_FLAG_HTIF5); //清除DMA传输完成标志

  631.     DMA_Cmd(USART_RX_DMA_STREAM, DISABLE);//发送先失能

  632.     DMA_Cmd(USART_RX_DMA_STREAM, ENABLE);//接收使能

  633. 

  634.     USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);

  635.     USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);

  636. }