HC32L17x的LL驱动库之usart

#ifndef HC32L1XX_LL_UART_H_
#define HC32L1XX_LL_UART_H_

#ifdef __cplusplus
extern "C" {
#endif 
	
	#include "hc32l1xx.h"
	#include "hc32l1xx_ll_bus.h"
	#include "hc32l1xx_ll_rcc.h"
	///
	#define LL_USART_DIRECTION_TX					USART_SCON_REN_TX
	#define LL_USART_DIRECTION_TX_RX				USART_SCON_REN_TX_RX

	#define LL_USART_DATAWIDTH_8B					0x00000000U 
	
	#define LL_USART_STOPBITS_1						USART_SCON_STOPBIT_1BIT 
	#define LL_USART_STOPBITS_1_5					USART_SCON_STOPBIT_1BIT5 
	#define LL_USART_STOPBITS_2						USART_SCON_STOPBIT_2BIT 
													
	#define LL_USART_PARITY_NONE					USART_SCON_B8CONT_NONE   
	#define LL_USART_PARITY_EVEN					USART_SCON_B8CONT_EVEN   
	#define LL_USART_PARITY_ODD						USART_SCON_B8CONT_ODD  

	#define LL_USART_HWCONTROL_NONE					0x00000000U                          
	#define LL_USART_HWCONTROL_RTS					USART_SCON_RTSEN                     
	#define LL_USART_HWCONTROL_CTS					USART_SCON_CTSEN                     
	#define LL_USART_HWCONTROL_RTS_CTS				(USART_SCON_RTSEN | USART_SCON_CTSEN)

	#define LL_USART_OVERSAMPLING1_16				USART_SCON_OVER1_16       
	#define LL_USART_OVERSAMPLING1_8				USART_SCON_OVER1_8        
	#define LL_USART_OVERSAMPLING2_32				USART_SCON_OVER2_32       
	#define LL_USART_OVERSAMPLING2_16				USART_SCON_OVER2_16        
	
	///
	//函		数：
	//功		能：串口使能
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_Enable(USART_TypeDef* USARTx)
	{
		//SET_BIT(USARTx->CR1, USART_CR1_UE);
	}

	///
	//函		数：
	//功		能：串口不使能
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_Disable(USART_TypeDef* USARTx)
	{
		//CLEAR_BIT(USARTx->CR1, USART_CR1_UE);
	}

	///
	//函		数：
	//功		能：校验串口是否使能
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabled(USART_TypeDef* USARTx)
	{
		//return (READ_BIT(USARTx->CR1, USART_CR1_UE) == (USART_CR1_UE));
		return 0;
	}
	
	///
	//函		数：
	//功		能：使能接收
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_EnableDirectionRx(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_REN);
	}

	///
	//函		数：
	//功		能：不使能接收
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_DisableDirectionRx(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_REN);
	}

	///
	//函		数：
	//功		能：设置传输方向
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_SetTransferDirection(USART_TypeDef* USARTx, uint32_t TransferDirection)
	{
		MODIFY_REG(USARTx->SCON, USART_SCON_REN, TransferDirection);
	}

	///
	//函		数：
	//功		能：获取传输方向的配置
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_GetTransferDirection(USART_TypeDef* USARTx)
	{
		return (uint32_t)(READ_BIT(USARTx->SCON, USART_SCON_REN));
	}

	///
	//函		数：
	//功		能：设置校验位
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_SetParity(USART_TypeDef* USARTx, uint32_t Parity)
	{
		MODIFY_REG(USARTx->SCON, USART_SCON_B8CONT, Parity);
	}

	///
	//函		数：
	//功		能：获取校验位
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_GetParity(USART_TypeDef* USARTx)
	{
		return (uint32_t)(READ_BIT(USARTx->SCON, USART_SCON_B8CONT));
	}

	///
	//函		数：
	//功		能：设置数据宽度
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_SetDataWidth(USART_TypeDef* USARTx, uint32_t DataWidth)
	{
		//MODIFY_REG(USARTx->CR1, USART_CR1_M, DataWidth);
	}

	///
	//函		数：
	//功		能：获取数据宽度
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_GetDataWidth(USART_TypeDef* USARTx)
	{
		//qreturn (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_M));
		return 0;
	}

	///
	//函		数：
	//功		能：设置停止位
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_SetStopBitsLength(USART_TypeDef* USARTx, uint32_t StopBits)
	{
		MODIFY_REG(USARTx->SCON, USART_SCON_STOPBIT, StopBits);
	}

	///
	//函		数：
	//功		能：串口使能
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_GetStopBitsLength(USART_TypeDef* USARTx)
	{
		return (uint32_t)(READ_BIT(USARTx->SCON, USART_SCON_STOPBIT));
	}

	///
	//函		数：
	//功		能：串口使能
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_ConfigAsyncMode(USART_TypeDef* USARTx)
	{
		
	}

	///
	//函		数：
	//功		能：串口使能
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_ConfigSyncMode(USART_TypeDef* USARTx)
	{
		
	}

	///
	//函		数：
	//功		能：奇偶校验错误中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsActiveFlag_PE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SR, USART_SR_PE) == (USART_SR_PE));
	}

	///
	//函		数：
	//功		能：CTS中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsActiveFlag_CTS(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SR, USART_SR_CTSIF) == (USART_SR_CTSIF));
	}

	///
	//函		数：
	//功		能：帧错误中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsActiveFlag_FE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SR, USART_SR_FE) == (USART_SR_FE));
	}

	///
	//函		数：
	//功		能：接收完成中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsActiveFlag_RXNE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SR, USART_SR_RC) == (USART_SR_RC));
	}
	
	///
	//函		数：
	//功		能：发送完成中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsActiveFlag_TC(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SR, USART_SR_TC) == (USART_SR_TC));
	}

	///
	//函		数：
	//功		能：发送寄存器空中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsActiveFlag_TXE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SR, USART_SR_TXE) == (USART_SR_TXE));
	}

	///
	//函		数：
	//功		能：清除奇偶校验中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_ClearFlag_PE(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->CSR, USART_CSR_PE);
	}
	
	///
	//函		数：
	//功		能：清除CTS中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_ClearFlag_CTS(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->CSR, USART_CSR_CTSIF);
	}


	///
	//函		数：
	//功		能：清除帧错误中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_ClearFlag_FE(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->CSR, USART_CSR_FE);
	}

	///
	//函		数：
	//功		能：清除发送完成中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_ClearFlag_TC(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->CSR, USART_CSR_TC);
	}

	///
	//函		数：
	//功		能：清除接收完成中断标志
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_ClearFlag_RXNE(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->CSR, USART_CSR_RC);
	}

	///
	//函		数：
	//功		能：使能接收完成中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_EnableIT_RXNE(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_RCIE);
	}

	///
	//函		数：
	//功		能：使能发送完成中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_EnableIT_TC(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_TCIE);
	}

	///
	//函		数：
	//功		能：使能发送空中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_EnableIT_TXE(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_TXEIE);
	}
	
	///
	//函		数：
	//功		能：使能奇偶校验错误中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_EnableIT_PE(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_PEIE);
	}

	///
	//函		数：
	//功		能：使能帧错误中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline  void LL_USART_EnableIT_CTS(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_CTSIE);
	}

	///
	//函		数：
	//功		能：使能帧错误中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline  void LL_USART_EnableIT_FE(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_FEIE);
	}

	///
	//函		数：
	//功		能：不使能接收完成中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_DisableIT_RXNE(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_RCIE);
	}

	///
	//函		数：
	//功		能：不使能发送完成中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_DisableIT_TC(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_TCIE);
	}

	///
	//函		数：
	//功		能：不使能发送空中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_DisableIT_TXE(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_TXEIE);
	}

	///
	//函		数：
	//功		能：不使能奇偶校验错误中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_DisableIT_PE(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_PEIE);
	}

	///
	//函		数：
	//功		能：不使能CTS中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_DisableIT_CTS(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_CTSIE);
	}


	///
	//函		数：
	//功		能：不使能帧错误中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_DisableIT_FE(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_FEIE);
	}

	///
	//函		数：
	//功		能：校验是否使能接收完成中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabledIT_RXNE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_RCIE) == (USART_SCON_RCIE));
	}

	///
	//函		数：
	//功		能：校验是否使能发送完成中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabledIT_TC(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_TCIE) == (USART_SCON_TCIE));
	}

	///
	//函		数：
	//功		能：校验是否使能发送空中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabledIT_TXE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_TXEIE) == (USART_SCON_TXEIE));
	}

	///
	//函		数：
	//功		能：校验是否使能奇偶校验错误中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabledIT_PE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_PEIE) == (USART_SCON_PEIE));
	}

	///
	//函		数：
	//功		能：校验是否使能CTS中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabledIT_CTS(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_CTSIE) == (USART_SCON_CTSIE));
	}

	///
	//函		数：
	//功		能：校验是否使能帧错误中断
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabledIT_FE(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_FEIE) == (USART_SCON_FEIE));
	}

	///
	//函		数：
	//功		能：使能接收DMA
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_Enable_DMAReq_RX(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_DMARXEN);
	}

	///
	//函		数：
	//功		能：不使能接收DMA
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_Disable_DMAReq_RX(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_DMARXEN);
	}

	///
	//函		数：
	//功		能：校验是否使能接收DMA
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabled_DMAReq_RX(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_DMARXEN) == (USART_SCON_DMARXEN));
	}
	
	///
	//函		数：
	//功		能：使能发送DMA
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_Enable_DMAReq_TX(USART_TypeDef* USARTx)
	{
		SET_BIT(USARTx->SCON, USART_SCON_DMATXEN);
	}

	///
	//函		数：
	//功		能：不使能发送DMA
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_Disable_DMAReq_TX(USART_TypeDef* USARTx)
	{
		CLEAR_BIT(USARTx->SCON, USART_SCON_DMATXEN);
	}

	///
	//函		数：
	//功		能：校验是否使能发送DMA
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_IsEnabled_DMAReq_TX(USART_TypeDef* USARTx)
	{
		return (READ_BIT(USARTx->SCON, USART_SCON_DMATXEN) == (USART_SCON_DMATXEN));
	}

	///
	//函		数：
	//功		能：DMA获取寄存器地址
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_USART_DMA_GetRegAddr(USART_TypeDef* USARTx)
	{
		return ((uint32_t) & (USARTx->SBUF));
	}

	///
	//函		数：
	//功		能：接收8BIT数据
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint8_t LL_USART_ReceiveData8(USART_TypeDef* USARTx)
	{
		return (uint8_t)(USARTx->SBUF);
	}
	
	///
	//函		数：
	//功		能：发送8BIT数据
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_USART_TransmitData8(USART_TypeDef* USARTx, uint8_t Value)
	{
		USARTx->SBUF = Value;
	}
	
	//===结构体定义
	typedef struct
	{
		uint32_t BaudRate;
		uint32_t DataWidth;   
		uint32_t StopBits;  
		uint32_t Parity;  
		uint32_t TransferDirection;
		uint32_t HardwareFlowControl; 
		uint32_t OverSampling; 
	} LL_USART_InitTypeDef;

	//===函数定义
	uint8_t LL_USART_DeInit(USART_TypeDef* USARTx);
	void LL_USART_StructInit(LL_USART_InitTypeDef* USART_InitStruct);
	uint8_t LL_USART_Init(USART_TypeDef* USARTx, LL_USART_InitTypeDef* USART_InitStruct);

	///
