devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

PY32F003F18之DMA串口_py32f003串口中断

作者：菜鸟追梦旅行 | 2024-05-21 12:24:34

赞

踩

py32f003串口中断

PY32F003F18使用DMA串口，官方程序省FLASH，但不省内存。单片机内存够大，节省没意义，故做了修改，少用HAL库中的发送和接收，从里面抠出有用的部分，修修改改就可以了。

一、DMA串口初始化流程：

假定：串口发送引脚USART2_TX使用PA0，串口接收引脚USART2_RX使用PA1
1、使能USART2外设时钟，__HAL_RCC_USART2_CLK_ENABLE();

2、使能GPIOA时钟，__HAL_RCC_GPIOA_CLK_ENABLE();

3、将串口发送引脚USART2_TX映射到PA0

4、将串口接收引脚USART2_RX映射到PA1

5、设置串口帧格式和波特率

6、将DMA通道1映射到USART2_TX，将DMA通道2映射到USART2_RX

  __HAL_RCC_SYSCFG_CLK_ENABLE();//使能RCC外设时钟
    HAL_SYSCFG_DMA_Req(0x0807);
    //配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
    //DMA1_MAP[4:0]=7,将DMA通道1映射到USART2_TX
    //DMA2_MAP[4:0]=8,将DMA通道2映射到USART2_RX

7、配置DMA串口发送，传输"从内存到外设"

8、配置DMA串口接收，传输"从外设到内存"

9、关闭串口接收中断

10、不使能"串口发送数据寄存器为空"产生中断

11、不使能"串口发送完成"产生中断

