canfd_types.h

Go to the documentation of this file.

 
#pragma once
#include <stdint.h>
#include <string.h>

namespace adtf
{

namespace devicetb
{

namespace sdk
{

namespace canfd
{

namespace axle
{
#pragma pack(push, 1)
 
using tChannelID = uint8_t;
using tSignalID = uint32_t;
using tMessageID = uint32_t;
using tNetworkNodeID = uint32_t;
 
static constexpr const uint8_t CANFD_CHANNEL_MIN = 1;
static constexpr const uint8_t CANFD_CHANNEL_MAX = 16;
// CANFD standard message id 0..0x7FF
static constexpr const uint32_t CANFD_MSGID_STANDARD_MAX = 0x7FF;
// CANFD extended message id 0..0x1FFFFFFF
static constexpr const uint32_t CANFD_MSGID_EXTENDED_MAX = 0x1FFFFFFF;
 
static constexpr const uint8_t INVALID_CHANNEL_ID = 0xFF;
static constexpr const uint32_t INVALID_SIGNAL_ID = 0xFFFFFFFF;
static constexpr const uint32_t INVALID_MESSAGE_ID = 0xFFFFFFFF;
 
static constexpr const uint32_t CANFD_SIGNALID_HEADER_TAG = 0x10000000;
static constexpr const uint32_t CANFD_SIGNALID_HEADER_CHANNEL = 0x10000001;
static constexpr const uint32_t CANFD_SIGNALID_HEADER_HWTIME = 0x10000002;
 
 
enum eSignalType
{
    CANFD_SIGNAL_TYPE_INVALID = 0,
    CANFD_SIGNAL_TYPE_NORMAL = 1,
    CANFD_SIGNAL_TYPE_MULTIPLEXOR = 2,
    CANFD_SIGNAL_TYPE_MULTIPLEXED = 3
};
 
struct tValueInfo
{
    uint32_t         nValue;                    
    const char*    strDescription;            
};
 
typedef enum
{
    DT_CANFD_UNKNOWN = 0,
    DT_CANFD_UNSIGNED = 1,
    DT_CANFD_SIGNED = 2,
    DT_CANFD_IEEE_FLOAT = 3,
    DT_CANFD_IEEE_DOUBLE = 4
} tSignalRawDataType;

struct tSignalInfo
{
    tSignalID  nSignalID;                 
    tMessageID nMessageId;                
    bool           bCANFDExtended;              
 
    const char*    strSignalName;             
    const char*    strUnit;                   
    const char*    strDescription;            
 
    uint8_t          nSignalType;               
    uint8_t            ui8Reserved;
 
    uint8_t          nBitlen;                   
    uint8_t          nType;                     
 
    bool           bByteOrderMotorola;        
    bool           bSigned;                   
    tSignalID       nMultiplexorSignalID;      
    int32_t          nRequiredMultiplexorValue; 
 
    uint64_t         nDefaultRawValue;          
    uint64_t         nStartRawValue;            
    double        f64Factor;                 
    double        f64Offset;                 
    double        f64Min;                    
    double        f64Max;                    
 
    uint32_t         nValueTableSize;           
    tValueInfo*     pValueTable;               
 
    uint16_t            nStartbit;                   
    uint16_t            ui16Reserved2;
    uint32_t            ui32Reserved3;
};
 
struct tSignalValue
{
    enum eTypeTag
    {
        TAG_INVALID = 0,
        TAG_RAW_VALUE = 1,
        TAG_FLOAT64 = 2,
        TAG_UINT64 = 3,
        TAG_INT64 = 4,
        TAG_UINT32 = 5,
        TAG_INT32 = 6,
        TAG_FLOAT32 = 7
    };
 
    uint8_t  nTypeTag = TAG_INVALID; // see eTypeTag
    uint8_t  nReserved[7] = {};           // reserved, set to 0
 
    union
    {
        float    f32Value;       // used when nTAG == TAG_FLOAT32
        double    f64Value;       // used when nTag == TAG_FLOAT64
        uint64_t     nui64Value;     // used when nTag == TAG_UINT64
        int64_t      ni64Value;      // used when nTag == TAG_INT64
        uint32_t     nui32Value;     // used when nTag == TAG_UINT32
        int32_t      ni32Value;      // used when nTag == TAG_INT32
        uint64_t     n64RawValue = 0;    // used when nTag == TAG_RAW_VALUE
    };
 
