#include "usart-board.h"
#include "usart.h"


#define UART_LPUART1_BUFF_SIZE     	256  // 4853
#define UART_LPUART2_BUFF_SIZE     	2400 // gsm
#define UART_UART1_BUFF_SIZE     	256  // 4852
#define UART_UART2_BUFF_SIZE     	2048 // debbug
#define UART_UART3_BUFF_SIZE     	256  // 4852 
#define UART_UART4_BUFF_SIZE     	2400 // eth1
#define UART_UART5_BUFF_SIZE     	256  // 4851
#define UART_UART6_BUFF_SIZE     	256  // view



static char  s_lpuart1_buff[UART_LPUART1_BUFF_SIZE];
static char  s_lpuart2_buff[UART_LPUART2_BUFF_SIZE];
static char  s_uart1_buff[UART_UART1_BUFF_SIZE];
static char  s_uart2_buff[UART_UART2_BUFF_SIZE];
static char  s_uart3_buff[UART_UART3_BUFF_SIZE];
static char  s_uart4_buff[UART_UART4_BUFF_SIZE];
static char  s_uart5_buff[UART_UART5_BUFF_SIZE];
static char  s_uart6_buff[UART_UART6_BUFF_SIZE];


extern UART_HandleTypeDef hlpuart1;
extern UART_HandleTypeDef hlpuart2;
extern UART_HandleTypeDef huart1;
extern UART_HandleTypeDef huart2;
extern UART_HandleTypeDef huart3;
extern UART_HandleTypeDef huart4;
extern UART_HandleTypeDef huart5;
extern UART_HandleTypeDef huart6;

UartDrv_t g_DebugDrv = {	G0_UART2, 		115200, 	PARITY_DATA_8N1, 	s_uart2_buff, 	0, 	NULL,	0 }; // 调试串口驱动
UartDrv_t g_U4851Drv = {	G0_UART5,		115200,		PARITY_DATA_8N1,	s_uart5_buff,	0,	NULL,	0 }; // 4851 驱动
UartDrv_t g_U4852Drv = {	G0_UART3,		115200,		PARITY_DATA_8N1,	s_uart3_buff,	0,	NULL,	0 }; // 4852 驱动
UartDrv_t g_U4853Drv = {	G0_UART1,		115200,		PARITY_DATA_8N1,	s_uart1_buff,	0,	NULL,	0 }; // 4853 驱动
UartDrv_t g_ViewDrv  = {	G0_UART6,		115200,		PARITY_DATA_8N1,	s_uart6_buff,	0,	NULL,	0 }; // view 驱动
UartDrv_t g_ETH1Drv  = {	G0_UART4,		115200,		PARITY_DATA_8N1,	s_uart4_buff,	0,	NULL,	0 }; // 以太网通道1 驱动
UartDrv_t g_ETH2Drv  = {	G0_LPUART1,		115200,		PARITY_DATA_8N1,	s_lpuart1_buff,	0,	NULL,	0 }; // 以太网通道2 驱动
UartDrv_t g_GSMDrv   = {	G0_LPUART2,		115200,		PARITY_DATA_8N1,	s_lpuart2_buff,	0,	NULL,	0 }; // 4G模块 驱动
UartDrv_t g_LoRaDrv  = {	G0_UART3,		115200,		PARITY_DATA_8N1,	s_uart3_buff,	0,	NULL,	0 };  // LoRa 模块驱动


