//********************************************************************
//  Ver 1.0
//  	2019.10.09  1、新建文件。
//  	2020.03.06  2、增加写入缓冲区数据时，复位串口超时计数
//********************************************************************
#include    "config.h"

UART_Str    UART_Info;

void    UART_ModeSet(USART_TypeDef* USARTx, INT8U ModeMask, INT8U Value)
{
    if (Value != 0)
    {
        USARTx->CR1 |= ((USART_Mode_Tx | USART_Mode_Rx) & ModeMask);
    }
    else
    {
        USARTx->CR1 &= ~((USART_Mode_Tx | USART_Mode_Rx) & ModeMask);
    }
}

INT8U   UART_Num(USART_TypeDef* USARTx)
{
    if(USARTx == USART1)        return(0);
    //else if(USARTx == USART2)   return(1);
    //else if(USARTx == USART3)   return(2);
    //else if(USARTx == USART4)   return(3);

    return((INT8U)USARTx);
}

//从串口发送数据
void    UART_SendChar(USART_TypeDef* USARTx, INT16U c)
{
    USART_ClearFlag(USARTx, USART_FLAG_TC);
	USART_SendData(USARTx,c);
	while (USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);
    USART_ClearFlag(USARTx, USART_FLAG_TC);
}

//向串口发送字符串
void    UART_SendString(USART_TypeDef* USARTx, uint8_t *s)
{
    while (*s != '\0')
    {
        UART_SendChar(USARTx, *s++);
    }
}

//写缓冲区
INT8U   UART_WriteBuff(USART_TypeDef* USARTx, INT8U *ptr, INT16U Len)
{
    INT16U  wrCnt;
    INT8U   UARTx=UART_Num(USARTx);

    if (UARTx > UART_SIZE)
    {
        return (0);
    }

    ATOMIC_Start();
    while (Len--)
    {
        wrCnt = (UART_Info.Uart[UARTx].wCnt + UART_Info.Uart[UARTx].wPtr) % UART_TX_BUFF_SIZE;
        UART_Info.Uart[UARTx].wBuff[wrCnt] = *ptr++; //写入一个字节
        if (UART_Info.Uart[UARTx].wCnt >= (UART_TX_BUFF_SIZE - 1))
        {
            UART_Info.Uart[UARTx].wPtr++;
            UART_Info.Uart[UARTx].wPtr%=UART_TX_BUFF_SIZE;
            break;
        }
        else
        {
            UART_Info.Uart[UARTx].wCnt++;
        }

        //ptr++;
    }
    ATOMIC_Stop();
	
	//RS485_TxEnable();
    USART_ITConfig(USARTx, USART_IT_TXE, ENABLE);
	

    return (1);
}

//读缓冲区
INT8U   UART_ReadBuff(USART_TypeDef* USARTx, INT8U *ptr, INT16U Len)
{
    INT8U   UARTx=UART_Num(USARTx);

    if (UARTx > UART_SIZE)
    {
        return (0);
    }

    ATOMIC_Start();
    while (Len--)
    {
        *ptr = UART_Info.Uart[UARTx].rBuff[UART_Info.Uart[UARTx].rPtr]; //写入一个字节

        if (UART_Info.Uart[UARTx].rPtr < (UART_RX_BUFF_SIZE - 1))
        {
            UART_Info.Uart[UARTx].rPtr++;
        }
        else
        {
            UART_Info.Uart[UARTx].rPtr = 0;
        }

        if (UART_Info.Uart[UARTx].rCnt == 0)
        {
            break;
        }
        else
        {
            UART_Info.Uart[UARTx].rCnt--;
        }

        ptr++;
    }
    ATOMIC_Stop();

    return (1);
}

void    UART_IdleCnt(void)
{
    INT8U i;

    for(i=0; i<UART_SIZE; i++)
    {
        if (UART_Info.Uart[i].Idle > 0)
        {
            UART_Info.Uart[i].Idle --;
        }
    }
}

INT8U    UART_IdleRest(USART_TypeDef* USARTx, INT16U Value)
{
	INT8U   UARTx=UART_Num(USARTx);
    
    if(UARTx > UART_SIZE) 
    {
        return(0);
    }
    
    UART_Info.Uart[UARTx].Idle=Value;
    
    return(1);
}

INT8U    UART_IdleState(USART_TypeDef* USARTx)
{
    INT8U   UARTx=UART_Num(USARTx);
    
    if(UARTx > UART_SIZE) 
    {
        return(0);
    }

    if(UART_Info.Uart[UARTx].Idle == 0)
    {
        return(1);
    }
    else
    {
        return(0);
    }
}