    const char*    strValue = nullptr; // Value from TEXTTABLE, may be NULL
    uint8_t          nReserved2[8] = {};  // reserved, set to 0
};
 
struct tMessageInfo
{
    tMessageID     nMessageID;            
    bool               bCANFDExtended;          
    const char*        strMessageName;        
 
    uint8_t              nDataLength;           
    bool                bExtendedDataLength;   
    bool               bBaudRateSwitch;       
    uint8_t              nReserved[2];          
 
    uint32_t             nCycleTime;            
    tNetworkNodeID nNetworkNodeID;        
 
    uint32_t             nSignalCount;          
    const tSignalInfo*  psSignalInfo;          
 
    const char*        strDescription;        
};

struct tCANFDData
{
    enum eMessageTag
    {
        MT_Data = 0,        
        MT_Status = 1,      
    };

    enum eDataFlags
    {
        DF_NONE = 0,                        
        DF_ERROR_FRAME = 1,          
        DF_REMOTE_FRAME = 2,            
        DF_TX_COMPLETED = 4,            
        DF_EXTENDED_DATA_LENGTH = 8,    
        DF_CAN_FD_FORMAT_IDENTIFIER = DF_EXTENDED_DATA_LENGTH, 
        DF_BAUD_RATE_SWITCH = 16,      
        DF_SET_CAN_FD_AND_BRS = DF_CAN_FD_FORMAT_IDENTIFIER | DF_BAUD_RATE_SWITCH, 
        DF_ERROR_STATE_INDICATOR = 32 
    };

    enum eBusStatus
    {
        BS_OFFLINE = 1,         
        BS_ERROR_PASSIVE = 2,   
        BS_ERROR_WARNING = 4,   
        BS_ERROR_ACTIVE = 8     
    };

    enum eMsgId
    {
        MSG_IDMASK_BASE = 0x000007FF,   
        MSG_IDMASK_EXTENDED = 0x1FFFFFFF,   
        MSG_EXTENDED_FLAG = 0x80000000   
    };

    struct tMessageHeader
    {
        uint8_t      ui8Tag;             
        [[deprecated("CAN FD channel is deprecated and is set to 0 by default.")]]
        uint8_t      ui8Channel;         
        int64_t      tmTimeStamp;        
    };

    struct tData
    {
        uint32_t     ui32Id;             
        uint8_t      ui8Length;          
        uint8_t      ui8Reserved;        
        uint16_t     ui16Flags;          
        uint16_t     ui16Reserved;       
        uint32_t     ui32Reserved;       
        uint8_t      aui8Data[64];       
    };

    struct tStatus
    {
        uint32_t     ui32BitRate;        
        uint32_t     ui32RxBitCount;     
        uint32_t     ui32TxBitCount;     
        uint16_t     ui16RxErrorCounter; 
        uint16_t     ui16TxErrorCounter; 
        uint8_t      ui8BusStatus;       
        uint8_t      ui8Reserved;        
        uint32_t     ui32DataBitRate;    
        uint8_t      aui8Reserved[56];   
    };
 
    tMessageHeader  sHeader;            
 
