N32G451CCL7芯片USART6串口中断接收初始化（PB0,PB1）

系统供电3.3V，USART6串口中断接收初始化（PB0,PB1），9600波特率，采用中断接收，主动发送，接收处理函数为GPS模块处理函数，移植时候可以根据项目需求，替换成自己的应用代码即可。同样，前面是头文件代码，后面是应用代码，仅做记录，方便以后移植应用，代码已实测。

#ifndef __USART6_H__

#define __USART6_H__

#include "main.h" //

#define   USART6_RX_LEN   128      //接受数据缓存区长度

#define   USART6_TX_LEN   128   //接受数据缓存区长度

struct __USART6_ //串口数据结构体

{

    char  rxBuf[USART6_RX_LEN];   //接收缓存区

    // char  txBuf[USART4_TX_LEN];   //发送缓存区

  u16   rxLen;                   //串口1接收到的数据长度

    u16   txLen;                   //串口1接收到的数据长度

  u8    rxOkFlag;                //RX 数据接收完成标志

    u8    txOkFlag;                //tx数据发送ready flag  

    u32   rxTimeOut;

};

extern struct __USART6_  Usart6; //串口数据结构体

void usart6Init(u32 baudRate ); //usart4 initial

void usart6Deal(void);  //usart data deal,figure out whether it's data EC800 or data JT808.

 

#endif

#include "usart6.h"

struct __USART6_  Usart6; //串口数据结构体

void usart6DmaInit(u32 baudRate ) // initial

{      

}

void usart6IntInit(u32 baudRate)  //usart initial,interupt rx mode

{

    RCC_EnableAPB2PeriphClk(RCC_APB2_PERIPH_GPIOB | RCC_APB2_PERIPH_AFIO, ENABLE);  //

    RCC_EnableAPB2PeriphClk(RCC_APB2_PERIPH_UART6, ENABLE); // Enable USART Clock

    NVIC_InitType NVIC_InitStructure;

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);              //Configure the NVIC Preemption Priority Bits

    NVIC_InitStructure.NVIC_IRQChannel            = UART6_IRQn; //Enable the UART4 Interrupt

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

    NVIC_InitStructure.NVIC_IRQChannelCmd         = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    GPIO_InitType GPIO_InitStructure;

    GPIO_InitStruct(&GPIO_InitStructure); //初始化结构体

    GPIO_InitStructure.Pin            = GPIO_PIN_0;      //Configure UART Tx as alternate function push-pull

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;

    GPIO_InitPeripheral(GPIOB, &GPIO_InitStructure);

    GPIO_InitStructure.Pin            = GPIO_PIN_1;       //Configure UART Rx as alternate function push-pull and pull-up

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_InitPeripheral(GPIOB, &GPIO_InitStructure);    

    GPIO_ConfigPinRemap(GPIO_RMP3_UART6,ENABLE);

   

    USART_InitType USART_InitStructure;

    USART_StructInit(&USART_InitStructure);

    USART_InitStructure.BaudRate            = baudRate;

    USART_InitStructure.WordLength          = USART_WL_8B;

    USART_InitStructure.StopBits            = USART_STPB_1;

    USART_InitStructure.Parity              = USART_PE_NO;

    USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;

    USART_InitStructure.Mode                = USART_MODE_RX | USART_MODE_TX;

    USART_Init(UART6, &USART_InitStructure);

    USART_ConfigInt(UART6, USART_INT_RXDNE, ENABLE);

  // USART_ConfigInt(UART6, USART_INT_TXDE, ENABLE);

    USART_Enable(UART6, ENABLE);  

}

void usart6Init(u32 baudRate )

{

    #ifdef USART4_DMA

      usart6DmaInit(baudRate); //usart initial,DMA rx mode

    #else

    usart6IntInit(baudRate);  //usart initial,interupt rx mode

      // printf("-------------------11111-----------------------------------");

    #endif

}

void usart6RxBuf(u8 rxData)

