Other Parts Discussed in Thread: C2000WARE
Hi experts,
I try to use MCAN module works as classic CAN with an extend ID.
So I combined "mcan_ex4_receive.c" and "mcan_ex9_transmit.c" in C2000Ware_5_04_00_00 and do some changes, it works with a standard ID (txMsg[loopCnt].xtd = 0U) in loopback mode(INTERNAL),but the ID
received is not equal to the ID I sent .
for example :
tx ID: 0x100000; rx ID:0x100008,
tx ID: 0x100001; rx ID:0x102008,
tx ID: 0x10000F; rx ID:0x11E008,
when I change txMsg[loopCnt].xtd to 1, it fails to communicate.//
// Include Files
//
#include "driverlib.h"
#include "device.h"
#include "inc/stw_types.h"
#include "inc/stw_dataTypes.h"
#include <string.h>
#define NUM_OF_MSG (1U)
#define MCAN_STD_ID_FILTER_NUM (1U)
#define MCAN_EXT_ID_FILTER_NUM (1U)
#define MCAN_FIFO_0_NUM (0U)
#define MCAN_FIFO_0_ELEM_SIZE (MCAN_ELEM_SIZE_64BYTES)
#define MCAN_FIFO_1_NUM (0U)
#define MCAN_FIFO_1_ELEM_SIZE (MCAN_ELEM_SIZE_64BYTES)
#define MCAN_RX_BUFF_NUM (10U)
#define MCAN_RX_BUFF_ELEM_SIZE (MCAN_ELEM_SIZE_8BYTES)
#define MCAN_TX_BUFF_SIZE (1U)
#define MCAN_TX_FQ_SIZE (0U)
#define MCAN_TX_BUFF_ELEM_SIZE (MCAN_ELEM_SIZE_8BYTES)
#define MCAN_TX_EVENT_SIZE (0U)
#define MCAN_STD_ID_FILT_START_ADDR (0x0U)
#define MCAN_EXT_ID_FILT_START_ADDR (MCAN_STD_ID_FILT_START_ADDR + ((MCAN_STD_ID_FILTER_NUM * MCANSS_STD_ID_FILTER_SIZE_WORDS * 4U)))
#define MCAN_FIFO_0_START_ADDR (MCAN_EXT_ID_FILT_START_ADDR + ((MCAN_EXT_ID_FILTER_NUM * MCANSS_EXT_ID_FILTER_SIZE_WORDS * 4U)))
#define MCAN_FIFO_1_START_ADDR (MCAN_FIFO_0_START_ADDR + (MCAN_getMsgObjSize(MCAN_FIFO_0_ELEM_SIZE) * 4U * MCAN_FIFO_0_NUM))
#define MCAN_RX_BUFF_START_ADDR (MCAN_FIFO_1_START_ADDR + (MCAN_getMsgObjSize(MCAN_FIFO_1_ELEM_SIZE) * 4U * MCAN_FIFO_1_NUM))
#define MCAN_TX_BUFF_START_ADDR (MCAN_RX_BUFF_START_ADDR + (MCAN_getMsgObjSize(MCAN_RX_BUFF_ELEM_SIZE) * 4U * MCAN_RX_BUFF_NUM))
#define MCAN_TX_EVENT_START_ADDR (MCAN_TX_BUFF_START_ADDR + (MCAN_getMsgObjSize(MCAN_TX_BUFF_ELEM_SIZE) * 4U * (MCAN_TX_BUFF_SIZE + MCAN_TX_FQ_SIZE)))
int32_t error = 0;
int32_t error1 = 0;
int a = 1;
int32_t id = 0x100000U;
MCAN_RxBufElement rxMsg[NUM_OF_MSG], rxMsg1;
MCAN_TxBufElement txMsg[NUM_OF_MSG];
int32_t loopCnt = 0U;
static void MCANConfig(void);
static void MCANIntrConfig(void);
__interrupt void MCANIntr1ISR(void);
void main()
{
int i = 0;
volatile uint32_t mode = 0U;
uint32_t dataBytes = 8;
//
// Initialize device clock and peripherals
//
Device_init();
//
// Initialize GPIO and unlock the GPIO configuration registers
//
Device_initGPIO();
//
// Configure the divisor for the MCAN bit-clock
//
SysCtl_setMCANClk(SYSCTL_MCANA, SYSCTL_MCANCLK_DIV_5);
//
// ISR Configuration.
//
MCANIntrConfig();
//
// Configure GPIO pins for MCANTX/MCANRX operation
//
GPIO_setPinConfig(DEVICE_GPIO_CFG_MCANRXA);
GPIO_setPinConfig(DEVICE_GPIO_CFG_MCANTXA);
//
// Initialize message to receive
//
rxMsg[loopCnt].id = 0U;
rxMsg[loopCnt].rtr = 0U;
rxMsg[loopCnt].xtd = 0U;
rxMsg[loopCnt].esi = 0U;
rxMsg[loopCnt].rxts = 0U; // Rx Timestamp
rxMsg[loopCnt].dlc = 0U;
rxMsg[loopCnt].brs = 0U;
rxMsg[loopCnt].fdf = 0U;
rxMsg[loopCnt].fidx = 0U; // Filter Index
// (of matching Rx acceptance filter element)
rxMsg[loopCnt].anmf = 0U; // Accepted Non-matching Frame
for(i = 0; i < dataBytes; i++) // Initialize receive buffer to 0
{
rxMsg[loopCnt].data[i] = 0;
}
txMsg[loopCnt].id = ((uint32_t)(0x4)) << 18U; // STDID[28:18]
txMsg[loopCnt].rtr = 0U; // RTR = 0 (Data frame)
txMsg[loopCnt].xtd = 0U; // XTD = 0 (11-bit standard identifier)
txMsg[loopCnt].esi = 0U;
txMsg[loopCnt].dlc = 8U; // 64 bytes
txMsg[loopCnt].brs = 1U; // Bit-rate switching enabled
txMsg[loopCnt].fdf = 1U; // Frame transmitted in CAN FD format
txMsg[loopCnt].efc = 1U; // Store TX events
txMsg[loopCnt].mm = 0xAAU;
txMsg[loopCnt].data[i] = 0x1;
for(i = 1; i < dataBytes; i++)
{
txMsg[loopCnt].data[i] = txMsg[loopCnt].data[i-1] + 1;
}
i = 0;
//
// Configure the MCAN Module.
//
MCANConfig();
//
// Enable Interrupts.
//
MCAN_enableIntr(MCANA_DRIVER_BASE, MCAN_INTR_MASK_ALL, 1U);
//
// Select Interrupt Line.
//
MCAN_selectIntrLine(MCANA_DRIVER_BASE, MCAN_INTR_MASK_ALL, MCAN_INTR_LINE_NUM_1);
//
// Enable Interrupt Line.
//
MCAN_enableIntrLine(MCANA_DRIVER_BASE, MCAN_INTR_LINE_NUM_1, 1U);
while(1)
{
//
// Adding delay of 1 second
//
txMsg[loopCnt].id = id;//((uint32_t)(0x4)) << 18U; // STDID[28:18]
txMsg[loopCnt].rtr = 0U; // RTR = 0 (Data frame)
txMsg[loopCnt].xtd = 0U; // XTD = 0 (11-bit standard identifier)
txMsg[loopCnt].esi = 0U;
txMsg[loopCnt].dlc = 8U; // 64 bytes
txMsg[loopCnt].brs = 1U; // Bit-rate switching enabled
txMsg[loopCnt].fdf = 1U; // Frame transmitted in CAN FD format
txMsg[loopCnt].efc = 1U; // Store TX events
txMsg[loopCnt].mm = 0xAAU;
txMsg[loopCnt].data[i] = 0x1;
for(i = 1; i < dataBytes; i++)
{
txMsg[loopCnt].data[i] = txMsg[loopCnt].data[i-1] + 1;
}
i = 0;
MCAN_writeMsgRam(MCANA_DRIVER_BASE, MCAN_MEM_TYPE_BUF, loopCnt,
&txMsg[loopCnt]);
//
// Add transmission request for Tx buffer 0
//
MCAN_txBufAddReq(MCANA_DRIVER_BASE, 0U);
DEVICE_DELAY_US(1000000);
//
// Message Handling Code goes here
//
}
//
// Stop Application.
//
asm(" ESTOP0");
}
static void MCANConfig(void)
{
MCAN_InitParams initParams;
MCAN_MsgRAMConfigParams msgRAMConfigParams;
MCAN_StdMsgIDFilterElement stdFiltelem;
MCAN_BitTimingParams bitTimes;
MCAN_ExtMsgIDFilterElement extFiltelem;
//
// Initializing all structs to zero to prevent stray values
//
memset(&initParams, 0, sizeof(initParams));
memset(&msgRAMConfigParams, 0, sizeof(msgRAMConfigParams));
memset(&stdFiltelem, 0, sizeof(stdFiltelem));
memset(&bitTimes, 0, sizeof(bitTimes));
memset(&extFiltelem, 0, sizeof(extFiltelem));
//
// Configure MCAN initialization parameters
//
initParams.fdMode = 0x0U; // FD operation enabled.
initParams.brsEnable = 0x0U; // Bit rate switching enabled
initParams.tdcConfig.tdcf = 0xAU;
initParams.tdcConfig.tdco = 0x6U;
//
// Initialize Message RAM Sections Configuration Parameters
//
msgRAMConfigParams.flssa = MCAN_STD_ID_FILT_START_ADDR;
// Standard ID Filter List Start Address.
msgRAMConfigParams.lss = MCAN_STD_ID_FILTER_NUM;
// List Size: Standard ID.
msgRAMConfigParams.flesa = MCAN_EXT_ID_FILT_START_ADDR;
msgRAMConfigParams.lse = MCAN_EXT_ID_FILTER_NUM;
msgRAMConfigParams.rxBufStartAddr = MCAN_RX_BUFF_START_ADDR;
// Rx Buffer Start Address.
msgRAMConfigParams.rxBufElemSize = MCAN_RX_BUFF_ELEM_SIZE;
// Rx Buffer Element Size.
msgRAMConfigParams.txStartAddr = MCAN_TX_BUFF_START_ADDR;
// Tx Buffers Start Address.
msgRAMConfigParams.txBufNum = MCAN_TX_BUFF_SIZE;
// Number of Dedicated Transmit Buffers.
msgRAMConfigParams.txBufMode = 0U;
msgRAMConfigParams.txFIFOSize = MCAN_TX_FQ_SIZE;
// Number of Tx FIFO or Tx Queue Elements
msgRAMConfigParams.txBufElemSize = MCAN_TX_BUFF_ELEM_SIZE;
// Tx Buffer Element Size.
//
// Initialize Rx Buffer Configuration parameters.
//
stdFiltelem.sfid2 = 0x0U; // Standard Filter ID 2.
// Configuring received frame to be stored in buffer element 0
stdFiltelem.sfid1 = 0x4U; // Standard Filter ID 1.
// Confifuring frames with msg ID = 0x4U to be accepted by filter element
stdFiltelem.sfec = 0x7U; // Store into Rx Buffer
// configuration of SFT[1:0] ignored
extFiltelem.efid2 = 0x0U;
extFiltelem.efid1 = 0x0U;
extFiltelem.efec = 0x0U;
extFiltelem.eft = 0x0U;
//
// Initialize bit timings.
//
bitTimes.nomRatePrescalar = 0xBU; // Nominal Baud Rate Pre-scaler
bitTimes.nomTimeSeg1 = 0x2U; // Nominal Time segment before SP
bitTimes.nomTimeSeg2 = 0x0U; // Nominal Time segment after SP
bitTimes.nomSynchJumpWidth = 0x0U; // Nominal SJW
bitTimes.dataRatePrescalar = 0x1U; // Data Baud Rate Pre-scaler
bitTimes.dataTimeSeg1 = 0xAU; // Data Time segment before SP
bitTimes.dataTimeSeg2 = 0x2U; // Data Time segment after SP
bitTimes.dataSynchJumpWidth = 0x2U; // Data SJW
//
// Wait for memory initialization to happen.
//
while(FALSE == MCAN_isMemInitDone(MCANA_DRIVER_BASE))
{
}
//
// Put MCAN in SW initialization mode.
//
MCAN_setOpMode(MCANA_DRIVER_BASE, MCAN_OPERATION_MODE_SW_INIT);
//
// Wait till MCAN is not initialized.
//
while (MCAN_OPERATION_MODE_SW_INIT != MCAN_getOpMode(MCANA_DRIVER_BASE))
{}
//
// Initialize MCAN module.
//
MCAN_init(MCANA_DRIVER_BASE, &initParams);
//
// Configure Bit timings.
//
MCAN_setBitTime(MCANA_DRIVER_BASE, &bitTimes);
//
// Configure Message RAM Sections
//
MCAN_msgRAMConfig(MCANA_DRIVER_BASE, &msgRAMConfigParams);
//
// Configure Standard ID filter element
//
MCAN_addStdMsgIDFilter(MCANA_DRIVER_BASE, 0U, &stdFiltelem);
MCAN_addExtMsgIDFilter(MCANA_DRIVER_BASE, 0U, &extFiltelem);
MCAN_lpbkModeEnable(MCANA_DRIVER_BASE, MCAN_LPBK_MODE_INTERNAL, TRUE);
//
// Take MCAN out of the SW initialization mode
//
MCAN_setOpMode(MCANA_DRIVER_BASE, MCAN_OPERATION_MODE_NORMAL);
while (MCAN_OPERATION_MODE_NORMAL != MCAN_getOpMode(MCANA_DRIVER_BASE))
{
}
}
//
// This function will configure X-BAR for MCAN interrupts.
//
static void MCANIntrConfig(void)
{
Interrupt_initModule();
Interrupt_initVectorTable();
Interrupt_register(INT_MCANA_1,&MCANIntr1ISR);
Interrupt_enable(INT_MCANA_1);
Interrupt_enableGlobal();
}
//
// This is Interrupt Service Routine for MCAN interrupt 1.
//
__interrupt void MCANIntr1ISR(void)
{
uint32_t intrStatus;
MCAN_RxNewDataStatus newData;
intrStatus = MCAN_getIntrStatus(MCANA_DRIVER_BASE);
//
// Clear the interrupt Status.
//
MCAN_clearIntrStatus(MCANA_DRIVER_BASE, intrStatus);
//
// Clearing the interrupt lineNum
//
MCAN_clearInterrupt(MCANA_DRIVER_BASE, 0x2);
//
// Check to see if the interrupt is caused by a message being
// received in dedicated RX Buffers
//
if((MCAN_INTR_SRC_DEDICATED_RX_BUFF_MSG & intrStatus) == MCAN_INTR_SRC_DEDICATED_RX_BUFF_MSG)
{
//
// Read the NewData registers
//
MCAN_getNewDataStatus(MCANA_DRIVER_BASE, &newData);
// If message is received in buffer element 0
if((newData.statusLow & (1UL << 0U)) != 0)
{
MCAN_readMsgRam(MCANA_DRIVER_BASE, MCAN_MEM_TYPE_BUF, 0U,
0, &rxMsg1);
rxMsg[loopCnt] = rxMsg1;
}
//
// Clearing the NewData registers
//
MCAN_clearNewDataStatus(MCANA_DRIVER_BASE, &newData);
}
else
{
error++;
//
// Interrupt handling for other interrupt sources goes here
//
}
//
// Acknowledge this interrupt located in group 9
//
Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP9);
}
what I realy want is a extend Id (29 bit) without any masks or filters,receive as it's sent.
