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