二、测试程序

  1. #include "USART2.h"
  2. #include "stdio.h"  //getchar(),putchar(),scanf(),printf(),puts(),gets(),sprintf()
  3. #include "string.h" //使能strcpy(),strlen(),memset()
  4. #include "My_DMA.h"
  5. #include "delay.h"
  6.  
  7. //PA0 ------> USART2_TX
  8. //PA1 ------> USART2_RX
  9.  
  10. uint8_t USART2_TX_Buffer[USART2_TX_Buffer_Size]; //USART2发送缓冲区数组;
  11. uint8_t USART2_TX_Buffer_Send_Index=0;          //USART2_TX_Buffer[]的发送索引值;
  12. uint8_t USART2_TX_Buffer_Load_Index=0;          //USART2_TX_Buffer[]的装载索引值
  13. uint8_t USART2_TX_Completed_Flag;
  14. uint8_t USART2_TX_Overtime_Conter;//USART2发送超时计数器
  15.  
  16. uint8_t USART2_RX_Buffer[USART2_RX_Buffer_Size]; //USART2接收缓冲区数组
  17. uint8_t USART2_RX_Buffer_StartIndex;//USART2_RX_Buffer[]的装载索引值
  18. uint8_t USART2_RX_Buffer_EndIndex;//USART2_RX_Buffer[]的装载索引值
  19. uint8_t USART2_RX1_Buffer[USART2_RX1_Buffer_Size]; //USART2接收缓冲区数组
  20.  
  21. void USART2_Init(uint32_t baudrate);
  22. void Usart2Send(void);
  23. void Usart2Receive(void);
  24.  
  25. void Usart2Send_DMA1_CH1_config(void);
  26. void Usart2Receive_DMA1_CH2_config(void);
  27.  
  28. #if USART2Type == 0 
  29. //函数功能:
  30. //PA2是为USART2_TX,PA3是USART2_RX
  31. //中断优先级为0x01
  32. //波特率为115200,数字为8位,停止位为1位,无奇偶校验,允许发送和接收数据,只允许接收中断,并使能串口
  33. void USART2_Init(uint32_t baudrate)
  34. {
  35.   GPIO_InitTypeDef  GPIO_InitStructureure;
  36. 	UART_HandleTypeDef UART_HandleStructureure;
  37.  
  38. /HAL_UART_MspInit开始
  39.   __HAL_RCC_USART2_CLK_ENABLE();//使能USART2外设时钟
  40.   __HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
  41.  
  42. //串口引脚映射开始/
  43.   GPIO_InitStructureure.Pin = GPIO_PIN_2;     //选择第2脚,PA2是为USART2_TX
  44.   GPIO_InitStructureure.Mode = GPIO_MODE_AF_PP;            //复用功能推挽模式
  45.   GPIO_InitStructureure.Pull = GPIO_PULLUP;                //引脚上拉被激活
  46.   GPIO_InitStructureure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //引脚速度为最高速
  47.   GPIO_InitStructureure.Alternate = GPIO_AF4_USART2;       //将引脚复用为USART2
  48.   HAL_GPIO_Init(GPIOA, &GPIO_InitStructureure);
  49. 	//根据GPIO_InitStructureure结构变量指定的参数初始化GPIOA的外设寄存器
  50. 	//将PA0初始化为USART2_TX
  51.  
  52.   GPIO_InitStructureure.Pin = GPIO_PIN_3;     //选择第3脚,PA3是USART2_RX
  53.   GPIO_InitStructureure.Mode = GPIO_MODE_AF_PP;            //复用功能推挽模式
  54.   GPIO_InitStructureure.Pull = GPIO_PULLUP;                //引脚上拉被激活
  55.   GPIO_InitStructureure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //引脚速度为最高速
  56.   GPIO_InitStructureure.Alternate = GPIO_AF4_USART2;       //将引脚复用为USART2
  57.   HAL_GPIO_Init(GPIOA, &GPIO_InitStructureure);
  58. 	//根据GPIO_InitStructureure结构变量指定的参数初始化GPIOA的外设寄存器
  59. 	//将PA1初始化为USART2_RX
  60. //串口引脚映射结束/
  61. /HAL_UART_MspInit结束
  62.  
  63.   UART_HandleStructureure.Instance          = USART2;              //接口为USART2
  64.   UART_HandleStructureure.Init.BaudRate     = baudrate;            //波特率为115200bps
  65.   UART_HandleStructureure.Init.WordLength   = UART_WORDLENGTH_8B;  //串口字长度为8
  66.   UART_HandleStructureure.Init.StopBits     = UART_STOPBITS_1;     //串口停止位为1位
  67.   UART_HandleStructureure.Init.Parity       = UART_PARITY_NONE;    //串口无需奇偶校验
  68.   UART_HandleStructureure.Init.HwFlowCtl    = UART_HWCONTROL_NONE; //串口无硬件流程控制
  69.   UART_HandleStructureure.Init.Mode         = UART_MODE_TX_RX;     //串口工作模式为发送和接收模式
  70. 	UART_HandleStructureure.AdvancedInit.AdvFeatureInit=UART_ADVFEATURE_NO_INIT;//不使用自动波特率
  71. //	UART_HandleStructureure.AdvancedInit.AdvFeatureInit=UART_ADVFEATURE_AUTOBAUDRATE_INIT;//使用自动波特率配置
  72. //	UART_HandleStructureure.AdvancedInit.AutoBaudRateEnable=UART_ADVFEATURE_AUTOBAUDRATE_ENABLE;//自动波特率使能
  73. //	UART_HandleStructureure.AdvancedInit.AutoBaudRateMode=UART_ADVFEATURE_AUTOBAUDRATE_ONSTARTBIT;//自动波特率模式
  74. 	HAL_UART_Init(&UART_HandleStructureure);
  75. 	//根据UART_HandleStructureure型结构初始化USART2
  76.   __HAL_RCC_SYSCFG_CLK_ENABLE();//使能RCC外设时钟
  77. 	HAL_SYSCFG_DMA_Req(0x0807);
  78. 	//配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
  79. 	//DMA1_MAP[4:0]=7,将DMA通道1映射到USART2_TX
  80. 	//DMA2_MAP[4:0]=8,将DMA通道2映射到USART2_RX
  81.  
  82.   Usart2Send_DMA1_CH1_config();
  83. 	Usart2Receive_DMA1_CH2_config();
  84.  
  85. //  HAL_NVIC_SetPriority(USART2_IRQn, 0x01, 0);
  86. 	//设置串口2中断优先级为0x01,0无意义.USART2_IRQn表示中断源为串口2
  87.  
  88. //	__HAL_UART_ENABLE_IT(&UART_HandleStructureure, UART_IT_RXNE);
  89. 	//开启串口接收中断
  90. 	//串口接收数据时,使能"接收数据寄存器不为空"则产生中断(位RXNE=1)
  91. 	//Enable the UART Data Register not empty Interrupt
  92.  
  93. 	__HAL_UART_DISABLE_IT(&UART_HandleStructureure, UART_IT_RXNE);
  94. 	//关闭串口接收中断
  95. 	//串口接收数据时,不使能"接收数据寄存器不为空"则产生中断(位RXNE=0)
  96.  
  97. 	__HAL_UART_DISABLE_IT(&UART_HandleStructureure, UART_IT_TXE);
  98. 	//串口发送数据时,不使能"串口发送数据寄存器为空"产生中断(位TXE=0)
  99. 	//Disable the UART Transmit Complete Interrupt
  100.  
  101. 	__HAL_UART_DISABLE_IT(&UART_HandleStructureure,UART_IT_TC);
  102. 	//串口发送数据时,不使能"串口发送完成"产生中断(位TC=1)
  103. /在串口中断服务函数中发送数据配置结束//
  104.  
  105. //  HAL_NVIC_EnableIRQ(USART2_IRQn);
  106. 	//使能串口2中断
  107. 	//USART2_IRQn表示中断源为串口2
  108. }
  109. #endif
  110.  
  111. #if USART2Type ==1
  112. //函数功能:
  113. //PA0是为USART2_TX,PA1是USART2_RX
  114. //中断优先级为0x01
  115. //波特率为115200,数字为8位,停止位为1位,无奇偶校验,允许发送和接收数据,只允许接收中断,并使能串口
  116. void USART2_Init(uint32_t baudrate)
  117. {
  118.   GPIO_InitTypeDef  GPIO_InitStructureure;
  119. 	UART_HandleTypeDef UART_HandleStructureure;
  120.  
  121. /HAL_UART_MspInit开始
  122.   __HAL_RCC_USART2_CLK_ENABLE();//使能USART2外设时钟
  123.   __HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
  124.  
  125. //串口引脚映射开始/
  126.   GPIO_InitStructureure.Pin = GPIO_PIN_0;     //选择第0脚,PA0是为USART2_TX
  127.   GPIO_InitStructureure.Mode = GPIO_MODE_AF_PP;            //复用功能推挽模式
  128.   GPIO_InitStructureure.Pull = GPIO_PULLUP;                //引脚上拉被激活
  129.   GPIO_InitStructureure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //引脚速度为最高速
  130.   GPIO_InitStructureure.Alternate = GPIO_AF9_USART2;       //将引脚复用为USART2
  131.   HAL_GPIO_Init(GPIOA, &GPIO_InitStructureure);
  132. 	//根据GPIO_InitStructureure结构变量指定的参数初始化GPIOA的外设寄存器
  133. 	//将PA0初始化为USART2_TX
  134.  
  135.   GPIO_InitStructureure.Pin = GPIO_PIN_1;     //选择第1脚,PA1是USART2_RX
  136.   GPIO_InitStructureure.Mode = GPIO_MODE_AF_PP;            //复用功能推挽模式
  137.   GPIO_InitStructureure.Pull = GPIO_PULLUP;                //引脚上拉被激活
  138.   GPIO_InitStructureure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //引脚速度为最高速
  139.   GPIO_InitStructureure.Alternate = GPIO_AF9_USART2;       //将引脚复用为USART2
  140.   HAL_GPIO_Init(GPIOA, &GPIO_InitStructureure);
  141. 	//根据GPIO_InitStructureure结构变量指定的参数初始化GPIOA的外设寄存器
  142. 	//将PA1初始化为USART2_RX
  143. //串口引脚映射结束/
  144. /HAL_UART_MspInit结束
  145.  
  146.   UART_HandleStructureure.Instance          = USART2;              //接口为USART2
  147.   UART_HandleStructureure.Init.BaudRate     = baudrate;            //波特率为115200bps
  148.   UART_HandleStructureure.Init.WordLength   = UART_WORDLENGTH_8B;  //串口字长度为8
  149.   UART_HandleStructureure.Init.StopBits     = UART_STOPBITS_1;     //串口停止位为1位
  150.   UART_HandleStructureure.Init.Parity       = UART_PARITY_NONE;    //串口无需奇偶校验
  151.   UART_HandleStructureure.Init.HwFlowCtl    = UART_HWCONTROL_NONE; //串口无硬件流程控制
  152.   UART_HandleStructureure.Init.Mode         = UART_MODE_TX_RX;     //串口工作模式为发送和接收模式
  153. 	UART_HandleStructureure.AdvancedInit.AdvFeatureInit=UART_ADVFEATURE_NO_INIT;//不使用自动波特率
  154. //	UART_HandleStructureure.AdvancedInit.AdvFeatureInit=UART_ADVFEATURE_AUTOBAUDRATE_INIT;//使用自动波特率配置
  155. //	UART_HandleStructureure.AdvancedInit.AutoBaudRateEnable=UART_ADVFEATURE_AUTOBAUDRATE_ENABLE;//自动波特率使能
  156. //	UART_HandleStructureure.AdvancedInit.AutoBaudRateMode=UART_ADVFEATURE_AUTOBAUDRATE_ONSTARTBIT;//自动波特率模式
  157. 	HAL_UART_Init(&UART_HandleStructureure);
  158. 	//根据UART_HandleStructureure型结构初始化USART2
  159.  
  160.   __HAL_RCC_SYSCFG_CLK_ENABLE();//使能RCC外设时钟
  161. 	HAL_SYSCFG_DMA_Req(0x0807);
  162. 	//配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
  163. 	//DMA1_MAP[4:0]=7,将DMA通道1映射到USART2_TX
  164. 	//DMA2_MAP[4:0]=8,将DMA通道2映射到USART2_RX
  165.  
  166.   Usart2Send_DMA1_CH1_config();
  167. 	Usart2Receive_DMA1_CH2_config();
  168.  
  169. //  HAL_NVIC_SetPriority(USART2_IRQn, 0x01, 0);
  170. 	//设置串口2中断优先级为0x01,0无意义.USART2_IRQn表示中断源为串口2
  171.  
  172. //	__HAL_UART_ENABLE_IT(&UART_HandleStructureure, UART_IT_RXNE);
  173. 	开启串口接收中断
  174. 	//串口接收数据时,使能"接收数据寄存器不为空"则产生中断(位RXNE=1)
  175. 	//Enable the UART Data Register not empty Interrupt
  176.  
  177. 	__HAL_UART_DISABLE_IT(&UART_HandleStructureure, UART_IT_RXNE);
  178. 	//关闭串口接收中断
  179. 	//串口接收数据时,不使能"接收数据寄存器不为空"则产生中断(位RXNE=0)
  180. 	
  181. 	__HAL_UART_DISABLE_IT(&UART_HandleStructureure, UART_IT_TXE);
  182. 	//串口发送数据时,不使能"串口发送数据寄存器为空"产生中断(位TXE=0)
  183. 	//Disable the UART Transmit Complete Interrupt
  184.  
  185. 	__HAL_UART_DISABLE_IT(&UART_HandleStructureure,UART_IT_TC);
  186. 	//串口发送数据时,不使能"串口发送完成"产生中断(位TC=1)
  187. /在串口中断服务函数中发送数据配置结束//
  188.  
  189. //  HAL_NVIC_EnableIRQ(USART2_IRQn);
  190. 	//使能串口2中断
  191. 	//USART2_IRQn表示中断源为串口2
  192. 	
  193. }
  194. #endif
  195.  
  196. //重定义fputc函数
  197. //函数功能:发送ch的值给USART2串口
  198. int fputc(int ch, FILE *f)
  199. {
  200.   _HAL_UART_SendByte(USART2, (unsigned char) ch);
  201.   while( _HAL_UART_GET_FLAG(USART2,USART_SR_TC)!= SET); //等待发送完成标志位被置1	
  202. 	return ch;
  203. }
  204.  
  205. //函数功能:串口2发送一个字节
  206. void USART2_SendByte(  unsigned char ch )
  207. {
  208.   _HAL_UART_SendByte(USART2, (unsigned char) ch);
  209.   while( _HAL_UART_GET_FLAG(USART2,USART_SR_TC)!= SET); //等待发送完成标志位被置1
  210. }
  211.  
  212. void Usart2Send_DMA1_CH1_config(void)
  213. {
  214. 	DMA_HandleTypeDef hdma_usart2_tx;
  215.  
  216. 	__HAL_RCC_SYSCFG_CLK_ENABLE();//使能RCC外设时钟
  217. 	__HAL_RCC_DMA_CLK_ENABLE();   //使能DMA时钟
  218.  
  219. 	///配置串口DMA发送开始
  220. 	hdma_usart2_tx.DmaBaseAddress = DMA1;                //选择DMA1传输
  221.   hdma_usart2_tx.Instance = DMA1_Channel1;             //DMA1通道1
  222.   hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;//DMA传输方向:从内存到外设
  223.   hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;    //不使能外设地址增量
  224.   hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;        //使能内存地址增量
  225.   hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;//外设数据宽度为8位
  226.   hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;   //存储器数据宽度为8位
  227.   hdma_usart2_tx.Init.Mode = DMA_NORMAL;                        //DMA普通模式
  228.   hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;              //DMA通道1优先级为低
  229.   HAL_DMA_DeInit(&hdma_usart2_tx);
  230. 	HAL_DMA_Init(&hdma_usart2_tx);
  231. ///配置串口DMA发送结束
  232.  
  233. //	HAL_DMA_ChannelMap(&hdma_usart2_tx,DMA_CHANNEL_MAP_USART2_TX);
  234. 	//配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
  235. 	//DMA1_MAP[4:0]=7,将DMA通道1映射到USART2_TX
  236. }
  237.  
  238. void Usart2Receive_DMA1_CH2_config(void)
  239. {
  240. 	DMA_HandleTypeDef hdma_usart2_rx;
  241.  
  242. 	__HAL_RCC_SYSCFG_CLK_ENABLE();//使能RCC外设时钟
  243. 	__HAL_RCC_DMA_CLK_ENABLE();   //使能DMA时钟
  244.  
  245.   hdma_usart2_rx.DmaBaseAddress = DMA1;                //选择DMA1传输
  246.   hdma_usart2_rx.Instance = DMA1_Channel2;             //DMA1通道2
  247. //	HAL_DMA_ChannelMap(&hdma_usart2_rx,DMA_CHANNEL_MAP_USART2_RX);
  248. 	//配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
  249. 	//DMA2_MAP[4:0]=8,将DMA通道2映射到USART2_RX
  250.  
  251. 	///配置串口DMA接收开始
  252.   hdma_usart2_rx.DmaBaseAddress = DMA1;                //选择DMA1传输
  253.   hdma_usart2_rx.Instance = DMA1_Channel2;             //DMA1通道2
  254.   hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;//DMA传输方向:从外设到内存
  255.   hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;    //不使能外设地址增量
  256.   hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;        //使能内存地址增量
  257.   hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设数据宽度为8位
  258.   hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    //存储器数据宽度为8位
  259.   hdma_usart2_rx.Init.Mode = DMA_NORMAL;                         //DMA普通模式
  260.   hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;               //DMA通道2优先级为低
  261. 	HAL_DMA_DeInit(&hdma_usart2_rx);
  262. 	HAL_DMA_Init(&hdma_usart2_rx);
  263. ///配置串口DMA接收结束
  264. //	HAL_DMA_ChannelMap(&hdma_usart2_rx,DMA_CHANNEL_MAP_USART2_RX);
  265. 	//配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
  266. 	//DMA2_MAP[4:0]=8,将DMA通道2映射到USART2_RX
  267.  
  268. 	__HAL_DMA_DISABLE(&hdma_usart2_rx);
  269. 	//将"DMA通道x配置寄存器DMA_CCRx"中的EN=0,DMA通道x不使能
  270. //	My_DMA_SetConfig(&hdma_usart2_rx,(uint32_t)&USART2->DR,(uint32_t)&USART2_RX_Buffer,USART2_RX_Buffer_Size);
  271. 	My_DMA1_SetConfig(DMA1_Channel2,(uint32_t)&USART2->DR,(uint32_t)&USART2_RX_Buffer,USART2_RX_Buffer_Size,0);
  272. 	__HAL_DMA_ENABLE(&hdma_usart2_rx);
  273. 	//将"DMA通道x配置寄存器DMA_CCRx"中的EN=1,DMA通道x使能
  274.  
  275. 	_HAL_UART_CLEAR_FLAG(USART2,UART_FLAG_RXNE);
  276. 	SET_BIT(USART2->CR3, USART_CR3_DMAR);
  277. 	//将"串口控制寄存器3(USART_CR3)中的DMAR位"置1,接收时使能DMA
  278. 		
  279. 	USART2_RX_Buffer_StartIndex=USART2_RX_Buffer_Size-_HAL_DMA_Transfer_Number_Get(DMA1_Channel2);//读DMA1通道2剩余空间
  280. 	USART2_RX_Buffer_EndIndex=USART2_RX_Buffer_StartIndex;
  281. }
  282.  
  283. //函数功能:将USART2_TX_Buffer[]中的字符串通过"DMA通道1"写入串口发送寄存器
  284. void Usart2Send1(void)
  285. {
  286. 	DMA_HandleTypeDef hdma_usart2_tx;
  287.  
  288. 	///配置串口DMA发送开始
  289. 	hdma_usart2_tx.DmaBaseAddress = DMA1;                //选择DMA1传输
  290.   hdma_usart2_tx.Instance = DMA1_Channel1;             //DMA1通道1
  291.   hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;//DMA传输方向:从内存到外设
  292.  
  293.   __HAL_DMA_DISABLE(&hdma_usart2_tx);
  294. 	My_DMA_SetConfig(&hdma_usart2_tx, (uint32_t)&USART2_TX_Buffer,(uint32_t)&USART2->DR,strlen( (char*)USART2_TX_Buffer ));
  295. 	__HAL_DMA_ENABLE(&hdma_usart2_tx);
  296. 	//将"DMA通道x配置寄存器DMA_CCRx"中的EN=1,通道x使能
  297. 	_HAL_UART_CLEAR_FLAG(USART2,UART_FLAG_TC);
  298. 	SET_BIT(USART2->CR3, USART_CR3_DMAT);
  299. 	//将"串口控制寄存器3(USART_CR3)中的DMAT位"置1,发送时使能DMA
  300.  
  301. 	while( __HAL_DMA_GET_FLAG(&hdma_usart2_tx,DMA_FLAG_TC1) == RESET)
  302. 	{//等待"DMA通道1"传输完成
  303. 	}
  304. 	__HAL_DMA_CLEAR_FLAG(DMA1_Channel1,DMA_FLAG_TC1);
  305. 	//将"DMA中断标志位清除寄存器DMA_IFCR"中的CTCIF1=0,通道1传输完成标志清零
  306. }
  307.  
  308. //函数功能:将USART2_TX_Buffer[]中的字符串通过"DMA通道1"写入串口发送寄存器
  309. void Usart2Send(void)
  310. {
  311.   _HAL_DMA_DISABLE(DMA1_Channel1);
  312. 	//将"DMA通道1配置寄存器DMA_CCR1"中EN=0,DMA通道1不使能
  313. 	My_DMA1_SetConfig(DMA1_Channel1,(uint32_t)&USART2_TX_Buffer,(uint32_t)&USART2->DR,strlen( (char*)USART2_TX_Buffer),1);
  314. 	_HAL_DMA_ENABLE(DMA1_Channel1);
  315. 	//将"DMA通道1配置寄存器DMA_CCR1"中的EN=1,通道1使能
  316. 	_HAL_UART_CLEAR_FLAG(USART2,UART_FLAG_TC);
  317. 	SET_BIT(USART2->CR3, USART_CR3_DMAT);
  318. 	//将"串口控制寄存器3(USART_CR3)中的DMAT位"置1,发送时使能DMA
  319.  
  320. 	while( __HAL_DMA_GET_FLAG(DMA1,DMA_FLAG_TC1) == RESET)
  321. 	{//等待"DMA通道1"传输完成
  322. 	}
  323. 	__HAL_DMA_CLEAR_FLAG(DMA1_Channel1,DMA_FLAG_TC1);
  324. 	//将"DMA中断标志位清除寄存器DMA_IFCR"中的CTCIF1=0,通道1传输完成标志清零
  325. }
  326.  
  327. //函数功能:
  328. //将"串口接收寄存器"通过"DMA1通道2"写入USART2_RX_Buffer[]
  329. //接收完成后,将接收到的有效数据拷贝到USART2_RX1_Buffer[]中
  330. void Usart2Receive(void)
  331. {
  332. 	uint8_t i;
  333. 	uint8_t len_New;
  334. 	uint8_t len_Old;
  335.  
  336. 	len_New=_HAL_DMA_Transfer_Number_Get(DMA1_Channel2);//读"DMA1通道2"剩余空间
  337. 	len_Old=len_New;
  338. 	USART2_RX_Buffer_EndIndex=USART2_RX_Buffer_Size-len_Old;
  339. 	if(USART2_RX_Buffer_StartIndex!=USART2_RX_Buffer_EndIndex)//发现新数据
  340. 	{
  341. 	  for(i=0;i<10;i++)//查询是否接收完成
  342. 	  {
  343. 		  delay_us(100);
  344. 		  len_New=_HAL_DMA_Transfer_Number_Get(DMA1_Channel2);//读DMA1通道2剩余空间
  345. 		  if(len_New!=len_Old)//接收没有完成
  346. 		  {
  347. 			  len_Old=len_New;
  348. 			  i=0;
  349. 		  }
  350. 		  else//接收超时,表示DMA接收完成
  351. 			{
  352. 		    USART2_RX_Buffer_EndIndex=USART2_RX_Buffer_Size-len_Old;
  353. 		    //记录尾部
  354. 		    for(i=0;USART2_RX_Buffer_StartIndex!=USART2_RX_Buffer_EndIndex;)
  355. 		    {//将接收到的数据保存到USART2_RX1_Buffer[]中;
  356. 			    USART2_RX1_Buffer[i]=USART2_RX_Buffer[USART2_RX_Buffer_StartIndex];
  357. 			    i++;
  358. 			    USART2_RX_Buffer_StartIndex++;
  359. 		    }
  360. 		    USART2_RX1_Buffer[i]='\0';
  361.  
  362. 				i=11;//接收完成
  363. 			}
  364. 	  }
  365.  
  366. 	  strcpy((char*)USART2_TX_Buffer,(char*)USART2_RX1_Buffer);
  367. 	  Usart2Send();//将接收到的数据回传
  368.  
  369.     Usart2Receive_DMA1_CH2_config();//重新初始化串口到DMA接收
  370. 	}
  371. }
  1. #ifndef __USART2_H
  2. #define __USART2_H
  3.  
  4. #include "py32f0xx_hal.h"
  5.  
  6. #define USART2Type  1  //
  7.  
  8. #define _HAL_UART_SendByte(__INSTANCE__, __DATA__) (__INSTANCE__)->DR = ( (__DATA__) & (uint16_t)0x01FF );
  9. //将(__DATA__)写入串口发送缓冲区
  10.  
  11. #define _HAL_UART_ReceiveByte(__INSTANCE__) ( (uint16_t)( (__INSTANCE__)->DR & (uint16_t)0x01FF) )
  12. //读串口接收缓冲区
  13.  
  14. #define _HAL_UART_GET_FLAG(__INSTANCE__, __FLAG__) ( ( (__INSTANCE__)->SR & (__FLAG__) ) == (__FLAG__) )
  15. //读串口中断标志位
  16. //(__FLAG__)=UART_IT_RXNE,读"串口接收寄存器为非空时产生的中断标志位"
  17. //(__FLAG__)=UART_IT_PE,读"串口奇偶校验错误产生的中断标志位"
  18. //(__FLAG__)=UART_IT_ERR,读"帧错误、噪音错误和溢出错误时产生的中断标志位"
  19. //(__FLAG__)=UART_IT_TXE时,读"串口发送寄存器为空产生的中断标志位"
  20. //(__FLAG__)=UART_IT_TC时,读"发送完成产生的中断标志位"
  21.  
  22. #define _HAL_UART_CLEAR_FLAG(__INSTANCE__, __FLAG__) ( (__INSTANCE__)->SR = ~(__FLAG__) )
  23. //清除串口中断标志位
  24. //(__FLAG__)=UART_IT_RXNE,清除"串口接收寄存器为非空时产生的中断标志位"
  25. //(__FLAG__)=UART_IT_PE,清除"串口奇偶校验错误产生的中断标志位"
  26. //(__FLAG__)=UART_IT_ERR,清除"帧错误、噪音错误和溢出错误时产生的中断标志位"
  27. //(__FLAG__)=UART_IT_TXE时,清除"串口发送寄存器为空产生的中断标志位"
  28. //(__FLAG__)=UART_IT_TC时,清除"发送完成产生的中断标志位"
  29.  
  30. #define _HAL_UART_ENABLE_IT(__INSTANCE__, __INTERRUPT__)   ((((__INTERRUPT__) >> 28U) == UART_CR1_REG_INDEX)? ((__INSTANCE__)->CR1 |= ((__INTERRUPT__) & UART_IT_MASK)): \
  31.                                                            (((__INTERRUPT__) >> 28U) == UART_CR2_REG_INDEX)? ((__INSTANCE__)->CR2 |= ((__INTERRUPT__) & UART_IT_MASK)): \
  32.                                                            ((__INSTANCE__)->CR3 |= ((__INTERRUPT__) & UART_IT_MASK)))
  33. //设置串口中断使能位
  34. //(__INTERRUPT__)=UART_IT_RXNE,设置"串口接收寄存器为非空"时,使其产生中断
  35. //(__INTERRUPT__)=UART_IT_PE,设置"串口奇偶校验错误"时,使其产生中断
  36. //(__INTERRUPT__)=UART_IT_ERR,设置"帧错误、噪音错误和溢出错误"时,使其产生中断
  37. //(__INTERRUPT__)=UART_IT_TXE时,设置"串口发送寄存器为空"时,使其产生中断
  38. //(__INTERRUPT__)=UART_IT_TC时,设置"串口发送寄存器发送完成"时,使其产生中断
  39.  
  40. #define _HAL_UART_DISABLE_IT(__INSTANCE__, __INTERRUPT__)  ((((__INTERRUPT__) >> 28U) == UART_CR1_REG_INDEX)? ((__INSTANCE__)->CR1 &= ~((__INTERRUPT__) & UART_IT_MASK)): \
  41.                                                            (((__INTERRUPT__) >> 28U) == UART_CR2_REG_INDEX)? ((__INSTANCE__)->CR2 &= ~((__INTERRUPT__) & UART_IT_MASK)): \
  42.                                                            ((__INSTANCE__)->CR3 &= ~ ((__INTERRUPT__) & UART_IT_MASK)))
  43. //设置串口中断不使能
  44. //(__INTERRUPT__)=UART_IT_RXNE,设置"串口接收寄存器为非空"时,不使其产生中断
  45. //(__INTERRUPT__)=UART_IT_PE,设置"串口奇偶校验错误"时,不使其产生中断
  46. //(__INTERRUPT__)=UART_IT_ERR,设置"帧错误、噪音错误和溢出错误"时,不使其产生中断
  47. //(__INTERRUPT__)=UART_IT_TXE时,设置"串口发送寄存器为空"时,不使其产生中断
  48. //(__INTERRUPT__)=UART_IT_TC时,设置"串口发送寄存器发送完成"时,不使其产生中断
  49.  
  50.  
  51. #define USART2_TX_Buffer_Size 		      15
  52. extern uint8_t USART2_TX_Buffer[USART2_TX_Buffer_Size];
  53. extern uint8_t USART2_TX_Buffer_Send_Index;//USART2_TX_Buffer[]的发送索引值;
  54. extern uint8_t USART2_TX_Buffer_Load_Index;//USART2_TX_Buffer[]的装载索引值
  55. extern uint8_t USART2_TX_Completed_Flag;
  56. extern uint8_t USART2_TX_Overtime_Conter;//USART2发送超时计数器
  57.  
  58. #define USART2_RX_Buffer_Size 		      125
  59. extern  uint8_t USART2_RX_Buffer[USART2_RX_Buffer_Size]; //USART2接收缓冲区数组
  60. extern uint8_t USART1_RX_Buffer_StartIndex;//USART1_RX_Buffer[]的装载索引值
  61. extern uint8_t USART1_RX_Buffer_EndIndex;//USART1_RX_Buffer[]的装载索引值
  62.  
  63. #define USART2_RX1_Buffer_Size 		      125
  64. extern uint8_t USART2_RX1_Buffer[USART2_RX1_Buffer_Size]; //USART2接收缓冲区数组
  65.  
  66. extern void USART2_Init(uint32_t baudrate);
  67. extern void Usart2Send(void);
  68. extern void Usart2Receive(void);
  69. #endif /* __USART2_H */
  1. #include "My_DMA.h"
  2.  
  3. void My_DMA_SetConfig(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength);
  4. void My_DMA1_SetConfig(DMA_Channel_TypeDef *instance, uint32_t srcAddress, uint32_t dstAddress, uint32_t dataLength,uint8_t direction);
  5.  
  6. #define _HAL_DMA_CLEAR_FLAG(__INSTANCE__, __FLAG__) ( (__INSTANCE__)->IFCR |= (__FLAG__) )
  7. //清除串口中断标志位
  8. //(__FLAG__)=0x01,CGIF1=1,清除"通道1全局中断标志"
  9. //(__FLAG__)=0x10,CGIF2=1,清除"通道2全局中断标志"
  10. //(__FLAG__)=0x100,CGIF3=1,清除"通道3全局中断标志"
  11.  
  12. //SrcAddress:源数据地址
  13. //DstAddress:目的数据地址
  14. //DataLength:传输数据长度
  15. void My_DMA_SetConfig(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
  16. {
  17.   /* Clear all flags */
  18. 	if(hdma->Instance==DMA1_Channel1) hdma->ChannelIndex=0x01;
  19. 	if(hdma->Instance==DMA1_Channel2) hdma->ChannelIndex=0x04;
  20. 	if(hdma->Instance==DMA1_Channel3) hdma->ChannelIndex=0x08;
  21.  
  22.   hdma->DmaBaseAddress->IFCR = (DMA_ISR_GIF1 << hdma->ChannelIndex);
  23. 	//将"DMA中断标志位清除寄存器DMA_IFCR"中的CGIFx设置为1,将DMA通道x全局中断标志清零
  24.  
  25.   /* Configure DMA Channel data length */
  26.   hdma->Instance->CNDTR = DataLength;//传输数据长度
  27.  
  28.   /* Memory to Peripheral */
  29.   if((hdma->Init.Direction) == DMA_MEMORY_TO_PERIPH)//从内存向外设传输
  30.   {
  31.     /* Configure DMA Channel destination address */
  32.     hdma->Instance->CPAR = DstAddress;//目的数据地址
  33.  
  34.     /* Configure DMA Channel source address */
  35.     hdma->Instance->CMAR = SrcAddress;//源数据地址
  36.   }
  37.   /* Peripheral to Memory */
  38.   else//从外设向内存传输
  39.   {
  40.     /* Configure DMA Channel source address */
  41.     hdma->Instance->CPAR = SrcAddress;//源数据地址
  42.  
  43.     /* Configure DMA Channel destination address */
  44.     hdma->Instance->CMAR = DstAddress;//目的数据地址
  45.   }
  46. }
  47.  
  48.  
  49. //srcAddress:源数据地址
  50. //dstAddress:目的数据地址
  51. //dataLength:传输数据长度
  52. //direction>0,从内存向外设传输;direction=0,从外设向内存传输
  53. void My_DMA1_SetConfig(DMA_Channel_TypeDef *instance, uint32_t srcAddress, uint32_t dstAddress, uint32_t dataLength,uint8_t direction)
  54. {
  55. 	uint8_t ChannelIndex;
  56.   /* Clear all flags */
  57. 	if(instance==DMA1_Channel1) ChannelIndex=0x01;
  58. 	if(instance==DMA1_Channel2) ChannelIndex=0x04;
  59. 	if(instance==DMA1_Channel3) ChannelIndex=0x08;
  60.  
  61.   DMA1->IFCR = (DMA_ISR_GIF1 << ChannelIndex);
  62. 	//将"DMA中断标志位清除寄存器DMA_IFCR"中的CGIFx设置为1,将DMA通道x全局中断标志清零
  63.  
  64.   /* Configure DMA Channel data length */
  65.   instance->CNDTR = dataLength;//传输数据长度
  66.  
  67.   /* Memory to Peripheral */
  68.   if( direction )//从内存向外设传输
  69.   {
  70.     /* Configure DMA Channel destination address */
  71.     instance->CPAR = dstAddress;//目的数据地址
  72.  
  73.     /* Configure DMA Channel source address */
  74.     instance->CMAR = srcAddress;//源数据地址
  75.   }
  76.   /* Peripheral to Memory */
  77.   else//从外设向内存传输
  78.   {
  79.     /* Configure DMA Channel source address */
  80.     instance->CPAR = srcAddress;//源数据地址
  81.  
  82.     /* Configure DMA Channel destination address */
  83.     instance->CMAR = dstAddress;//目的数据地址
  84.   }
  85. }
  1. #ifndef __My_DMA_H
  2. #define __My_DMA_H
  3.  
  4. #include "py32f0xx_hal.h"
  5.  
  6. #define _HAL_DMA_ENABLE(__INSTANCE__)        ((__INSTANCE__)->CCR |= DMA_CCR_EN)
  7. //将"DMA通道x配置寄存器DMA_CCRx"中EN=1,DMA通道x使能
  8.  
  9. #define _HAL_DMA_DISABLE(__INSTANCE__)       ((__INSTANCE__)->CCR &= ~DMA_CCR_EN)
  10. //将"DMA通道x配置寄存器DMA_CCRx"中EN=0,DMA通道x不使能
  11.  
  12. #define _HAL_DMA_Transfer_Number_Get(__INSTANCE__)       ( (__INSTANCE__)->CNDTR )
  13. //读DMA1通道x剩余空间
  14.  
  15. extern void My_DMA_SetConfig(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength);
  16. extern void My_DMA1_SetConfig(DMA_Channel_TypeDef *instance, uint32_t srcAddress, uint32_t dstAddress, uint32_t dataLength,uint8_t direction);
  17. #endif /* __My_DMA_H */
  1. #include "py32f0xx_hal.h"
  2. #include "SystemClock.h"
  3. #include "delay.h"
  4. #include "LED.h"
  5. #include "USART2.h"
  6. #include "stdio.h"  //getchar(),putchar(),scanf(),printf(),puts(),gets(),sprintf()
  7. #include "string.h" //使能strcpy(),strlen(),memset()
  8. #include "SystemClock.h"
  9.  
  10. const char CPU_Reset_REG[]="\r\nCPU reset!\r\n";
  11.  
  12. int main(void)
  13. {
  14. 	HSE_Config();
  15. //	HAL_Init();//systick初始化
  16.   delay_init();
  17. 	HAL_Delay(1000);
  18.  
  19. 	USART2_Init(115200);
  20. //PA0是为USART2_TX,PA1是USART2_RX
  21. //中断优先级为0x01
  22. //波特率为115200,数字为8位,停止位为1位,无奇偶校验,允许发送和接收数据,只允许接收中断,并使能串口
  23. //	printf("%s",CPU_Reset_REG);
  24. 	strcpy((char*)USART2_TX_Buffer,CPU_Reset_REG);
  25. 	Usart2Send();
  26.  
  27. 	TIM1_LED_Init();
  28. 	TIM3_LED_Init();
  29. 	TIM_LED_Init();
  30.  
  31.  
  32.   while (1)
  33.   {
  34. 		delay_ms(100);
  35. 		Usart2Receive();
  36. //	  strcpy((char*)USART2_TX_Buffer,"A234567890\r\n");
  37. //	  Usart2Send();
  38.   }
  39. }

三、测试结果

 四、不用HAL库DMA函数的目的

因为HAL库的DMA传输函数，需要将UART_HandleTypeDef，DMA_HandleTypeDef结构型数据申请为全局变量，才可以使用，太浪费内存了。
UART_HandleTypeDef UART_HandleStructureure;
DMA_HandleTypeDef hdma_usart2_tx;
DMA_HandleTypeDef hdma_usart2_rx;

实在太浪费了。
贴出官方的测试代码，以示如下：

  1. #include "USART2.h"
  2. #include "stdio.h"  //getchar(),putchar(),scanf(),printf(),puts(),gets(),sprintf()
  3. #include "string.h" //使能strcpy(),strlen(),memset()
  4.  
  5. //PA0 ------> USART2_TX
  6. //PA1 ------> USART2_RX
  7. UART_HandleTypeDef UART_HandleStructureure;
  8. DMA_HandleTypeDef hdma_usart2_tx;
  9. DMA_HandleTypeDef hdma_usart2_rx;
  10.  
  11. uint8_t aTxBuffer[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
  12. uint8_t aRxBuffer[12] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  13.  
  14. void USART2_Init(uint32_t baudrate);
  15. void USART2_Work(void);
  16.  
  17. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
  18. {
  19. 	GPIO_InitTypeDef  GPIO_InitStructureure;
  20.  
  21. 	if(huart->Instance==USART2)
  22. 	{
  23.     __HAL_RCC_USART2_CLK_ENABLE();//使能USART2外设时钟
  24.     __HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
  25. 		__HAL_RCC_SYSCFG_CLK_ENABLE();//使能RCC外设时钟
  26. 		__HAL_RCC_DMA_CLK_ENABLE();   //使能DMA时钟
  27.  
  28. //串口引脚映射开始/
  29.     GPIO_InitStructureure.Pin = GPIO_PIN_0;     //选择第0脚,PA0是为USART2_TX
  30.     GPIO_InitStructureure.Mode = GPIO_MODE_AF_PP;            //复用功能推挽模式
  31.     GPIO_InitStructureure.Pull = GPIO_PULLUP;                //引脚上拉被激活
  32.     GPIO_InitStructureure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //引脚速度为最高速
  33.     GPIO_InitStructureure.Alternate = GPIO_AF9_USART2;       //将引脚复用为USART2
  34.     HAL_GPIO_Init(GPIOA, &GPIO_InitStructureure);
  35. 	  //根据GPIO_InitStructureure结构变量指定的参数初始化GPIOA的外设寄存器
  36. 	  //将PA0初始化为USART2_TX
  37.  
  38.     GPIO_InitStructureure.Pin = GPIO_PIN_1;     //选择第1脚,PA1是USART2_RX
  39.     GPIO_InitStructureure.Mode = GPIO_MODE_AF_PP;            //复用功能推挽模式
  40.     GPIO_InitStructureure.Pull = GPIO_PULLUP;                //引脚上拉被激活
  41.     GPIO_InitStructureure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //引脚速度为最高速
  42.     GPIO_InitStructureure.Alternate = GPIO_AF9_USART2;       //将引脚复用为USART2
  43.     HAL_GPIO_Init(GPIOA, &GPIO_InitStructureure);
  44. 	  //根据GPIO_InitStructureure结构变量指定的参数初始化GPIOA的外设寄存器
  45. 	  //将PA1初始化为USART2_RX
  46. //串口引脚映射结束/
  47.  
  48.     HAL_NVIC_SetPriority(USART2_IRQn, 0, 1);
  49. 	  //设置串口2中断优先级为0x00,1无意义
  50.     HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 1);
  51. 	  //设置DMA1通道1中断优先级为0x00,1无意义
  52. 	  HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 1, 0);
  53. 	  //设置DMA1通道2和通道3中断优先级为0x01,0无意义
  54. 	}
  55. }
  56.  
  57. //函数功能:
  58. //PA0是为USART2_TX,PA1是USART2_RX
  59. //中断优先级为0x01
  60. //波特率为115200,数字为8位,停止位为1位,无奇偶校验,允许发送和接收数据,只允许接收中断,并使能串口
  61. void USART2_Init(uint32_t baudrate)
  62. {
  63.   UART_HandleStructureure.Instance          = USART2;              //接口为USART2
  64.   UART_HandleStructureure.Init.BaudRate     = baudrate;            //波特率为115200bps
  65.   UART_HandleStructureure.Init.WordLength   = UART_WORDLENGTH_8B;  //串口字长度为8
  66.   UART_HandleStructureure.Init.StopBits     = UART_STOPBITS_1;     //串口停止位为1位
  67.   UART_HandleStructureure.Init.Parity       = UART_PARITY_NONE;    //串口无需奇偶校验
  68.   UART_HandleStructureure.Init.HwFlowCtl    = UART_HWCONTROL_NONE; //串口无硬件流程控制
  69.   UART_HandleStructureure.Init.Mode         = UART_MODE_TX_RX;     //串口工作模式为发送和接收模式
  70. 	UART_HandleStructureure.AdvancedInit.AdvFeatureInit=UART_ADVFEATURE_NO_INIT;//不使用自动波特率
  71. //	UART_HandleStructureure.AdvancedInit.AdvFeatureInit=UART_ADVFEATURE_AUTOBAUDRATE_INIT;//使用自动波特率配置
  72. //	UART_HandleStructureure.AdvancedInit.AutoBaudRateEnable=UART_ADVFEATURE_AUTOBAUDRATE_ENABLE;//自动波特率使能
  73. //	UART_HandleStructureure.AdvancedInit.AutoBaudRateMode=UART_ADVFEATURE_AUTOBAUDRATE_ONSTARTBIT;//自动波特率模式
  74. 	HAL_UART_Init(&UART_HandleStructureure);
  75. 	//根据UART_HandleStructureure型结构初始化USART2
  76.  
  77. //	HAL_SYSCFG_DMA_Req(0x0807);
  78. 	//配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
  79. 	//DMA1_MAP[4:0]=7,将DMA通道1映射到USART2_TX
  80. 	//DMA2_MAP[4:0]=8,将DMA通道2映射到USART2_RX
  81.  
  82. 	hdma_usart2_tx.DmaBaseAddress = DMA1;                //选择DMA1传输
  83.   hdma_usart2_tx.Instance = DMA1_Channel1;             //DMA1通道1
  84.   hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;//DMA传输方向:从内存到外设
  85.   hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;    //不使能外设地址增量
  86.   hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;        //使能内存地址增量
  87.   hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;//外设数据宽度为8位
  88.   hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;   //存储器数据宽度为8位
  89.   hdma_usart2_tx.Init.Mode = DMA_NORMAL;                        //DMA普通模式
  90.   hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;              //DMA通道1优先级为低
  91. 	HAL_DMA_Init(&hdma_usart2_tx);
  92. 	__HAL_LINKDMA(&UART_HandleStructureure, hdmatx, hdma_usart2_tx);
  93.   //这里必须要连接DMA句柄
  94.   //令UART_HandleStructureure.hdmatx=&hdma_usart2_tx;//记录
  95.   //令hdma_usart2_tx.Parent=&UART_HandleStructureure;//记录
  96.  
  97.   hdma_usart2_rx.DmaBaseAddress = DMA1;                //选择DMA1传输
  98.   hdma_usart2_rx.Instance = DMA1_Channel2;             //DMA1通道2
  99.   hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;//DMA传输方向:从外设到内存
  100.   hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;    //不使能外设地址增量
  101.   hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;        //使能内存地址增量
  102.   hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设数据宽度为8位
  103.   hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    //存储器数据宽度为8位
  104.   hdma_usart2_rx.Init.Mode = DMA_NORMAL;                         //DMA普通模式
  105.   hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;               //DMA通道2优先级为低
  106. 	HAL_DMA_Init(&hdma_usart2_rx);
  107. 	__HAL_LINKDMA(&UART_HandleStructureure, hdmarx, hdma_usart2_rx);
  108.   //连接DMA句柄
  109. 	//令UART_HandleStructureure.hdmarx=&hdma_usart2_rx;//记录
  110. 	//令hdma_usart2_rx.Parent=&UART_HandleStructureure;//记录
  111. HAL_DMA_ChannelMap(&hdma_usart2_tx,DMA_CHANNEL_MAP_USART2_TX);
  112. HAL_DMA_ChannelMap(&hdma_usart2_rx,DMA_CHANNEL_MAP_USART2_RX);
  113.  
  114. //	HAL_SYSCFG_DMA_Req(0x0807);
  115. 	//配置"SYSCFG配置寄存器3(SYSCFG_CFGR3)"
  116. 	//DMA1_MAP[4:0]=7,将DMA通道1映射到USART2_TX
  117. 	//DMA2_MAP[4:0]=8,将DMA通道2映射到USART2_RX
  118.  
  119.   HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
  120.   HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
  121.   HAL_NVIC_EnableIRQ(USART2_IRQn);
  122. 	//使能串口2中断
  123. 	//USART2_IRQn表示中断源为串口2
  124. }
  125.  
  126. //重定义fputc函数
  127. //函数功能:发送ch的值给USART2串口
  128. int fputc(int ch, FILE *f)
  129. {
  130.   _HAL_UART_SendByte(USART2, (unsigned char) ch);
  131.   while( _HAL_UART_GET_FLAG(USART2,USART_SR_TC)!= SET); //等待发送完成标志位被置1	
  132. 	return ch;
  133. }
  134.  
  135. //函数功能:串口2发送一个字节
  136. void USART2_SendByte(  unsigned char ch )
  137. {
  138.   _HAL_UART_SendByte(USART2, (unsigned char) ch);
  139.   while( _HAL_UART_GET_FLAG(USART2,USART_SR_TC)!= SET); //等待发送完成标志位被置1
  140. }
  141.  
  142. void USART2_Work(void)
  143. {
  144.     /* 通过DMA方式接收数据 */
  145.     if (HAL_UART_Receive_DMA(&UART_HandleStructureure, (uint8_t *)aRxBuffer, 12) != HAL_OK)
  146.     {
  147.     }
  148.     /* 等待接收数据完成 */
  149.     while(HAL_UART_GetState(&UART_HandleStructureure) != HAL_UART_STATE_READY)
  150.     {}
  151.  
  152.     /* 通过DMA方式发送数据 */
  153.     if (HAL_UART_Transmit_DMA(&UART_HandleStructureure, (uint8_t *)aRxBuffer, 12) != HAL_OK)
  154.     {
  155.     }
  156.     /* 等待发送数据完成 */
  157.     while(HAL_UART_GetState(&UART_HandleStructureure) != HAL_UART_STATE_READY)
  158.     {}
  159. }
  160.  
  161. //DMA通道1负责串口发送
  162. void DMA1_Channel1_IRQHandler(void)
  163. {
  164. 	HAL_DMA_IRQHandler(&hdma_usart2_tx);
  165. //若为"DMA通道x半传输中断",则清除“DMA通道x半传输中断”标志位
  166. //若为“DMA通道x传输完成中断”,则清除“DMA通道x传输完成中断”标志位
  167. //若为"DMA通道x传输错误中断",则不使能"DMA通道x传输完成中断"、"DMA通道x半传输中断"和"通道x传输错误中断"，清除通道x全局中断标志
  168. //  HAL_DMA_IRQHandler(UART_HandleStructureure.hdmatx);
  169. }
  170.  
  171. //DMA通道2负责串口接收
  172. void DMA1_Channel2_3_IRQHandler(void)
  173. {
  174. 	HAL_DMA_IRQHandler(&hdma_usart2_rx);
  175. //若为"DMA通道x半传输中断",则清除“DMA通道x半传输中断”标志位
  176. //若为“DMA通道x传输完成中断”,则清除“DMA通道x传输完成中断”标志位
  177. //若为"DMA通道x传输错误中断",则不使能"DMA通道x传输完成中断"、"DMA通道x半传输中断"和"通道x传输错误中断"，清除通道x全局中断标志
  178. //  HAL_DMA_IRQHandler(UART_HandleStructureure.hdmarx);
  179. }
  180.  
  181. void USART2_IRQHandler(void)
  182. {
  183.   HAL_UART_IRQHandler(&UART_HandleStructureure);
  184. }

耗内存，占用FLASH较小。FLASH那么大，节省没啥用。思绪再三，还是修改掉。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/602499
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号