#include "bsp_Uart.h"
#include "string.h"

#define  RX_TEMP_BUFF_NUM (1100)

#define UART1_TX_LEN (32)
#define UART1_RX_LEN (1100)

#define UART2_TX_LEN (32)
#define UART2_RX_LEN (1100)

u8 Rx_Temp_Buff[RX_TEMP_BUFF_NUM];

/*发送使用DMA发送 接收*/
u8 Uart1_TX_Buff[UART1_TX_LEN];
u8 Uart1_Rx_Buff[UART1_RX_LEN];  

u8 Uart2_TX_Buff[UART1_TX_LEN];
u8 Uart2_Rx_Buff[UART1_RX_LEN];



/*接收使用DMA+串口空闲+超时检测*/

static void bsp_Uart_Init(bsp_Uart_t *p_Uart);
static void bsp_Uart_Send(bsp_Uart_t *p_Uart,u8 *pData, u16 Len);
static void bsp_Uart_Tx_DMA_TCInt(bsp_Uart_t *p_Uart);
static void bsp_Uart_Rx_IdleInt(bsp_Uart_t *p_Uart);
static void bsp_Uart_Rx_TimeIncrement(bsp_Uart_t *p_Uart,u16 Time);
static void bsp_Uart_Rx_TimeStart(bsp_Uart_t *p_Uart);
static void bsp_Uart_Rx_TimeStop(bsp_Uart_t *p_Uart);
static void bsp_Uart_Rx_Task(bsp_Uart_t *p_Uart);

bsp_Uart_t COM_Uart1 =
{ 
    .RxQueue = queue(u8,UART1_RX_LEN),
    .Uart =USART1,

    .Tx_DMA = DMA1,
    .Rx_DMA = DMA1,

    .Rx_DMA_CH = LL_DMA_CHANNEL_4,
    .Tx_DMA_CH = LL_DMA_CHANNEL_5,

    .Tx_DMA_Len = UART1_TX_LEN,
    .Rx_DMA_Len = UART1_RX_LEN, 

    .Tx_Addr = &Uart1_TX_Buff[0],
    .Rx_Addr = &Uart1_Rx_Buff[0],

    .Tx_DMA_CompleteFlag = 1,
    .Rx_TimeOver = 10,                          /*接收超时时间10ms 设置为0时为串口空闲中断触发 无超时检测*/

    .Init = bsp_Uart_Init,
    .Send = bsp_Uart_Send,

    .Tx_DMA_TCInt = bsp_Uart_Tx_DMA_TCInt,

    .Rx_IdleInt = bsp_Uart_Rx_IdleInt,
    .Rx_TimeIncrementInt = bsp_Uart_Rx_TimeIncrement,
    .Rx_DataAnalysis = NULL,
    .Rx_Task = bsp_Uart_Rx_Task,
};

bsp_Uart_t COM_Uart2 =
{ 
    .RxQueue = queue(u8,UART2_RX_LEN),
    .Uart =USART2,

    .Tx_DMA = DMA1,
    .Rx_DMA = DMA1,

    .Rx_DMA_CH = LL_DMA_CHANNEL_1,
    .Tx_DMA_CH = LL_DMA_CHANNEL_2,

    .Tx_DMA_Len = UART2_TX_LEN,
    .Rx_DMA_Len = UART2_RX_LEN, 

    .Tx_Addr = &Uart2_TX_Buff[0],
    .Rx_Addr = &Uart2_Rx_Buff[0],

    .Tx_DMA_CompleteFlag = 1,
    .Rx_TimeOver = 5,                          /*接收超时时间10ms设置为0时为串口空闲中断触发 无超时检测*/

    .Init = bsp_Uart_Init,
    .Send = bsp_Uart_Send,

    .Tx_DMA_TCInt = bsp_Uart_Tx_DMA_TCInt,

    .Rx_IdleInt = bsp_Uart_Rx_IdleInt,
    .Rx_TimeIncrementInt = bsp_Uart_Rx_TimeIncrement,
    .Rx_DataAnalysis = NULL,
    .Rx_Task = bsp_Uart_Rx_Task,
};