{

    if(Usart6.rxLen<USART6_RX_LEN)

    {

        if (Usart6.rxOkFlag != OK   )

        {

            Usart6.rxBuf[Usart6.rxLen++] = rxData;

            Usart6.rxTimeOut = 0;

            if (Usart6.rxBuf[0] == '$')

            {

                if(Usart6.rxLen>10)

                {

                    if(Usart6.rxBuf[Usart6.rxLen-2] == 0x0d && Usart6.rxBuf[Usart6.rxLen-1] == 0x0a)

                    {

                        // Usart6.rxOkFlag = TRUE;

                        memcpy(Gps.rxBuf,Usart6.rxBuf,Usart6.rxLen);    //copy the data to buf

                        Gps.rxLen = Usart6.rxLen;                      

                        Gps.rxOkFlag = OK;                          

                        memset(Usart6.rxBuf,0,Usart6.rxLen); //clear the data buf.          

                        Usart6.rxLen = 0;      

                    }

                }

            }

            else

            {

                Usart6.rxLen = 0;

            }

        }

       

               

    }

    else

    {

        Usart6.rxLen =0;

        memset(Usart6.rxBuf,0,USART6_RX_LEN); //clear the data buf.        

    }

}

#ifdef UART4_DMA

void UART4_IRQHandler(void) //重写串口中断处理函数

{

    uint32_t temp;  

    if (   (USART_GetIntStatus(UART6, USART_INT_OREF) != RESET) //Overrun error

          || (USART_GetIntStatus(UART6, USART_INT_NEF) != RESET)        //Noise error flag

          || (USART_GetIntStatus(UART6, USART_INT_FEF) != RESET)        //Framing error

       )

    {

        temp = UART4->STS;

        temp = UART4->DAT;

    }  

    if((USART_GetIntStatus(UART6,USART_INT_IDLEF) != RESET))//IDLE line detected

    {  

        temp = UART4->STS;//清IDLE标志

        temp = UART4->DAT;

    DMA_EnableChannel(DMA1_CH5,DISABLE);

        temp = DMA_GetCurrDataCounter(DMA1_CH5); //应该是当前接收数据缓存器剩余空间长度

        Usart6.rxLen =  USART1_RX_LEN - temp;  //计算出当前接收数据长度

        DMA1_CH5->TXNUM=USART1_RX_LEN;

        DMA_EnableChannel(DMA1_CH5,ENABLE);

    if(Usart6.rxLen<=USART1_RX_LEN)

            Usart6.rxOkFlag =1;                //数据包接收完成标志  

            //printf("Usart1 data packet Usart6.rxLen = %d.",Usart6.rxLen);

    }  

}

#else

void UART6_IRQHandler(void)

{

    u8 rec = 0;

    if (USART_GetIntStatus(UART6, USART_INT_RXDNE) != RESET)

    {          

        rec = USART_ReceiveData(UART6);

        usart6RxBuf(rec);          

    }

    if (USART_GetIntStatus(UART6, USART_INT_TXDE) != RESET)

    {

           

    }

    if(USART_GetIntStatus(UART6, USART_INT_OREF) != RESET)

    {

            /*Read the STS register first,and the read the DAT

            register to clear the overflow interrupt*/

            (void)UART6->STS;

            (void)UART6->DAT;

    }

}

#endif

#ifdef USART6_DMA

    void usart6Deal(void)  //usart data deal,figure out whether it's data EC800 or data JT808.

    {

        if(Usart6.rxOkFlag == 1) //数据包接收完成标志

        // if((Usart6.rxLen>1)&&(Usart6.rxTimeOut>100))

        {

            Usart6.rxOkFlag =0;

            // if(Usart6.rxBuf[0]==0x7E && Usart6.rxBuf[Usart6.rxLen-1]==0x7E) //JT808数据包

            // {            

            //  memcpy(jt808.rxBuf,Usart6.rxBuf,Usart6.rxLen);  //copy the data to buf

            //  jt808.rxLen = Usart6.rxLen;     //

            //  jt808.rxOkFlag = OK;  //jt808接收数据包完成标志置位

            // }

            // else //EC800 AT指令反馈或自动上传数据

            {

                memcpy(ec800.rxBuf,Usart6.rxBuf,Usart6.rxLen);  //copy the data to buf

                ec800.rxBufLen = Usart6.rxLen;      //

                ec800.rxOkFlag = OK;            

                //if(ec800.debug) log_debug("EC800  receive control CMD ********************************************************* \r\n"); //This code just for test.Edit by kevin.  

            }    

        // usartSendBuf(USART3,Usart6.rxBuf,Usart6.rxLen); //发送整包数据到log串口  

            memset(Usart6.rxBuf,0,Usart6.rxLen); //清零串口数据缓存    

            Usart6.rxTimeOut = 0;

            Usart6.rxLen = 0;

        }  

    }

#else

    void usart6Deal(void)  //usart data deal

    {

        // if((Usart6.rxLen>1)&&(Usart6.rxTimeOut>10))

        // {

        //  Usart6.rxTimeOut = 0;

       

        //  Usart6.rxLen = 0;

        // }    

    }

#endif