0103_APP/Hardware/Uart.c

#include "Uart.h"
#include "fifo.h"

uint8_t g_bPrintDebug = 0;


void usart0_config(void)
{
    /* enable GPIO clock */
    rcu_periph_clock_enable(RCU_GPIOA);

    /* enable USART clock */
    rcu_periph_clock_enable(RCU_USART0);

    /* connect port to USARTx_Tx */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);

    /* connect port to USARTx_Rx */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10);

    /* USART configure */
    usart_deinit(USART0);
    usart_word_length_set(USART0, USART_WL_8BIT);
    usart_stop_bit_set(USART0, USART_STB_1BIT);
    usart_parity_config(USART0, USART_PM_NONE);
    usart_baudrate_set(USART0, 115200U);
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    usart_enable(USART0);
}

/* retarget the C library printf function to the USART */
int fputc(int ch, FILE *f)
{
    usart_data_transmit(USART0, (uint8_t)ch);
    while(RESET == usart_flag_get(USART0, USART_FLAG_TC));
    return ch;
}
/*测试串口输出4G接收到的数据*/
void data_dump(const char *name, uint8_t *data, uint16_t length)
{
    int index = 0;
    if(g_bPrintDebug == 0) return;
    printf("%s Data Info: \r\n    ", name);

    for(index = 0;index < length;index++) {
        if((index%4 == 0)&&index) {
            if((index%16 == 0)&&index) {
                printf("\r\n    ");
            } else {
                printf(" ");
            }
        }
        printf("%02x ", *(data + index));
    }
    printf("\r\n");
}


uartInfo_t g_uart1Info;
uint8_t U1_RxBuff[U1_RX_SIZE];
UCB_CB U1CB;
void dma_init_uart_4G(void)
{
    dma_parameter_struct dma_init_Usart1_TX;
    dma_parameter_struct dma_init_Usart1_RX;

    rcu_periph_clock_enable(RCU_DMA0);

    dma_deinit(DMA0, DMA_CH5);
    dma_deinit(DMA0, DMA_CH6);

    /* initialize DMA0 channel6(Usart1_TX) */
    dma_init_Usart1_TX.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_Usart1_TX.memory_addr = (uint32_t)g_uart1Info.txfifo;
    dma_init_Usart1_TX.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_Usart1_TX.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_Usart1_TX.number = (uint32_t)USART1_TX_SIZE;
    dma_init_Usart1_TX.periph_addr = (uint32_t)(&USART_DATA(USART1));
    dma_init_Usart1_TX.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_Usart1_TX.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_Usart1_TX.priority = DMA_PRIORITY_LOW;
    dma_init(DMA0, DMA_CH6, &dma_init_Usart1_TX);
    dma_circulation_disable(DMA0, DMA_CH6);

    /* initialize DMA0 channel5(Usart1_RX) */
    dma_init_Usart1_RX.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_Usart1_RX.memory_addr = (uint32_t)U1_RxBuff;
    dma_init_Usart1_RX.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_Usart1_RX.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_Usart1_RX.number = (uint32_t)U1_RX_MAX+1;
    dma_init_Usart1_RX.periph_addr = (uint32_t)(&USART_DATA(USART1));
    dma_init_Usart1_RX.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_Usart1_RX.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_Usart1_RX.priority = DMA_PRIORITY_HIGH;//DMA_PRIORITY_LOW;
    dma_init(DMA0, DMA_CH5, &dma_init_Usart1_RX);
    dma_circulation_disable(DMA0, DMA_CH5);//circulate or not makes no difference

    dma_memory_to_memory_disable(DMA0,DMA_CH5);
    dma_memory_to_memory_disable(DMA0,DMA_CH6);

    /* enable all DMA channels you need */
    dma_channel_enable(DMA0,DMA_CH5);
    dma_channel_disable(DMA0,DMA_CH6);

}
void usart_4g_ptr_init(void)
{
    U1CB.URxDataIN = &U1CB.URxDataPtr[0];
    U1CB.URxDataOUT = &U1CB.URxDataPtr[0];
    U1CB.URxDataEND = &U1CB.URxDataPtr[NUM-1];
    U1CB.URxDataIN->start = U1_RxBuff;
    U1CB.URxCounter = 0;
}

