#include <stdio.h>
#include <string.h>
#include "isotp_defines.h"
#include "isotp_config.h"
#include "isotp_user.h"

Include dependency graph for isotp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	IsoTpLink
	Struct containing the data for linking an application to a CAN instance. The data stored in this struct is used internally and may be used by software programs using this library. More...

Typedefs
typedef struct IsoTpLink	IsoTpLink
	Struct containing the data for linking an application to a CAN instance. The data stored in this struct is used internally and may be used by software programs using this library. More...

Functions
void	isotp_init_link (IsoTpLink link, uint32_t sendid, uint8_t sendbuf, uint16_t sendbufsize, uint8_t *recvbuf, uint16_t recvbufsize)
	Initialises the ISO-TP library. More...

void	isotp_poll (IsoTpLink *link)
	Polling function; call this function periodically to handle timeouts, send consecutive frames, etc. More...

void	isotp_on_can_message (IsoTpLink link, uint8_t data, uint8_t len)
	Handles incoming CAN messages. Determines whether an incoming message is a valid ISO-TP frame or not and handles it accordingly. More...

int	isotp_send (IsoTpLink *link, const uint8_t payload[], uint16_t size)
	Sends ISO-TP frames via CAN, using the ID set in the initialising function. More...

int	isotp_send_with_id (IsoTpLink *link, uint32_t id, const uint8_t payload[], uint16_t size)
	See isotp_send, with the exception that this function is used only for functional addressing. More...

int	isotp_receive (IsoTpLink link, uint8_t payload, const uint16_t payload_size, uint16_t *out_size)
	Receives and parses the received data and copies the parsed data in to the internal buffer. More...

Typedef Documentation

◆ IsoTpLink

typedef struct IsoTpLink IsoTpLink

Struct containing the data for linking an application to a CAN instance. The data stored in this struct is used internally and may be used by software programs using this library.

Function Documentation

◆ isotp_init_link()

void isotp_init_link	(	IsoTpLink *	link,
		uint32_t	sendid,
		uint8_t *	sendbuf,
		uint16_t	sendbufsize,
		uint8_t *	recvbuf,
		uint16_t	recvbufsize
	)

Initialises the ISO-TP library.

Parameters

link	The IsoTpLink IsoTpLink Struct containing the data for linking an application to a CAN instance. The data stored in this stru... Definition: isotp.h:22 instance used for transceiving data.
sendid	The ID used to send data to other CAN nodes.
sendbuf	A pointer to an area in memory which can be used as a buffer for data to be sent.
sendbufsize	The size of the buffer area.
recvbuf	A pointer to an area in memory which can be used as a buffer for data to be received.
recvbufsize	The size of the buffer area.

Definition at line 450 of file isotp.c.

                                                                                                                                       {
    memset(link, 0, sizeof(*link));
    link->receive_status = ISOTP_RECEIVE_STATUS_IDLE;
    link->send_status = ISOTP_SEND_STATUS_IDLE;
    link->send_arbitration_id = sendid;
    link->send_buffer = sendbuf;
    link->send_buf_size = sendbufsize;
    link->receive_buffer = recvbuf;
    link->receive_buf_size = recvbufsize;
    
    return;
}

References ISOTP_RECEIVE_STATUS_IDLE, ISOTP_SEND_STATUS_IDLE, IsoTpLink::receive_buf_size, IsoTpLink::receive_buffer, IsoTpLink::receive_status, IsoTpLink::send_arbitration_id, IsoTpLink::send_buf_size, IsoTpLink::send_buffer, and IsoTpLink::send_status.

◆ isotp_on_can_message()

void isotp_on_can_message	(	IsoTpLink *	link,
		uint8_t *	data,
		uint8_t	len
	)

Handles incoming CAN messages. Determines whether an incoming message is a valid ISO-TP frame or not and handles it accordingly.

Parameters

link	The IsoTpLink instance used for transceiving data.
data	The data received via CAN.
len	The length of the data received.

