新唐NUC131OBD与汽车模拟器之间的can通信交互

只看该作者 · 2015-12-2 15:19

本人嵌入式小白一个，目前在弄一个OBD与汽车模拟器之间的通信。基于新唐给的BSP弄了一个交互的程序，发送数据OK，模拟器也有反应，正常情况下模拟器应该有反馈的数据可以接收的，可是我接收到的数据包是空的？不知道问题到底在哪里？希望有懂的大神帮我排解一下问题。我把主程序的代码传一下，大家帮我看看。谢谢。

复制

#include <stdio.h>

#include "NUC131.h"





#define PLL_CLOCK       48000000



/*---------------------------------------------------------------------------*/

/*  Function Declare                                                         */

/*---------------------------------------------------------------------------*/

extern char GetChar(void);

void CAN_ShowMsg(STR_CANMSG_T* Msg);



/* Declare a CAN message structure */

STR_CANMSG_T tMsg;                //transmit data message structure

STR_CANMSG_T rrMsg;   //recieve data message structure

CAN_T *tCAN;        



/*---------------------------------------------------------------------------------------------------------*/

/* ISR to handle CAN interrupt event                                                                       */

/*---------------------------------------------------------------------------------------------------------*/

void CAN_MsgInterrupt(CAN_T *tCAN, uint32_t u32IIDR)

{

                printf("\nThe recieved data is:\n");

        

    if(u32IIDR == 1)

    {

        CAN_Receive(tCAN, 0, &rrMsg);  

        CAN_ShowMsg(&rrMsg);

    }

    if(u32IIDR == 5 + 1)

    {

        CAN_Receive(tCAN, 5, &rrMsg);

        CAN_ShowMsg(&rrMsg);

    }

    if(u32IIDR == 31 + 1)

    {

        CAN_Receive(tCAN, 31, &rrMsg);

        CAN_ShowMsg(&rrMsg);

    }

}



/*---------------------------------------------------------------------------------------------------------*/

/* CAN0 interrupt handler                                                                                  */

/*---------------------------------------------------------------------------------------------------------*/

void CAN0_IRQHandler(void)

{

    uint32_t u8IIDRstatus;



    u8IIDRstatus = CAN0->IIDR;



    if(u8IIDRstatus == 0x00008000)        /* Check Status Interrupt Flag (Error status Int and Status change Int) */

    {

        /**************************/

        /* Status Change interrupt*/

        /**************************/

        if(CAN0->STATUS & CAN_STATUS_RXOK_Msk)

        {

            CAN0->STATUS &= ~CAN_STATUS_RXOK_Msk;   /* Clear RxOK status*/

        }



        if(CAN0->STATUS & CAN_STATUS_TXOK_Msk)

        {

            CAN0->STATUS &= ~CAN_STATUS_TXOK_Msk;    /* Clear TxOK status*/

        }



        /**************************/

        /* Error Status interrupt */

        /**************************/

        if(CAN0->STATUS & CAN_STATUS_BOFF_Msk)

        {

            printf("BOFF INT\n") ;

        }

        else if(CAN0->STATUS & CAN_STATUS_EWARN_Msk)

        {

            printf("EWARN INT\n") ;

        }

        else if((CAN0->ERR & CAN_ERR_TEC_Msk) != 0)

        {

            printf("Transmit error!\n") ;

        }

        else if((CAN0->ERR & CAN_ERR_REC_Msk) != 0)

        {

            printf("Receive error!\n") ;

        }



    }

    else if((u8IIDRstatus >= 0x1) || (u8IIDRstatus <= 0x20))

    {

                                CAN_MsgInterrupt(CAN0, u8IIDRstatus);

                        

        CAN_CLR_INT_PENDING_BIT(CAN0, (u8IIDRstatus - 1)); /* Clear Interrupt Pending */

    }

    else if(CAN0->WU_STATUS == 1)

    {

        printf("Wake up\n");



        CAN0->WU_STATUS = 0;    /* Write '0' to clear */

    }



}







