/**
*
* The entry point for showing the XCanPs driver in polled mode. The example
* configures the device for internal loop back mode, then sends a Can
* frame, receives the same Can frame, and verifies the frame contents.
*
* @param DeviceId is the XPAR_<CANPS_instance>_DEVICE_ID value from
* xparameters.h
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note
*
* If the device is not working correctly, this function may enter an infinite
* loop and will never return to the caller.
*
******************************************************************************/
int CanPsPolledExample(u16 DeviceId)
{
int Status;
XCanPs *CanInstPtr = &Can;
XCanPs_Config *ConfigPtr;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(DeviceId);
if (CanInstPtr == NULL) {
return XST_FAILURE;
}
Status = XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enter Configuration Mode so we can setup Baud Rate Prescaler
* Register (BRPR) and Bit Timing Register (BTR).
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_CONFIG);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_CONFIG);
/*
* Setup Baud Rate Prescaler Register (BRPR) and
* Bit Timing Register (BTR).
*/
XCanPs_SetBaudRatePrescaler(CanInstPtr, TEST_BRPR_BAUD_PRESCALAR);
XCanPs_SetBitTiming(CanInstPtr, TEST_BTR_SYNCJUMPWIDTH,
TEST_BTR_SECOND_TIMESEGMENT,
TEST_BTR_FIRST_TIMESEGMENT);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Send a frame, receive the frame via the loop back and verify its
* contents.
*/
Status = SendFrame(CanInstPtr);
if (Status != XST_SUCCESS) {
return Status;
}
Status = RecvFrame(CanInstPtr);
return Status;
}
/**
*
* The main entry point for showing the XCanPs driver in interrupt mode.
* The example configures the device for internal loop back mode, then
* sends a CAN frame and receives the same CAN frame.
*
* @param IntcInstPtr is a pointer to the instance of the INTC driver.
* @param CanInstPtr is a pointer to the instance of the CAN driver which
* is going to be connected to the interrupt controller.
* @param CanDeviceId is the device Id of the CAN device and is typically
* XPAR_<CANPS_instance>_DEVICE_ID value from xparameters.h.
* @param CanIntrId is the interrupt Id and is typically
* XPAR_<CANPS_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note If the device is not working correctly, this function may enter
* an infinite loop and will never return to the caller.
*
******************************************************************************/
int CanPsIntrExample(INTC *IntcInstPtr, XCanPs *CanInstPtr,
u16 CanDeviceId, u16 CanIntrId)
{
int Status;
XCanPs_Config *ConfigPtr;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(CanDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Configure CAN device.
*/
Config(CanInstPtr);
/*
* Set interrupt handlers.
*/
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_SEND,
(void *)SendHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_RECV,
(void *)RecvHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_ERROR,
(void *)ErrorHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_EVENT,
(void *)EventHandler, (void *)CanInstPtr);
/*
* Initialize the flags.
*/
SendDone = FALSE;
RecvDone = FALSE;
LoopbackError = FALSE;
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(IntcInstPtr,
CanInstPtr,
CanIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable all interrupts in CAN device.
*/
XCanPs_IntrEnable(CanInstPtr, XCANPS_IXR_ALL);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Loop back a frame. The RecvHandler is expected to handle
* the frame reception.
*/
SendFrame(CanInstPtr); /* Send a frame */
/*
* Wait here until both sending and reception have been completed.
*/
while ((SendDone != TRUE) || (RecvDone != TRUE));
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_LOOPBACK_ERROR;
}
return XST_SUCCESS;
}
/**
*
* The main entry point for showing the usage of XCanPs driver in interrupt
* mode. The example configures the device for internal loop back mode, then
* sends multiple CAN frames and receives the same number of CAN frame's
* using the Rx Watermark Interrupt.
*
* @param IntcInstPtr is a pointer to the instance of the ScuGic driver.
* @param CanInstPtr is a pointer to the instance of the CAN driver which
* is going to be connected to the interrupt controller.
* @param CanDeviceId is the device Id of the CAN device and is typically
* XPAR_<CANPS_instance>_DEVICE_ID value from xparameters.h.
* @param CanIntrId is the interrupt Id and is typically
* XPAR_<CANPS_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note If the device is not working correctly, this function may enter
* an infinite loop and will never return to the caller.
*
******************************************************************************/
int CanPsWatermarkIntrExample(XScuGic *IntcInstPtr, XCanPs *CanInstPtr,
u16 CanDeviceId, u16 CanIntrId)
{
int Status;
XCanPs_Config *ConfigPtr;
u32 Index;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(CanDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Configure the CAN device.
*/
Config(CanInstPtr);
/*
* Set the interrupt handlers.
*/
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_SEND,
(void *)SendHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_RECV,
(void *)RecvHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_ERROR,
(void *)ErrorHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_EVENT,
(void *)EventHandler, (void *)CanInstPtr);
/*
* Initialize flags.
*/
SendDone = FALSE;
RecvDone = FALSE;
LoopbackError = FALSE;
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(IntcInstPtr,
CanInstPtr,
CanIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable all interrupts in CAN device.
*/
XCanPs_IntrEnable(CanInstPtr, XCANPS_IXR_ALL);
/*
* Disable the Receive FIFO Not Empty Interrupt and the
* New Message Received Interrupt.
*/
XCanPs_IntrDisable(CanInstPtr,
XCANPS_IXR_RXNEMP_MASK |
XCANPS_IXR_RXOK_MASK);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Send a number of frames.
*/
TestDataOffset = 1;
for (Index = 0; Index < TEST_THRESHOLD; Index++) {
SendFrame(CanInstPtr); /* Send a frame */
TestDataOffset++;
}
/*
* Wait here until both sending and reception have been completed.
*/
while ((SendDone < TEST_THRESHOLD) || (RecvDone != TRUE));
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_FAILURE;
}
/*
* Read the Received Frames from the FIFO.
*/
TestDataOffset = 1;
Status = ReceiveData(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_LOOPBACK_ERROR;
}
return XST_SUCCESS;
}
