#include "SN_UART.h"
#include <stdio.h>

/*
文件名：SN_UART.c/.h
作者： SN_FAE_黄泽洪
免责声明：无版权，可随意传播和篡改，该代码仅供开发参考，如需使用请自行验证
本人不担负商业使用上带来的风险。
*/

/*
SN_UART 模块的使用方法

	SN_UART.h 文件中的： SN_PRINTF_DEFAULT 的宏定义  //默认使用UART1作为printf()  注释掉这行宏定义就使用UART2作为printf()

方法1：使用printf()  修改头文件中的宏定义，选择UART1 或是 UART2 作为printf接口
	int main(void){
			SN_SYSCLK_set(SYSCLK_48MHZ);
			std_delay_init();
		SN_UART_init(UART1,9600, UART1_RX_PA4 ,UART1_TX_PA3 );

		while(1){
				   std_delayms(500);
				   printf("CIU32F003,司诺电子一级代理\r\n");
			  }
			}

方法2：发送数组数据

	 uint8_t TX_BULL[8] = {1,2,3,4,5,6,7,8};

	 int main(void){

		   SN_SYSCLK_set(SYSCLK_48MHZ);
		   std_delay_init();
	   SN_UART_init(UART1,9600, UART1_RX_PA4 ,UART1_TX_PA3 );


			 while(1){
				std_delayms(500);
				SN_UART_TX_BULL(UART1,TX_BULL , 8);
			 }
		 }


方法3：接收数据到缓存数组中
	uint8_t RX_BULL[8] = {0};
		uint8_t val = 0;

	int main(void){

		  SN_SYSCLK_set(SYSCLK_48MHZ);
			std_delay_init();
	  SN_UART_init(UART1,9600, UART1_RX_PA4 ,UART1_TX_PA3 );
	  SN_UART_RX_BULL_set(UART1, RX_BULL ,8,NVIC_PRIO_2 );//设置缓冲区和缓冲区大小，并启动中断接收

	  while(1){
				//用户直接处理自己数组内容
					td_delayms(500);
					val = RX_BULL[0];
			}

		}

方法4：接收数据自己处理

	//用户自定义的处理函数
	void  fun(void){

		   RX_BULL[k++] = std_uart_rx_read_data(UART1);
		 std_gpio_toggle_pin(LED_GPIO_PORT, LED_PIN);
		if(k == 8){ k = 0;}
	   }

		 int main(void){
		  //处理串口设置
			SN_UART_init(UART1,9600, UART1_RX_PA4 ,UART1_TX_PA3 );
	  SN_UART_RX_CALL(UART1, fun, NVIC_PRIO_2 );	//UART1_CALL_FUN 是用户自己的代码处理逻辑

			while(1){};
		}


其他可用的std标准接口：
std_uart_overrun_disable(UART_t *uartx) //关闭ORE
std_uart_overrun_enable(UART_t *uartx)	//开启ORE

std_uart_cr1_interrupt_disable(UART_t *uartx, uint32_t interrupt) //关闭对应的中断
std_uart_cr1_interrupt_enable(UART_t *uartx, uint32_t interrupt)  //开启对应的中断

其他接口访问： #include "ciu32f003_std_uart.h"
*/

/*
该函数是KEIL C 提供的标准printf重定向
必须勾选Micro LIB
* @brief  重定向c库函数printf到串口，重定向后可使用printf函数
* @param  ch 待发送字符
* @retval ch 发送的字符
*/
#ifdef SN_PRINTF_DEFAULT
int fputc(int ch, FILE *f)
{
	/* 发送一个字节数据到串口 */
	std_uart_tx_write_data(UART1, (uint32_t)ch);
	/* 等待发送完毕 */
	while (!std_uart_get_flag(UART1, UART_FLAG_TXE))
		;
	return ch;
}

int fgetc(FILE *f)
{
	/* 等待接收完毕 */
	while (!std_uart_get_flag(UART1, UART_FLAG_RXNE))
		;
	return (int)std_uart_rx_read_data(UART2);
}

#else
int fputc(int ch, FILE *f)
{
	/* 发送一个字节数据到串口 */
	std_uart_tx_write_data(UART2, (uint32_t)ch);
	/* 等待发送完毕 */
	while (!std_uart_get_flag(UART2, UART_FLAG_TXE))
		;
	return ch;
}

