[技术问答] 关于NUC131中断入口的问题！！！想不通！

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

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

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

 * $Revision: 1 $

 * $Date: 14/10/01 5:10p $

 * [url=home.php?mod=space&uid=247401]@brief[/url]    NUC230_240 Series CAN Driver Sample Code

 *

 * @note

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

 *

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

#include <stdio.h>

#include "NUC230_240.h"





#define PLL_CLOCK       50000000



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

/*  Function Declare                                                         */

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

extern char GetChar(void);

void CAN_ShowMsg(STR_CANMSG_T* Msg);



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

/* Define global variables and constants                                                                   */

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

/* Declare a CAN message structure */

STR_CANMSG_T rrMsg;





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

/* ISR to handle CAN interrupt event                                                                       */

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

void CAN_MsgInterrupt(CAN_T *tCAN, uint32_t u32IIDR)

{

    if(u32IIDR == 1) {

        printf("Msg-0 INT and Callback\n");

        CAN_Receive(tCAN, 0, &rrMsg);

        CAN_ShowMsg(&rrMsg);

    }

    if(u32IIDR == 5 + 1) {

        printf("Msg-5 INT and Callback \n");

        CAN_Receive(tCAN, 5, &rrMsg);

        CAN_ShowMsg(&rrMsg);

    }

    if(u32IIDR == 31 + 1) {

        printf("Msg-31 INT and Callback \n");

        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*/



            printf("RxOK INT\n") ;

        }



        if(CAN0->STATUS & CAN_STATUS_TXOK_Msk) {

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



            printf("TxOK INT\n") ;

        }



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

        /* Error Status interrupt */

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

        if(CAN0->STATUS & CAN_STATUS_EWARN_Msk) {

            printf("EWARN INT\n") ;

        }



        if(CAN0->STATUS & CAN_STATUS_BOFF_Msk) {

            printf("BOFF INT\n") ;

        }

    } else if(u8IIDRstatus != 0) {

        printf("=> Interrupt Pointer = %d\n", CAN0->IIDR - 1);



        CAN_MsgInterrupt(CAN0, u8IIDRstatus);



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

    } else if(CAN0->WU_STATUS == 1) {

        printf("Wake up\n");



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

    }



}



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

/* CAN1 interrupt handler                                                                                  */

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

void CAN1_IRQHandler(void)

{

    uint32_t u8IIDRstatus;



    u8IIDRstatus = CAN1->IIDR;



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

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

        /* Status Change interrupt*/

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

        if(CAN1->STATUS & CAN_STATUS_RXOK_Msk) {

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



            printf("RxOK INT\n") ;

        }



        if(CAN1->STATUS & CAN_STATUS_TXOK_Msk) {

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



            printf("TxOK INT\n") ;

        }



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

        /* Error Status interrupt */

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

        if(CAN1->STATUS & CAN_STATUS_EWARN_Msk) {

            printf("EWARN INT\n") ;

        }



        if(CAN1->STATUS & CAN_STATUS_BOFF_Msk) {

            printf("BOFF INT\n") ;

        }

    } else if(u8IIDRstatus != 0) {

        printf("=> Interrupt Pointer = %d\n", CAN1->IIDR - 1);



        CAN_MsgInterrupt(CAN1, u8IIDRstatus);



        CAN_CLR_INT_PENDING_BIT(CAN1, ((CAN1->IIDR) - 1)); /* Clear Interrupt Pending */

    } else if(CAN1->WU_STATUS == 1) {

        printf("Wake up\n");



        CAN1->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");

}



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

/* Disable CAN Clock and Reset it                                                                          */

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

void CAN_STOP(void)

{

    /* Disable CAN0 Clock and Reset it */

    SYS_ResetModule(CAN0_RST);

    CLK_DisableModuleClock(CAN0_MODULE);



    /* Disable CAN1 Clock and Reset it */

    SYS_ResetModule(CAN1_RST);

    CLK_DisableModuleClock(CAN1_MODULE);

}



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;



    /* Set PA multi-function pins for CANTX1, CANRX1 */

//     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA10_Msk | SYS_GPA_MFP_PA11_Msk);

//     SYS->GPA_MFP = SYS_GPA_MFP_PA10_CAN1_TXD | SYS_GPA_MFP_PA11_CAN1_RXD;

//     SYS->ALT_MFP &= ~(SYS_ALT_MFP_PA10_Msk | SYS_ALT_MFP_PA11_Msk);

//     SYS->ALT_MFP |= SYS_ALT_MFP_PA10_CAN1_TXD | SYS_ALT_MFP_PA11_CAN1_RXD;



}



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

/* Init UART                                                                                               */

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

void UART0_Init()

{

    /* Reset IP */

    SYS_ResetModule(UART0_RST);



    /* Configure UART0 and set UART0 Baudrate */

    UART_Open(UART0, 115200);

}



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