#ifdef __cplusplus
}
#endif 

#endif /* HC32L1XX_LL_UART_H */

#include "hc32l1xx_ll_usart.h"

///
//函		数:
//功		能: 注销串口的初始化
//输入参	数:
//输出参	数:
//说		明:
//
uint8_t LL_USART_DeInit(USART_TypeDef* USARTx)
{
#ifdef UART0
	if (USARTx==UART0)
	{
		LL_PER0_GRP1_ForceReset(LL_PER0_GRP1_PERIPH_UART0);
		LL_PER0_GRP1_ReleaseReset(LL_PER0_GRP1_PERIPH_UART0);
		return 0;
	}
#endif

#ifdef UART1
	if (USARTx == UART1)
	{
		LL_PER0_GRP1_ForceReset(LL_PER0_GRP1_PERIPH_UART1);
		LL_PER0_GRP1_ReleaseReset(LL_PER0_GRP1_PERIPH_UART1);
		return 0;
	}
#endif

#ifdef UART2
	if (USARTx == UART2)
	{
		LL_PER1_GRP1_ForceReset(LL_PER1_GRP1_PERIPH_UART2);
		LL_PER1_GRP1_ReleaseReset(LL_PER1_GRP1_PERIPH_UART2);
		return 0;
	}
#endif

#ifdef UART3
	if (USARTx == UART3)
	{
		LL_PER1_GRP1_ForceReset(LL_PER1_GRP1_PERIPH_UART3);
		LL_PER1_GRP1_ReleaseReset(LL_PER1_GRP1_PERIPH_UART3);
		return 0;
	}
#endif
	return 1;
}