int fgetc(FILE *f)
{
	/* 等待接收完毕 */
	while (!std_uart_get_flag(UART2, UART_FLAG_RXNE))
		;
	return (int)std_uart_rx_read_data(UART2);
}

#endif

// UARTx_IO列表
const uint32_t UARTX_IO_list[] =
	{
		// TX  UART1
		GPIO_PIN_3,
		GPIO_PIN_6,
		GPIO_PIN_7,
		GPIO_PIN_0,
		GPIO_PIN_4,
		GPIO_PIN_6,
		GPIO_PIN_0,
		// RX
		GPIO_PIN_2,
		GPIO_PIN_4,
		GPIO_PIN_7,
		GPIO_PIN_5,
		GPIO_PIN_7,
		// TX	UART2
		GPIO_PIN_4,
		GPIO_PIN_5,
		GPIO_PIN_6,
		// RX
		GPIO_PIN_3,
		GPIO_PIN_6,
		GPIO_PIN_2,

};

// 全局接收数组设定
uint8_t *G_UART1_BULL = NULL;
// 全局接收数组长度设定
uint8_t G_UART1_BULL_LEN = 0;
// 全局接收接口函数使用选择
uint8_t G_UART1_RX_FUN = 0;
// 全局接收函数指针
void (*UART1_RX_CALL)(void) = NULL;
// 全局ORE溢出函数指针
void (*UART1_ORE_CALL)(void) = NULL;

// 全局接收数组设定
uint8_t *G_UART2_BULL = NULL;
// 全局接收数组长度设定
uint8_t G_UART2_BULL_LEN = 0;
// 全局接收接口函数使用选择
uint8_t G_UART2_RX_FUN = 0;
// 全局接收函数指针
void (*UART2_RX_CALL)(void) = NULL;
// 全局ORE溢出函数指针
void (*UART2_ORE_CALL)(void) = NULL;

/*
函数：SN_UART1_init(uint32_t baudrate,uint16_t RX_IO,uint32_t TX_IO)

功能：初始化串口1

参数：UART1设备
		 @UART1
				 @UART2

参数：baudrate  波特率

参数：RX_IO  接收引脚IO

				 #UART1_RX_PA2
				 #UART1_RX_PA4
				 #UART1_RX_PA7
				 #UART1_RX_PB5
				 #UART1_RX_PB7

								 #UART2_TX_PA4
								 #UART2_TX_PA5
								 #UART2_TX_PB6

参数：TX_IO  发送硬件IO

				 #UART1_TX_PA3
								 #UART1_TX_PA6
								 #UART1_TX_PA7
								 #UART1_TX_PB0
								 #UART1_TX_PB4
								 #UART1_TX_PB6
								 #UART1_TX_PC0  (PC0该引脚需要修改选项字节之后才能使用，不推荐使用这个引脚)

								 #UART2_RX_PA3
								 #UART2_RX_PA6
								 #UART2_RX_PB2

返回值：无
*/