#if 0
int	fputc(int ch, FILE *f)
{
	while (USART_GetFlagStatus(PRINTF_UART, USART_FLAG_TXE) == RESET);
	USART_SendData(PRINTF_UART, (unsigned char)ch);
	return(ch);
}

int fgetc(FILE *f)
{
	while (USART_GetFlagStatus(PRINTF_UART, USART_FLAG_RXNE) == RESET);
	return(USART_ReceiveData(PRINTF_UART));
}

uint8_t USART_Scanf(uint32_t value)
{
	uint32_t index = 0;
	uint32_t tmp[2] = {0, 0};

	while (index < 2)
	{
		/* Loop until RXNE = 1 */
		while (USART_GetFlagStatus(PRINTF_UART, USART_FLAG_RXNE) == RESET)
		{
			NOP();
		}
		tmp[index++] = (USART_ReceiveData(PRINTF_UART));
		if ((tmp[index - 1] < 0x30) || (tmp[index - 1] > 0x39))
		{
			UART_SendString(PRINTF_UART, "\n\r Please enter valid number between 0 and 9 \n\r");
			index--;
		}
	}
	/* Calculate the Corresponding value */
	index = (tmp[1] - 0x30) + ((tmp[0] - 0x30) * 10);
	/* Checks */
	if (index > value)
	{
		UART_SendString(PRINTF_UART, "\n\r Please enter valid number between 0 and 59 \n\r");
		return 0xFF;
	}
	return index;
}
#endif

//UART1接收中断服务程序
void USART1_IRQHandler(void)
{
    INT16U wrCnt;

    UART_IdleRest(USART1, 10);

    if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);                 // 清除接收中断标志
        wrCnt = (UART_Info.Uart[0].rCnt + UART_Info.Uart[0].rPtr) % UART_RX_BUFF_SIZE;          //使用覆盖写入的方式
        UART_Info.Uart[0].rBuff[wrCnt] = USART_ReceiveData(USART1);                         // 读取数据
        if (UART_Info.Uart[0].rCnt < (UART_RX_BUFF_SIZE - 1))
        {
            UART_Info.Uart[0].rCnt++;
        }
        else
        {
            if (UART_Info.Uart[0].rPtr < (UART_RX_BUFF_SIZE - 1))
            {
                UART_Info.Uart[0].rPtr++;
            }
            else
            {
                UART_Info.Uart[0].rPtr = 0;
            }
        }
    }

    if (USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
    {
        USART_ClearITPendingBit(USART1, USART_IT_TXE);
        if (UART_Info.Uart[0].wCnt == 0) //发送数据已经完成，关闭发送使能中断
        {
            USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
        }
        else
        {
            USART_SendData(USART1, UART_Info.Uart[0].wBuff[UART_Info.Uart[0].wPtr]);  //取一个数据发送出去
            UART_Info.Uart[0].wCnt --;   //写入数据个数减1
            if (UART_Info.Uart[0].wPtr < (UART_TX_BUFF_SIZE - 1))
            {
                UART_Info.Uart[0].wPtr++;
            }
            else
            {
                UART_Info.Uart[0].wPtr = 0;
            }
        }
    }
	else if (USART_GetITStatus(USART1, USART_IT_TC) != RESET)
    {
        USART_ClearITPendingBit(USART1, USART_IT_TC);
        USART_ITConfig(USART1, USART_IT_TC, DISABLE);
        UART_Info.Uart[0].wPtr=0;
        UART_Info.Uart[0].wCnt=0;
    }

    USART_ClearITPendingBit(USART1, USART_IT_ORE);
    USART_ClearITPendingBit(USART1, USART_IT_CM);
    USART_ClearITPendingBit(USART1, USART_IT_FE);
    USART_ClearITPendingBit(USART1, USART_IT_PE);
}

