#include "uart_transfer.h"

AT(.com_text.isr)
void uart_isr(void)
{
    if (uart_get_flag(UART0, UART_FLAG_RX) != RESET)
    {
        uart_clear_flag(UART0, UART_FLAG_RX);
        Write_RingBuff(uart_receive_data(UART0));      //读取接收到的数据
    }

    if (uart_get_flag(UART1, UART_FLAG_RX) != RESET)
    {
        uart_clear_flag(UART1, UART_FLAG_RX);
        Write_RingBuff(uart_receive_data(UART1));      //读取接收到的数据
    }

    if (uart_get_flag(UART2, UART_FLAG_RX) != RESET)
    {
        uart_clear_flag(UART2, UART_FLAG_RX);
        Write_RingBuff(uart_receive_data(UART2));      //读取接收到的数据
    }
}

void uart0_init(u32 baud)
{
    uart_init_typedef uart_init_struct;
    gpio_init_typedef gpio_init_structure;

    clock_gate0_cmd(CLOCK_GATE0_UART0, ENABLE);

    uart_cmd(UART0, DISABLE);

    gpio_init_structure.gpio_pin = GPIO_PIN_6;
    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
    gpio_init_structure.gpio_fen = GPIO_FEN_PER;
    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
    gpio_init_structure.gpio_pupd = GPIO_PUPD_UP;
    gpio_init(GPIOE_REG, &gpio_init_structure);

    gpio_init_structure.gpio_pin = GPIO_PIN_7;
    gpio_init_structure.gpio_dir = GPIO_DIR_OUTPUT;
    gpio_init_structure.gpio_drv = GPIO_DRV_8MA;
    gpio_init(GPIOE_REG, &gpio_init_structure);

    gpio_func_mapping(UT0RXMAP_PE6);
    gpio_func_mapping(UT0TXMAP_PE7);

    uart_init_struct.baud = baud;
    uart_init_struct.mode = UART_SEND_MODE | UART_RW_MODE;
    uart_init_struct.work_len = UART_WORD_LENGTH_8b;
    uart_init_struct.stop_bits = UART_STOP_BIT_1BIT;
    uart_init_struct.one_line_enable = UART_SEPARATE;
    uart_init_struct.clock_source = UART_INC_CLOCK;
    uart_init_struct.inc_div = UART_INC_DIV2;
    uart_init(UART0, &uart_init_struct);

    uart_pic_config(UART0, uart_isr, 0, UART_CON_RXIE, ENABLE);

    uart_cmd(UART0, ENABLE);
}

void uart1_init(u32 baud)
{
    uart_init_typedef uart_init_struct;
    gpio_init_typedef gpio_init_structure;

    clock_gate0_cmd(CLOCK_GATE0_UART1, ENABLE);
    uart_cmd(UART1, DISABLE);

    gpio_init_structure.gpio_pin = GPIO_PIN_3;
    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
    gpio_init_structure.gpio_fen = GPIO_FEN_PER;
    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
    gpio_init_structure.gpio_pupd = GPIO_PUPD_UP;
    gpio_init(GPIOA_REG, &gpio_init_structure);

    gpio_init_structure.gpio_pin = GPIO_PIN_4;
    gpio_init_structure.gpio_dir = GPIO_DIR_OUTPUT;
    gpio_init_structure.gpio_drv = GPIO_DRV_8MA;
    gpio_init(GPIOA_REG, &gpio_init_structure);

    gpio_func_mapping(UT1RXMAP_PA3);
    gpio_func_mapping(UT1TXMAP_PA4);

    uart_init_struct.baud = baud;
    uart_init_struct.mode = UART_SEND_MODE | UART_RW_MODE;
    uart_init_struct.work_len = UART_WORD_LENGTH_8b;
    uart_init_struct.stop_bits = UART_STOP_BIT_1BIT;
    uart_init_struct.one_line_enable = UART_SEPARATE;
    uart_init_struct.clock_source = UART_INC_CLOCK;
    uart_init_struct.inc_div = UART_INC_DIV2;
    uart_init(UART1, &uart_init_struct);

    uart_pic_config(UART1, uart_isr, 0, UART_CON_RXIE, ENABLE);

    uart_cmd(UART1, ENABLE);
}