void usart_4G_dma_init(void)
{

    rcu_periph_clock_enable(RCU_GPIOA);/* enable GPIO clock */
    rcu_periph_clock_enable(RCU_AF);

    rcu_periph_clock_enable(RCU_USART1);/* enable USART clock */

    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_2);/* connect port to USARTx_Tx */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_3);/* connect port to USARTx_Rx */

    /* USART configure */
    usart_deinit(USART1);
    usart_word_length_set(USART1, USART_WL_8BIT);
    usart_stop_bit_set(USART1, USART_STB_1BIT);
    usart_parity_config(USART1, USART_PM_NONE);
    usart_baudrate_set(USART1, 115200U);
    usart_hardware_flow_rts_config(USART1, USART_RTS_DISABLE);
    usart_hardware_flow_cts_config(USART1, USART_CTS_DISABLE);
    usart_receive_config(USART1, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART1, USART_TRANSMIT_ENABLE);

    /* config USARTx_TX transmit by DMA */
    usart_dma_transmit_config(USART1,USART_DENT_ENABLE);
    usart_dma_receive_config(USART1,USART_DENR_ENABLE);

    /* USART1 IRQ set */

    nvic_irq_enable(USART1_IRQn, 1, 0);
    nvic_irq_enable(DMA0_Channel6_IRQn, 1, 1);
    usart_interrupt_enable(USART1, USART_INT_IDLE);

    dma_interrupt_enable(DMA0,DMA_CH6,DMA_INT_FTF); /* 使能DAM发送完成中断 */
    dma_channel_enable(DMA0, DMA_CH6);


    usart_4g_ptr_init();


    usart_enable(USART1);
}

void USART1_IRQHandler(void)
{
    if((RESET != usart_interrupt_flag_get(USART1, USART_INT_FLAG_IDLE)) \
            && (RESET != usart_flag_get(USART1, USART_FLAG_IDLEF)))//
    {
        usart_flag_get(USART1,USART_FLAG_IDLEF);
        usart_data_receive(USART1);
       // len = (U1_RX_MAX+1) - dma_transfer_number_get(DMA0,DMA_CH5);
       // if(len >1){
            U1CB.URxCounter += (U1_RX_MAX+1) - dma_transfer_number_get(DMA0,DMA_CH5);
            U1CB.URxDataIN->end = &U1_RxBuff[U1CB.URxCounter-1];
            U1CB.URxDataIN++;
            if(U1CB.URxDataIN == U1CB.URxDataEND){
                U1CB.URxDataIN = &U1CB.URxDataPtr[0];
            }
            if(U1_RX_SIZE - U1CB.URxCounter >= U1_RX_MAX){
                U1CB.URxDataIN->start = &U1_RxBuff[U1CB.URxCounter];
            }
            else {
                U1CB.URxDataIN->start = U1_RxBuff;
                U1CB.URxCounter = 0;

            }
            dma_channel_disable(DMA0, DMA_CH5);
            dma_memory_address_config(DMA0, DMA_CH5,(uint32_t)U1CB.URxDataIN->start);
            dma_transfer_number_config(DMA0, DMA_CH5, U1_RX_MAX+1);
            dma_channel_enable(DMA0, DMA_CH5);
        //}
        //usart_interrupt_flag_clear(USART1, USART_INT_FLAG_IDLE);//
        //usart_flag_clear(USART1, USART_FLAG_IDLEF);
    }
}
void DMA0_Channel6_IRQHandler(void)
{
    if(dma_interrupt_flag_get(DMA0, DMA_CH6, DMA_INT_FLAG_FTF)){
        dma_interrupt_flag_clear(DMA0, DMA_CH6, DMA_INT_FLAG_G);
        g_uart1Info.bSdFinish = 1;
    }
}