void MX_UART_TickHandle (void)
{
	// 调试串口
	if (g_DebugDrv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_DebugDrv.rxdone != NULL)
		{
			g_DebugDrv.rxdone();// 接受回调函数处理
		}
	}
	if (g_DebugDrv.rx_timer > 1)
		g_DebugDrv.rx_timer--;

	// 4851


	if (g_U4851Drv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_U4851Drv.rxdone != NULL)
		{
			g_U4851Drv.rxdone();// 接受回调函数处理
		}
	}
	if (g_U4851Drv.rx_timer > 1)
		g_U4851Drv.rx_timer--;
	// 4852
	if (g_U4852Drv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_U4852Drv.rxdone != NULL)
		{
			g_U4852Drv.rxdone();// 接受回调函数处理
		}
	}
	if (g_U4852Drv.rx_timer > 1)
		g_U4852Drv.rx_timer--;

	// 4853
	if (g_U4853Drv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_U4853Drv.rxdone != NULL)
		{
			g_U4853Drv.rxdone();// 接受回调函数处理
		}
	}
	if (g_U4853Drv.rx_timer > 1)
		g_U4853Drv.rx_timer--;
	// GSM
	if (g_GSMDrv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_GSMDrv.rxdone != NULL)
		{
			g_GSMDrv.rxdone();// 接受回调函数处理
		}
	}
	if (g_GSMDrv.rx_timer > 1)
		g_GSMDrv.rx_timer--;
	// ETH1
	if (g_ETH1Drv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_ETH1Drv.rxdone != NULL)
		{
			g_ETH1Drv.rxdone();// 接受回调函数处理
		}
	}
	if (g_ETH1Drv.rx_timer > 1)
		g_ETH1Drv.rx_timer--;
	// ETH2
	if (g_ETH2Drv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_ETH2Drv.rxdone != NULL)
		{
			g_ETH2Drv.rxdone();// 接受回调函数处理
		}
	}
	if (g_ETH2Drv.rx_timer > 1)
		g_ETH2Drv.rx_timer--;
	//VIEW
	if (g_ViewDrv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_ViewDrv.rxdone != NULL)
		{
			g_ViewDrv.rxdone();// 接受回调函数处理
		}
	}
	if (g_ViewDrv.rx_timer > 1)
		g_ViewDrv.rx_timer--;
	// LORA
	if (g_LoRaDrv.rx_timer == 2)  // 通过事件通知到业务app
	{
		if (g_LoRaDrv.rxdone != NULL)
		{
			g_LoRaDrv.rxdone();// 接受回调函数处理
		}
	}
	if (g_LoRaDrv.rx_timer > 1)
		g_LoRaDrv.rx_timer--;

}


/********************************************
 函数名称：UartInfoInit
 输入参数：串口句柄
 输出参数：NULL
 功能描述：初始化一个串口
********************************************/


