CAN Communication

CAN (Controller Area Network) is the backbone of every XBB recipe. Through CAN, your recipe reads vehicle signals - ignition state, speed, light switches, door locks - and sends commands to other modules on the bus. TSharkRex provides four core function blocks for CAN communication: CAN_TX for transmitting frames, CAN_RX for filtered reception, CAN_RX_ALL for unfiltered reception, and CAN_MODE for controller configuration.

CAN_TX - Transmit CAN Frame

CAN_TX sends a single CAN frame onto the bus. You populate a data buffer, set the CAN ID and data length, then call the function block with ENABLE := TRUE. The frame is transmitted on the next bus cycle.

Parameters

Basic Transmit Example

This example sends a UDS diagnostic request (Read Data By Identifier) on the standard OBD-II broadcast address 0x7DF:

VAR
    CANSEND : CAN_TX;
    SENDDATA : ARRAY[0..7] OF BYTE;
END_VAR;

SENDDATA[0] := 0x03;    // PCI: 3 data bytes follow
SENDDATA[1] := 0x22;    // Service: Read Data By Identifier
SENDDATA[2] := 0x45;    // DID high byte
SENDDATA[3] := 0x55;    // DID low byte
SENDDATA[4] := 0x00;    // Padding
SENDDATA[5] := 0x00;
SENDDATA[6] := 0x00;
SENDDATA[7] := 0x00;

CANSEND(ENABLE := TRUE, ID := 0x7DF, EXT := FALSE, DATALENGTH := 8, DATA := SENDDATA);

// Change CAN_RX filter ID: must cycle ENABLE
CANRECV(ENABLE := FALSE);                              // Disable first
CANRECV(ENABLE := TRUE, ID := 0x7E8, DATA := DATA);   // New filter ID takes effect

Periodic Transmit with Timer

In most recipes, you do not want to blast CAN frames every scan cycle. Use a timer to control the transmit rate:

VAR
    CANSEND : CAN_TX;
    SENDDATA : ARRAY[0..7] OF BYTE;
    TMR_SEND : TON;
END_VAR;