/*------------------------------------------485----------------------------------------*/
void UART3_IRQHandler(void)
{
    volatile uint8_t len = 0;
    if((RESET != usart_interrupt_flag_get(UART3, USART_INT_FLAG_IDLE)) \
        && (RESET != usart_flag_get(UART3, USART_FLAG_IDLEF)))
    {
        usart_interrupt_flag_clear(UART3, USART_INT_FLAG_IDLE);//
        usart_flag_clear(UART3, USART_FLAG_IDLEF);
        dma_channel_disable(DMA1, DMA_CH2);
        usart_data_receive(UART3);
        len = USART3_RX_SIZE - dma_transfer_number_get(DMA1,DMA_CH2);
        if(len>12)
            fifo_write(&g_rxfifo,usart485RX_Buffer,len);
        dma_memory_address_config(DMA1, DMA_CH2,(uint32_t)usart485RX_Buffer);
        dma_transfer_number_config(DMA1, DMA_CH2, USART3_RX_SIZE);/* reset DMA_Channel CNT */
        dma_channel_enable(DMA1, DMA_CH2);/* enable USART1_RX DMA_Channel */
        g_uart485.bRcv = 1;

    }
    else if(RESET != usart_interrupt_flag_get(UART3,USART_INT_FLAG_TC)) { // 发送完成中断
        usart_interrupt_flag_clear(UART3, USART_INT_FLAG_TC);//
        usart_flag_clear(UART3, USART_FLAG_TC);
        g_uart485.bSdFinish = 1;
        gpio_bit_reset(GPIOC,  GPIO_PIN_12);
    }
}

void DMA1_Channel3_4_IRQHandler(void)
{
    if(dma_interrupt_flag_get(DMA1, DMA_CH4, DMA_INT_FLAG_FTF)){
        dma_interrupt_flag_clear(DMA1, DMA_CH4, DMA_INT_FLAG_G);
        //g_uart485.bSdFinish = 1;
        //gpio_bit_reset(GPIOC,  GPIO_PIN_12);
        usart_interrupt_enable(UART3, USART_INT_TC); // 全能接收完成中断
    }
}




uint8_t usart485TX_Buffer[USART3_TX_SIZE] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08};
uint8_t usart485RX_Buffer[USART3_RX_SIZE] = {0};
uart485Info_t g_uart485;

void dam_init_uart_485(void)
{
    dma_parameter_struct dma_init_Usart3_TX;
    dma_parameter_struct dma_init_Usart3_RX;

    rcu_periph_clock_enable(RCU_DMA1);

    dma_deinit(DMA1, DMA_CH2); // RX
    dma_deinit(DMA1, DMA_CH4); // TX

    /* initialize DMA1 channel4(Uart3_TX) */
    dma_init_Usart3_TX.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_Usart3_TX.memory_addr = (uint32_t)usart485TX_Buffer;
    dma_init_Usart3_TX.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_Usart3_TX.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_Usart3_TX.number = (uint32_t)USART3_TX_SIZE;
    dma_init_Usart3_TX.periph_addr = (uint32_t)(&USART_DATA(UART3));
    dma_init_Usart3_TX.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_Usart3_TX.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_Usart3_TX.priority = DMA_PRIORITY_LOW;
    dma_init(DMA1, DMA_CH4, &dma_init_Usart3_TX);
    dma_circulation_disable(DMA1, DMA_CH4);

    /* initialize DMA1 channel2(Uart3_RX) */
    dma_init_Usart3_RX.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_Usart3_RX.memory_addr = (uint32_t)usart485RX_Buffer;
    dma_init_Usart3_RX.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_Usart3_RX.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_Usart3_RX.number = (uint32_t)USART3_RX_SIZE;
    dma_init_Usart3_RX.periph_addr = (uint32_t)(&USART_DATA(UART3));
    dma_init_Usart3_RX.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_Usart3_RX.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_Usart3_RX.priority = DMA_PRIORITY_LOW;
    dma_init(DMA1, DMA_CH2, &dma_init_Usart3_RX);
    dma_circulation_disable(DMA1, DMA_CH2);//circulate or not makes no difference

    dma_memory_to_memory_disable(DMA1,DMA_CH2);
    dma_memory_to_memory_disable(DMA1,DMA_CH4);

    /* enable all DMA channels you need */
    dma_channel_enable(DMA1,DMA_CH2);
    dma_channel_disable(DMA1,DMA_CH4);
}
/*------------------------------------------------------------------------------------
 *  485初始化 UART3
 * -----------------------------------------------------------------------------------*/