Definition at line 281 of file isotp.c.

                                                                       {
    IsoTpCanMessage message;
    int ret;
    
    if (len < 2 || len > 8) {
        return;
    }
 
    memcpy(message.as.data_array.ptr, data, len);
    memset(message.as.data_array.ptr + len, 0, sizeof(message.as.data_array.ptr) - len);
 
    switch (message.as.common.type) {
        case ISOTP_PCI_TYPE_SINGLE: {
            /* update protocol result */
            if (ISOTP_RECEIVE_STATUS_INPROGRESS == link->receive_status) {
                link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_UNEXP_PDU;
            } else {
                link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_OK;
            }
 
            /* handle message */
            ret = isotp_receive_single_frame(link, &message, len);
            
            if (ISOTP_RET_OK == ret) {
                /* change status */
                link->receive_status = ISOTP_RECEIVE_STATUS_FULL;
            }
            break;
        }
        case ISOTP_PCI_TYPE_FIRST_FRAME: {
            /* update protocol result */
            if (ISOTP_RECEIVE_STATUS_INPROGRESS == link->receive_status) {
                link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_UNEXP_PDU;
            } else {
                link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_OK;
            }
 
            /* handle message */
            ret = isotp_receive_first_frame(link, &message, len);
 
            /* if overflow happened */
            if (ISOTP_RET_OVERFLOW == ret) {
                /* update protocol result */
                link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_BUFFER_OVFLW;
                /* change status */
                link->receive_status = ISOTP_RECEIVE_STATUS_IDLE;
                /* send error message */
                isotp_send_flow_control(link, PCI_FLOW_STATUS_OVERFLOW, 0, 0);
                break;
            }
 
            /* if receive successful */
            if (ISOTP_RET_OK == ret) {
                /* change status */
                link->receive_status = ISOTP_RECEIVE_STATUS_INPROGRESS;
                /* send fc frame */
                link->receive_bs_count = ISO_TP_DEFAULT_BLOCK_SIZE;
                isotp_send_flow_control(link, PCI_FLOW_STATUS_CONTINUE, link->receive_bs_count, ISO_TP_DEFAULT_ST_MIN_US);
                /* refresh timer cs */
                link->receive_timer_cr = isotp_user_get_us() + ISO_TP_DEFAULT_RESPONSE_TIMEOUT_US;
            }
            
            break;
        }
        case TSOTP_PCI_TYPE_CONSECUTIVE_FRAME: {
            /* check if in receiving status */
            if (ISOTP_RECEIVE_STATUS_INPROGRESS != link->receive_status) {
                link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_UNEXP_PDU;
                break;
            }
 
            /* handle message */
            ret = isotp_receive_consecutive_frame(link, &message, len);
 
            /* if wrong sn */
            if (ISOTP_RET_WRONG_SN == ret) {
                link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_WRONG_SN;
                link->receive_status = ISOTP_RECEIVE_STATUS_IDLE;
                break;
            }
 
            /* if success */
            if (ISOTP_RET_OK == ret) {
                /* refresh timer cs */
                link->receive_timer_cr = isotp_user_get_us() + ISO_TP_DEFAULT_RESPONSE_TIMEOUT_US;
                
                /* receive finished */
                if (link->receive_offset >= link->receive_size) {
                    link->receive_status = ISOTP_RECEIVE_STATUS_FULL;
                } else {
                    /* send fc when bs reaches limit */
                    if (0 == --link->receive_bs_count) {
                        link->receive_bs_count = ISO_TP_DEFAULT_BLOCK_SIZE;
                        isotp_send_flow_control(link, PCI_FLOW_STATUS_CONTINUE, link->receive_bs_count, ISO_TP_DEFAULT_ST_MIN_US);
                    }
                }
            }
            
            break;
        }
        case ISOTP_PCI_TYPE_FLOW_CONTROL_FRAME:
            /* handle fc frame only when sending in progress  */
            if (ISOTP_SEND_STATUS_INPROGRESS != link->send_status) {
                break;
            }
 
            /* handle message */
            ret = isotp_receive_flow_control_frame(link, &message, len);
            
            if (ISOTP_RET_OK == ret) {
                /* refresh bs timer */
                link->send_timer_bs = isotp_user_get_us() + ISO_TP_DEFAULT_RESPONSE_TIMEOUT_US;
 
                /* overflow */
                if (PCI_FLOW_STATUS_OVERFLOW == message.as.flow_control.FS) {
                    link->send_protocol_result = ISOTP_PROTOCOL_RESULT_BUFFER_OVFLW;
                    link->send_status = ISOTP_SEND_STATUS_ERROR;
                }
 
                /* wait */
                else if (PCI_FLOW_STATUS_WAIT == message.as.flow_control.FS) {
                    link->send_wtf_count += 1;
                    /* wait exceed allowed count */
                    if (link->send_wtf_count > ISO_TP_MAX_WFT_NUMBER) {
                        link->send_protocol_result = ISOTP_PROTOCOL_RESULT_WFT_OVRN;
                        link->send_status = ISOTP_SEND_STATUS_ERROR;
                    }
                }
 
                /* permit send */
                else if (PCI_FLOW_STATUS_CONTINUE == message.as.flow_control.FS) {
                    if (0 == message.as.flow_control.BS) {
                        link->send_bs_remain = ISOTP_INVALID_BS;
                    } else {
                        link->send_bs_remain = message.as.flow_control.BS;
                    }
                    uint32_t message_st_min_us = isotp_st_min_to_us(message.as.flow_control.STmin);
                    link->send_st_min_us = message_st_min_us > ISO_TP_DEFAULT_ST_MIN_US ? message_st_min_us : ISO_TP_DEFAULT_ST_MIN_US; // prefer as much st_min as possible for stability?
                    link->send_wtf_count = 0;
                }
            }
            break;
        default:
            break;
    };
    
    return;
}

