canitpSessionCreate (Function)

Create an ISO-TP session using an already opened CAN port.

A callback function is used to notify the application that a message is received. (See CALLBACK for more information)

The ISO-TP protocol uses two way communication so the CAN write capability must be enabled.

If CAN write is not enabled, or monitor mode is used, then messages cannot be received or send.

A maximum of 30 sessions can be created on a CAN port, if none of its filters are in use by the other functions.

To create more than a total of 16 connections, it is necessary to reduce the size of the internal transmit and receive buffers. If e.g. only sending small messages, the transmit buffer can be reduced significantly, increasing the total number of connections.

Input:

port : SINT (1/2) (default 1)

The port of the CAN bus to use for ISO-TP.

src : DINT

The CAN ID to filter for incoming ISO-TP messages.

dst : DINT

The CAN ID where ISO-TP messages are sent to.

xtd : BOOL (default TRUE)

Set to FALSE to use standard identifiers (11 bits), leave at TRUE for extended identifiers (29 bits).

cb_receive : CALLBACK

The callback function for received messages. (See the canitpRecv callback declaration below)

cb_data : PTR

The buffer where the received message will be stored.

cb_arg : DINT

User argument to pass on to the callback. Can e.g. be used to select the buffer to read from.

cb_size : INT (1..4095)

The size of the buffer to place the received data in.

If an incoming ISO-TP message is too large for the receive buffer it will be discarded.

rx_size : INT (6..4095, default 4095)

The size of the internal receive buffer. Can be reduced to increase the number of simultaneous sessions.

tx_size : INT (6..4095, default 4095)

The size of the internal transmit buffer. Can be reduced to increase the number of simultaneous sessions.

Output:

handle : SYSHANDLE

The handle to this ISO-TP session.

Returns: INT

Declaration:

FUNCTION canitpSessionCreate  : INT;
VAR_INPUT
   handle  : ACCESS SYSHANDLE;
   src     : DINT;
   dst     : DINT;
   cb_receive : CALLBACK;
   cb_data : PTR;
   cb_arg  : DINT;
   cb_size : INT;
   rx_size : INT;
   tx_size : INT;
   xtd     : BOOL := TRUE;
   port    : SINT := 1;
END_VAR;

Callback declaration:

FUNCTION CALLBACK canitpRecv
VAR_INPUT
   handle  : SYSHANDLE;
   arg     : DINT;
   size    : INT;
END_VAR;

Example:

INCLUDE rtcu.inc
VAR
   buf   : ARRAY [1..4096] OF SINT;
END_VAR;
 
FUNCTION CALLBACK canitpRecv
VAR_INPUT
   handle : SYSHANDLE; //Handle to session
   arg    : DINT; //User data
   size   : INT; //Size of the data received.
END_VAR;
   DebugMsg(message := strFromMemory(src := PTR(arg), len := size));
END_FUNCTION;
 
 
PROGRAM example;
VAR
   handle: SYSHANDLE;
   rc    : INT;
   str   : STRING;
   out   : ARRAY [1..4095] OF SINT;
   len   : INT;
END_VAR;
 
   // Open can
   canOpen(baud := 250, monitor := FALSE);
 
   // Create ISO-TP session
   rc := canitpSessionCreate(handle:=handle,
                    port     := 1,
                    src      := 16#12345678,
                    dst      := 16#12345679,
                    cb_receive := @canitpRecv,
                    cb_data    := ADDR(buf),
                    cb_arg     := DINT(ADDR(buf)),
                    cb_size    := SIZEOF(buf));
   IF rc < 1 THEN
      DebugFmt(message := "canitpSessionCreate=\1", v1 := rc);
      RETURN;
   END_IF;
 
   // Build message
   str := "Hello from RTCU device";
 
   // Send message
   len := strLen(str := str);
   strToMemory(str := str, dst := ADDR(out), len := len);
   rc  := canitpSessionSend(handle:=handle, data := ADDR(out), size := len);
   IF rc < 1 THEN
      DebugFmt(message := "canitpSessionSend=\1", v1 := rc);
      RETURN;
   END_IF;
 
BEGIN
 
END;
END_PROGRAM;