181 lines
3.7 KiB
C++
181 lines
3.7 KiB
C++
/**
|
|
* \copyright
|
|
* (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
|
|
* All rights reserved.
|
|
*/
|
|
|
|
/**
|
|
* Contains Cpp2CAN CANFrame.
|
|
* @file CANFrame.h
|
|
* @ingroup cpp2can
|
|
*/
|
|
#ifndef CANFRAME_H
|
|
#define CANFRAME_H
|
|
|
|
#include "commonTypes.h"
|
|
#include <cassert>
|
|
|
|
namespace can
|
|
{
|
|
|
|
/**
|
|
* Class representing a CANFrame.
|
|
* @author matthias.kessler
|
|
*
|
|
* A object of type CANFrame does not provide any payload-buffer by default.
|
|
* It has to be provided with buffers by using a certain constructor or the
|
|
* setPayload() method.
|
|
*
|
|
* @note
|
|
* CANFrame may be used as base class for special frame classes providing
|
|
* the programmer with explicit methods to access the signals that are
|
|
* encoded in the CANFrames payload.
|
|
*/
|
|
class CANFrame
|
|
{
|
|
public:
|
|
/** bitmask to extract sender */
|
|
static const uint8 SENDER_MASK = 0xFF;
|
|
/** overhead of a CANFrame (in bit) */
|
|
static const uint8 CAN_OVERHEAD_BITS = 47;
|
|
/** maximum payload length of a CANFrame */
|
|
static const uint8 MAX_FRAME_LENGTH = 8;
|
|
/** maximum value of a CANFrame id */
|
|
static const uint16 MAX_FRAME_ID = 0x7FF;
|
|
|
|
/**
|
|
* @post getId() == 0x00
|
|
* @post getPayload() == NULL
|
|
* @post getPayloadLength() == 0
|
|
* @post getTimestamp() == 0
|
|
*/
|
|
CANFrame();
|
|
|
|
/**
|
|
* Copy constructor
|
|
* @param frame CANFrame to copy content from
|
|
*/
|
|
CANFrame(const CANFrame& frame);
|
|
|
|
/**
|
|
* Constructor initializing id, payload and length
|
|
*
|
|
* @pre id <= MAX_FRAME_ID
|
|
* @pre length <= MAX_FRAME_LENGTH
|
|
* @throws assertion
|
|
*
|
|
* The payload will not be copied, it is passed as a
|
|
* reference and CANFrame will work on this payload!
|
|
*/
|
|
CANFrame(uint16 id, uint8 payload[], uint8 length);
|
|
|
|
uint16 getId() const
|
|
{
|
|
return fId;
|
|
}
|
|
|
|
void setId(uint16 id)
|
|
{
|
|
this->fId = id;
|
|
}
|
|
|
|
/**
|
|
* @return pointer to modifiable payload of this CANFrame
|
|
*/
|
|
uint8* getPayload()
|
|
{
|
|
return fpPayload;
|
|
}
|
|
|
|
/**
|
|
* @return pointer to read only payload of this CANFrame
|
|
*/
|
|
const uint8* getPayload() const
|
|
{
|
|
return fpPayload;
|
|
}
|
|
|
|
/**
|
|
* Sets the CANFrames payload and length
|
|
*
|
|
* @note
|
|
* This method just sets a pointer to the payload and does not copy it!
|
|
*
|
|
* @post getPayload() == payload
|
|
* @post getPayloadLength() == length
|
|
* @post getMaxPayloadLength() == length
|
|
*/
|
|
void setPayload(uint8 payload[], uint8 length)
|
|
{
|
|
fpPayload = payload;
|
|
fPayloadLength = length;
|
|
fMaxPayloadLength = length;
|
|
}
|
|
|
|
/**
|
|
* @pre getPayload() != NULL
|
|
* @pre length <= getMaxPayloadLength()
|
|
* @throws assertion
|
|
*/
|
|
void setPayloadLength(uint8 length);
|
|
|
|
uint8 getPayloadLength() const
|
|
{
|
|
return fPayloadLength;
|
|
}
|
|
|
|
uint8 getMaxPayloadLength() const
|
|
{
|
|
return fMaxPayloadLength;
|
|
}
|
|
|
|
/**
|
|
* Assigns content of a CANFrame to another.
|
|
* @param canFrame frame to copy from
|
|
* @return reference to frame with new content
|
|
* @pre getMaxPayloadLength() >= canFrame.getPayloadLength()
|
|
* @throws assertion
|
|
*/
|
|
CANFrame& operator=(const CANFrame& canFrame);
|
|
|
|
/**
|
|
* @return modifiable reference to timestamp
|
|
*/
|
|
uint64& getTimestamp()
|
|
{
|
|
return fTimestamp; // PRQA S 4024
|
|
}
|
|
|
|
/**
|
|
* @return read only access to timestamp
|
|
*/
|
|
const uint64& getTimestamp() const
|
|
{
|
|
return fTimestamp;
|
|
}
|
|
|
|
bool isExtended() const { return false; } /* TODO: cleanup */
|
|
|
|
protected:
|
|
friend bool operator==(const CANFrame& frame1, const CANFrame& frame2);
|
|
|
|
uint8* fpPayload;
|
|
uint16 fId;
|
|
uint8 fPayloadLength;
|
|
uint8 fMaxPayloadLength;
|
|
uint64 fTimestamp;
|
|
};
|
|
|
|
/**
|
|
* Compares two CANFrames without considering the timestamp
|
|
* @param frame1 first frame to compare
|
|
* @param frame2 second frame to compare
|
|
* @return
|
|
* - true if frames are equal
|
|
* - false if frames are not equal
|
|
*/
|
|
bool operator==(const CANFrame& frame1, const CANFrame& frame2);
|
|
|
|
} /* namespace can */
|
|
|
|
#endif /* CANFRAME_H */
|