/*  Some description about how to create test environment                     */

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

void Note_Configure()

{

    printf("\n\n");

    printf("+--------------------------------------------------------------------------+\n");

    printf("|  About CAN sample code configure                                         |\n");

    printf("+--------------------------------------------------------------------------+\n");

    printf("|   The sample code provide a simple sample code for you study CAN         |\n");

    printf("|   Before execute it, please check description as below                   |\n");

    printf("|                                                                          |\n");

    printf("|   1.CAN_TX and CAN_RX should be connected to your CAN transceiver        |\n");

    printf("|   2.Using two module board and connect to the same CAN BUS               |\n");

    printf("|   3.Check the terminal resistor of bus is connected                      |\n");

    printf("|   4.Using UART0 as print message port                                    |\n");

    printf("|                                                                          |\n");

    printf("|  |--------|       |-----------|   CANBUS  |-----------|       |--------| |\n");

    printf("|  |        |------>|           |<--------->|           |<------|        | |\n");

    printf("|  |        |CAN_TX |    CAN    |   CAN_H   |   CAN     |CAN_TX |        | |\n");

    printf("|  | NUC2XX |       |Transceiver|           |Transceiver|       | NUC2XX | |\n");

    printf("|  |        |<------|           |<--------->|           |------>|        | |\n");

    printf("|  |        |CAN_RX |           |   CAN_L   |           |CAN_RX |        | |\n");

    printf("|  |--------|       |-----------|           |-----------|       |--------| |\n");

    printf("|  |                                                            |          |\n");

    printf("|  |                                                            |          |\n");

    printf("|  V                                                            V          |\n");

    printf("| UART0                                                         UART0      |\n");

    printf("|(print message)                                          (print message)  |\n");

    printf("+--------------------------------------------------------------------------+\n");

}



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

/*  Set the CAN speed                                                         */

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

void SelectCANSpeed(CAN_T  *tCAN)

{

    uint32_t unItem;

    int32_t i32Err = 0;



    printf("Please select CAN speed you desired\n");

    printf("[0] 1000Kbps\n");

    printf("[1]  500Kbps\n");

    printf("[2]  250Kbps\n");

    printf("[3]  125Kbps\n");

    printf("[4]  100Kbps\n");

    printf("[5]   50Kbps\n");



    unItem = GetChar();

    printf("%c\n", unItem);

    if(unItem == '1')

        i32Err = CAN_Open(tCAN,  500000, CAN_BASIC_MODE);//Set target baud-rate and operation mode.

    else if(unItem == '2')

        i32Err = CAN_Open(tCAN,  250000, CAN_BASIC_MODE);

    else if(unItem == '3')

        i32Err = CAN_Open(tCAN,  125000, CAN_BASIC_MODE);

    else if(unItem == '4')

        i32Err = CAN_Open(tCAN,  100000, CAN_BASIC_MODE);

    else if(unItem == '5')

        i32Err = CAN_Open(tCAN,   50000, CAN_BASIC_MODE);

    else

        i32Err = CAN_Open(tCAN, 1000000, CAN_BASIC_MODE);



    if(i32Err < 0)

        printf("Set CAN bit rate is fail\n");

    else

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



}



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

/*  Test Menu                                                                 */

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

void TestItem(void)

{

    printf("\n");

    printf("+------------------------------------------------------------------ +\n");

    printf("|  Nuvoton CAN BUS DRIVER DEMO                                      |\n");

    printf("+-------------------------------------------------------------------+\n");

    printf("|                                                                   |\n");

    printf("|     Transmit a message by basic mode                              |\n");

    printf("|     (At first, another module board should be set to              |\n");

    printf("|     [CAN_BasicMode_Receive] waiting for receiving data)           |\n");

    printf("|                                                                   |\n");

    printf("+-------------------------------------------------------------------+\n");

}



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

/*  Send Tx Msg by Basic Mode Function (Without Message RAM)                  */

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

void Test_BasicMode_Tx(CAN_T  *tCAN)