/*---------------------------------------------------------------------------*/

/*  Show Message Function                                                    */

/*---------------------------------------------------------------------------*/

void CAN_ShowMsg(STR_CANMSG_T* Msg)

{

    uint8_t i;



    /* Show the message information */

    printf("Read ID=0x%X, Type=%s, DLC=%d, Data=", Msg->Id, Msg->IdType ? "EXT" : "STD", Msg->DLC);

    for(i = 0; i < Msg->DLC; i++)

        printf("%X,", Msg->Data[i]);

    printf("\n\n");

}



void SYS_Init(void)

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init System Clock                                                                                       */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Enable Internal RC 22.1184MHz clock */

    CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);



    /* Waiting for Internal RC clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);



    /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));



    /* Enable external XTAL 12MHz clock */

    CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);



    /* Waiting for external XTAL clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);



    /* Set core clock as PLL_CLOCK from PLL */

    CLK_SetCoreClock(PLL_CLOCK);



    /* Enable UART module clock */

    CLK_EnableModuleClock(UART0_MODULE);



    /* Enable CAN module clock */

    CLK_EnableModuleClock(CAN0_MODULE);

    //CLK_EnableModuleClock(CAN1_MODULE);



    /* Select UART module clock source */

    CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_PLL, CLK_CLKDIV_UART(1));



    /*---------------------------------------------------------------------------------------------------------*/

    /* Init I/O Multi-function                                                                                 */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Set GPB multi-function pins for UART0 RXD and TXD */

    SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);

    SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;



    /* Set PD multi-function pins for CANTX0, CANRX0 */

    SYS->GPD_MFP &= ~(SYS_GPD_MFP_PD6_Msk | SYS_GPD_MFP_PD7_Msk);

    SYS->GPD_MFP = SYS_GPD_MFP_PD6_CAN0_RXD | SYS_GPD_MFP_PD7_CAN0_TXD;



}



/*---------------------------------------------------------------------------------------------------------*/

/* Init UART                                                                                               */

/*---------------------------------------------------------------------------------------------------------*/

void UART0_Init()

{

    /* Reset IP */

    SYS_ResetModule(UART0_RST);



    /* Configure UART0 and set UART0 Baudrate */

    UART_Open(UART0, 115200);

}







/*----------------------------------------------------------------------------*/

/*  Check the real baud-rate                                                  */

/*----------------------------------------------------------------------------*/

void BaudRateCheck(uint32_t u32BaudRate, uint32_t u32RealBaudRate)

{

    /* Get Core Clock Frequency */

    SystemCoreClockUpdate();



    if(u32BaudRate != u32RealBaudRate)

    {

        printf("\nSetting CAN baud-rate failed.\n");

        printf("Real baud-rate value(bps): %d\n", u32RealBaudRate);

        printf("CAN baud-rate calculation equation as below:\n");

        printf("CAN baud-rate(bps) = Fin/(BPR+1)*(Tseg1+Tseg2+3)\n");

        printf("where: Fin: System clock freq.(Hz)\n");

        printf("       BRP: The baud rate prescale. It is composed of BRP (CAN_BTIME[5:0]) and BRPE (CAN_BRPE[3:0]).\n");

        printf("       Tseg1: Time Segment before the sample point. You can set tseg1 (CAN_BTIME[11:8]).\n");

        printf("       Tseg2: Time Segment after the sample point. You can set tseg2 (CAN_BTIME[14:12]).\n");



        if(SystemCoreClock % u32BaudRate != 0)

            printf("\nThe BPR does not calculate, the Fin must be a multiple of the CAN baud-rate.\n");



        else

            printf("\nThe BPR does not calculate, the (Fin/(CAN baud-rate)) must be a multiple of the (Tseg1+Tseg1+3).\n");

    }

    else

        printf("\nReal baud-rate value(bps): %d\n", u32RealBaudRate);

}



/*----------------------------------------------------------------------------*/

/*  Set the CAN speed                                                         */

/*----------------------------------------------------------------------------*/

void SetCANSpeed(CAN_T  *tCAN)