void MX_UART_Init (UartDrv_t *drv)
{
	uint32_t Parity = NULL, WordLength = NULL;
	// 检验位
	if (drv->DataParity && PARITY_EVEN_MASK != 0)
	{
		Parity = UART_PARITY_EVEN;
	}
	else if (drv->DataParity && PARITY_ODD_MASK != 0)
	{
		Parity = UART_PARITY_ODD;
	}
	else
	{
		Parity = UART_PARITY_NONE;
	}
	// 数据位
	if (drv->DataParity && DATA8_MASK != 0)
	{
		WordLength =  UART_WORDLENGTH_7B;
	}
	else
	{
		WordLength =  UART_WORDLENGTH_8B;
	}
	switch (drv->Id)
	{
	case G0_LPUART1:  // ETH2
	{
		hlpuart1.Instance = LPUART1;
		hlpuart1.Init.BaudRate = drv->BaudRate;
		hlpuart1.Init.WordLength = WordLength;
		hlpuart1.Init.Parity = Parity;
		hlpuart1.Init.StopBits = UART_STOPBITS_1;
		hlpuart1.Init.Mode = UART_MODE_TX_RX;
		hlpuart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		hlpuart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		hlpuart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		hlpuart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		hlpuart1.FifoMode = UART_FIFOMODE_DISABLE;
		if (HAL_UART_Init (&hlpuart1) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_DisableFifoMode (&hlpuart1) != HAL_OK)
		{
			Error_Handler();
		}
		__HAL_UART_ENABLE_IT (&hlpuart1, UART_IT_RXNE);
		break;
	}
	case G0_LPUART2 : // GSM
		hlpuart2.Instance = LPUART2;
		hlpuart2.Init.BaudRate = drv->BaudRate;
		hlpuart2.Init.WordLength = WordLength;
		hlpuart2.Init.Parity = Parity;
		hlpuart2.Init.StopBits = UART_STOPBITS_1;
		hlpuart2.Init.Mode = UART_MODE_TX_RX;
		hlpuart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		hlpuart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		hlpuart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		hlpuart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		hlpuart2.FifoMode = UART_FIFOMODE_DISABLE;
		if (HAL_UART_Init (&hlpuart2) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_DisableFifoMode (&hlpuart2) != HAL_OK)
		{
			Error_Handler();
		}
		__HAL_UART_ENABLE_IT (&hlpuart2, UART_IT_RXNE);
		break;
	case G0_UART1 : // 4853
		huart1.Instance = USART1;
		huart1.Init.BaudRate = drv->BaudRate;
		huart1.Init.WordLength = WordLength;
		huart1.Init.StopBits = UART_STOPBITS_1;
		huart1.Init.Parity = Parity;
		huart1.Init.Mode = UART_MODE_TX_RX;
		huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		huart1.Init.OverSampling = UART_OVERSAMPLING_16;
		huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		if (HAL_UART_Init (&huart1) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetTxFifoThreshold (&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetRxFifoThreshold (&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_DisableFifoMode (&huart1) != HAL_OK)
		{
			Error_Handler();
		}
		break;
	case G0_UART2:   // debug
		huart2.Instance = USART2;
		huart2.Init.BaudRate = drv->BaudRate;
		huart2.Init.WordLength = WordLength;
		huart2.Init.StopBits = UART_STOPBITS_1;
		huart2.Init.Parity = Parity;
		huart2.Init.Mode = UART_MODE_TX_RX;
		huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		huart2.Init.OverSampling = UART_OVERSAMPLING_16;
		huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		// 初始化串口
		if (HAL_UART_Init (&huart2) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetTxFifoThreshold (&huart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetRxFifoThreshold (&huart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_DisableFifoMode (&huart2) != HAL_OK)
		{
			Error_Handler();
		}
		// 使能串口接受中断，用于接受数据
		__HAL_UART_ENABLE_IT (&huart2, UART_IT_RXNE);
		break;
	case G0_UART3:   // 4852
		huart3.Instance = USART3;
		huart3.Init.BaudRate = drv->BaudRate;
		huart3.Init.WordLength = WordLength;
		huart3.Init.StopBits = UART_STOPBITS_1;
		huart3.Init.Parity = Parity;
		huart3.Init.Mode = UART_MODE_TX_RX;
		huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		huart3.Init.OverSampling = UART_OVERSAMPLING_16;
		huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		if (HAL_UART_Init (&huart3) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetTxFifoThreshold (&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_SetRxFifoThreshold (&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
		{
			Error_Handler();
		}
		if (HAL_UARTEx_DisableFifoMode (&huart3) != HAL_OK)
		{
			Error_Handler();
		}
		__HAL_UART_ENABLE_IT (&huart3, UART_IT_RXNE);
		break;
	case G0_UART4:  // ETH1
		huart4.Instance = USART4;
		huart4.Init.BaudRate = drv->BaudRate;
		huart4.Init.WordLength = WordLength;
		huart4.Init.StopBits = UART_STOPBITS_1;
		huart4.Init.Parity = Parity;
		huart4.Init.Mode = UART_MODE_TX_RX;
		huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		huart4.Init.OverSampling = UART_OVERSAMPLING_16;
		huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		if (HAL_UART_Init (&huart4) != HAL_OK)
		{
			Error_Handler();
		}
		/* USER CODE BEGIN USART4_Init 2 */
		__HAL_UART_ENABLE_IT (&huart4, UART_IT_RXNE);
		break;
	case G0_UART5:  // 4851
		huart5.Instance = USART5;
		huart5.Init.BaudRate = drv->BaudRate;
		huart5.Init.WordLength = WordLength;
		huart5.Init.StopBits = UART_STOPBITS_1;
		huart5.Init.Parity = Parity;
		huart5.Init.Mode = UART_MODE_TX_RX;
		huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		huart5.Init.OverSampling = UART_OVERSAMPLING_16;
		huart5.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		huart5.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		huart5.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		if (HAL_UART_Init (&huart5) != HAL_OK)
		{
			Error_Handler();
		}
		/* USER CODE BEGIN USART5_Init 2 */
		__HAL_UART_ENABLE_IT (&huart5, UART_IT_RXNE);
		break;
	case G0_UART6:  // View
		huart6.Instance = USART6;
		huart6.Init.BaudRate = drv->BaudRate;
		huart6.Init.WordLength = WordLength;
		huart6.Init.StopBits = UART_STOPBITS_1;
		huart6.Init.Parity = Parity;
		huart6.Init.Mode = UART_MODE_TX_RX;
		huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
		huart6.Init.OverSampling = UART_OVERSAMPLING_16;
		huart6.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
		huart6.Init.ClockPrescaler = UART_PRESCALER_DIV1;
		huart6.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
		if (HAL_UART_Init (&huart6) != HAL_OK)
		{
			Error_Handler();
		}
		__HAL_UART_ENABLE_IT (&huart6, UART_IT_RXNE);
		break;
	default:
		break;
	}
}



void MX_UART_IRQHandle (void)
{
	uint8_t ret;
	if (USART3->ISR & (1 << 5)) // 串口2
	{
		ret = USART3->RDR;
		if (g_U4852Drv.rx_buffer != NULL)
		{
			g_U4852Drv.rx_buffer[g_U4852Drv.rx_size++] = ret;
			g_U4852Drv.rx_timer = 30;  // 30ms
			if (g_U4852Drv.rx_size > UART_UART3_BUFF_SIZE)
				g_U4852Drv.rx_size = 0;
		}
	}
	if (USART2->ISR & (1 << 5)) // 串口2
	{
		ret = USART2->RDR;
		if (g_DebugDrv.rx_buffer != NULL)
		{
			g_DebugDrv.rx_buffer[g_DebugDrv.rx_size++] = ret;
			g_DebugDrv.rx_timer = 30;  // 30ms
			if (g_DebugDrv.rx_size > UART_UART2_BUFF_SIZE)
				g_DebugDrv.rx_size = 0;
		}
	}
	if (USART4->ISR & (1 << 5))
	{
		ret = USART4->RDR;
		if (g_ETH1Drv.rx_buffer != NULL)
		{
			g_ETH1Drv.rx_buffer[g_ETH1Drv.rx_size++] = ret;
			g_ETH1Drv.rx_timer = 30;  // 30ms
			if (g_ETH1Drv.rx_size > UART_UART4_BUFF_SIZE)
				g_ETH1Drv.rx_size = 0;
		}
	}
	if (USART5->ISR & (1 << 5))
	{
		ret = USART5->RDR;
		if (g_U4851Drv.rx_buffer != NULL)
		{
			g_U4851Drv.rx_buffer[g_U4851Drv.rx_size++] = ret;
			g_U4851Drv.rx_timer = 30;  // 30ms
			if (g_U4851Drv.rx_size > UART_UART5_BUFF_SIZE)
				g_U4851Drv.rx_size = 0;
		}
	}
	if (USART6->ISR & (1 << 5))
	{
		ret = USART6->RDR;
		if (g_ViewDrv.rx_buffer != NULL)
		{
			g_ViewDrv.rx_buffer[g_ViewDrv.rx_size++] = ret;
			g_ViewDrv.rx_timer = 30;  // 30ms
			if (g_ViewDrv.rx_size > UART_UART6_BUFF_SIZE)
				g_ViewDrv.rx_size = 0;
		}
	}

	if (LPUART1->ISR & (1 << 5))
	{
		ret = LPUART1->RDR;
		if (g_ETH2Drv.rx_buffer != NULL)
		{
			g_ETH2Drv.rx_buffer[g_ETH2Drv.rx_size++] = ret;
			g_ETH2Drv.rx_timer = 30;  // 30ms
			if (g_ETH2Drv.rx_size > UART_LPUART1_BUFF_SIZE)
				g_ETH2Drv.rx_size = 0;
		}
	}

	if (LPUART2->ISR & (1 << 5))
	{
		ret = LPUART2->RDR;
		if (g_GSMDrv.rx_buffer != NULL)
		{
			g_GSMDrv.rx_buffer[g_GSMDrv.rx_size++] = ret;
			g_GSMDrv.rx_timer = 30;  // 30ms
			if (g_GSMDrv.rx_size > UART_LPUART2_BUFF_SIZE)
				g_GSMDrv.rx_size = 0;
		}
	}
}


void MX_UART_Clear (UartDrv_t * drv)
{
	drv->rx_size = 0;
	drv->rx_timer = 0;
}

void MX_UART_PutChar (UartDrv_t * drv, char ch)
{
	switch (drv->Id)
	{
	case G0_LPUART1:
		HAL_UART_Transmit (&hlpuart1, (uint8_t *) &ch, 1, 1000);
		break;
	case G0_LPUART2:
		HAL_UART_Transmit (&hlpuart2, (uint8_t *) &ch, 1, 1000);
		break;
	case G0_UART1:
		HAL_UART_Transmit (&huart1, (uint8_t *) &ch, 1, 1000);
		break;
	case G0_UART2:
		HAL_UART_Transmit (&huart2, (uint8_t *) &ch, 1, 1000);
		break;
	case G0_UART3:
		HAL_UART_Transmit (&huart3, (uint8_t *) &ch, 1, 1000);
		break;
	case G0_UART4:
		HAL_UART_Transmit (&huart4, (uint8_t *) &ch, 1, 1000);
		break;
	case G0_UART5:
		HAL_UART_Transmit (&huart5, (uint8_t *) &ch, 1, 1000);
		break;
	case G0_UART6:
		HAL_UART_Transmit (&huart6, (uint8_t *) &ch, 1, 1000);
		break;
	default:
		break;
	}
}

void MX_UART_PutBuffer (UartDrv_t * drv, char *buff, int size)
{
	for (int i = 0; i < size; i++)
	{
		MX_UART_PutChar (drv, buff[i]);
	}
}

#include <stdarg.h>
#include <stdio.h>
// 重定义fputc函数
int fputc (int ch, FILE *f)
{
	HAL_UART_Transmit (&huart2, (uint8_t *) &ch, 1, 2000);
	return ch;
}