{

    int32_t delaycount;



    /* Declare a CAN message structure */

    STR_CANMSG_T msg1;

    delaycount=1000;



    /* Enable CAN interrupt */

    CAN_EnableInt(tCAN, CAN_CON_IE_Msk | CAN_CON_SIE_Msk);

    /* Set Interrupt Priority */

    NVIC_SetPriority(CAN0_IRQn, (1 << __NVIC_PRIO_BITS) - 2);

    NVIC_SetPriority(CAN1_IRQn, (1 << __NVIC_PRIO_BITS) - 2);

    /* Enable External Interrupt */

    NVIC_EnableIRQ(CAN0_IRQn);

    NVIC_EnableIRQ(CAN1_IRQn);



    /* Send Message No.1 */

    msg1.FrameType = CAN_DATA_FRAME;

    msg1.IdType   = CAN_STD_ID;

    msg1.Id       = 0x001;

    msg1.DLC      = 2;

    msg1.Data[0]  = 0x00;

    msg1.Data[1]  = 0x2;

    CAN_Transmit(tCAN, 0, &msg1);//Send CAN message

    printf("Send STD_ID:0x1,Data[0,2]\n");

    CLK_SysTickDelay(delaycount);   /* Generate the Delay Time by Systick */



    /* Send Message No.2 */

    msg1.FrameType = CAN_DATA_FRAME;

    msg1.IdType   = CAN_STD_ID;

    msg1.Id       = 0x1AC;

    msg1.DLC      = 8;

    msg1.Data[0]  = 0x11;

    msg1.Data[1]  = 0x12;

    msg1.Data[2]  = 0x13;

    msg1.Data[3]  = 0x14;

    msg1.Data[4]  = 0x15;

    msg1.Data[5]  = 0x16;

    msg1.Data[6]  = 0x17;

    msg1.Data[7]  = 0x18;

    CAN_Transmit(tCAN, 0, &msg1);//Send CAN message

    printf("Send STD_ID:0x1AC,Data[11,12,13,14,15,16,17,18]\n");

    CLK_SysTickDelay(delaycount);   /* Generate the Delay Time by Systick */



    /* Send Message No.3 */

    msg1.FrameType = CAN_DATA_FRAME;

    msg1.IdType   = CAN_STD_ID;

    msg1.Id       = 0x310;

    msg1.DLC      = 8;

    msg1.Data[0]  = 0x21;

    msg1.Data[1]  = 0x22;

    msg1.Data[2]  = 0x23;

    msg1.Data[3]  = 0x24;

    msg1.Data[4]  = 0x25;

    msg1.Data[5]  = 0x26;

    msg1.Data[6]  = 0x27;

    msg1.Data[7]  = 0x28;

    CAN_Transmit(tCAN, 0, &msg1);//Send CAN message

    printf("Send STD_ID:0x310,Data[21,22,23,24,25,26,27,28]\n");

    CLK_SysTickDelay(delaycount);   /* Generate the Delay Time by Systick */



    /* Send Message No.4 */

    msg1.FrameType = CAN_DATA_FRAME;

    msg1.IdType   = CAN_EXT_ID;

    msg1.Id       = 0x3377;

    msg1.DLC      = 8;

    msg1.Data[0]  = 0x31;

    msg1.Data[1]  = 0x32;

    msg1.Data[2]  = 0x33;

    msg1.Data[3]  = 0x34;

    msg1.Data[4]  = 0x35;

    msg1.Data[5]  = 0x36;

    msg1.Data[6]  = 0x37;

    msg1.Data[7]  = 0x38;

    CAN_Transmit(tCAN, 0, &msg1);//Send CAN message

    printf("Send EXT_ID:0x3377,Data[31,32,33,34,35,36,37,38]\n");

    CLK_SysTickDelay(delaycount);   /* Generate the Delay Time by Systick */



    /* Send Message No.5 */

    msg1.FrameType = CAN_DATA_FRAME;

    msg1.IdType   = CAN_EXT_ID;

    msg1.Id       = 0x7755;

    msg1.DLC      = 8;

    msg1.Data[0]  = 0x41;

    msg1.Data[1]  = 0x42;

    msg1.Data[2]  = 0x43;

    msg1.Data[3]  = 0x44;

    msg1.Data[4]  = 0x45;

    msg1.Data[5]  = 0x46;

    msg1.Data[6]  = 0x47;

    msg1.Data[7]  = 0x48;



    CAN_Transmit(tCAN, 0, &msg1);//Send CAN message

    printf("Send EXT_ID:0x7755,Data[41,42,43,44,45,46,47,48]\n");

    CLK_SysTickDelay(delaycount);   /* Generate the Delay Time by Systick */



}



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

/* MAIN function                                                                                           */

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

int main(void)

{

    CAN_T *tCAN;

    tCAN = (CAN_T *) CAN0;

    //tCAN = (CAN_T *) CAN1;



    /* 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();



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

    /* SAMPLE CODE                                                                                             */

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



//     /* Set GPB12 to control CAN transceiver for Nuvoton board */

//     PB12 = 0;



    /* Some description about how to create test environment */

    Note_Configure();



    /* configuring the Bit Timing */

    SelectCANSpeed(tCAN);



    /* Test Menu */

    TestItem();



    printf("Transmit a message by basic mode\n\n");

    printf("Please confirm receiver is ready.\n");

    printf("Press any key to continue ...\n\n");

    GetChar();



    /* Send Tx Msg by Basic Mode Function (Without Message RAM) */

    Test_BasicMode_Tx(tCAN);



    /* Disable CAN */

    CAN_Close(tCAN);



    /* Disable CAN Clock and Reset it */

    CAN_STOP();



    while(1);



}