References IsoTpCanMessage::common, IsoTpCanMessage::data_array, IsoTpCanMessage::flow_control, ISOTP_PCI_TYPE_FIRST_FRAME, ISOTP_PCI_TYPE_FLOW_CONTROL_FRAME, ISOTP_PCI_TYPE_SINGLE, isotp_receive_consecutive_frame(), isotp_receive_first_frame(), isotp_receive_flow_control_frame(), isotp_receive_single_frame(), ISOTP_RECEIVE_STATUS_FULL, ISOTP_RECEIVE_STATUS_IDLE, ISOTP_RECEIVE_STATUS_INPROGRESS, isotp_send_flow_control(), ISOTP_SEND_STATUS_ERROR, ISOTP_SEND_STATUS_INPROGRESS, isotp_st_min_to_us(), isotp_user_get_us(), PCI_FLOW_STATUS_CONTINUE, PCI_FLOW_STATUS_OVERFLOW, PCI_FLOW_STATUS_WAIT, IsoTpDataArray::ptr, IsoTpLink::receive_bs_count, IsoTpLink::receive_offset, IsoTpLink::receive_protocol_result, IsoTpLink::receive_size, IsoTpLink::receive_status, IsoTpLink::receive_timer_cr, IsoTpLink::send_bs_remain, IsoTpLink::send_protocol_result, IsoTpLink::send_st_min_us, IsoTpLink::send_status, IsoTpLink::send_timer_bs, IsoTpLink::send_wtf_count, and TSOTP_PCI_TYPE_CONSECUTIVE_FRAME.

◆ isotp_poll()

void isotp_poll ( IsoTpLink * link )

Polling function; call this function periodically to handle timeouts, send consecutive frames, etc.

Parameters

link	The IsoTpLink instance used.

