/****************************************************************************
* [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 */
}
}
/*---------------------------------------------------------------------------------------------------------*/
/* CAN0 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 */
}
}
/*---------------------------------------------------------------------------------------------------------*/
/* Reset message interface parameters */
/*---------------------------------------------------------------------------------------------------------*/
void CAN_ResetIF(CAN_T *tCAN, uint8_t u8IF_Num)
{
if(u8IF_Num > 1)
return;
tCAN->IF[u8IF_Num].CREQ = 0x0; // set bit15 for sending
tCAN->IF[u8IF_Num].CMASK = 0x0;
tCAN->IF[u8IF_Num].MASK1 = 0x0; // useless in basic mode
tCAN->IF[u8IF_Num].MASK2 = 0x0; // useless in basic mode
tCAN->IF[u8IF_Num].ARB1 = 0x0; // ID15~0
tCAN->IF[u8IF_Num].ARB2 = 0x0; // MsgVal, eXt, xmt, ID28~16
tCAN->IF[u8IF_Num].MCON = 0x0; // DLC
tCAN->IF[u8IF_Num].DAT_A1 = 0x0; // data0,1
tCAN->IF[u8IF_Num].DAT_A2 = 0x0; // data2,3
tCAN->IF[u8IF_Num].DAT_B1 = 0x0; // data4,5
tCAN->IF[u8IF_Num].DAT_B2 = 0x0; // data6,7
}
/*---------------------------------------------------------------------------*/
/* 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;
/* 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);
}
/*---------------------------------------------------------------------------------------------------------*/
/* 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);
}
/*----------------------------------------------------------------------------*/
/* 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_NORMAL_MODE);//Set target baud-rate and operation mode.
else if(unItem == '2')
i32Err = CAN_Open(tCAN, 250000, CAN_NORMAL_MODE);
else if(unItem == '3')
i32Err = CAN_Open(tCAN, 125000, CAN_NORMAL_MODE);
else if(unItem == '4')
i32Err = CAN_Open(tCAN, 100000, CAN_NORMAL_MODE);
else if(unItem == '5')
i32Err = CAN_Open(tCAN, 50000, CAN_NORMAL_MODE);
else
i32Err = CAN_Open(tCAN, 1000000, CAN_NORMAL_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("| Receive a message by normal mode |\n");
printf("| |\n");
printf("+-------------------------------------------------------------------+\n");
}
/*----------------------------------------------------------------------------*/
/* Send Rx Msg by Normal Mode Function (With Message RAM) */
/*----------------------------------------------------------------------------*/
void Test_NormalMode_Rx(CAN_T *tCAN)
{
if(CAN_SetRxMsg(tCAN, MSG(0), CAN_STD_ID, 0x7FF) == FALSE) {
printf("Set Rx Msg Object failed\n");
return;
}
if(CAN_SetRxMsg(tCAN, MSG(5), CAN_EXT_ID, 0x12345) == FALSE) {
printf("Set Rx Msg Object failed\n");
return;
}
if(CAN_SetRxMsg(tCAN, MSG(31), CAN_EXT_ID, 0x7FF01) == FALSE) {
printf("Set Rx Msg Object failed\n");
return;
}
/*Choose one mode to test*/
#if 1
/* Polling Mode */
while(1) {
while(tCAN->IIDR == 0); /* Wait IDR is changed */
printf("IDR = %x\n", tCAN->IIDR);
CAN_Receive(tCAN, tCAN->IIDR - 1, &rrMsg); /* Get the message */
CAN_ShowMsg(&rrMsg); /* Show the message object */
}
#else
/* INT Mode */
CAN_EnableInt(tCAN, CAN_CON_IE_Msk); /* Enable CAN interrupt and corresponding NVIC of CAN */
NVIC_SetPriority(CAN0_IRQn, (1 << __NVIC_PRIO_BITS) - 2); /* Install CAN call back functions */
NVIC_SetPriority(CAN1_IRQn, (1 << __NVIC_PRIO_BITS) - 2);
NVIC_EnableIRQ(CAN0_IRQn);
NVIC_EnableIRQ(CAN1_IRQn);
printf("Wait Msg\n");
printf("Enter any key to exit\n");
GetChar();
#endif
}
/*---------------------------------------------------------------------------------------------------------*/
/* 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("Receive a message by normal mode\n\n");
/* Send Rx Msg by Normal Mode Function (With Message RAM) */
Test_NormalMode_Rx(tCAN);
/* Disable CAN */
CAN_Close(tCAN);
/* Disable CAN Clock and Reset it */
CAN_STOP();
while(1);
}
楼主
标题置顶
标题高亮