    union
    {
        tData   sData;                  
        tStatus sStatus;                
    };
};
 
#pragma pack(pop)
 
} //namespace axle

namespace ignition
{
#pragma pack(push, 1)
 
// CAN FD Channel ID (see CANFD_CHANNEL_MIN and CANFD_CHANNEL_MAX for limits)
using tChannelID = uint8_t;
// CAN FD Signal ID which represents the internal signal identifier
using tSignalID = uint32_t;
// CAN FD Message ID which represents the CAN message identifier
using tMessageID = uint32_t;
// CAN FD PDU ID which represents the internal PDU identifier
using tPDUID = uint32_t;
// CAN FD Frame ID which represents the internal frame identifier
using tFrameID = uint32_t;
 
static constexpr const uint8_t CANFD_CHANNEL_MIN = 1;
static constexpr const uint8_t CANFD_CHANNEL_MAX = 16;
// CANFD standard message id 0..0x7FF
static constexpr const uint32_t CANFD_MSGID_STANDARD_MAX = 0x7FF;
// CANFD extended message id 0..0x1FFFFFFF
static constexpr const uint32_t CANFD_MSGID_EXTENDED_MAX = 0x1FFFFFFF;
 
static constexpr const uint8_t INVALID_CHANNEL_ID = 0xFF;
static constexpr const uint32_t INVALID_SIGNAL_ID = 0xFFFFFFFF;
static constexpr const uint32_t INVALID_MESSAGE_ID = 0xFFFFFFFF;
 
static constexpr const uint32_t CANFD_SIGNALID_HEADER_TAG = 0x10000000;
static constexpr const uint32_t CANFD_SIGNALID_HEADER_CHANNEL = 0x10000001;
static constexpr const uint32_t CANFD_SIGNALID_HEADER_HWTIME = 0x10000002;

enum class eSignalType : uint8_t
{
    CANFD_SIGNAL_TYPE_INVALID = 0,
    CANFD_SIGNAL_TYPE_NORMAL = 1,
};

enum class tSignalRawDataType : uint8_t
{
    DT_CANFD_UNKNOWN = 0,
    // Unsigned signal type
    DT_CANFD_UNSIGNED = 1,
    // Signed signal type (2C)
    DT_CANFD_SIGNED = 2,
    // IEEE 754 Float for 16, 32 and 64 Bit length
    DT_CANFD_IEEE_754 = 3
};

struct tDataBuffer
{
    // Offset to data buffer in bit
    uint64_t nBitOffset;
 
    // Length of data buffer in bit
    uint64_t nBitLength;
 
    // Byte order of data buffer
    bool bByteOrderMotorola;
};

union uValueType
{
    uint64_t u;
    int64_t s;
    float f;
    double d;
};

struct tEcuInfo
{
    // internal ECU id
    uint32_t nId = 0;
 
    // ECU short name
    const char* pstrName = nullptr;
 
    // ECU full name including path
    const char* pstrPath = nullptr;
};

struct tCompuScale
{
    // Rule applies if ((raw & nMask) >= nLowerLimit && (raw & nMask) <= nUpperLimit)
    // Multiple rules can overlap for text-table.
    // At most a single numeric conversion rule must match at a time - if no numeric rule matches, physical value is invalid.
    uValueType nLowerLimit;
    uValueType nUpperLimit;
 
    // Only applicable for eBasicSignalType::BST_NONE and eBasicSignalType::BST_UNSIGNED
    uint64_t nMask;
 
    union uCompuType
    {
        struct tLinear
        {
            // Use for formula physical = nFactor * raw + nOffset
            // nFactor may be 0, representing a constant
            double nFactor;
            double nOffset;
        } oLinear;
 
        struct tTextConstant
        {
            // Use for all text-tables (enums, bitfields, error codes etc.)
            const char* pText;
        } oTextConstant;
        
        // placeholder
        uint8_t nReserved[16];
    } oCompuType;
 
    enum eCompuScaleType : uint8_t
    {
        LINEAR = 0,
        TEXTCONSTANT,
    } oCompuScaleType;
};

struct tSignalInfo
{
    // Signal identifier
    tSignalID nId = 0;
 
    // Signal short name
    const char* pstrName = nullptr;
 
    // Signal full name including path
    const char* pstrPath = nullptr;
 
    // Signal unit information from database
    const char* pstrUnit = nullptr;
 
    // Signal description from database
    const char* pstrDescription = nullptr;
 
    // Signal type
    eSignalType nType = eSignalType::CANFD_SIGNAL_TYPE_INVALID;
 
    // Signal length in bits
    uint8_t nBitlen = 0;
 
    // Signal raw type from database
    tSignalRawDataType nRawType = tSignalRawDataType::DT_CANFD_UNKNOWN;
 
    // Signal byte order
    bool bByteOrderMotorola = false;
 
    // Signal computation scales for de- and encoding
    uint32_t nCompuScalesCount = 0;
    const tCompuScale* pCompuScales = nullptr;
 
