N32L406C8芯片USART3串口3中断接收初始化（PB10,PB11）

系统供电3.3V，USART3串口3中断接收初始化（PB10,PB11），115200波特率，采用中断接收，主动发送，接收完成的处理函数为OBD指令解析，不用在意，移植时候可以根据项目需求，替换成自己的应用代码即可。同样，前面是头文件代码，后面是应用代码，仅做记录，方便以后移植应用，代码已实测。

#ifndef __USART3_H__

#define __USART3_H__

#include "main.h" //

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

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

struct __USART3_ //串口数据结构体

{

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

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

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

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

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

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

    u32   rxTimeOut;

};

extern struct __USART3_  usart3; //串口数据结构体

void usart3Init(u32 baudRate ); //usart4 initial

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

#endif

#include "usart3.h"

struct __USART3_  usart3; //串口数据结构体

// #define USART3_DMA   1

 

void usart3DmaInit(u32 baudRate ) // initial

{

       

}

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

{

    RCC_EnableAPB2PeriphClk(RCC_APB2_PERIPH_GPIOB| RCC_APB2_PERIPH_AFIO, ENABLE); //Enable GPIO clock

    RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_USART3, ENABLE); // Enable USART Clock

    // GPIO_ConfigPinRemap(GPIO_RMP_USART3,ENABLE);  //

    NVIC_InitType NVIC_InitStructure;

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

    NVIC_InitStructure.NVIC_IRQChannel            = USART3_IRQn; //Enable the USART3 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_10;      //Configure USART3 Tx as alternate function push-pull

    GPIO_InitStructure.GPIO_Mode      = GPIO_Mode_AF_PP;

    GPIO_InitStructure.GPIO_Alternate = GPIO_AF0_USART3;

    GPIO_InitPeripheral(GPIOB, &GPIO_InitStructure);

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

    GPIO_InitStructure.GPIO_Pull      = GPIO_Pull_Up;

    GPIO_InitStructure.GPIO_Alternate = GPIO_AF5_USART3;

    GPIO_InitPeripheral(GPIOB, &GPIO_InitStructure);    

   

    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(USART3, &USART_InitStructure);

    USART_ConfigInt(USART3, USART_INT_RXDNE, ENABLE);

  // USART_ConfigInt(USART3, USART_INT_TXDE, ENABLE);

    USART_Enable(USART3, ENABLE);

}

void usart3Init(u32 baudRate )

{

    #ifdef USART3_DMA

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

    #else

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

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

    #endif

}

void usart3RxBuf(u8 rxData)

{

    if(usart3.rxLen<USART3_RX_LEN)

    {

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

        usart3.rxTimeOut = 0;  

        // if (usart3.rxOkFlag != OK    )

        // {

        //  usart3.rxBuf[usart3.rxLen++] = rxData;

        //  usart3.rxTimeOut = 0;

        //  if (usart3.rxBuf[0] == '$')

        //  {

        //      if(usart3.rxLen>10)

        //      {

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

        //          {

        //              // usart3.rxOkFlag = TRUE;

        //              // memcpy(gps.rxBuf,usart3.rxBuf,usart3.rxLen); //copy the data to buf

        //              // gps.rxLen = usart3.rxLen;                        

        //              // gps.rxOkFlag = OK;                          

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

        //              // usart3.rxLen = 0;        

        //          }

        //      }

        //  }

        //  else

        //  {

        //      usart3.rxLen = 0;

        //  }

        // }            

    }

    else

    {

        usart3.rxLen =0;

        memset(usart3.rxBuf,0,USART3_RX_LEN); //clear the data buf.        

    }

}

#ifdef USART3_DMA

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

{

    uint32_t temp;  

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

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

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

       )

    {

        temp = USART3->STS;

        temp = USART3->DAT;

    }  

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

    {  

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

        temp = USART3->DAT;

    DMA_EnableChannel(DMA1_CH5,DISABLE);

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

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

        DMA1_CH5->TXNUM=USART3_RX_LEN;

        DMA_EnableChannel(DMA1_CH5,ENABLE);

    if(usart3.rxLen<=USART3_RX_LEN)

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

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

    }  

}

#else

void USART3_IRQHandler(void)

{

    u8 rec = 0;

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

    {          

        rec = USART_ReceiveData(USART3);

        usart3RxBuf(rec);          

    }

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

    {          

    }

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

    {

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

        register to clear the overflow interrupt*/

        (void)USART3->STS;

        (void)USART3->DAT;

    }

}

#endif

 

#ifdef USART3_DMA

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

    {

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

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

        {

            usart3.rxOkFlag =0;

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

            // {            

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

            //  jt808.rxLen = usart3.rxLen;     //

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

            // }

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

            {

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

                ec800.rxBufLen = usart3.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,usart3.rxBuf,usart3.rxLen); //发送整包数据到log串口  

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

            usart3.rxTimeOut = 0;

            usart3.rxLen = 0;

        }  

    }

#else

    void usart3Deal(void)  //usart data deal

    {      

        if((usart3.rxLen>1)&&(usart3.rxTimeOut>10))

        {

            usart3.rxTimeOut = 0;      

            printf("收到OBD串口数据.\r\n");    

            obdParser(usart3.rxBuf,usart3.rxLen);   //ODB数据解析。

            // usartSendBuf(USART1,(u8*)usart3.rxBuf,usart3.rxLen); //

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

            usart3.rxLen = 0;

        }  

    }

#endif