#if 0
//UART2接收中断服务程序
void USART2_IRQHandler(void)
{
    INT16U wrCnt;

    UART_IdleRest(USART2, 10);

    if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
    {
        USART_ClearITPendingBit(USART2, USART_IT_RXNE);                 // 清除接收中断标志
        wrCnt = (UART_Info.Uart[1].rCnt + UART_Info.Uart[1].rPtr) % UART_RX_BUFF_SIZE;          //使用覆盖写入的方式
        UART_Info.Uart[1].rBuff[wrCnt] = USART_ReceiveData(USART2);                         // 读取数据
        if (UART_Info.Uart[1].rCnt < (UART_RX_BUFF_SIZE - 1))
        {
            UART_Info.Uart[1].rCnt++;
        }
        else
        {
            if (UART_Info.Uart[1].rPtr < (UART_RX_BUFF_SIZE - 1))
            {
                UART_Info.Uart[1].rPtr++;
            }
            else
            {
                UART_Info.Uart[1].rPtr = 0;
            }
        }
    }

    if (USART_GetITStatus(USART2, USART_IT_TXE) != RESET)
    {
        USART_ClearITPendingBit(USART2, USART_IT_TXE);
        if (UART_Info.Uart[1].wCnt == 0) //发送数据已经完成，关闭发送使能中断
        {
            USART_ITConfig(USART2, USART_IT_TXE, DISABLE);
			//RS485_RxEnable();
        }
        else
        {
            USART_SendData(USART2, UART_Info.Uart[1].wBuff[UART_Info.Uart[1].wPtr]);  //取一个数据发送出去
            UART_Info.Uart[1].wCnt --;   //写入数据个数减1
            if (UART_Info.Uart[1].wPtr < (UART_TX_BUFF_SIZE - 1))
            {
                UART_Info.Uart[1].wPtr++;
            }
            else
            {
                UART_Info.Uart[1].wPtr = 0;
            }
        }
    }
	else if (USART_GetITStatus(USART2, USART_IT_TC) != RESET)
    {
        USART_ClearITPendingBit(USART2, USART_IT_TC);
        USART_ITConfig(USART2, USART_IT_TC, DISABLE);
        UART_Info.Uart[1].wPtr=0;
        UART_Info.Uart[1].wCnt=0;
    }

	USART_ClearITPendingBit(USART2, USART_IT_ORE);
    USART_ClearITPendingBit(USART2, USART_IT_CM);
    USART_ClearITPendingBit(USART2, USART_IT_FE);
    USART_ClearITPendingBit(USART2, USART_IT_PE);
}


//UART3接收中断服务程序
void USART3_4_IRQHandler(void)
{
    INT16U wrCnt;

    UART_IdleRest(USART3, 10);

    if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    {
        USART_ClearITPendingBit(USART3, USART_IT_RXNE);                 // 清除接收中断标志
        wrCnt = (UART_Info.Uart[2].rCnt + UART_Info.Uart[2].rPtr) % UART_RX_BUFF_SIZE;          //使用覆盖写入的方式
        UART_Info.Uart[2].rBuff[wrCnt] = USART_ReceiveData(USART3);                         // 读取数据
        if (UART_Info.Uart[2].rCnt < (UART_RX_BUFF_SIZE - 1))
        {
            UART_Info.Uart[2].rCnt++;
        }
        else
        {
            if (UART_Info.Uart[2].rPtr < (UART_RX_BUFF_SIZE - 1))
            {
                UART_Info.Uart[2].rPtr++;
            }
            else
            {
                UART_Info.Uart[2].rPtr = 0;
            }
        }
    }

    if (USART_GetITStatus(USART3, USART_IT_TXE) != RESET)
    {
        USART_ClearITPendingBit(USART3, USART_IT_TXE);
        if (UART_Info.Uart[2].wCnt == 0) //发送数据已经完成，关闭发送使能中断
        {
            USART_ITConfig(USART3, USART_IT_TXE, DISABLE);
            USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
			//RS485_RxEnable();
        }
        else
        {
            USART_SendData(USART3, UART_Info.Uart[2].wBuff[UART_Info.Uart[2].wPtr]);  //取一个数据发送出去
            UART_Info.Uart[2].wCnt --;   //写入数据个数减1
            if (UART_Info.Uart[2].wPtr < (UART_TX_BUFF_SIZE - 1))
            {
                UART_Info.Uart[2].wPtr++;
            }
            else
            {
                UART_Info.Uart[2].wPtr = 0;
            }
        }
    }
	else if (USART_GetITStatus(USART3, USART_IT_TC) != RESET)
    {
        USART_ClearITPendingBit(USART3, USART_IT_TC);
        USART_ITConfig(USART3, USART_IT_TC, DISABLE);
        UART_Info.Uart[2].wPtr=0;
        UART_Info.Uart[2].wCnt=0;
    }

    USART_ClearITPendingBit(USART3, USART_IT_ORE);
    USART_ClearITPendingBit(USART3, USART_IT_CM);
    USART_ClearITPendingBit(USART3, USART_IT_FE);
    USART_ClearITPendingBit(USART3, USART_IT_PE);
}
#endif