    // Signal default raw value from database
    uint64_t nDefaultRawValue = 0;
 
    // placeholder
    uint8_t nReserved[16];
};

struct tSignalValue
{
    // Signal data type tags
    enum eTypeTag : uint8_t
    {
        TAG_INVALID = 0,
        TAG_RAW_VALUE = 1,
        TAG_FLOAT64 = 2,
        TAG_UINT64 = 3,
        TAG_INT64 = 4,
        TAG_UINT32 = 5,
        TAG_INT32 = 6,
        TAG_FLOAT32 = 7
    };
 
    // Signal data type
    eTypeTag  nTypeTag = TAG_INVALID;
 
    // Union to keep the signal value
    union uData
    {
        float    f32Value;       // used when nTAG == TAG_FLOAT32
        double    f64Value;       // used when nTag == TAG_FLOAT64
        uint64_t     nui64Value;     // used when nTag == TAG_UINT64
        int64_t      ni64Value;      // used when nTag == TAG_INT64
        uint32_t     nui32Value;     // used when nTag == TAG_UINT32
        int32_t      ni32Value;      // used when nTag == TAG_INT32
        uint64_t     n64RawValue;    // used when nTag == TAG_RAW_VALUE
    } oData;
 
    // placeholder
    uint8_t  nReserved[8];
};

struct tPduSignalInfo
{
    // Signal offset inside the message in bit
    uint16_t nBitOffset = 0;
 
    // Signal info structure
    const tSignalInfo* pInfo = nullptr;
    
    // placeholder
    uint8_t  nReserved[8];
};

struct tCanFdTransformation
{
    enum eTransformationType : uint8_t
    {
        TT_NONE = 0,
        TT_E2E,
        TT_MULTIPLEXED,
        TT_FRAGMENTED,
        TT_CONTAINER_WITH_OFFSET,
        TT_CONTAINER_WITH_HEADER
    };
    eTransformationType nTransformationType = TT_NONE;
 
    // Number of leading header bits added by e.g. secured header
    uint16_t nHeaderBits;
    // Number of trailing bits added by e.g. E2E authentification header
    uint16_t nTrailingBits;
 
    // Internal id for child PDU
    uint32_t nChildPduId;
 
    struct tE2E
    {
        // playholder for encoding
    };
 
    // Information for the multiplexed use case
    struct tMultiplexed
    {
        // If true, this is the initial dynamic PDU
        bool bIsInitialPdu;
 
        // Selector code for Mux PDU
        uint64_t nSelectorFieldCode;
        // may be empty for static segmented or IContainer-PDU(s)
        tDataBuffer oSelectorFieldInfo;
 
        // Count of multiplexed fragments
        uint64_t nMultiplexedFragments;
        // Multiplexed fragements array
        const tDataBuffer* pMultiplexedFragments;
    };
 
    struct tFragmented
    {
        // placeholder for N-PDUs
    };
 
    // is used if container uses no header.
    struct tContainerWithOffset
    {
        uint32_t nOffset;
        uint16_t nUpdateIndicationBitPosition; // specifies the bit location of ContainedPduInfo Update-Bit in the ContainerPdu.
    };
 
    // is used if container uses long or short header
    struct tContainerWithHeader
    {
        enum eHeaderType : uint8_t
        {
            LONG_HEADER, // Header size is 64 bit: Header-Id 32 bit; Dlc 32 bit
            SHORT_HEADER     // Header size is 32 bit: Header Id 24 bit; Dlc 8 bit
        };
        eHeaderType nHeaderType;
        bool bByteOrderMotorola; // Defines the endianess of the header. Applies to both header Id and DLC encoding.
        uint8_t nUnusedBitPattern; // fills not updated areas of the ContainerPduInfo with this pattern
    };
 
    union uDetails
    {
        tE2E oE2E;
        tMultiplexed oMultiplexed;
        tFragmented oFragmented;
        tContainerWithOffset oContainerWithOffset;
        tContainerWithHeader oContainerWithHeader;
 
        // placeholder
        uint8_t nReserved[64];
    } oDetails;
};

struct tPduInfo
{
    // Internal PDU id
    uint32_t nId = 0;
 
