/*
     for GD32F3x0
*/


#include "gd32f30x.h"
#include <stdio.h>
#include "systick.h"
#include "uart.h"
#include "./mcu_sdk/mcu_api.h"
uint8_t usart0_tx_len=0,usart1_tx_len=0;
uint8_t usart0_tx_cnt=0,usart1_tx_cnt=0;
uint8_t usart0_tx[64] = {1,2,3,4,5,6,7,8,9,10};

uint8_t usart0_rx[128];
uint8_t usart1_rx[128];
uint8_t usart1_tx[64] = {1,2,3,4,5,6,7,8,9,10};

uint8_t rx_length;
uint8_t receivesize = 0;
volatile uint16_t rxcount = 0;


//
void gpio_uart_config(void)
{
	 rcu_periph_clock_enable(RCU_GPIOA); // 使能GPIOA时钟
    rcu_periph_clock_enable(RCU_USART0); // 使能USART1时钟
  
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9); // 初始化PA9，复用为USART1_TX
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10); // 初始化PA10，复用为USART1_RX

   

 /*   usart_deinit(USART0); // 复位USART1

    // 配置USART1的参数
    usart_baudrate_set(USART0, 115200U); // 波特率设置为115200
    usart_word_length_set(USART0, USART_WL_8BIT); // 数据位长度设置为8位
    usart_stop_bit_set(USART0, USART_STB_1BIT); // 停止位设置为1位
    usart_parity_config(USART0, USART_PM_NONE); // 无校验位
    usart_hardware_flow_rts_config(USART0, USART_RTS_DISABLE); // 禁用RTS
    usart_hardware_flow_cts_config(USART0, USART_CTS_DISABLE); // 禁用CTS
    usart_receive_config(USART0, USART_RECEIVE_ENABLE); // 使能接收
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE); // 使能发送
    usart_enable(USART0); // 使能USART1*/

}

/*!
    \brief      configure the USART0
    \param[in]  none
    \param[out] none
    \retval     none
*/
void usart_config(void)
{
    /* enable USART0 clock */
	nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
    nvic_irq_enable(USART0_IRQn, 2, 0);
	
    rcu_periph_clock_enable(RCU_USART0);     
	
    /* USART0 configure */
    usart_deinit(USART0);
    usart_baudrate_set(USART0, 115200U);
	usart_word_length_set(USART0, USART_WL_8BIT);      	// 帧数据字长
    usart_stop_bit_set(USART0, USART_STB_1BIT);      	 	// 停止位1位
    usart_parity_config(USART0, USART_PM_NONE);       	// 无奇偶校验位 
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);

    usart_enable(USART0);	  
	usart_interrupt_enable(USART0, USART_INT_RBNE);	
}
 uint8_t mUart0Send1ByteEnd = 0;
void start_usart0_tx(uint8_t tx_buffer[], uint8_t length)
{
	int a=0,b=0;
	  usart0_tx_len = length;
	  usart0_tx_cnt = 1;
	 // usart0_tx_ptr = tx_buffer;
      usart_data_transmit(USART0, (uint8_t) tx_buffer[0]);
	  mUart0Send1ByteEnd = 0;
	//printf("2222mUart0Send1ByteEnd %x\r\n",mUart0Send1ByteEnd);
	  usart_interrupt_enable(USART0, USART_INT_TBE);
	// while(mUart0Send1ByteEnd == 0)printf("221313131mUart0Send1ByteEnd %x\r\n",mUart0Send1ByteEnd);;
	//printf("224122mUart0Send1ByteEnd %x\r\n",mUart0Send1ByteEnd);
	while(1)
	{
		b++;
		a++;
		if(a!=b)  break;
		if(mUart0Send1ByteEnd == 1) break;
	}
	
	
}

extern void uart_receive_input(unsigned char value);
void USART0_IRQHandler(void)
{
    /*if(RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) {
			  usart0_rx[0] = usart_data_receive(USART0);
        // receive data 
        usart0_rx[rxcount++] = usart_data_receive(USART0);
        if(rxcount == receivesize) {
			printf("\r\n ");
            usart_interrupt_disable(USART0, USART_INT_RBNE);
        }
    }*/
	if(RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) {
			  usart0_rx[0] = usart_data_receive(USART0);
			  uart_receive_input(usart0_rx[0]);//zigbee 串口接收处理函数
			  
        /* receive data 
        usart0_rx[rxcount++] = usart_data_receive(USART0);
        if(rxcount == receivesize) {
            usart_interrupt_disable(EVAL_COM, USART_INT_RBNE);
        }*/
    }
    if(RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_TBE)) {
        /* transmit data */
			mUart0Send1ByteEnd = 1;
	//	printf("21212mUart0Send1ByteEnd %x\r\n",mUart0Send1ByteEnd);
			  if(usart0_tx_cnt<usart0_tx_len)
          usart_data_transmit(USART0, usart0_tx[usart0_tx_cnt++]);
				else
				  usart_interrupt_disable(USART0, USART_INT_TBE);
        
    }
}