void uart2_init(u32 baud)
{
    uart_init_typedef uart_init_struct;
    gpio_init_typedef gpio_init_structure;

    clock_gate1_cmd(CLOCK_GATE1_UART2, ENABLE);
    uart_cmd(UART2, DISABLE);

    gpio_init_structure.gpio_pin = GPIO_PIN_1;
    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
    gpio_init_structure.gpio_fen = GPIO_FEN_PER;
    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
    gpio_init_structure.gpio_pupd = GPIO_PUPD_UP;
    gpio_init(GPIOB_REG, &gpio_init_structure);

    gpio_init_structure.gpio_pin = GPIO_PIN_2;
    gpio_init_structure.gpio_dir = GPIO_DIR_OUTPUT;
    gpio_init_structure.gpio_drv = GPIO_DRV_8MA;
    gpio_init(GPIOB_REG, &gpio_init_structure);

    gpio_func_mapping(UT2RXMAP_PB1);
    gpio_func_mapping(UT2TXMAP_PB2);

    uart_init_struct.baud = baud;
    uart_init_struct.mode = UART_SEND_MODE | UART_RW_MODE;
    uart_init_struct.work_len = UART_WORD_LENGTH_8b;
    uart_init_struct.stop_bits = UART_STOP_BIT_1BIT;
    uart_init_struct.one_line_enable = UART_SEPARATE;
    uart_init_struct.clock_source = UART_INC_CLOCK;
    uart_init_struct.inc_div = UART_INC_DIV2;
    uart_init(UART2, &uart_init_struct);

    uart_pic_config(UART2, uart_isr, 0, UART_CON_RXIE, ENABLE);

    uart_cmd(UART2, ENABLE);
}

/*****串口0发送函数-调试口用的就是串口0，初始化串口0后，调试口无输出*********/
/*串口发送一个字节*/
void uart0_SendByte(uint8_t Byte)
{
	uart_send_data(UART0, Byte);
	while (uart_get_flag(UART0, UART_FLAG_TX) == RESET);
}

/*串口发送带长度的字符串*/
void uart0_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		uart0_SendByte(Array[i]);
	}
}
/*串口发送字符串*/
void uart0_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		uart0_SendByte(String[i]);
	}
}

uint32_t uart_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y --){
		Result *= X;
	}
	return Result;
}

/*串口发送十进制数字*/
void uart0_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++){
		uart0_SendByte(Number / uart_Pow(10, Length - i - 1) % 10 + '0');
	}
}
/****************************/

/*****串口1发送函数*********/
/*串口发送一个字节*/
void uart1_SendByte(uint8_t Byte)
{
	uart_send_data(UART1, Byte);
	while (uart_get_flag(UART1, UART_FLAG_TX) == RESET);
}

/*串口发送带长度的字符串*/
void uart1_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		uart1_SendByte(Array[i]);
	}
}
/*串口发送字符串*/
void uart1_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		uart1_SendByte(String[i]);
	}
}

/*串口发送十进制数字*/
void uart1_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++){
		uart1_SendByte(Number / uart_Pow(10, Length - i - 1) % 10 + '0');
	}
}
/****************************/

/*****串口2发送函数*********/
/*串口发送一个字节*/
void uart2_SendByte(uint8_t Byte)
{
	uart_send_data(UART2, Byte);
	while (uart_get_flag(UART2, UART_FLAG_TX) == RESET);
}

/*串口发送带长度的字符串*/
void uart2_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		uart2_SendByte(Array[i]);
	}
}
/*串口发送字符串*/
void uart2_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		uart2_SendByte(String[i]);
	}
}
/*串口发送十进制数字*/
void uart2_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++){
		uart2_SendByte(Number / uart_Pow(10, Length - i - 1) % 10 + '0');
	}
}
/*************************/

/**
* @brief  RingBuff_Init
* @param  void
* @return void
* @note   初始化环形缓冲区
*/
volatile RingBuff_t ringBuff;
void RingBuff_Init(void)
{
   //初始化相关信息
   ringBuff.Head = 0;
   ringBuff.Tail = 0;
   ringBuff.Lenght = 0;
   ringBuff.sendlen = 0;
}
/**
* @brief  Write_RingBuff
* @param  u8 data
* @return FLASE:环形缓冲区已满，写入失败;TRUE:写入成功
* @note   往环形缓冲区写入u8类型的数据
*/
u8 Write_RingBuff(u8 data)
{
   if(ringBuff.Lenght >= RINGBUFF_LEN) //判断缓冲区是否已满
    {
      return FLASE;
    }
    ringBuff.Ring_Buff[ringBuff.Tail]=data;
//    ringBuff.Tail++;
	ringBuff.sendlen++;
    ringBuff.Tail = (ringBuff.Tail+1)%RINGBUFF_LEN;//防止越界非法访问
    ringBuff.Lenght++;
    return TRUE;
}

/**
* @brief  Read_RingBuff
* @param  u8 *rData，用于保存读取的数据
* @return FLASE:环形缓冲区没有数据，读取失败;TRUE:读取成功
* @note   从环形缓冲区读取一个u8类型的数据
*/
u8 Read_RingBuff(u8 *rData)
{
   if(ringBuff.Lenght == 0)//判断非空
    {
       return FLASE;
    }
   *rData = ringBuff.Ring_Buff[ringBuff.Head];//先进先出FIFO，从缓冲区头出
//   ringBuff.Head++;
   ringBuff.Head = (ringBuff.Head+1)%RINGBUFF_LEN;//防止越界非法访问
   ringBuff.Lenght--;
   return TRUE;
}

/**
* @brief  Send_RingBuffOver
* @param  void
* @return void
* @note   从环形缓冲区读取一个u8类型的数据后，调用此函数
*/
void Send_RingBuffOver(void)
{
   ringBuff.sendlen--;
}