{

    uint32_t BaudRate = 0, RealBaudRate = 0;

                BaudRate = 250000;

                RealBaudRate = CAN_Open(tCAN,  BaudRate, CAN_NORMAL_MODE);

        

    /* Check the real baud-rate is OK */

    BaudRateCheck(BaudRate, RealBaudRate);

}



//set the param of the corresponding mode

void Set_NormalMode_Tx(CAN_T *tCAN)

{



    CAN_EnableInt(tCAN, CAN_CON_IE_Msk | CAN_CON_SIE_Msk);      /* Enable CAN interrupt and corresponding NVIC of CAN */

    NVIC_SetPriority(CAN0_IRQn, (1 << __NVIC_PRIO_BITS) - 2);   /* Install CAN call back functions */

    NVIC_EnableIRQ(CAN0_IRQn);

        

    printf("Use Message Object No.0 to send STD_ID:0x7DF, Data[02,01]\n\n\n");

        

                tMsg.FrameType = CAN_DATA_FRAME;                        //接收帧的类型

    tMsg.IdType    = CAN_STD_ID;                                   //标准帧报文

    tMsg.Id        = 0x7DF;                                                                //目的地址

    tMsg.DLC       = 2;                                                                                //发送报文字节数

                tMsg.Data[0]   = 0X02;                         

                tMsg.Data[1]   = 0x01;        



}





/*---------------------------------------------------------------------------------------------------------*/

/* MAIN function                                                                                           */

/*---------------------------------------------------------------------------------------------------------*/

int main(void)

{



    tCAN = (CAN_T *) CAN0;



    /* Unlock protected registers */

    SYS_UnlockReg();



    /* Init System, IP clock and multi-function I/O */

    SYS_Init();



    /* Lock protected registers */

    SYS_LockReg();



    /* Init UART0 for printf */

    UART0_Init();



    /* Configuring the Bit Timing */

    SetCANSpeed(tCAN);

                

                Set_NormalMode_Tx(tCAN); 

                

                while(1)

                {

                        CLK_SysTickDelay(100000);

                        

                        if(CAN_Transmit(tCAN, MSG(0), &tMsg)==TRUE)                    

                                        printf("Transmit succeeded.\n");

                        else

                                        printf("Transmit failed.\n");                        

                        

                        if(CAN_SetRxMsg(tCAN, MSG(0), rrMsg.IdType, rrMsg.Id) == FALSE)                        //配置接收数据的报文对象

                                        printf("Set Rx Msg Object failed\n");

                }

}

只看该作者 · 2015-12-2 15:20

在线等大神解答。

只看该作者 · 2015-12-2 15:24

拜托啦，有没有大神愿意帮忙的啊。

只看该作者 · 2015-12-2 16:20

这是串口调试助手显示的内容，就是没有接收数据。

只看该作者 · 2015-12-2 17:56

楼主，如果比较急，需要技术支持，可加FAE QQ2355898184

只看该作者 · 2015-12-2 20:52

can是不是和uart是一样的吗

只看该作者 · 2015-12-5 20:35

嵌入式初涉江湖发表于 2015-12-2 16:20
这是串口调试助手显示的内容，就是没有接收数据。

得先查查有没有初始化成功啊

只看该作者 · 2015-12-7 14:19

加我QQ 1932861944

只看该作者 · 2015-12-7 14:20

我们是专业OBD技术提供商，可以开放源码供你参考加我QQ 1932861944

只看该作者 · 2015-12-7 14:57

小猫爱吃鱼发表于 2015-12-5 20:35
得先查查有没有初始化成功啊

你说的初始化是指什么呢？发送成功了啊

1万 · 2015-12-7 20:48

复制

/******************************************************************************

 * [url=home.php?mod=space&uid=288409]@file[/url]     main.c

 * [url=home.php?mod=space&uid=895143]@version[/url]  V1.00

 * $Revision: 4 $

 * $Date: 14/09/11 7:15p $

 * [url=home.php?mod=space&uid=247401]@brief[/url]    Demonstrate Smartcard UART mode by connecting PA.8 and PA.9 pins.

 *

 * @note

 * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.

*****************************************************************************/

