Signal conversion between CAN and SPI protocols can be implemented through either hardware-level bit shifting or microcontroller-based message processing. The microcontroller approach offers simpler implementation despite slightly higher costs.

SDK Configuration Method

CAN0 Peripheral Initialization

Initialize the CAN0 peripheral clock and basic controller settings.

Receive Buffer Configuration

Define the RX message structure properties including standard/extended frame types and remote frame handling.

Transmit Buffer Configuration

Configure TX message parametres for frame type and transmission mode.

Message ID Filter Mask Setup

Set global mask registers for message filtering, where 0 indicates don't-care bits and 1 requires exact matching.

Interrupt Callback Registration

Register the receive interrupt handler function for incoming messages.

Receive Function Configuration

Enable the message reception mechanism with proper buffer allocation.

can_buff_config_t transmitConfig = {
    .enableFD = false,
    .enableBRS = false,
    .fdPadding = 0U,
    .idType = CAN_MSG_ID_EXT,
    .isRemote = false
};

can_buff_config_t receiveConfig = {
    .enableFD = false,
    .enableBRS = false,
    .fdPadding = 0U,
    .idType = CAN_MSG_ID_EXT,
    .isRemote = false
};

Critical implementation note: RX and TX buffer configuration structures must be declared as global variables to prevent stack allocation issues during CAN operations.

void initializeCAN0(void) {
    CAN_Init(&can_instance_0, &can_config_0);
    CAN_ConfigRxBuff(&can_instance_0, RX_MAILBOX, &receiveConfig, RX_FILTER);
    CAN_ConfigTxBuff(&can_instance_0, TX_MAILBOX, &transmitConfig);
    
    // Set mask to 0 to receive all message IDs
    CAN_SetRxFilter(&can_instance_0, CAN_MSG_ID_EXT, RX_MAILBOX, 0);
    
    CAN_InstallEventCallback(&can_instance_0, &CAN0_InterruptHandler, (void*)0);
    CAN_Receive(&can_instance_0, RX_MAILBOX, &receivedMessage);
}

Interrupt Handler Implementation

Process incoming messages within the interrupt service routine.

void CAN0_InterruptHandler(uint32_t instance, can_event_t event, 
                          uint32_t bufferIndex, void* state) {
    (void)state;
    (void)instance;
    (void)bufferIndex;
    
    CAN_Receive(&can_instance_0, RX_MAILBOX, &receivedMessage);
    
    switch(event) {
        case CAN_EVENT_RX_COMPLETE:
            // Handle received message
            break;
        case CAN_EVENT_TX_COMPLETE:
            // Handle transmission completion
            break;
        default:
            break;
    }
}

Message Transmission

Configure and send CAN messages with specified identifiers and data payload.

can_message_t outgoingMessage;
outgoingMessage.id = 0x181056F4;
outgoingMessage.length = 8;
outgoingMessage.data[0] = 0xFF;
outgoingMessage.data[1] = 0xFF;
outgoingMessage.data[2] = 0xFF;
outgoingMessage.data[3] = 0xFF;
outgoingMessage.data[4] = 0x02;
outgoingMessage.data[5] = 0xFF;
outgoingMessage.data[6] = 0xFF;
outgoingMessage.data[7] = 0xFF;

CAN_SendBlocking(&can_instance_0, TX_MAILBOX, &outgoingMessage, TIMEOUT_MS);

Initialize the CAN peripheral in main() and implement periodic transmission within task cycles, while message reception occurs via interrupt handling.