Definition at line 463 of file isotp.c.

                                 {
    int ret;
 
    /* only polling when operation in progress */
    if (ISOTP_SEND_STATUS_INPROGRESS == link->send_status) {
 
        /* continue send data */
        if (/* send data if bs_remain is invalid or bs_remain large than zero */
        (ISOTP_INVALID_BS == link->send_bs_remain || link->send_bs_remain > 0) &&
        /* and if st_min is zero or go beyond interval time */
        (0 == link->send_st_min_us || IsoTpTimeAfter(isotp_user_get_us(), link->send_timer_st))) {
            
            ret = isotp_send_consecutive_frame(link);
            if (ISOTP_RET_OK == ret) {
                if (ISOTP_INVALID_BS != link->send_bs_remain) {
                    link->send_bs_remain -= 1;
                }
                link->send_timer_bs = isotp_user_get_us() + ISO_TP_DEFAULT_RESPONSE_TIMEOUT_US;
                link->send_timer_st = isotp_user_get_us() + link->send_st_min_us;
 
                /* check if send finish */
                if (link->send_offset >= link->send_size) {
                    link->send_status = ISOTP_SEND_STATUS_IDLE;
                }
            } else if (ISOTP_RET_NOSPACE == ret) {
                /* shim reported that it isn't able to send a frame at present, retry on next call */
            } else {
                link->send_status = ISOTP_SEND_STATUS_ERROR;
            }
        }
 
        /* check timeout */
        if (IsoTpTimeAfter(isotp_user_get_us(), link->send_timer_bs)) {
            link->send_protocol_result = ISOTP_PROTOCOL_RESULT_TIMEOUT_BS;
            link->send_status = ISOTP_SEND_STATUS_ERROR;
        }
    }
 
    /* only polling when operation in progress */
    if (ISOTP_RECEIVE_STATUS_INPROGRESS == link->receive_status) {
        
        /* check timeout */
        if (IsoTpTimeAfter(isotp_user_get_us(), link->receive_timer_cr)) {
            link->receive_protocol_result = ISOTP_PROTOCOL_RESULT_TIMEOUT_CR;
            link->receive_status = ISOTP_RECEIVE_STATUS_IDLE;
        }
    }
 
    return;
}

References ISOTP_RECEIVE_STATUS_IDLE, ISOTP_RECEIVE_STATUS_INPROGRESS, isotp_send_consecutive_frame(), ISOTP_SEND_STATUS_ERROR, ISOTP_SEND_STATUS_IDLE, ISOTP_SEND_STATUS_INPROGRESS, isotp_user_get_us(), IsoTpLink::receive_protocol_result, IsoTpLink::receive_status, IsoTpLink::receive_timer_cr, IsoTpLink::send_bs_remain, IsoTpLink::send_offset, IsoTpLink::send_protocol_result, IsoTpLink::send_size, IsoTpLink::send_st_min_us, IsoTpLink::send_status, IsoTpLink::send_timer_bs, and IsoTpLink::send_timer_st.

◆ isotp_receive()

int isotp_receive	(	IsoTpLink *	link,
		uint8_t *	payload,
		const uint16_t	payload_size,
		uint16_t *	out_size
	)

Receives and parses the received data and copies the parsed data in to the internal buffer.

Parameters

link	The IsoTpLink instance used to transceive data.
payload	A pointer to an area in memory where the raw data is copied from.
payload_size	The size of the received (raw) CAN data.
out_size	A reference to a variable which will contain the size of the actual (parsed) data.

Returns

Possible return values:

Definition at line 430 of file isotp.c.

                                                                                                      {
    uint16_t copylen;
    
    if (ISOTP_RECEIVE_STATUS_FULL != link->receive_status) {
        return ISOTP_RET_NO_DATA;
    }
 
    copylen = link->receive_size;
    if (copylen > payload_size) {
        copylen = payload_size;
    }
 
    memcpy(payload, link->receive_buffer, copylen);
    *out_size = copylen;
 
    link->receive_status = ISOTP_RECEIVE_STATUS_IDLE;
 
    return ISOTP_RET_OK;
}

References ISOTP_RECEIVE_STATUS_FULL, ISOTP_RECEIVE_STATUS_IDLE, IsoTpLink::receive_buffer, IsoTpLink::receive_size, and IsoTpLink::receive_status.

◆ isotp_send()

