#include <vxWorks.h>
#include <can.h>

int main() {
    // CAN device identifier - might be different based on your hardware setup
    CAN_ID canId;
    
    // Open the CAN device. "/can/0" represents the first CAN controller on the board.
    int fd = canDevCreate("/can/0", &canId);
    if (fd < 0) {
        printf("Failed to initialize CAN device\n");
        return -1;
    }
    // 'fd' now holds the file descriptor for this CAN device, used for all subsequent operations.
}

// Structure to hold CAN configuration parameters
CAN_CONFIG config;

// Set the bit rate to 500 kbps (common for many automotive applications)
config.bitRate = 500000;

// Sample point at 87.5% of the bit time for noise immunity
config.samplePoint = 875;

// Synchronization jump width - how much the bit timing can be adjusted to synchronize with other nodes
config.sjw = 1;

// Apply configuration to the CAN device
if (canIoctl(fd, CAN_CMD_SET_CONFIG, (int)&config) != OK) {
    printf("Failed to configure CAN bus\n");
    return -1;
}

// Prepare a CAN frame for transmission
CAN_FRAME txFrame;
txFrame.id = 0x123; // CAN message identifier (arbitrarily chosen here)
txFrame.dlc = 8;    // Data Length Code, specifying 8 bytes of data

// Fill the data bytes. Here, we're just using a simple increment for demonstration.
for (int i = 0; i < 8; i++) {
    txFrame.data[i] = i;
}

// Send the CAN frame. The '1' indicates we're sending one frame.
if (canWrite(fd, &txFrame, 1) != 1) {
    printf("Failed to send CAN message\n");
}

CAN_FRAME rxFrame;

// Loop to continuously check for received messages
while (1) {
    // Read one CAN frame. 'canRead' returns the number of frames read or an error code.
    int bytesRead = canRead(fd, &rxFrame, 1);
    if (bytesRead == 1) {
        printf("Received CAN message with ID: 0x%X\n", rxFrame.id);
        // Print each byte of the received data
        for (int i = 0; i < rxFrame.dlc; i++) {
            printf("Byte %d: %X\n", i, rxFrame.data[i]);
        }
    } else if (bytesRead < 0) {
        printf("Error reading CAN message\n");
        break; // Exit loop on error
    }
}

{
// Close the CAN device when done
canDevDelete(fd);
return 0;
}

// Define an interrupt handler for CAN events
void canInterruptHandler(int vector) {
    // Check for new messages or handle errors. This might involve reading status registers.
}

// Connect the ISR to the CAN interrupt vector. CAN_INTERRUPT_VECTOR should be defined according to your hardware setup.
intConnect(INUM_TO_IVEC(CAN_INTERRUPT_VECTOR), canInterruptHandler, 0);

CAN_ERROR_STATUS errorStatus;
// Check for CAN bus errors like bit errors, stuff errors, etc.
canIoctl(fd, CAN_CMD_GET_ERROR_STATUS, (int)&errorStatus);
if (errorStatus.txErrorCounter > 127 || errorStatus.rxErrorCounter > 127) {
    printf("Warning: CAN bus approaching error state\n");
}

if (errorStatus.busOff) {
    // If the CAN controller goes into bus off state, reset it
    canIoctl(fd, CAN_CMD_RESET, 0);
    printf("CAN bus reset due to bus off condition\n");
}