void SN_UART_init(UART_t *uartx, uint32_t baudrate, uint8_t RX_IO, uint8_t TX_IO)
{
	GPIO_t *GPIO_X = NULL;
	std_gpio_init_t gpio_config = {0};

	gpio_config.mode = GPIO_MODE_ALTERNATE;
	gpio_config.pull = GPIO_PULLUP;
	gpio_config.output_type = GPIO_OUTPUT_PUSHPULL;

	if (uartx == UART1)
	{
		// 设置TX

		if (TX_IO < 7)
		{
			if (TX_IO < 3)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOA);
				GPIO_X = GPIOA;
			}
			else if (TX_IO < 6)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOB);
				GPIO_X = GPIOB;
			}
			else if (TX_IO == 6)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOC);
				GPIO_X = GPIOC;
			}
		}
		gpio_config.pin = UARTX_IO_list[TX_IO];
		gpio_config.alternate = GPIO_AF1_UART1;
		std_gpio_init(GPIO_X, &gpio_config);

		// 设置RX
		GPIO_X = NULL;
		if (RX_IO > 7)
		{
			if (RX_IO < 10)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOA);
				GPIO_X = GPIOA;
				if (RX_IO == 9)
				{
					gpio_config.alternate = GPIO_AF5_UART1;
				}
			}
			else if (RX_IO < 12)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOB);
				GPIO_X = GPIOB;
			}
		}
		gpio_config.pin = UARTX_IO_list[RX_IO];
		std_gpio_init(GPIO_X, &gpio_config);
	}
	else
	{

		gpio_config.alternate = GPIO_AF5_UART2;

		// 设置TX
		if (TX_IO < 15)
		{
			if (TX_IO < 14)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOA);
				GPIO_X = GPIOA;
			}
			else if (TX_IO == 14)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOB);
				GPIO_X = GPIOB;
			}
		}
		gpio_config.pin = UARTX_IO_list[TX_IO];
		std_gpio_init(GPIO_X, &gpio_config);

		// 设置RX
		GPIO_X = NULL;

		if (RX_IO > 14)
		{
			if (RX_IO < 17)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOA);
				GPIO_X = GPIOA;
			}
			else if (RX_IO == 17)
			{
				std_rcc_gpio_clk_enable(RCC_PERIPH_CLK_GPIOB);
				GPIO_X = GPIOB;
			}
		}
		gpio_config.pin = UARTX_IO_list[RX_IO];
		std_gpio_init(GPIO_X, &gpio_config);
	}

	// 初始串口
	std_uart_init_t uart_confg = {0};

	/* UART 时钟使能 */
	if (uartx == UART1)
	{
		std_rcc_apb2_clk_enable(RCC_PERIPH_CLK_UART1);
	}
	else
	{
		std_rcc_apb1_clk_enable(RCC_PERIPH_CLK_UART2);
	}

	/* UART 初始化 */
	uart_confg.baudrate = baudrate;
	uart_confg.direction = UART_DIRECTION_SEND_RECEIVE;
	uart_confg.wordlength = UART_WORDLENGTH_8BITS;
	uart_confg.stopbits = UART_STOPBITS_1;
	uart_confg.parity = UART_PARITY_NONE;
	std_uart_init(uartx, &uart_confg);

	/* 使能UART */
	std_uart_enable(uartx);
}

/*
函数：SN_UART_TX_BULL(UART_t *uartx ,uint8_t * BULL , uint16_t BULL_LEN)

功能：通过UART发送一组数据

参数：UART1设备
		 @UART1
				 @UART2

参数：BULL 数据数组

参数：BULL_LEN 数据数组长度

*/

void SN_UART_TX_BULL(UART_t *uartx, uint8_t *BULL, uint16_t BULL_LEN)
{

	for (int i = 0; i < BULL_LEN; i++)
	{
		while (!std_uart_get_flag(uartx, UART_FLAG_TXE))
			;
		std_uart_tx_write_data(uartx, BULL[i]);
	}

	while (!std_uart_get_flag(uartx, UART_FLAG_TC))
		;
}

/*
函数：SN_UART1_RX_BULL_set(UART_t *uartx ,uint8_t * BULL,uint16_t BULL_LEN );

功能：设置自动接收的数组（缓冲区）  使用了该接口后就不能使用SN_UART1_RX_CALL（）

参数：UART1设备
		 @UART1
				 @UART2

参数：BULL                   数据数组

参数：BULL_LEN               长度大小

参数：NVIC_PRIO_X            中断优先级
			 @NVIC_PRIO_0   高
			 @NVIC_PRIO_1
			 @NVIC_PRIO_2
			 @NVIC_PRIO_3   低
返回：无

*/
void SN_UART_RX_BULL_set(UART_t *uartx, uint8_t *BULL, uint16_t BULL_LEN, uint16_t NVIC_PRIO_x)
{

	/* 配置UART1中断优先级以及使能UART1的NVIC中断 */
	if (uartx == UART1)
	{
		G_UART1_BULL = BULL;
		G_UART1_BULL_LEN = BULL_LEN;
		NVIC_SetPriority(UART1_IRQn, NVIC_PRIO_x);
		NVIC_EnableIRQ(UART1_IRQn);
	}
	else
	{
		G_UART2_BULL = BULL;
		G_UART2_BULL_LEN = BULL_LEN;
		NVIC_SetPriority(UART2_IRQn, NVIC_PRIO_x);
		NVIC_EnableIRQ(UART2_IRQn);
	}

	/* UART 使能中断接收 */
	std_uart_cr1_interrupt_enable(uartx, UART_CR1_INTERRUPT_RXNE);
}