    // PDU short name
    const char* pstrName = nullptr;
 
    // PDU full name including path
    const char* pstrPath = nullptr;
 
    // Message length in byte
    uint16_t nDataLength = 0;
 
    // Number of transformations to convert this message back for payload decoding
    uint32_t nTransformationCount = 0;
 
    // Array which contain information about the transformation chain
    const tCanFdTransformation* pTransformations = nullptr;
 
    // Number of signals in this message
    uint32_t nPduSignalCount = 0;
 
    // Array if signals including their information
    const tPduSignalInfo* pPduSignalInfo = nullptr;
};

struct tFrameInfo
{
    // Internal frame id
    tFrameID nId = 0;
 
    // Message id from database as seen on the bus
    tMessageID nMessageId = 0;
 
    // Flag if frame is extended or standard
    bool bCANFDExtended = false;
 
    // Frame short name
    const char* pstrName = nullptr;
 
    // Frame full name including path
    const char* pstrPath = nullptr;
 
    // Length of the frame in bytes
    uint8_t nDataLength = 0;
 
    // Extended data length of the frame in bytes
    bool bExtendedDataLength = false;
 
    // Flag if frame uses higher Baud Rate in Data Phase
    bool bBaudRateSwitch = false;
 
    // Cycle time of frame in milliseconds (0 if undefined)
    uint32_t nCycleTime = 0;
 
    // PDU info
    const tPduInfo* pPduInfo = nullptr;
};
 
#pragma pack(pop)
 
} //namespace ignition

namespace jack
{
#pragma pack(push, 1)
 
static constexpr const uint8_t CANFD_CHANNEL_MIN = 0;

struct tContainedPduHeader
{
    ignition::tCanFdTransformation::tContainerWithHeader::eHeaderType nHeaderType;
    // Id only in host byte order. Byte order conversion according to tContainerWithHeader::bByteOrderMotorola.
    // For 24bit headers, only lower 24bit are significant.
    uint32_t nHeaderId;
};

struct tContainedPduInfo
{
    enum eContainedPduCollectionSemantics : uint8_t
    {
        LAST_IS_BEST,
        QUEUED
    };
 
    eContainedPduCollectionSemantics nContainedPduCollectionSemantics = LAST_IS_BEST; // Defines whether this ContainedPduInfo shall be collected using a lastisbest or queued semantics. Necessary for encoding if the same pdu should appear multiple times in the container.
    tContainedPduHeader oHeader; // header struct which contains id and header type
    const adtf::devicetb::sdk::canfd::ignition::tPduInfo* pPduInfo = nullptr; // pointer to the containedPdu
    // placeholder
    uint8_t nReserved[64];
};
 
#pragma pack(pop)
} //namespace jack

namespace manifold
{
static constexpr const uint8_t CANFD_CHANNEL_MAX = 32;
} //namespace manifold
 
using jack::CANFD_CHANNEL_MIN;
using manifold::CANFD_CHANNEL_MAX;
 
using tCANFDData = axle::tCANFDData;    
 
using tChannelID = ignition::tChannelID;    
using tSignalID = ignition::tSignalID;    
using tMessageID = ignition::tMessageID;    
using tPDUID = ignition::tPDUID;    
using tFrameID = ignition::tFrameID;    
using eSignalType = ignition::eSignalType;    
using tSignalRawDataType = ignition::tSignalRawDataType;    
using tDataBuffer = ignition::tDataBuffer;    
using uValueType = ignition::uValueType;    
using tEcuInfo = ignition::tEcuInfo;    
using tCompuScale = ignition::tCompuScale;    
using tSignalInfo = ignition::tSignalInfo;    
using tSignalValue = ignition::tSignalValue;    
using tPduSignalInfo = ignition::tPduSignalInfo;    
using tPduInfo = ignition::tPduInfo;    
using tFrameInfo = ignition::tFrameInfo;    
using tCanFdTransformation = ignition::tCanFdTransformation;    
 
using tContainedPduInfo = jack::tContainedPduInfo;    
using tContainedPduHeader = jack::tContainedPduHeader;    
 
} // namespace canfd
} // namespace sdk
} // namespace devicetb
} // namespace adtf