int fputc(int ch, FILE *f)
{
    usart_data_transmit(USART0,(uint8_t) ch);
    while(RESET == usart_flag_get(USART0, USART_FLAG_TBE)); // 等待发送数据缓冲区标志置位
    return ch;
}

 //以下为IDLE模式串口配置
/*void gpio_uart_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    
    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_9);
    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_10);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_9);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_9);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_10);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_10);
    
    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_2);
    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_3);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_2);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_2);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_3);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_3);
	
	// enable the LED GPIO clock 
    rcu_periph_clock_enable(RCU_GPIOC);
    // configure led GPIO port/
    //gpio_mode_set(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_2);
    //gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_2);

    //gpio_bit_reset(GPIOC, GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_2);
}

void usart_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    rcu_periph_clock_enable(RCU_USART0);
    rcu_periph_clock_enable(RCU_USART1);
    rcu_periph_clock_enable(RCU_DMA);
    
    nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
    nvic_irq_enable(USART0_IRQn, 0, 0);
    nvic_irq_enable(USART1_IRQn, 0, 0);

    usart_deinit(USART0);
    usart_baudrate_set(USART0, 115200U);
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    usart_enable(USART0);
    usart_interrupt_enable(USART0, USART_INT_IDLE);
    usart_dma_transmit_config(USART0, USART_DENT_ENABLE);
    usart_dma_receive_config(USART0, USART_DENR_ENABLE);
    
    dma_deinit(DMA_CH1);
    dma_struct_para_init(&dma_init_struct);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)usart0_tx;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = 10;
    dma_init_struct.periph_addr = (uint32_t) &USART_TDATA(USART0);
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH1, &dma_init_struct);
    dma_circulation_disable(DMA_CH1);
    dma_memory_to_memory_disable(DMA_CH1);
    
    dma_deinit(DMA_CH2);
    dma_struct_para_init(&dma_init_struct);
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)usart0_rx;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = 10;
    dma_init_struct.periph_addr = (uint32_t) &USART_RDATA(USART0);
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH2, &dma_init_struct);
    dma_channel_enable(DMA_CH2);
    dma_circulation_disable(DMA_CH2);
    dma_memory_to_memory_disable(DMA_CH2);
    

    
    usart_deinit(USART1);
    usart_baudrate_set(USART1, 115200U);
    usart_receive_config(USART1, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART1, USART_TRANSMIT_ENABLE);
    usart_interrupt_enable(USART1, USART_INT_IDLE);
    usart_enable(USART1);
    usart_dma_transmit_config(USART1, USART_DENT_ENABLE);
    usart_dma_receive_config(USART1, USART_DENR_ENABLE);
    
    dma_deinit(DMA_CH3);
    dma_struct_para_init(&dma_init_struct);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)usart1_tx;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = 10;
    dma_init_struct.periph_addr = (uint32_t) &USART_TDATA(USART1);
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH3, &dma_init_struct);
    dma_circulation_disable(DMA_CH3);
    dma_memory_to_memory_disable(DMA_CH3);
    
    dma_deinit(DMA_CH4);
    dma_struct_para_init(&dma_init_struct);
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)usart1_rx;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = 10;
    dma_init_struct.periph_addr = (uint32_t) &USART_RDATA(USART1);
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH4, &dma_init_struct);
    dma_channel_enable(DMA_CH4);
    dma_circulation_disable(DMA_CH4);
    dma_memory_to_memory_disable(DMA_CH4);
}

void start_usart0_tx(uint8_t tx_buffer[], uint8_t length)
{
    dma_channel_disable(DMA_CH1);
    dma_memory_address_config(DMA_CH1, (uint32_t)tx_buffer);
    dma_transfer_number_config(DMA_CH1, length);
    dma_channel_enable(DMA_CH1);
}

void start_usart1_tx(uint8_t tx_buffer[], uint8_t length)
{
    dma_channel_disable(DMA_CH3);
    dma_memory_address_config(DMA_CH3, (uint32_t)tx_buffer);
    dma_transfer_number_config(DMA_CH3, length);
    dma_channel_enable(DMA_CH3);
}
void USART0_IRQHandler(void)
{
    if(RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE))
    {
        usart_interrupt_flag_clear(USART0, USART_INT_FLAG_IDLE);
        rx_length = 10 - dma_transfer_number_get(DMA_CH2);
        dma_channel_disable(DMA_CH2);
        dma_memory_address_config(DMA_CH2, (uint32_t)usart0_rx);
        dma_transfer_number_config(DMA_CH2, 10);
        dma_channel_enable(DMA_CH2);
        start_usart0_tx(usart0_rx, rx_length);
    }
}

void USART1_IRQHandler(void)
{
    if(RESET != usart_interrupt_flag_get(USART1, USART_INT_FLAG_IDLE))
    {
        usart_interrupt_flag_clear(USART1, USART_INT_FLAG_IDLE);
        rx_length = 10 - dma_transfer_number_get(DMA_CH4);
        dma_channel_disable(DMA_CH4);
        dma_memory_address_config(DMA_CH4, (uint32_t)usart1_rx);
        dma_transfer_number_config(DMA_CH4, 10);
        dma_channel_enable(DMA_CH4);
        start_usart1_tx(usart1_rx, rx_length);
    }
}
*/