static void bsp_Uart_Init(bsp_Uart_t *p_Uart)
{ 
/*配置数据解析函数*/
    p_Uart->Rx_DataAnalysis = NULL;

/*RX*/
    if(NULL == p_Uart->Uart)
        return;
    LL_USART_EnableIT_RXNE(p_Uart->Uart); //使能串口接收中断
    if(NULL != p_Uart->Rx_DMA)
    {

    }

}


static void bsp_Uart2_DMASend(bsp_Uart_t *p_Uart,u8 *pData, u16 Len)
{
    while (!p_Uart->Tx_DMA_CompleteFlag);    /*等待传输完成标志*/
    p_Uart->Tx_DMA_CompleteFlag = 0;    

    if(p_Uart->Tx_DMA_Len < Len)
        Len = p_Uart->Tx_DMA_Len;

    memcpy(p_Uart->Tx_Addr, pData, Len);    /*拷贝数据到发送缓冲*/

}




/*空闲中断*/
static void bsp_Uart_Rx_IdleInt(bsp_Uart_t *p_Uart)
{
    u8 rx_data;
    rx_data = LL_USART_ReceiveData8(p_Uart->Uart);
    queue_push_back(p_Uart->RxQueue,(void *)&rx_data);
    /*开始计数*/
    bsp_Uart_Rx_TimeStart(p_Uart);
}

/*大数据量发送*/
static void bsp_Uart_Send(bsp_Uart_t *p_Uart,u8 *pData, u16 Len)
{
    u16 i;
    for (i = 0; i < Len; i++) 
    {
        while (!LL_USART_IsActiveFlag_TXE(p_Uart->Uart));
        LL_USART_TransmitData8(p_Uart->Uart, pData[i]); // 发送一个字节的数据
    }
}

static void bsp_Uart_Tx_DMA_TCInt(bsp_Uart_t *p_Uart)
{
    p_Uart->Tx_DMA_CompleteFlag = 1;
}    

/*中断计数*/
static void bsp_Uart_Rx_TimeIncrement(bsp_Uart_t *p_Uart,u16 Time)
{
    /*开始计数*/
    if(1 == p_Uart->Rx_StartFlag)
    {
        p_Uart->Rx_TimeCount += Time;
    }
}

/*开始计数*/
static void bsp_Uart_Rx_TimeStart(bsp_Uart_t *p_Uart)
{
    p_Uart->Rx_StartFlag = 1;
    p_Uart->Rx_TimeCount = 0;
}

/*停止计数*/
static void bsp_Uart_Rx_TimeStop(bsp_Uart_t *p_Uart)
{
    p_Uart->Rx_StartFlag = 0;
    p_Uart->Rx_TimeCount = 0;
}

static void bsp_Uart_Rx_Task(bsp_Uart_t *p_Uart)
{
  /*超时计数完成，接收到一帧数据*/
    if(p_Uart->Rx_TimeOver < p_Uart->Rx_TimeCount)
    {
        p_Uart->Rx_Len = queue_size(p_Uart->RxQueue);
        /*停止计数*/
        bsp_Uart_Rx_TimeStop(p_Uart);   
        if(p_Uart->Rx_Len <= p_Uart->Rx_DMA_Len && (0 != p_Uart->Rx_Len))
        {
            if(RX_TEMP_BUFF_NUM < p_Uart->Rx_Len)
            {
                 queue_clear(p_Uart->RxQueue);
            }
            else
            {
                for(u16 i = 0;i < p_Uart->Rx_Len;i++)
                {
                    queue_pop(p_Uart->RxQueue,&Rx_Temp_Buff[i]);
                }
                if(NULL != p_Uart->Rx_DataAnalysis)
                {
                    p_Uart->Rx_DataAnalysis(Rx_Temp_Buff,p_Uart->Rx_Len,p_Uart);  /*解析数据*/  
                }
                //p_Uart->Send(p_Uart,Rx_Buff,p_Uart->Rx_Len);
            }
        }
    }
}