STM32：USART
1 前言
串口，即数据按位串行发送的通信接口协议，比如usart串行通讯协议；
usart全称universal synchronous asynchronous receiver transmitter通用同步异步接收发送器；
usart接口通过RX，TX，GND同其他设备相连；速率最高约4.5Mbps，波特率最高460800baud；
1.1 通讯名词
同步通讯：收发双方使用相同的时钟信号线进行通讯，数据传输效率高；
异步通讯：收发双方使用各自的时钟信号线进行通讯，通过起始位和停止位来确定收发数据，数据传输效率低；
异步指使用的是各自的时钟信号发生器；发送方发送的时候接收方没收到，数据就丢失了；处理信息还是要同时处理；
单工通讯：单向通讯，器件要么只发送数据，要么只接收数据；一条数据线工作，数据线不能分时复用收发；
双工通讯：双向通讯，器件可以发送数据，也可以接收数据；两条数据线工作；
半双工通讯：接口协议在同一时刻，只能发送数据或者接收数据；一条数据线工作，数据线分时复用收发；
全双工通讯：接口协议在同一时刻，发送数据的同时也可以接收数据；两条数据线工作；
1.3 波特率和比特率
波特率：每秒内传输的信号可变化次数，单位baud；顾名思义理解为每秒内信号可波动的次数；
比特率：每秒内传输的数据bit位数，单位bps；如果一个电平变化有6种状态，那么变化一次传输的是3bit数据；
对于单片机而言，每次传输数据不是0就是1，所以波动一次表示1bit数据，二进制传输的波特率等于比特率；
2 USART的帧格式
目前遇到过的串口协议都是1bit起始位，8bit数据位，1bit停止位，无校验位；
3 USART的寄存器
每个usart都有7个自己的寄存器，功能简略概括如下；搭配中文参考手册25.3小节的图248-usart功能框图理解；
其中，与串行通信协议相关的部分寄存器如下列出，也是常见usart协议使用到的寄存器部分；
3.1 DR数据寄存器工作框图
TXE置1表示TDR可写，也可理解为TDR未写入新数据；
RXNE置1表示RDR可读，也可理解为RDR未读出新数据；
TC置1表示TDR没有新的数据，且移位寄存器发送完毕，即全部数据帧发送完毕；
4 USART的代码
4.1 标准库封装
USART_TypeDef
/***lie in stm32f10x.h ***/
typedef struct
{
__IO uint16_t SR;
uint16_t RESERVED0;
__IO uint16_t DR;
uint16_t RESERVED1;
__IO uint16_t BRR;
uint16_t RESERVED2;
__IO uint16_t CR1;
uint16_t RESERVED3;
__IO uint16_t CR2;
uint16_t RESERVED4;
__IO uint16_t CR3;
uint16_t RESERVED5;
__IO uint16_t GTPR;
uint16_t RESERVED6;
} USART_TypeDef;
#define PERIPH_BASE ((uint32_t)0x40000000)
#define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
#define USART1_BASE (APB2PERIPH_BASE + 0x3800)
#define USART1 ((USART_TypeDef *) USART1_BASE)USART_InitTypeDef
/***stm32f10x_usart.h***/
typedef struct
{
uint32_t USART_BaudRate;
uint16_t USART_WordLength;
uint16_t USART_StopBits;
uint16_t USART_Parity;
uint16_t USART_Mode;
uint16_t USART_HardwareFlowControl;
} USART_InitTypeDef;
#define IS_USART_BAUDRATE(BAUDRATE) (((BAUDRATE) > 0) && ((BAUDRATE) < 0x0044AA21))
#define USART_WordLength_8b ((uint16_t)0x0000)
#define USART_WordLength_9b ((uint16_t)0x1000)
#define USART_StopBits_1 ((uint16_t)0x0000)
#define USART_StopBits_0_5 ((uint16_t)0x1000)
#define USART_StopBits_2 ((uint16_t)0x2000)
#define USART_StopBits_1_5 ((uint16_t)0x3000)
#define USART_Parity_No ((uint16_t)0x0000)
#define USART_Parity_Even ((uint16_t)0x0400)
#define USART_Parity_Odd ((uint16_t)0x0600)
#define USART_Mode_Rx ((uint16_t)0x0004)
#define USART_Mode_Tx ((uint16_t)0x0008)
/***这是CR1中的TE、RE位，收发器使能位；放在这里配置的；***/
#define USART_HardwareFlowControl_None ((uint16_t)0x0000)
#define USART_HardwareFlowControl_RTS ((uint16_t)0x0100)
#define USART_HardwareFlowControl_CTS ((uint16_t)0x0200)
#define USART_HardwareFlowControl_RTS_CTS ((uint16_t)0x0300)4.2 USART的库代码
USART_DeInit（）
void USART_DeInit(USART_TypeDef* USARTx)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
if (USARTx == USART1)
{
RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE);
}
else if (USARTx == USART2)
{
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE);
}
else if (USARTx == USART3)
{
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE);
}
else if (USARTx == UART4)
{
RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, DISABLE);
}
else
{
if (USARTx == UART5)
{
RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE);
}
}
}USART_Init（）
#define CR2_STOP_CLEAR_Mask ((uint16_t)0xCFFF) /*!< USART CR2 STOP Bits Mask */
#define CR1_CLEAR_Mask ((uint16_t)0xE9F3) /*!< USART CR1 Mask */
/***其中波特率代码的计算公式不知道为什么这么计算的，有空再补充；***/
void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)
{
uint32_t tmpreg = 0x00, apbclock = 0x00;
uint32_t integerdivider = 0x00;
uint32_t fractionaldivider = 0x00;
uint32_t usartxbase = 0;
RCC_ClocksTypeDef RCC_ClocksStatus;
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_BAUDRATE(USART_InitStruct->USART_BaudRate));
assert_param(IS_USART_WORD_LENGTH(USART_InitStruct->USART_WordLength));
assert_param(IS_USART_STOPBITS(USART_InitStruct->USART_StopBits));
assert_param(IS_USART_PARITY(USART_InitStruct->USART_Parity));
assert_param(IS_USART_MODE(USART_InitStruct->USART_Mode));
assert_param(IS_USART_HARDWARE_FLOW_CONTROL(USART_InitStruct->USART_HardwareFlowControl));
/* The hardware flow control is available only for USART1, USART2 and USART3 */
if (USART_InitStruct->USART_HardwareFlowControl != USART_HardwareFlowControl_None)
{
assert_param(IS_USART_123_PERIPH(USARTx));
}
usartxbase = (uint32_t)USARTx;
/*---------------------------- USART CR2 Configuration -----------------------*/
tmpreg = USARTx->CR2;
tmpreg &= CR2_STOP_CLEAR_Mask;
/***0xCFFF:1100 1111 1111 1111b，清0bit[13:12] CR2的停止位***/
tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits;
/* Write to USART CR2 */
USARTx->CR2 = (uint16_t)tmpreg;
/*---------------------------- USART CR1 Configuration -----------------------*/
tmpreg = USARTx->CR1;
tmpreg &= CR1_CLEAR_Mask;
/***0xE9F3:1110 1001 1111 0011b，掩码作用是清0 CR1的bit[12,10,9,3,2],
***[12]M字长位,[10]PCE (Parity control enable)校验控制使能, [9]PS (Parity selection)奇偶校验选择
***[3]TE发送器使能位,[2]RE接收器使能位;
***然后下面代码就配置上面的参数***/
tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity |
USART_InitStruct->USART_Mode;
USARTx->CR1 = (uint16_t)tmpreg;
/*---------------------------- USART CR3 Configuration -----------------------*/
tmpreg = USARTx->CR3;
/* Clear CTSE and RTSE bits */
tmpreg &= CR3_CLEAR_Mask;
/* Configure the USART HFC -------------------------------------------------*/
/* Set CTSE and RTSE bits according to USART_HardwareFlowControl value */
tmpreg |= USART_InitStruct->USART_HardwareFlowControl;
/* Write to USART CR3 */
USARTx->CR3 = (uint16_t)tmpreg;
/*---------------------------- USART BRR Configuration -----------------------*/
/* Configure the USART Baud Rate -------------------------------------------*/
RCC_GetClocksFreq(&RCC_ClocksStatus);
if (usartxbase == USART1_BASE)
{
apbclock = RCC_ClocksStatus.PCLK2_Frequency;
}
else
{
apbclock = RCC_ClocksStatus.PCLK1_Frequency;
}
/* Determine the integer part */
if ((USARTx->CR1 & CR1_OVER8_Set) != 0)
{
/* Integer part computing in case Oversampling mode is 8 Samples */
integerdivider = ((25 * apbclock) / (2 * (USART_InitStruct->USART_BaudRate)));
}
else /* if ((USARTx->CR1 & CR1_OVER8_Set) == 0) */
{
/* Integer part computing in case Oversampling mode is 16 Samples */
integerdivider = ((25 * apbclock) / (4 * (USART_InitStruct->USART_BaudRate)));
}
tmpreg = (integerdivider / 100) << 4;
/* Determine the fractional part */
fractionaldivider = integerdivider - (100 * (tmpreg >> 4));
/* Implement the fractional part in the register */
if ((USARTx->CR1 & CR1_OVER8_Set) != 0)
{
tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
}
else /* if ((USARTx->CR1 & CR1_OVER8_Set) == 0) */
{
tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
}
/* Write to USART BRR */
USARTx->BRR = (uint16_t)tmpreg;
}USART_StructInit（）
/***stm32f10x_usart.c 标准库提供的默认配置代码；***/
void USART_StructInit(USART_InitTypeDef* USART_InitStruct)
{
/* USART_InitStruct members default value */
USART_InitStruct->USART_BaudRate = 9600;
USART_InitStruct->USART_WordLength = USART_WordLength_8b;
USART_InitStruct->USART_StopBits = USART_StopBits_1;
USART_InitStruct->USART_Parity = USART_Parity_No ;
USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None;
}USART_Cmd（）
void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState != DISABLE)
{
/* Enable the selected USART by setting the UE bit in the CR1 register */
USARTx->CR1 |= CR1_UE_Set;
}
else
{
/* Disable the selected USART by clearing the UE bit in the CR1 register */
USARTx->CR1 &= CR1_UE_Reset;
}
}USART_ITConfig（）
/***stm32f10x_usart.c ***/
/***usartreg[7:5],itpos[4:0]***/
#define USART_IT_PE ((uint16_t)0x0028) /***0000 0000 0010 1000b***/
#define USART_IT_TXE ((uint16_t)0x0727) /***0000 0111 0010 0111b***/
#define USART_IT_TC ((uint16_t)0x0626) /***0000 0110 0010 0110b***/
#define USART_IT_RXNE ((uint16_t)0x0525) /***0000 0101 0010 0101b***/
#define USART_IT_IDLE ((uint16_t)0x0424) /***0000 0100 0010 0100***/
#define USART_IT_LBD ((uint16_t)0x0846) /***0000 1000 0100 0110b***/
#define USART_IT_CTS ((uint16_t)0x096A) /***0000 1001 0110 1010b***/
#define USART_IT_ERR ((uint16_t)0x0060) /***0000 0000 0110 0000b***/
#define USART_IT_ORE ((uint16_t)0x0360) /***0000 0011 0110 0000b***/
#define USART_IT_NE ((uint16_t)0x0260) /***0000 0010 0110 0000b***/
#define USART_IT_FE ((uint16_t)0x0160) /***0000 0001 0110 0000b***/
#define IS_USART_CONFIG_IT(IT) (((IT) == USART_IT_PE) || ((IT) == USART_IT_TXE) || \
((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \
((IT) == USART_IT_IDLE) || ((IT) == USART_IT_LBD) || \
((IT) == USART_IT_CTS) || ((IT) == USART_IT_ERR))
void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState)
{
uint32_t usartreg = 0x00, itpos = 0x00, itmask = 0x00;
uint32_t usartxbase = 0x00;
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_CONFIG_IT(USART_IT));
assert_param(IS_FUNCTIONAL_STATE(NewState));
/* The CTS interrupt is not available for UART4 and UART5 */
if (USART_IT == USART_IT_CTS)
{
assert_param(IS_USART_123_PERIPH(USARTx));
}
usartxbase = (uint32_t)USARTx;
/* Get the USART register index */
usartreg = (((uint8_t)USART_IT) >> 0x05);
/* Get the interrupt position */
itpos = USART_IT & IT_Mask;
itmask = (((uint32_t)0x01) << itpos);
if (usartreg == 0x01) /* The IT is in CR1 register */
{
usartxbase += 0x0C;
}
else if (usartreg == 0x02) /* The IT is in CR2 register */
{
usartxbase += 0x10;
}
else /* The IT is in CR3 register */
{
usartxbase += 0x14;
}
if (NewState != DISABLE)
{
*(__IO uint32_t*)usartxbase |= itmask;
}
else
{
*(__IO uint32_t*)usartxbase &= ~itmask;
}
}USART_SendData（）
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_DATA(Data));
/* Transmit Data */
USARTx->DR = (Data & (uint16_t)0x01FF);
}USART_ReceiveData（）
uint16_t USART_ReceiveData(USART_TypeDef* USARTx)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
/* Receive Data */
return (uint16_t)(USARTx->DR & (uint16_t)0x01FF);
}USART_GetFlagStatus（）
#define USART_FLAG_CTS ((uint16_t)0x0200)
#define USART_FLAG_LBD ((uint16_t)0x0100)
#define USART_FLAG_TXE ((uint16_t)0x0080)
#define USART_FLAG_TC ((uint16_t)0x0040)
#define USART_FLAG_RXNE ((uint16_t)0x0020)
#define USART_FLAG_IDLE ((uint16_t)0x0010)
#define USART_FLAG_ORE ((uint16_t)0x0008)
#define USART_FLAG_NE ((uint16_t)0x0004)
#define USART_FLAG_FE ((uint16_t)0x0002)
#define USART_FLAG_PE ((uint16_t)0x0001)
#define IS_USART_FLAG(FLAG) (((FLAG) == USART_FLAG_PE) || ((FLAG) == USART_FLAG_TXE) || \
((FLAG) == USART_FLAG_TC) || ((FLAG) == USART_FLAG_RXNE) || \
((FLAG) == USART_FLAG_IDLE) || ((FLAG) == USART_FLAG_LBD) || \
((FLAG) == USART_FLAG_CTS) || ((FLAG) == USART_FLAG_ORE) || \
((FLAG) == USART_FLAG_NE) || ((FLAG) == USART_FLAG_FE))
FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG)
{
FlagStatus bitstatus = RESET;
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_FLAG(USART_FLAG));
/* The CTS flag is not available for UART4 and UART5 */
if (USART_FLAG == USART_FLAG_CTS)
{
assert_param(IS_USART_123_PERIPH(USARTx));
}
if ((USARTx->SR & USART_FLAG) != (uint16_t)RESET)
{
bitstatus = SET;
}
else
{
bitstatus = RESET;
}
return bitstatus;
}USART_ClearFlag（）
#define IS_USART_CLEAR_FLAG(FLAG) ((((FLAG) & (uint16_t)0xFC9F) == 0x00) && ((FLAG) != (uint16_t)0x00))
/***0xFC9F:1111 1100 1001 1111b; FLAG:bit[9,8,6,5];***/
void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_CLEAR_FLAG(USART_FLAG));
/* The CTS flag is not available for UART4 and UART5 */
if ((USART_FLAG & USART_FLAG_CTS) == USART_FLAG_CTS)
{
assert_param(IS_USART_123_PERIPH(USARTx));
}
USARTx->SR = (uint16_t)~USART_FLAG;
}USART_GetITStatus（）
ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT)
{
uint32_t bitpos = 0x00, itmask = 0x00, usartreg = 0x00;
ITStatus bitstatus = RESET;
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_GET_IT(USART_IT));
/* The CTS interrupt is not available for UART4 and UART5 */
if (USART_IT == USART_IT_CTS)
{
assert_param(IS_USART_123_PERIPH(USARTx));
}
/* Get the USART register index */
usartreg = (((uint8_t)USART_IT) >> 0x05);
/* Get the interrupt position */
itmask = USART_IT & IT_Mask;
itmask = (uint32_t)0x01 << itmask;
if (usartreg == 0x01) /* The IT is in CR1 register */
{
itmask &= USARTx->CR1;
}
else if (usartreg == 0x02) /* The IT is in CR2 register */
{
itmask &= USARTx->CR2;
}
else /* The IT is in CR3 register */
{
itmask &= USARTx->CR3;
}
bitpos = USART_IT >> 0x08;
bitpos = (uint32_t)0x01 << bitpos;
bitpos &= USARTx->SR;
if ((itmask != (uint16_t)RESET)&&(bitpos != (uint16_t)RESET))
{
bitstatus = SET;
}
else
{
bitstatus = RESET;
}
return bitstatus;
}USART_DMACmd（）
/***配置CR3中的dma传输位，配合DMA_Init()使用；***/
#define USART_DMAReq_Tx ((uint16_t)0x0080)
#define USART_DMAReq_Rx ((uint16_t)0x0040)
#define IS_USART_DMAREQ(DMAREQ) ((((DMAREQ) & (uint16_t)0xFF3F) == 0x00) && ((DMAREQ) != (uint16_t)0x00))
void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_USART_DMAREQ(USART_DMAReq));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState != DISABLE)
{
/* Enable the DMA transfer for selected requests by setting the DMAT and/or
DMAR bits in the USART CR3 register */
USARTx->CR3 |= USART_DMAReq;
}
else
{
/* Disable the DMA transfer for selected requests by clearing the DMAT and/or
DMAR bits in the USART CR3 register */
USARTx->CR3 &= (uint16_t)~USART_DMAReq;
}
}4.2 USART1使用代码
usart.c
#include "usart.h"
u8 USART1_REV_BUF[256]; //接收缓存
u8 USART1_REV_CNT = 0; //接收字节计数
u8 USART1_REV_FLAG = 0; //收到\r\n
u8 USART2_REV_BUF[256];
u8 USART2_REV_CNT = 0;
u8 USART2_REV_FLAG = 0;
//usart1初始化之后，便可以通过串口读写了；
void usart1_init(u32 bound)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
//USART1外设中断配置
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//GPIO初始化 USART1_TX PA9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//GPIO初始化 USART1_RX PA10
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);
//USART1初始化
USART_InitStructure.USART_BaudRate = bound;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //CR1中的TE,RE
USART_Init(USART1, &USART_InitStructure);
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//CR1中的RXNEIE中断
USART_Cmd(USART1, ENABLE); //CR1中的UE使能
}
#if 1
//将想要通过串口发送的buff和buff长度传入即可，不用配置其他参数，函数执行完即发送完成；
void USART1_sendbuff(u8 *buf,u16 len)
{
u16 t;
for(t=0;t<len;t++)
{
USART_SendData(USART1,buf[t]);
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);
//等待TC硬件置1，则发送完毕，继续发送；；
}
}
#else
void USART1_sendbuff(u8 *buf,u16 len)
{
u16 t=0;
for(t=0;t<len;t++)
{
USART_SendData(USART1,buf[t]);
while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET)
;
}
}
#endif
void USART1_IRQHandler(void)
{
if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
{
USART1_REV_BUF[USART1_REV_CNT] =USART_ReceiveData(USART1);
USART1_REV_CNT++;
if( (USART1_REV_BUF[USART1_REV_CNT-2]==0x0d) && (USART1_REV_BUF[USART1_REV_CNT-1]==0x0a) )
{
USART1_REV_FLAG = 1;
printf(" IRQ USART1_REV_FLAG \r\n");
}
}
//详见<中文参考手册>25.3.3 字符接收小节
if(USART_GetFlagStatus(USART1,USART_FLAG_ORE) == SET)
{
printf("USART_FLAG_ORE \r\n");
USART_ReceiveData(USART1);
//USART_ClearFlag(USART1,USART_FLAG_ORE);
//先读SR,后读DR，可以复位ORE位；但是前面有个bug可能是卡在这里了，注释掉等下次出现再看看；
}
}
/***等待上位机发送/r/n后，USART1_REV_FLAG置1，然后回发数据；***/
void usart1_receive_test(int bound)
{
usart1_init(bound);
while(1)
{
if(USART1_REV_FLAG)
{
USART1_REV_FLAG = 0;
printf( "USART1_REV_FLAG 1 \r\n");
USART1_sendbuff(USART1_REV_BUF,USART1_REV_CNT);
USART1_REV_CNT = 0;
}
}
}main.c
#include "main.h"
int main(void)
{
usart1_receive_test(115200);
}4.2.1 不使用RXNEIE中断的串口收发
/***不使能RXNEIE，使能CR1中的UE、TE和RE之后，usart也可以正常工作了，直接通过对SR状态寄存器的读取来收发也是可以的
***因为没有使用中断，所以不配置NVIC，串口也可以使用***/main.c
#include "main.h"
int main(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
//NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE);
//NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
//USART1外设中断配置
//NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
//NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;
//NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
//NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//NVIC_Init(&NVIC_InitStructure);
//GPIO初始化 USART1_TX PA9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//GPIO初始化 USART1_RX PA10
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//USART1初始化
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //CR1中的TE,RE
USART_Init(USART1, &USART_InitStructure);
//USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//CR1中的RXNEIE中断
USART_Cmd(USART1, ENABLE); //CR1中的UE使能
while(1)
{
if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET)
{
USART1_REV_BUF[USART1_REV_CNT] =USART_ReceiveData(USART1);
USART1_REV_CNT++;
if( (USART1_REV_BUF[USART1_REV_CNT-2]==0x0d) && (USART1_REV_BUF[USART1_REV_CNT-1]==0x0a) )
{
USART1_REV_FLAG = 1;
printf(" IRQ USART1_REV_FLAG \r\n";
}
}
if(USART1_REV_FLAG)
{
u16 t;
for(t=0;t<USART1_REV_CNT;t++)
{
USART_SendData(USART1,USART1_REV_BUF[t]);
while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET)
;
//等待TXE硬件置1；
}
USART1_REV_FLAG = 0;
USART1_REV_CNT = 0;
}
}
}5 重定向printf（）
fputc（）
#if 1
/***
***半主机模式就是半独立的主机模式，是单片机的一种功能；为什么是半独立的呢？
***因为它没有自己配套的输入输出设备，需要和其他主机通信，借用其他主机配套的输入输出设备显示；
***那该怎么使用半主机模式呢？通过仿真器连接其他主机，代码中应该就可以直接使用printf和scanf了；
***
***printf和scanf属于"stdio.h"库函数；stdio.h库属于microLIB库；
***#pragma import(__use_no_semihosting)禁用半主机模式，你都禁用了还怎么调用fputc和fgetc呢？
***
***/
/***使用举例：
printf("enter byte:\r\n");
scanf("%d",&scan_num);
printf("%d",scan_num);***/
//#pragma import(__use_no_semihosting)
//上面这个定义和microLIB冲突，所以“勾选microLIB、#pregma”二选一；我选勾microLIB;
//Error: L6915E: Library reports error: __use_no_semihosting was requested, but a semihosting fgetc was linked in
//下面这些函数都是不使用mircoLIB时需要配置的函数，我使用microLIB注释掉好像也没什么问题；
//struct __FILE
//{
// int handle;
//};
//FILE __stdout;
//FILE __stdint;
//调用了库函数之后都会通过_sys_exit()退出库；
//void _sys_exit(int x)
//{
// x = x;
//}
int fputc(int ch, FILE *f)
{
while( !(USART1->SR&USART_FLAG_TXE) )
;
USART1->DR = (u8) ch;
return ch;
}
//编译没有问题，等待扫描的样子也有，但是数据不对，这个get函数跑不对有点离谱，先放着吧；
//所以这个代码scanf不能用，printf能用；
int fgetc(FILE *f)
{
while( !(USART1->SR&USART_FLAG_RXNE) )
;
return (u8)USART1->DR;
}
#endif6 RS232、RS485
usart使用TTL电平标准，抗干扰能力弱通常用于板间通信；所以又陆续制定了RS232、RS485电平标准的usart通讯；
RS232通讯、RS485通讯本质依旧是usart通讯，外加了电平转换芯片，然后换了数据线而已；
RS232协议：将usart的RX、TX、GND通过232电平转换芯片转换成232电平，实现板与板的板外通讯；
RS485协议：将usart的RX、TX、GND通过485电平转换芯片转换成485电平，实现板与板的板外通讯；
这个差分信号如何差分，起始电平是多少呢？是TX-RX呢，还是RX-TX呢？不管了，先放着吧；
7 总结
USART的功能没想到还挺多的，寄存器看起来就有些费时了，很多概念都是新的，不好理解，直接拉低了效率；
于是觉得这样不行，应该用什么看什么，用到再看，学海无涯，精力有限；
另外人家费心费力写好标准库不就是为了帮开发人员省时间吗？了解一下即可，以后没必要深入；
2023-03-14如果不看寄存器就不会知道底层代码什么意思，虽然代码能跑但是不知道代码为什么能跑，少了点踏实感，至于效率拉低就拉低把；
本来是尝试直接在接收函数里将接收到的函数发送回去的；大概因为都是寄存器的操作，并且又是在中断函数里容易被中断打断；
所以不稳定，容易出现寄存器操作到一半被中断打断；读写序列打乱，导致程序丢帧或不能正常运行；
2023-03-14这个问题大概率是ORE的溢出错误，没有判断是否溢出，不过不容易重现；
关于NVIC中断优先级管理，占个坑；