// Send every 100ms
TMR_SEND(IN := NOT TMR_SEND.Q, PT := T#100ms);
IF TMR_SEND.Q THEN
    SENDDATA[0] := 0x03;
    SENDDATA[1] := 0x22;
    SENDDATA[2] := 0x45;
    SENDDATA[3] := 0x55;
    CANSEND(ENABLE := TRUE, ID := 0x7DF, EXT := FALSE, DATALENGTH := 8, DATA := SENDDATA);
    TMR_SEND(IN := FALSE);
END_IF;

Extended ID (29-bit) Example

For J1939 or ISO 15765-4 with extended addressing, set EXT := TRUE:

VAR
    CANSEND : CAN_TX;
    SENDDATA : ARRAY[0..7] OF BYTE;
END_VAR;

SENDDATA[0] := 0x03;
SENDDATA[1] := 0x22;
SENDDATA[2] := 0xF1;
SENDDATA[3] := 0x90;

CANSEND(ENABLE := TRUE, ID := 0x18DB33F1, EXT := TRUE, DATALENGTH := 8, DATA := SENDDATA);

CAN-FD Example

CAN-FD allows payloads up to 64 bytes and optionally a higher data-phase bitrate via BRS:

VAR
    CANSEND : CAN_TX;
    FD_DATA : ARRAY[0..63] OF BYTE;
END_VAR;

FD_DATA[0] := 0x10;
FD_DATA[1] := 0x20;
// ... fill remaining bytes ...

CANSEND(ENABLE := TRUE, ID := 0x641, EXT := FALSE, FD := TRUE, BRS := TRUE,
        DATALENGTH := 64, DATA := FD_DATA);

CAN_RX - Receive CAN Frame (Filtered)

CAN_RX listens for frames with a specific CAN ID. You provide the ID to filter on, and the function block buffers incoming matches. When AVAILABLE is greater than zero, new data has arrived in your receive buffer.

Parameters

Basic Receive Example

Filter for a specific ECU response address and process incoming data:

VAR
    CANRECV : CAN_RX;
    RECVDATA : ARRAY[0..7] OF BYTE;
    SIGNAL_TANDNING : BOOL;
END_VAR;

CANRECV(ENABLE := TRUE, ID := 0x320, EXT := FALSE, MSG_COUNT := 5, DATA := RECVDATA);

IF CANRECV.AVAILABLE > 0 THEN
    // Byte 0, bit 0 contains ignition status
    SIGNAL_TANDNING := (RECVDATA[0] AND 0x01) > 0;
END_IF;

Processing the Message Queue

When MSG_COUNT is greater than 1, multiple messages can be buffered. Use a WHILE loop to drain the queue - each call to CAN_RX after the first pops the next message:

VAR
    CANRECV : CAN_RX;
    RECVDATA : ARRAY[0..7] OF BYTE;
    didValue : DINT;
END_VAR;

CANRECV(ENABLE := TRUE, ID := 0x7E8, EXT := FALSE, MSG_COUNT := 10, DATA := RECVDATA);

WHILE CANRECV.AVAILABLE > 0 DO
    // Check if this is a positive response to our DID request
    IF RECVDATA[0] = 0x04 AND RECVDATA[1] = 0x62 THEN
        // Extract 16-bit DID value from bytes 4-5
        didValue := RECVDATA[4] * 256 + RECVDATA[5];
    END_IF;

    // Pop next message from queue
    CANRECV(ENABLE := TRUE, ID := 0x7E8, EXT := FALSE, MSG_COUNT := 10, DATA := RECVDATA);
END_WHILE;

CAN_RX_ALL - Receive ALL CAN Frames

CAN_RX_ALL receives every frame on the CAN bus without any ID filter. This is essential when you need to listen for responses from multiple ECUs (for example, after a broadcast UDS request) or when scanning the bus to discover which CAN IDs are present.

CAN_RX vs CAN_RX_ALL

The key difference is the direction of the ID parameter:

Parameters

Broadcast DID Request Example

A common pattern is to send a UDS broadcast request on 0x7DF and then capture all ECU responses. Each ECU responds on its own address (e.g., 0x7E8, 0x7E9, 0x7EA, etc.):

VAR
    CANSEND : CAN_TX;
    CANRECV_ALL : CAN_RX_ALL;
    SENDDATA : ARRAY[0..7] OF BYTE;
    RECVDATA : ARRAY[0..7] OF BYTE;
    TMR_POLL : TON;
    responseId : DINT;
    ecuCount : INT := 0;
END_VAR;

// Send broadcast DID request every 500ms
TMR_POLL(IN := NOT TMR_POLL.Q, PT := T#500ms);
IF TMR_POLL.Q THEN
    SENDDATA[0] := 0x03;
    SENDDATA[1] := 0x22;    // Read Data By Identifier
    SENDDATA[2] := 0xF1;    // DID 0xF190 (VIN)
    SENDDATA[3] := 0x90;
    CANSEND(ENABLE := TRUE, ID := 0x7DF, EXT := FALSE, DATALENGTH := 8, DATA := SENDDATA);
    ecuCount := 0;
    TMR_POLL(IN := FALSE);
END_IF;

// Receive all responses
CANRECV_ALL(ENABLE := TRUE, MSG_COUNT := 20, DATA := RECVDATA);

WHILE CANRECV_ALL.AVAILABLE > 0 DO
    responseId := CANRECV_ALL.ID;

    // Check if this is a UDS positive response (service 0x62)
    IF RECVDATA[1] = 0x62 AND responseId >= 0x7E8 AND responseId <= 0x7EF THEN
        ecuCount := ecuCount + 1;
        // Process response from ECU at address responseId
    END_IF;

    CANRECV_ALL(ENABLE := TRUE, MSG_COUNT := 20, DATA := RECVDATA);
END_WHILE;

UDS Addressing (TX/RX)

After discovering an ECU via broadcast, calculate its direct TX address using the formula TX = RX − 8:

For 29-bit extended addressing, the broadcast address is 0x18DB33F1.

Standard UDS DIDs

Common DIDs used with ReadDataByIdentifier (service 0x22):

CAN_MODE - Set CAN Controller Mode

CAN_MODE configures the CAN controller’s operating mode and baud rate. This must be called before any CAN communication can take place.

Parameters

Initialization Pattern

VAR
    CANMODE : CAN_MODE;
    INIT : BOOL := FALSE;
END_VAR;

// Standard CAN at 500 kbit/s (most passenger cars)
IF NOT INIT THEN
    CANMODE(MODE := CAN_MODE_NORMAL, BAUDRATE := 500);
    INIT := TRUE;
END_IF;

CAN-FD Initialization

For CAN-FD, set both BAUDRATE (arbitration phase) and FD_BAUDRATE (data phase):

VAR
    CANMODE : CAN_MODE;
    INIT : BOOL := FALSE;
END_VAR;

// CAN-FD: 500 kbit/s arbitration + 2000 kbit/s data phase
IF NOT INIT THEN
    CANMODE(MODE := CAN_MODE_NORMAL, BAUDRATE := 500, FD_BAUDRATE := 2000);
    INIT := TRUE;
END_IF;

Common CAN-FD Baudrate Combinations

Mode Constants

Common Baud Rates

CAN-FD Baud Rates

When using CAN-FD with bit rate switching (BRS := TRUE), the arbitration phase runs at the standard baud rate, and the data phase runs at a higher speed:

CAN_FILTER and CAN_MASK

Hardware CAN filters allow the controller to reject unwanted frames before they reach your program, reducing CPU load on busy networks.

CAN_FILTER Parameters

CAN_MASK Parameters

Filter/Mask Truth Table

For each bit position, the mask determines whether the filter bit is compared against the incoming frame’s ID:

Example: Accept Only UDS Responses

Accept CAN IDs 0x7E8 through 0x7EF (all standard ECU response addresses):

VAR
    CANFILTER : CAN_FILTER;
    CANMASK : CAN_MASK;
    CANMODE : CAN_MODE;
    INIT : BOOL := FALSE;
END_VAR;

IF NOT INIT THEN
    CANMODE(MODE := CAN_MODE_NORMAL, BAUDRATE := 500);

    // Mask: bits that must match = 0x7F8 (ignore lower 3 bits)
    CANMASK(SLOT := 0, ID := 0x7F8, EXT := FALSE);

    // Filter: accept 0x7E8 (with mask, this accepts 0x7E8-0x7EF)
    CANFILTER(SLOT := 0, ID := 0x7E8, EXT := FALSE);

    INIT := TRUE;
END_IF;

UDS Broadcast Addresses

UDS (Unified Diagnostic Services) uses well-known broadcast addresses to communicate with all ECUs on the bus simultaneously:

TX/RX Address Calculation

In the standard UDS addressing scheme, each ECU has a request (TX) and response (RX) address pair. The relationship is:

TX address = RX address - 8

So if you send a request to an ECU, you listen for the response at TX + 8:

Complete Example: Read Vehicle Speed via UDS

This example ties together all the CAN function blocks to read the vehicle speed from the engine ECU using UDS service 0x22 (Read Data By Identifier):

VAR
    // CAN function blocks
    CANMODE : CAN_MODE;
    CANSEND : CAN_TX;
    CANRECV : CAN_RX;

    // Buffers
    SENDDATA : ARRAY[0..7] OF BYTE;
    RECVDATA : ARRAY[0..7] OF BYTE;

    // Control
    INIT : BOOL := FALSE;
    TMR_POLL : TON;

    // Outputs
    SIGNAL_HASTIGHET : INT := 0;         // Vehicle speed (km/h)
    SIGNAL_HASTIGHET_RAW : DINT := 0;    // Raw DID value
END_VAR;

// === INIT (runs once) ===
IF NOT INIT THEN
    CANMODE(MODE := CAN_MODE_NORMAL, BAUDRATE := 500);
    INIT := TRUE;
END_IF;

// === SEND: Poll speed DID every 200ms ===
TMR_POLL(IN := NOT TMR_POLL.Q, PT := T#200ms);
IF TMR_POLL.Q THEN
    SENDDATA[0] := 0x03;       // PCI: 3 bytes follow
    SENDDATA[1] := 0x22;       // Service: Read Data By Identifier
    SENDDATA[2] := 0xF4;       // DID high byte (example)
    SENDDATA[3] := 0x0D;       // DID low byte (speed)
    SENDDATA[4] := 0x00;
    SENDDATA[5] := 0x00;
    SENDDATA[6] := 0x00;
    SENDDATA[7] := 0x00;

    CANSEND(ENABLE := TRUE, ID := 0x7E0, EXT := FALSE, DATALENGTH := 8, DATA := SENDDATA);
    TMR_POLL(IN := FALSE);
END_IF;

// === RECEIVE: Process ECU response ===
CANRECV(ENABLE := TRUE, ID := 0x7E8, EXT := FALSE, MSG_COUNT := 5, DATA := RECVDATA);

WHILE CANRECV.AVAILABLE > 0 DO
    // Positive response: 0x62 + DID + value
    IF RECVDATA[1] = 0x62 AND RECVDATA[2] = 0xF4 AND RECVDATA[3] = 0x0D THEN
        SIGNAL_HASTIGHET_RAW := RECVDATA[4] * 256 + RECVDATA[5];
        SIGNAL_HASTIGHET := TRUNC(SIGNAL_HASTIGHET_RAW / 100, INT);
    END_IF;

    CANRECV(ENABLE := TRUE, ID := 0x7E8, EXT := FALSE, MSG_COUNT := 5, DATA := RECVDATA);
END_WHILE;