#include <stdio.h>

#include "Nano100Series.h"



uint8_t au8TxBuf[] = "Hello World!";





/**

  * @brief  The interrupt services routine of smartcard port 0

  * @param  None

  * @retval None

  */

void SC0_IRQHandler(void)

{

    // Print SCUART received data to UART port

    // Data length here is short, so we're not care about UART FIFO over flow.

    UART_WRITE(UART0, SCUART_READ(SC0));



    // RDA is the only interrupt enabled in this sample, this status bit

    // automatically cleared after Rx FIFO empty. So no need to clear interrupt

    // status here.



    return;

}



void SYS_Init(void)

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init System Clock                                                                                       */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Unlock protected registers */

    SYS_UnlockReg();



    /* Enable External XTAL (4~24 MHz) */

    CLK_EnableXtalRC(CLK_PWRCTL_HXT_EN_Msk);



    /* Waiting for 12MHz clock ready */

    CLK_WaitClockReady( CLK_CLKSTATUS_HXT_STB_Msk);



    /* Switch HCLK clock source to HXT */

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HXT,CLK_HCLK_CLK_DIVIDER(1));



    /* Enable IP clock */

    CLK_EnableModuleClock(UART0_MODULE);

    CLK_EnableModuleClock(SC0_MODULE);





    /* Select IP clock source */

    CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_UART_CLK_DIVIDER(1));

    CLK_SetModuleClock(SC0_MODULE, CLK_CLKSEL2_SC_S_HXT, CLK_SC0_CLK_DIVIDER(1));



    /* Update System Core Clock */

    /* User can use SystemCoreClockUpdate() to calculate SystemCoreClock. */

    SystemCoreClockUpdate();





    /*---------------------------------------------------------------------------------------------------------*/

    /* Init I/O Multi-function                                                                                 */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Set GPB multi-function pins for UART0 RXD and TXD */

    SYS->PB_L_MFP &= ~(SYS_PB_L_MFP_PB0_MFP_Msk | SYS_PB_L_MFP_PB1_MFP_Msk);

    SYS->PB_L_MFP |= (SYS_PB_L_MFP_PB1_MFP_UART0_TX | SYS_PB_L_MFP_PB0_MFP_UART0_RX);

    /* Set PA.8 and PA.9 pin for SC UART mode */

    SYS->PA_H_MFP &= ~(SYS_PA_H_MFP_PA8_MFP_Msk | SYS_PA_H_MFP_PA9_MFP_Msk);

    SYS->PA_H_MFP |= (SYS_PA_H_MFP_PA8_MFP_SC0_CLK | SYS_PA_H_MFP_PA9_MFP_SC0_DAT);



    /* Lock protected registers */

    SYS_LockReg();

}



int main(void)

{

    /* Init System, IP clock and multi-function I/O

       In the end of SYS_Init() will issue SYS_LockReg()

       to lock protected register. If user want to write

       protected register, please issue SYS_UnlockReg()

       to unlock protected register if necessary */

    SYS_Init();



    /* Init UART to 115200-8n1 for print message */

    UART_Open(UART0, 115200);



    printf("This sample code demos smartcard interface UART mode\n");

    printf("Please connect SC0 CLK pin(PA.8) with SC0 I/O pin(PA.9)\n");

    printf("Hit any key to continue\n");

    getchar();



    // Open smartcard interface 0 in UART mode.

    SCUART_Open(SC0, 115200);

    // Enable smartcard receive interrupt

    SCUART_ENABLE_INT(SC0, SC_IER_RDA_IE_Msk);

    NVIC_EnableIRQ(SC0_IRQn);



    // Write output buffer to smartcard tx FIFO

    SCUART_Write(SC0, au8TxBuf, sizeof(au8TxBuf));







    while(1);

}



/*** (C) COPYRIGHT 2014 Nuvoton Technology Corp. ***/