///
//函		数: 
//功		能: 
//输入参	数: 
//输出参	数: 
//说		明: 
//
void LL_USART_StructInit(LL_USART_InitTypeDef* USART_InitStruct)
{
	USART_InitStruct->BaudRate = 9600;
	USART_InitStruct->DataWidth = LL_USART_DATAWIDTH_8B;
	USART_InitStruct->StopBits = LL_USART_STOPBITS_1;
	USART_InitStruct->Parity = LL_USART_PARITY_NONE;
	USART_InitStruct->TransferDirection = LL_USART_DIRECTION_TX_RX;
	USART_InitStruct->HardwareFlowControl = LL_USART_HWCONTROL_NONE;
	USART_InitStruct->OverSampling = LL_USART_OVERSAMPLING1_16;
}

///
//函		数:
//功		能: 初始化串口,只支持HC32的串口模式1/3
//输入参	数:
//输出参	数:
//说		明:
//
uint8_t LL_USART_Init(USART_TypeDef* USARTx, LL_USART_InitTypeDef* USART_InitStruct)
{
	LL_RCC_TypeDef rccclock = { 0 };
	uint32_t scon = 0;
	double scnt = 0.0f;
	//---硬件流控制
	scon |= USART_InitStruct->HardwareFlowControl;
	//---停止位
	scon |= USART_InitStruct->StopBits;
	//---过采样率
	scon |= USART_InitStruct->OverSampling;
	//---判断校验位
	if (USART_InitStruct->Parity== LL_USART_PARITY_NONE)
	{
		//---工作模式为模式1
		scon |= USART_SCON_SM_MODE1;
	}
	else
	{
		//---工作模式为模式3
		scon |= USART_SCON_SM_MODE3;
	}	
	//---收发控制
	scon |= USART_InitStruct->TransferDirection;
	//---奇偶校验
	scon |= USART_InitStruct->Parity;
	//---将数据写入控制寄存器
	WRITE_REG(USARTx->SCON, scon);
	//---设置波特率
	if (USART_InitStruct->OverSampling==LL_USART_OVERSAMPLING1_16)
	{
		scon = 16;
	}
	else
	{
		scon = 8;
	}
	//---获取系统外设的时钟
	LL_RCC_GetSystemClocks(&rccclock);
	//---计算波特率
	scnt =(double)(rccclock.PCLK0) / scon;
	scnt/= USART_InitStruct->BaudRate;
	//---将数据写入波特率寄存器
	WRITE_REG(USARTx->SCNT, (uint16_t)(float)(scnt + 0.5f));
	return 0;
}