IsoTpBase Class Reference

#include <isotp.h>

Inheritance diagram for IsoTpBase:

Collaboration diagram for IsoTpBase:

Public Member Functions
	IsoTpBase (ICanTransmitter *p_txTransport, size_t p_busIndex, uint32_t p_rxFrameId, uint32_t p_txFrameId)
int	sendFrame (const IsoTpFrameHeader &header, const uint8_t *data, int num, can_sysinterval_t timeout)
void	sendFlowControl (can_sysinterval_t timeout)
can_msg_t	transmit (CanTxMessage &ctfp, can_sysinterval_t timeout)

Data Fields
size_t	isoHeaderByteIndex = 0
ICanTransmitter *	txTransport
size_t	busIndex
uint32_t	rxFrameId
uint32_t	txFrameId

Detailed Description

Definition at line 87 of file isotp.h.

Constructor & Destructor Documentation

IsoTpBase()

IsoTpBase::IsoTpBase ( ICanTransmitter *  p_txTransport, size_t  p_busIndex, uint32_t  p_rxFrameId, uint32_t  p_txFrameId  )

inline

Definition at line 89 of file isotp.h.

        :
        txTransport(p_txTransport),
        busIndex(p_busIndex),
        rxFrameId(p_rxFrameId),
        txFrameId(p_txFrameId)
        {}

Member Function Documentation

sendFlowControl()

void IsoTpBase::sendFlowControl

(

can_sysinterval_t

timeout

)

Definition at line 80 of file isotp.cpp.

                                                         {
    IsoTpFrameHeader header;
    header.frameType = ISO_TP_FRAME_FLOW_CONTROL;
    header.fcFlag = 0;          // = "continue to send"
    header.blockSize = 0;       // = the remaining "frames" to be sent without flow control or delay
    header.separationTime = 0;  // = wait 0 milliseconds, send immediately
    sendFrame(header, nullptr, 0, timeout);
}

Referenced by IsoTpRx::readTimeout(), and CanStreamerState::receiveFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

sendFrame()

int IsoTpBase::sendFrame	(	const IsoTpFrameHeader &	header,
		const uint8_t *	data,
		int	num,
		can_sysinterval_t	timeout
	)

Definition at line 14 of file isotp.cpp.

                                                                                                                {
    // Calculate needed DLC and maximum payload
    int offset, numBytes;
    switch (header.frameType) {
    case ISO_TP_FRAME_SINGLE:
        offset = isoHeaderByteIndex + 1;
        numBytes = minI(num, maxDlc - offset);
        break;
    case ISO_TP_FRAME_FIRST:
        offset = isoHeaderByteIndex + 2;
        numBytes = minI(num, maxDlc - offset);
        break;
    case ISO_TP_FRAME_CONSECUTIVE:
        offset = isoHeaderByteIndex + 1;
        numBytes = minI(num, maxDlc - offset);
        break;
    case ISO_TP_FRAME_FLOW_CONTROL:
        offset = isoHeaderByteIndex + 3;
        numBytes = 0;   // no data is sent with 'flow control' frame
        break;
    default:
        // bad frame type
        return 0;
    }
 
    int dlc = offset + numBytes;
    CanTxMessage txmsg(CanCategory::SERIAL, txFrameId, dlc, busIndex, IS_EXT_RANGE_ID(txFrameId));
 
    // fill the frame data according to the CAN-TP protocol (ISO 15765-2)
    txmsg[isoHeaderByteIndex] = (uint8_t)((header.frameType & 0xf) << 4);
    switch (header.frameType) {
    case ISO_TP_FRAME_SINGLE:
        txmsg[isoHeaderByteIndex] |= numBytes;
        break;
    case ISO_TP_FRAME_FIRST:
        txmsg[isoHeaderByteIndex] |= (header.numBytes >> 8) & 0xf;
        txmsg[isoHeaderByteIndex + 1] = (uint8_t)(header.numBytes & 0xff);
        break;
    case ISO_TP_FRAME_CONSECUTIVE:
        txmsg[isoHeaderByteIndex] |= header.index & 0xf;
        break;
    case ISO_TP_FRAME_FLOW_CONTROL:
        txmsg[isoHeaderByteIndex] |= header.fcFlag & 0xf;
        txmsg[isoHeaderByteIndex + 1] = (uint8_t)(header.blockSize);
        txmsg[isoHeaderByteIndex + 2] = (uint8_t)(header.separationTime);
        break;
    default:
        // bad frame type
        return 0;
    }
 
    // copy the contents
    if (data != nullptr) {
        for (int i = 0; i < numBytes; i++) {
            txmsg[i + offset] = data[i];
        }
    }
 
    // send the frame!
    if (transmit(txmsg, timeout) == CAN_MSG_OK) {
        return numBytes;
    }
 
    return 0;
}

Referenced by CanStreamerState::sendDataTimeout(), sendFlowControl(), and IsoTpRxTx::writeTimeout().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit()

can_msg_t IsoTpBase::transmit ( CanTxMessage &  ctfp, can_sysinterval_t  timeout  )

inline

Definition at line 101 of file isotp.h.

                                                                      {
        if (isoHeaderByteIndex) {
            // yes that would be truncated to byte, that's expected
            ctfp[0] = rxFrameId & 0xff;
        }
        if (txTransport) {
            return txTransport->transmit(ctfp, timeout);
        }
        return CAN_MSG_OK;
    }

Referenced by sendFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

busIndex

size_t IsoTpBase::busIndex

Definition at line 118 of file isotp.h.

Referenced by IsoTpRx::resetRxVerbose(), and sendFrame().

isoHeaderByteIndex

size_t IsoTpBase::isoHeaderByteIndex = 0

Definition at line 114 of file isotp.h.

Referenced by IsoTpRx::decodeFrame(), IsoTpRx::readTimeout(), CanStreamerState::receiveFrame(), CanStreamerState::sendDataTimeout(), sendFrame(), transmit(), and IsoTpRxTx::writeTimeout().

rxFrameId

uint32_t IsoTpBase::rxFrameId

Definition at line 119 of file isotp.h.

Referenced by transmit().

txFrameId

uint32_t IsoTpBase::txFrameId

Definition at line 120 of file isotp.h.

Referenced by IsoTpRx::decodeFrame(), and sendFrame().

txTransport

ICanTransmitter* IsoTpBase::txTransport

Definition at line 116 of file isotp.h.

Referenced by transmit().

---

The documentation for this class was generated from the following files:

• controllers/can/isotp/isotp.h
• controllers/can/isotp/isotp.cpp