int isotp_send	(	IsoTpLink *	link,
		const uint8_t	payload[],
		uint16_t	size
	)

Sends ISO-TP frames via CAN, using the ID set in the initialising function.

Single-frame messages will be sent immediately when calling this function. Multi-frame messages will be sent consecutively when calling isotp_poll.

Parameters

link	The IsoTpLink instance used for transceiving data.
payload	The payload to be sent. (Up to 4095 bytes).
size	The size of the payload to be sent.

Returns

Possible return values:

ISOTP_RET_OVERFLOW
ISOTP_RET_INPROGRESS

ISOTP_RET_INPROGRESS
#define ISOTP_RET_INPROGRESS
Definition: isotp_defines.h:39
ISOTP_RET_OK
The return value of the user shim function isotp_user_send_can().

Sends ISO-TP frames via CAN, using the ID set in the initialising function.

Definition at line 229 of file isotp.c.

                                                                        {
    return isotp_send_with_id(link, link->send_arbitration_id, payload, size);
}

References isotp_send_with_id(), and IsoTpLink::send_arbitration_id.

◆ isotp_send_with_id()

int isotp_send_with_id	(	IsoTpLink *	link,
		uint32_t	id,
		const uint8_t	payload[],
		uint16_t	size
	)

See isotp_send, with the exception that this function is used only for functional addressing.

Definition at line 233 of file isotp.c.

                                                                                             {
    int ret;
 
    if (link == 0x0) {
        isotp_user_debug("Link is null!");
        return ISOTP_RET_ERROR;
    }
 
    if (size > link->send_buf_size) {
        isotp_user_debug("Message size too large. Increase ISO_TP_MAX_MESSAGE_SIZE to set a larger buffer\n");
        char message[128];
        sprintf(&message[0], "Attempted to send %d bytes; max size is %d!\n", size, link->send_buf_size);
        isotp_user_debug(message);
        return ISOTP_RET_OVERFLOW;
    }
 
    if (ISOTP_SEND_STATUS_INPROGRESS == link->send_status) {
        isotp_user_debug("Abort previous message, transmission in progress.\n");
        return ISOTP_RET_INPROGRESS;
    }
 
    /* copy into local buffer */
    link->send_size = size;
    link->send_offset = 0;
    (void) memcpy(link->send_buffer, payload, size);
 
    if (link->send_size < 8) {
        /* send single frame */
        ret = isotp_send_single_frame(link, id);
    } else {
        /* send multi-frame */
        ret = isotp_send_first_frame(link, id);
 
        /* init multi-frame control flags */
        if (ISOTP_RET_OK == ret) {
            link->send_bs_remain = 0;
            link->send_st_min_us = 0;
            link->send_wtf_count = 0;
            link->send_timer_st = isotp_user_get_us();
            link->send_timer_bs = isotp_user_get_us() + ISO_TP_DEFAULT_RESPONSE_TIMEOUT_US;
            link->send_protocol_result = ISOTP_PROTOCOL_RESULT_OK;
            link->send_status = ISOTP_SEND_STATUS_INPROGRESS;
        }
    }
 
    return ret;
}

References isotp_send_first_frame(), isotp_send_single_frame(), ISOTP_SEND_STATUS_INPROGRESS, isotp_user_debug(), isotp_user_get_us(), IsoTpLink::send_bs_remain, IsoTpLink::send_buf_size, IsoTpLink::send_buffer, IsoTpLink::send_offset, IsoTpLink::send_protocol_result, IsoTpLink::send_size, IsoTpLink::send_st_min_us, IsoTpLink::send_status, IsoTpLink::send_timer_bs, IsoTpLink::send_timer_st, and IsoTpLink::send_wtf_count.

Referenced by isotp_send().

Data Structures

Typedefs

Functions

Typedef Documentation

◆ IsoTpLink

Function Documentation

◆ isotp_init_link()

◆ isotp_on_can_message()

◆ isotp_poll()

◆ isotp_receive()

◆ isotp_send()

◆ isotp_send_with_id()