can_types.h

Go to the documentation of this file.

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

namespace adtf
{

namespace devicetb
{

namespace sdk
{

namespace can
{

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 CAN_CHANNEL_MIN = 1;
static constexpr const uint8_t CAN_CHANNEL_MAX = 16;
// CAN standard message id 0..0x7FF
static constexpr const uint32_t CAN_MSGID_STANDARD_MAX = 0x7FF;
// CAN extended message id 0..0x1FFFFFFF
static constexpr const uint32_t CAN_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 CAN_SIGNALID_HEADER_TAG = 0x10000000;
static constexpr const uint32_t CAN_SIGNALID_HEADER_CHANNEL = 0x10000001;
static constexpr const uint32_t CAN_SIGNALID_HEADER_HWTIME = 0x10000002;
 
enum eSignalType
{
    CAN_SIGNAL_TYPE_INVALID = 0,
    CAN_SIGNAL_TYPE_NORMAL = 1,
    CAN_SIGNAL_TYPE_MULTIPLEXOR = 2,
    CAN_SIGNAL_TYPE_MULTIPLEXED = 3
};
 
struct tValueInfo
{
    uint32_t         nValue;                    
    const char*    strDescription;            
};
 
typedef enum
{
    DT_CAN_UNKNOWN     = 0,
    DT_CAN_UNSIGNED    = 1,
    DT_CAN_SIGNED      = 2,
    DT_CAN_IEEE_FLOAT  = 3,
    DT_CAN_IEEE_DOUBLE = 4
} tSignalRawDataType;
 
struct tSignalInfo
{
    tSignalID    nSignalID;                 
    tMessageID   nMessageId;                
    bool           bCANExtended;              
 
    const char*    strSignalName;             
    const char*    strUnit;                   
    const char*    strDescription;            
 
    uint8_t          nSignalType;               
    uint8_t          nStartbit;                 
    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;               
 
    uint64_t         nReserved2;                
};
 
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               bCANExtended;          
    const char*        strMessageName;        
 
    uint8_t              nDataLength;           
    uint8_t              nReserved[3];          
 
    uint32_t             nCycleTime;            
    tNetworkNodeID   nNetworkNodeID;        
 
    uint32_t             nSignalCount;          
    const tSignalInfo*  psSignalInfo;          
 
    const char*        strDescription;        
};

struct tCANData
{
    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,            
    };

    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;             
        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[8];        
    };

    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     ui32Reserved;       
    };
 
    tMessageHeader  sHeader;            
 
    union
    {
        tData   sData;                  
        tStatus sStatus;                
    };
};
 
#pragma pack(pop)
 
} // namespace axle

namespace jack
{
#pragma pack(push, 1)
 
static constexpr const uint8_t CAN_CHANNEL_MIN = 0;
 
#pragma pack(pop)
} //namespace jack
 
using jack::CAN_CHANNEL_MIN;
using axle::CAN_CHANNEL_MAX;
 
using tCANData = axle::tCANData;    
using tChannelID = axle::tChannelID;    
using tSignalID = axle::tSignalID;    
using tMessageID = axle::tMessageID;    
using eSignalType = axle::eSignalType;    
using tSignalRawDataType = axle::tSignalRawDataType;    
using tSignalInfo = axle::tSignalInfo;    
using tSignalValue = axle::tSignalValue;    
using tMessageInfo = axle::tMessageInfo;    
 
} // namespace can
} // namespace sdk
} // namespace devicetb
} // namespace adtf