/*
函数：SN_UART1_RX_CALL(UART_t *uartx, void (*UART1_CALL_FUN)(void),uint16_t NVIC_PRIO_x );

功能：用户自己处理中断接收处理 （使用了该接口后就不能使用 SN_UART1_RX_BULL_set（））

参数：UART1设备
		 @UART1
				 @UART2

参数：*UART1_CALL_FUN        自定义中断处理函数

参数：NVIC_PRIO_X            中断优先级
			 @NVIC_PRIO_0
			 @NVIC_PRIO_1
			 @NVIC_PRIO_2
			 @NVIC_PRIO_3
返回：无

*/
void SN_UART_RX_CALL(UART_t *uartx, void (*UART_CALL_FUN)(void), uint16_t NVIC_PRIO_x)
{

	/* 配置UART1中断优先级以及使能UART1的NVIC中断 */
	if (uartx == UART1)
	{

		NVIC_SetPriority(UART1_IRQn, NVIC_PRIO_x);
		NVIC_EnableIRQ(UART1_IRQn);
		UART1_RX_CALL = UART_CALL_FUN;
		G_UART1_RX_FUN = 1;
	}
	else
	{

		NVIC_SetPriority(UART2_IRQn, NVIC_PRIO_x);
		NVIC_EnableIRQ(UART2_IRQn);
		UART2_RX_CALL = UART_CALL_FUN;
		G_UART2_RX_FUN = 1;
	}
	/* UART 使能中断接收 */
	std_uart_cr1_interrupt_enable(uartx, UART_CR1_INTERRUPT_RXNE);
}

/*
函数：SN_UART_ORE_CALL(UART_t *uartx, void (*UART1_CALL_FUN)(void) );

功能：用户自己处理中断接收处理 （使用了该接口后就不能使用 SN_UART1_RX_BULL_set（））

参数：UART1设备
		 @UART1
				 @UART2

参数：*UART1_CALL_FUN        自定义中断处理函数

返回：无

*/
void SN_UART_ORE_CALL(UART_t *uartx, void (*UART_CALL_FUN)(void))
{

	if (uartx == UART1)
	{
		UART1_ORE_CALL = UART_CALL_FUN;
	}
	else
	{
		UART2_ORE_CALL = UART_CALL_FUN;
	}
}

// 中断处理--------------------------------------------------------------------
void UART1_IRQHandler(void)
{

	static uint16_t len = 0;

	if (std_uart_get_cr1_interrupt_enable(UART1, UART_CR1_INTERRUPT_RXNE) && std_uart_get_flag(UART1, UART_FLAG_RXNE))
	{
		std_uart_clear_flag(UART1, UART_FLAG_RXNE);

		if (G_UART1_RX_FUN)
		{

			UART1_RX_CALL(); // 用户自定义处理
		}
		else
		{

			G_UART1_BULL[len++] = std_uart_rx_read_data(UART1); // 默认处理
			if (len >= G_UART1_BULL_LEN)
			{
				len = 0;
			}
		}
	}

	// ORE中断
	if (std_uart_get_flag(UART1, UART_FLAG_ORE))
	{
		std_uart_clear_flag(UART1, UART_CLEAR_ORE);

		UART1_ORE_CALL();
	}
}

// 中断处理--------------------------------------------------------------------
void UART2_IRQHandler(void)
{

	static uint16_t len1 = 0;

	if (std_uart_get_cr1_interrupt_enable(UART2, UART_CR1_INTERRUPT_RXNE) && std_uart_get_flag(UART2, UART_FLAG_RXNE))
	{
		std_uart_clear_flag(UART2, UART_FLAG_RXNE);

		if (G_UART2_RX_FUN)
		{

			UART2_RX_CALL(); // 用户自定义处理
		}
		else
		{

			G_UART1_BULL[len1++] = std_uart_rx_read_data(UART2); // 默认处理
			if (len1 >= G_UART2_BULL_LEN)
			{
				len1 = 0;
			}
		}
	}

	// ORE中断
	if (std_uart_get_flag(UART2, UART_FLAG_ORE))
	{
		std_uart_clear_flag(UART2, UART_CLEAR_ORE);

		UART2_ORE_CALL();
	}
}

/*
函数名称：SN_UART_Deinit(uint8 UART_X)
参数： UART1
	   UART2

返回：无
*/

void SN_UART_Deinit(UART_t *uartx)
{

	std_uart_deinit(uartx);
	if (uartx == UART1)
	{
		std_rcc_apb2_clk_disable(RCC_PERIPH_CLK_UART1);
	}
	else if (uartx == UART2)
	{
		std_rcc_apb1_clk_disable(RCC_PERIPH_CLK_UART2);
	}
}