IsoTpRx Class Reference

#include <isotp.h>

Inheritance diagram for IsoTpRx:

Collaboration diagram for IsoTpRx:

Public Member Functions
	IsoTpRx (size_t p_busIndex, uint32_t p_rxFrameId, uint32_t p_txFrameId)
	~IsoTpRx ()
void	reset ()
virtual void	decodeFrame (const CANRxFrame &frame, efitick_t nowNt)
int	readTimeout (uint8_t *rxbuf, size_t *size, sysinterval_t timeout)
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)
can_msg_t	transmit (CanTxMessage &ctfp, can_sysinterval_t timeout)

Protected Attributes
fifo_buffer_sync< CANRxFrame, ISOTP_RX_QUEUE_LEN >	rxFifoBuf

Private Attributes
int	waitingForNumBytes = 0
uint8_t	waitingForFrameIndex = 0

Additional Inherited Members
Data Fields inherited from IsoTpBase
size_t	isoHeaderByteIndex = 0
ICanTransmitter *	txTransport
size_t	busIndex
uint32_t	rxFrameId
uint32_t	txFrameId

Detailed Description

Definition at line 176 of file isotp.h.

Constructor & Destructor Documentation

IsoTpRx()

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

inline

Definition at line 178 of file isotp.h.

    :
        CanListener(p_rxFrameId),
        IsoTpBase(nullptr, p_busIndex, p_rxFrameId, p_txFrameId)
    {
        rxFifoBuf.clear();
        registerCanListener(*this);
    }

Here is the call graph for this function:

~IsoTpRx()

IsoTpRx::~IsoTpRx ( )

inline

Definition at line 187 of file isotp.h.

               {
        unregisterCanListener(*this);
    }

Here is the call graph for this function:

Member Function Documentation

decodeFrame()

virtual void IsoTpRx::decodeFrame ( const CANRxFrame &  frame, efitick_t  nowNt  )

inlinevirtual

Implements CanListener.

Definition at line 198 of file isotp.h.

    {
        if (frame.DLC < 1 + isoHeaderByteIndex) {
            // invalid++;
            return;
        }
 
        if (isoHeaderByteIndex) {
            if (frame.data8[0] != (txFrameId & 0xff)) {
                return;
            }
        }
 
        if (!rxFifoBuf.put(frame)) {
            // overruns++;
        }
    }

readTimeout()

int IsoTpRx::readTimeout	(	uint8_t *	rxbuf,
		size_t *	size,
		sysinterval_t	timeout
	)

Definition at line 348 of file isotp.cpp.

{
    //is fxbuf is too small?
    bool overflow = false;
    bool isFirstFrame = true;
    size_t availableAtBuffer = *size;
    uint8_t *buf = rxbuf;
 
    do {
        CANRxFrame rxmsg;
 
        // TODO: adjust timeout!
        if (!rxFifoBuf.get(rxmsg, timeout)) {
            // TODO: error codes
            if (isFirstFrame) {
                efiPrintf("IsoTp: rx timeout, nothing received");
            } else {
                efiPrintf("IsoTP: rx timeout, %d left to receive", waitingForNumBytes);
            }
            return -1;
        }
 
        uint8_t frameType = (rxmsg.data8[isoHeaderByteIndex] >> 4) & 0xf;
        if (engineConfiguration->verboseIsoTp) {
            efiPrintf("receiveFrame frameType=%d", frameType);
    #if EFI_PROD_CODE
            printCANRxFrame(-1, rxmsg);
    #endif // EFI_PROD_CODE
        }
        size_t numBytesAvailable;
        uint8_t frameIdx;
        const uint8_t *srcBuf;
        switch (frameType) {
        case ISO_TP_FRAME_SINGLE:
            // TODO: check that this is first packet! see isFirstFrame
            numBytesAvailable = rxmsg.data8[isoHeaderByteIndex] & 0xf;
            waitingForNumBytes = numBytesAvailable;
            srcBuf = rxmsg.data8 + 1 + isoHeaderByteIndex;
            break;
        case ISO_TP_FRAME_FIRST:
            // TODO: check that this is first packet! see isFirstFrame
            waitingForNumBytes = ((rxmsg.data8[isoHeaderByteIndex] & 0xf) << 8) | rxmsg.data8[isoHeaderByteIndex + 1];
            waitingForFrameIndex = 1;
            numBytesAvailable = minI(waitingForNumBytes, 6 - isoHeaderByteIndex);
            srcBuf = rxmsg.data8 + 2 + isoHeaderByteIndex;
//          rxTransport->onTpFirstFrame(); // used to send flow control message
            break;
        case ISO_TP_FRAME_CONSECUTIVE:
            frameIdx = rxmsg.data8[isoHeaderByteIndex] & 0xf;
            if (waitingForNumBytes < 0 || waitingForFrameIndex != frameIdx) {
                // todo: that's an abnormal situation, and we probably should react?
                // TODO: error codes
                return -2;
            }
            numBytesAvailable = minI(waitingForNumBytes, 7 - isoHeaderByteIndex);
            srcBuf = rxmsg.data8 + 1 + isoHeaderByteIndex;
            waitingForFrameIndex = (waitingForFrameIndex + 1) & 0xf;
            break;
        case ISO_TP_FRAME_FLOW_CONTROL:
            // todo: currently we just ignore the FC frame
            // TODO: we should not receive FC frame while receiving data
            break;
        default:
            // bad frame type
            // TODO: error codes
            return -3;
        }
 
        if (isFirstFrame) {
            if ((buf) && (waitingForNumBytes > availableAtBuffer)) {
                efiPrintf("receive buffer is not enough %d > %d", waitingForNumBytes, availableAtBuffer);
            }
            isFirstFrame = false;
        }
 
        if (buf != nullptr) {
            int numBytesToCopy = minI(availableAtBuffer, numBytesAvailable);
 
            memcpy(buf, srcBuf, numBytesToCopy);
            buf += numBytesToCopy;
            availableAtBuffer -= numBytesToCopy;
 
            // if there are some more bytes left, receive and drop
            if (numBytesAvailable > numBytesToCopy) {
                overflow = true;
            }
        }
 
        // according to the specs, we need to acknowledge the received multi-frame start frame
        if (frameType == ISO_TP_FRAME_FIRST) {
            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);
        }
 
        waitingForNumBytes -= numBytesAvailable;
    } while (waitingForNumBytes > 0);
 
    // received size
    *size = buf - rxbuf;
 
    return overflow ? 1 : 0;
}

Here is the call graph for this function:

reset()

void IsoTpRx::reset ( )

inline

Definition at line 191 of file isotp.h.

                 {
        rxFifoBuf.clear();
        waitingForNumBytes = 0;
        waitingForFrameIndex = 0;
    }

Field Documentation

rxFifoBuf

fifo_buffer_sync<CANRxFrame, ISOTP_RX_QUEUE_LEN> IsoTpRx::rxFifoBuf

protected

Definition at line 225 of file isotp.h.

Referenced by decodeFrame(), IsoTpRx(), readTimeout(), reset(), and IsoTpRxTx::writeTimeout().

waitingForFrameIndex

uint8_t IsoTpRx::waitingForFrameIndex = 0

private

Definition at line 222 of file isotp.h.

Referenced by readTimeout(), and reset().

waitingForNumBytes

int IsoTpRx::waitingForNumBytes = 0

private

Definition at line 221 of file isotp.h.

Referenced by readTimeout(), and reset().

---

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

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