• PY32F003F18之DMA串口

    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那么大，节省没啥用。思绪再三，还是修改掉。

  • 相关阅读:
    2022年下半年 软件设计师 上午试卷（41题—75题）
    【Java中23种面试常考的设计模式之适配器模式(Adapter)---结构型模式】
    开源情报 (OSINT)
    JavaScript中的map()和forEach()方法有什么区别？
    Zookeeper：分布式过程协同技术
    元宇宙电商-NFG系统，是如何让数字藏品流通的？
    细节决定成败：探究Mybatis中javaType和ofType的区别
    win11和虚拟机上的ubuntu系统共享文件夹
    GNN Tensorflow packages
    工程水文学复习资料
  • 原文地址：https://blog.csdn.net/weixin_42550185/article/details/133079343