void usart_485_dma_init(void)
{
    rcu_periph_clock_enable(RCU_GPIOC);/* enable GPIO clock */
    rcu_periph_clock_enable(RCU_AF);

    rcu_periph_clock_enable(RCU_UART3);/* enable USART clock */

    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_10);/* connect port to USARTx_Tx */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_11);/* connect port to USARTx_Rx */

    //设置rs485芯片，收发模式控制引脚 PC12，低电平接收，高电平发送，初始化为接收模式
    gpio_init(GPIOC, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_12);
    gpio_bit_reset(GPIOC,  GPIO_PIN_12);


    /* USART configure */
    usart_deinit(UART3);
    usart_word_length_set(UART3, USART_WL_8BIT);
    usart_stop_bit_set(UART3, USART_STB_1BIT);
    usart_parity_config(UART3, USART_PM_NONE);
    usart_baudrate_set(UART3, 115200U);
    usart_hardware_flow_rts_config(UART3, USART_RTS_DISABLE);
    usart_hardware_flow_cts_config(UART3, USART_CTS_DISABLE);
    usart_receive_config(UART3, USART_RECEIVE_ENABLE);
    usart_transmit_config(UART3, USART_TRANSMIT_ENABLE);
    usart_enable(UART3);

    /* config USARTx_TX transmit by DMA */
    usart_dma_transmit_config(UART3,USART_DENT_ENABLE);
    usart_dma_receive_config(UART3,USART_DENR_ENABLE);

    /* UART3 IRQ set */
    nvic_irq_enable(UART3_IRQn, 4, 0);
    usart_interrupt_enable(UART3, USART_INT_FLAG_IDLE);

    dma_interrupt_enable(DMA1,DMA_CH4,DMA_INT_FTF); /* 使能DAM发送完成中断 */
    dma_channel_enable(DMA1, DMA_CH4);
    nvic_irq_enable(DMA1_Channel3_Channel4_IRQn, 4, 1);
    g_uart485.bSdFinish = 1;
    g_rxfifo.flag = FALSE;
    g_rxfifo.front = 0;
    g_rxfifo.rear = 0;

}

void usart_tx_dma_send(uint32_t usart_periph,uint8_t* data_buffer,uint16_t length)
{
    volatile uint32_t i = 0;
    if(usart_periph==USART1)
    {
        /* Channel disable */
        dma_channel_disable(DMA0, DMA_CH6);

        dma_memory_address_config(DMA0, DMA_CH6,(uint32_t)data_buffer);
        dma_transfer_number_config(DMA0,DMA_CH6,length);

        /* enable DMA channel to start send */
        dma_channel_enable(DMA0, DMA_CH6);
        g_uart1Info.bSdFinish = 0;
    }
    else if(usart_periph==UART3)
    {
        /* Channel disable */
        gpio_bit_set(GPIOC,  GPIO_PIN_12);
        dma_interrupt_flag_clear(DMA1, DMA_CH4, DMA_INT_FLAG_FTF);
        usart_interrupt_flag_clear(UART3,USART_INT_FLAG_TC);
        usart_flag_clear(UART3,USART_FLAG_TC);
        for(i=0;i<0xFF;i++);
//        if(dma_flag_get(DMA1,DMA_FLAG_FTF)!=RESET){

//        }
        dma_channel_disable(DMA1, DMA_CH4);
        dma_memory_address_config(DMA1, DMA_CH4,(uint32_t)data_buffer);
        dma_transfer_number_config(DMA1,DMA_CH4,length);
        /* enable DMA channel to start send */
        dma_channel_enable(DMA1, DMA_CH4);
        usart_dma_transmit_config(UART3,USART_DENT_ENABLE);
        g_uart485.bRcv = 0;
        g_uart485.bSdFinish = 0;
    }
}