IsoTpRxTx Class Reference

#include <isotp.h>

Inheritance diagram for IsoTpRxTx:

Collaboration diagram for IsoTpRxTx:

Public Member Functions
	IsoTpRxTx (size_t p_busIndex, uint32_t p_rxFrameId, uint32_t p_txFrameId)
int	writeTimeout (const uint8_t *txbuf, size_t size, sysinterval_t timeout)
Public Member Functions inherited from IsoTpRx
	IsoTpRx (size_t p_busIndex, uint32_t p_rxFrameId, uint32_t p_txFrameId)
	~IsoTpRx ()
void	reset ()
bool	isRxEmpty ()
virtual void	decodeFrame (const CANRxFrame &frame, efitick_t nowNt)
int	readTimeout (uint8_t *rxbuf, size_t *size, sysinterval_t timeout)
void	resetRxVerbose ()
Public Member Functions inherited from CanListener
	CanListener (uint32_t id)
CanListener *	processFrame (const size_t busIndex, const CANRxFrame &frame, efitick_t nowNt)
uint32_t	getId ()
void	setNext (CanListener *next)
virtual CanListener *	request ()
CanListener *	getNext () const
virtual bool	acceptFrame (const size_t busIndex, const CANRxFrame &frame) const
Public Member Functions inherited from IsoTpBase
	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)

Additional Inherited Members
Data Fields inherited from IsoTpBase
size_t	isoHeaderByteIndex = 0
ICanTransmitter *	txTransport
size_t	busIndex
uint32_t	rxFrameId
uint32_t	txFrameId
Protected Attributes inherited from IsoTpRx
fifo_buffer_sync< CANRxFrame, ISOTP_RX_QUEUE_LEN >	rxFifoBuf

Detailed Description

Definition at line 238 of file isotp.h.

Constructor & Destructor Documentation

IsoTpRxTx()

IsoTpRxTx::IsoTpRxTx ( size_t  p_busIndex, uint32_t  p_rxFrameId, uint32_t  p_txFrameId  )

inline

Definition at line 240 of file isotp.h.

    :
        IsoTpRx(p_busIndex, p_rxFrameId, p_txFrameId)
        {}

Member Function Documentation

writeTimeout()

int IsoTpRxTx::writeTimeout	(	const uint8_t *	txbuf,
		size_t	size,
		sysinterval_t	timeout
	)

Definition at line 492 of file isotp.cpp.

                                                                                    {
    int offset = 0;
 
    if (engineConfiguration->verboseIsoTp) {
        PRINT("*** INFO: sendDataTimeout %d" PRINT_EOL, size);
    }
 
    if (size < 1)
        return 0;
 
    // 1 frame
    if (size <= 7 - isoHeaderByteIndex) {
        IsoTpFrameHeader header;
        header.frameType = ISO_TP_FRAME_SINGLE;
        header.numBytes = size;
        return IsoTpBase::sendFrame(header, txbuf, size, timeout);
    }
 
    // multiple frames
 
    // send the first header frame (FF)
    IsoTpFrameHeader header;
    header.frameType = ISO_TP_FRAME_FIRST;
    header.numBytes = size;
    int numSent = IsoTpBase::sendFrame(header, txbuf + offset, size, timeout);
    offset += numSent;
    size -= numSent;
 
    // get a flow control (FC) frame
#if !EFI_UNIT_TEST // todo: add FC to unit-tests?
    CANRxFrame rxmsg;
    size_t numFcReceived = 0;
    int separationTimeUs = 0;
    while (numFcReceived < 3) {
        // TODO: adjust timeout!
        if (!rxFifoBuf.get(rxmsg, timeout)) {
            efiPrintf("IsoTp: Flow Control frame not received");
            //warning(ObdCode::CUSTOM_ERR_CAN_COMMUNICATION, "CAN Flow Control frame not received");
            return 0;
        }
        uint8_t frameType = (rxmsg.data8[isoHeaderByteIndex] >> 4) & 0xf;
 
        // if something is not ok
        if (frameType != ISO_TP_FRAME_FLOW_CONTROL) {
            // should we expect only FC here?
            continue;
        }
 
        // Ok, frame is FC
        numFcReceived++;
        uint8_t flowStatus = rxmsg.data8[isoHeaderByteIndex] & 0xf;
 
        if (flowStatus == CAN_FLOW_STATUS_ABORT) {
            efiPrintf("IsoTp: Flow Control ABORT");
            // TODO: error codes
            return -4;
        }
 
        if (flowStatus == CAN_FLOW_STATUS_WAIT_MORE) {
            // if the receiver is not ready yet and asks to wait for the next FC frame (give it 3 attempts)
            if (numFcReceived < 3) {
                continue;
            }
            // TODO: error codes
            return -5;
        }
 
        if (flowStatus != CAN_FLOW_STATUS_OK) {
            efiPrintf("IsoTp: Flow Control unknown Status %d", flowStatus);
            // TODO: error codes
            return -6;
        }
 
        uint8_t blockSize = rxmsg.data8[isoHeaderByteIndex + 1];
        uint8_t minSeparationTime = rxmsg.data8[isoHeaderByteIndex + 2];
        if (blockSize != 0) {
            // todo: process other Flow Control fields (see ISO 15765-2)
            efiPrintf("IsoTp: Flow Control blockSize is not supported %d", blockSize);
            // TODO: error codes
            return -7;
        }
 
        if (minSeparationTime <= 0x7f) {
            // mS units
            separationTimeUs = minSeparationTime * 1000;
        } else if ((minSeparationTime >= 0xf1) && (minSeparationTime <= 0xf9)) {
            // 100 uS units
            separationTimeUs = (minSeparationTime - 0xf0) * 100;
        }
 
        break;
    }
#endif /* EFI_UNIT_TEST */
 
    // send the rest of the data
    uint8_t idx = 1;
    while (size > 0) {
        int len = minI(size, 7 - isoHeaderByteIndex);
        // send the consecutive frames
        header.frameType = ISO_TP_FRAME_CONSECUTIVE;
        header.index = ((idx++) & 0x0f);
        header.numBytes = len;
        numSent = IsoTpBase::sendFrame(header, txbuf + offset, len, timeout);
        if (numSent < 1)
            break;
        offset += numSent;
        size -= numSent;
 
#if ! EFI_UNIT_TEST
        if (separationTimeUs) {
            chThdSleepMicroseconds(separationTimeUs);
        }
#endif // EFI_UNIT_TEST
    }
    return offset;
}

Here is the call graph for this function:

---

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

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