flexray_database_intf.h

Go to the documentation of this file.

 
#pragma once
 
#include "flexray_types.h"
#include <a_utils.h>
#include <adtf_ucom3.h>
 
 
#define CID_DEVTB_FLEXRAYDB_PARSER "flexray_database_parser.service.devicetb.cid"
 
namespace adtf
{
 
namespace devicetb
{
 
namespace sdk
{
 
namespace flexray
{
 
namespace axle
{
using tDeviceChannel = uint8_t;
#define FLEXRAY_DEVICECHANNEL_MIN        1         
#define FLEXRAY_DEVICECHANNEL_MAX        9         
 
struct tClusterConfig
{
    int32_t      nBusGuardianEnable;
    int32_t      nBaudrate;
    int32_t      nBusGuardianTick;
    int32_t      nExternalClockCorrectionMode;
    int32_t      nColdStartAttempts;
    int32_t      nListenNoise;
    int32_t      nMacroPerCycle;
    int32_t      nMaxWithoutClockCorrectionFatal;
    int32_t      nMaxWithoutClockCorrectionPassive;
    int32_t      nNetworkManagementVectorLength;
    int32_t      nNumberOfMinislots;
    int32_t      nNumberOfStaticSlots;
    int32_t      nOffsetCorrectionStart;
    int32_t      nPayloadLengthStatic;
    int32_t      nSyncNodeMax;
    int32_t      nActionPointOffset;
    int32_t      nDynamicSlotIdlePhase;
    int32_t      gdMacrotick;
    int32_t      nMinislot;
    int32_t      nMiniSlotActionPointOffset;
    int32_t      nNIT;
    int32_t      nStaticSlot;
    int32_t      nSymbolWindow;
    int32_t      nTSSTransmitter;
    int32_t      nCASRxLowMax;
    int32_t      nWakeupSymbolRxIdle;
    int32_t      nWakeupSymbolRxLow;
    int32_t      nWakeupSymbolRxWindow;
    int32_t      nWakeupSymbolTxIdle;
    int32_t      nWakeupSymbolTxLow;
    int32_t      nCycleDuration;
    float    fOffsetCorrectionMax;
};
 
struct tSignalPDUMappingConfig
{
    // Global cluster configuration info
    struct tClusterConfig *pClusterConfig;
    int32_t      nBitCountingPolicy;
    int32_t      nIsHighLowBitOrder;
    int32_t      nReserved1;
    int32_t      nReserved2;
};
 
struct tECUInfo
{
    const char*    strID;          
    const char*    strName;        
 
    uint32_t         nPDUIDTXCount;  
    tPDUID*         aPDUIDTX;       
};
 
struct tECUConfig
{
    int32_t      nAllowHaltDueToClock;
    int32_t      nAllowPassiveToActive;
    int32_t      nChannels;
    int32_t      nClusterDriftDamping;
    int32_t      nDecodingCorrection;
    int32_t      nDelayCompensationA;
    int32_t      nDelayCompensationB;
    int32_t      nExternOffsetCorrection;
    int32_t      nExternRateCorrection;
    int32_t      nKeySlotUsedForStartup;
    int32_t      nKeySlotUsedForSync;
    int32_t      nLatestTx;
    int32_t      nMacroInitialOffsetA;
    int32_t      nMacroInitialOffsetB;
    int32_t      nMaxPayloadLengthDynamic;
    int32_t      nMicroInitialOffsetA;
    int32_t      nMicroInitialOffsetB;
    int32_t      nMicroPerCycle;
    int32_t      nMicroPerMacroNom;
    int32_t      nOffsetCorrectionOut;
    int32_t      nRateCorrectionOut;
    int32_t      nSamplesPerMicrotick;
    int32_t      nSingleSlotEnabled;
    int32_t      nWakeupChannel;
    int32_t      nWakeupPattern;
    int32_t      nAcceptedStartupRange;
    int32_t      nListenTimeout;
    int32_t      nMaxDrift;
    float    fMicrotick;
    int32_t      nExternOffsetControl;
    int32_t      nExternRateControl;
    int32_t      nChannelsMTS;
};
 
struct tCompInfo
{
    double        fPhysLowerLimit;    
    double        fPhysUpperLimit;    
    double        fRawLowerLimit;     
    double        fRawUpperLimit;     
    const char*    strValue;           
    double        fFactor;            
    double        fOffset;            
};
 
struct tSignalInfo
{
    typedef enum
    {
        dtInvalid           = 0,        
        dtInt8              = 1,        
        dtInt16             = 2,        
        dtInt32             = 3,        
        dtInt64             = 4,        
        dtUInt8             = 5,        
        dtUInt16            = 6,        
        dtUInt32            = 7,        
        dtUInt64            = 8,        
        dtBool              = 9,        
        dtFloat32           = 10,       
        dtFloat64           = 11,       
        dtAsciiString       = 12,       
        dtUnicode2String    = 13,       
        dtByteField         = 14,       
        dtBitField          = 15        
    } tDataType;
 
    const char* strID;                 
    const char* strShortName;          
    const char* strDescription;        
    const char* strUnit;               
 
    uint16_t     nDataType;              
    uint16_t     nBitlen;                
    bool       bSigned;                
    double    fDefault;               
 
    uint32_t     nCompInfoCount;         
    tCompInfo*  paCompInfo;             
 
    tECUID      nECUID;                 
    tPDUID      nPDUID;                 
    uint16_t     nBitPos;                
    bool       bByteOrderMotorola;     
};
 
struct tSignalValue
{
    tTimeStamp      nTimeStamp = 0;         
    uint64_t         nRawValue = 0;          
    double        nf64Value = std::numeric_limits<double>::quiet_NaN();          
    const char*    strTextValue = nullptr;       
};
 
struct tOrderedSignalInfo
{
    uint16_t     nBitPos;                
    int16_t      nUpdateBitPosition;     
    bool       bByteOrderMotorola;     
    tSignalID   nSignalID;              
};
 
struct tSignalGroupInfo
{
    const char*        strSignalGroupID;       
    uint16_t             nBitPos;                
    uint16_t             nBitLength;             
    uint32_t             nOrderedSignalCount;    
    tOrderedSignalInfo* aOrderedSignal;         
};
 
struct tPDUInfo
{
    enum tPDUType
    {
        OTHER = 0,
        APPLICATION,
        BAP,
        DIAG_REQUEST,
        DIAG_RESPONSE,
        DIAG_STATE,
        NM,
        SERVICE,
        TPL,
        XCP_PRE_CONFIGURED,
        XCP_RUNTIME_CONFIGURED
    };
 
    tPDUID              nPDUID;                 
    const char*        strID;                  
    const char*        strShortName;           
 
    uint8_t              nPayloadLength;         
 
    tECUID              nECUID;                 
 
    uint32_t             nSignalGroupCount;      
    tSignalGroupInfo*   aSignalGroup;           
 
    uint32_t             nSignalCount;           
    tSignalID*          aSignalID;              
 
    uint8_t              nType;                  
};
 
struct tFramePDUInfo
{
    tPDUID          nPDUID;                     
    uint8_t          nBytePosition;              
    uint8_t          nPayloadLength;             
    int16_t          nUpdateBitPosition;         
};
 
struct tFrameInfo
{
    enum tFrameType
    {
        OTHER = 0,
        APPLICATION,
        BAP,
        DIAG_REQUEST,
        DIAG_RESPONSE,
        DIAG_STATE,
        NM,
        SERVICE,
        TPL,
        XCP_PRE_CONFIGURED,
        XCP_RUNTIME_CONFIGURED
    };
 
    tECUID          nECUID;             
    uint8_t          nSize;              
    tCycleID        nBaseCycle;         
    int8_t           nCycleRepetition;   
    tSlotID         nSlot;              
    uint32_t         nFramePDUCount;     
    tFramePDUInfo*  aFramePDU;          
 
    uint8_t          nType;              
};
 
struct tCycleInfo
{
    uint32_t         nFrameCount;    
    tFrameInfo**    paFrame;        
};
 
struct tClusterNameLst
{
    std::vector<adtf::util::cString>    strClusterNames;
    uint8_t                  nClusterCount;
};
 
struct tECUNameLst
{
    std::vector<adtf::util::cString>    strECUNames;
    uint8_t                  nECUCount;
};
 
 
class IFlexRayDatabase : public adtf::ucom::ant::IObject
{
public:
    ADTF_IID(IFlexRayDatabase, "flexray_database.axle.flexray.sdk.devicetb.adtf.iid");
public:
    virtual const char* GetName() const = 0;
 
    virtual tResult GetClusterConfig(tClusterConfig* pCluster) = 0;
 
    virtual tResult GetChannelName(tChannelID nChannel, const char** pChannelName) const = 0;
 
    virtual tResult GetECUCount(uint32_t* pnECUCount) const = 0;
 
    virtual tResult GetECUName(tECUID nECUID, const char** pECUName) const = 0;
 
    virtual tResult GetECUID(const char* strECUName, tECUID* pnECUID) const = 0;
 
    virtual tResult GetECUInfo(tECUID nECUID, const tECUInfo** pECUInfo) const = 0;
 
    virtual tResult GetECUConfig(const char* strECU, tECUConfig* pECUConfig) = 0;
 
    virtual tResult GetSignalCount(uint32_t* pnSignalCount) const = 0;
 
    virtual tResult GetSignalName(tSignalID nSignalID, const char** pSignalName) const = 0;
 
    virtual tResult GetSignalUnit(tSignalID nSignalID, const char** pSignalUnit) const = 0;
 
    virtual tResult GetSignalDescription(tSignalID nSignalID, const char** pSignalDescription) const = 0;
 
    virtual tResult GetSignalInfo(tSignalID nSignalID, const tSignalInfo** pSignalInfo) const = 0;
 
    virtual tResult GetPDUCount(uint32_t* pnPDUCount) const = 0;
 
    virtual tResult GetPDUID(const char* strPDUName, tPDUID* pnPDUID) const = 0;
 
    virtual tResult GetPDUName(tPDUID nPDUID, const char** pPDUName) const = 0;
 
    virtual tResult GetPDUInfo(tPDUID nPDUID, const tPDUInfo** pPDUInfo) const = 0;
 
    virtual tResult GetPDUSignalMap(tPDUID nPDUID, uint32_t* nSignalCount, const tSignalID** pSignalMap) const = 0;
 
    virtual tResult GetSignalID(const char* strSignalName, tSignalID* pnSignalID) const = 0;
 
    virtual tResult GetFrameInfo(tChannelID nChannel, tCycleID nCycle, tSlotID nSlot,
                                 const tFrameInfo** pFrameInfo) const = 0;
 
    virtual tResult GetCycleInfo(tChannelID nChannel, tCycleID nCycle,
                                 const tCycleInfo** pCycleInfo) const = 0;
 
    virtual tResult GetChannelsForECU(tECUID nECUID, tChannelID** pChannelIDs, uint8_t* pChannelCount) const = 0;
 
    virtual tResult GetClusterConfig(tChannelID nChannelID, tClusterConfig* pConfig) = 0;
 
    virtual tResult GetSignalPDUMappingConfig(tChannelID nChannelID, tSignalPDUMappingConfig* pConfig) = 0;
 
    virtual tResult GetClusterName(tChannelID nChannelID, const char** strClusterName) = 0;
 
    virtual tResult GetNetworkID(const char* strClusterName, tNetworkID* nNetworkID) = 0;
 
    virtual tResult SetChannelID(tNetworkID nNetworkID, tChannelABID nChannelABID, tChannelID* pChannelID) const = 0;
 
    virtual tResult GetNetworkID(tChannelID nChannelID, tNetworkID* pNetworkID) const = 0;
 
    virtual tResult GetChannelABID(tChannelID nChannelID, tChannelABID* pChannelABID) const = 0;
 
    virtual tResult GetAllClusterNames(tClusterNameLst* pClusterNames) = 0;
 
    virtual tResult GetAllECUNames(const char *strProjectID, tECUNameLst* pECUNames) = 0;
 
    virtual tResult GetProjectID(const char* strFileName, const char** strProjectID) = 0;
};
 
} //namespace axle
 
namespace hood
{
 
struct tSwitchedPDU
{
    tPDUID nPDU; 
    uint64_t nSwitchValue; 
};
 
struct tSwitchedPDUs
{
    int16_t nSwitchPosition; 
    uint8_t nSwitchSize; 
    bool bByteOrderMotorola; 
    uint16_t nDynamicOffset; 
    uint64_t nSwitchedPDUCount; 
    tSwitchedPDU* aSwitchedPDUs; 
};
 
struct tPDUInfo: public axle::tPDUInfo
{
    tSwitchedPDUs* pSwitchedPDUs; 
    tPDUID nParentPDUID; 
};
 
class IFlexRayDatabase : public axle::IFlexRayDatabase
{
public:
    ADTF_IID(IFlexRayDatabase, "flexray_database.hood.flexray.sdk.devicetb.adtf.iid");
public:
    using axle::IFlexRayDatabase::GetPDUInfo;
 
    virtual tResult GetPDUInfo(tPDUID nPDUID, const tPDUInfo** pPDUInfo) const = 0;
};
 
}
 
using tDeviceChannel = axle::tDeviceChannel;    
using tClusterConfig = axle::tClusterConfig;    
using tSignalPDUMappingConfig = axle::tSignalPDUMappingConfig;    
using tECUInfo = axle::tECUInfo;    
using tECUConfig = axle::tECUConfig;    
using tCompInfo = axle::tCompInfo;    
using tSignalInfo = axle::tSignalInfo;    
using tSignalValue = axle::tSignalValue;    
using tOrderedSignalInfo = axle::tOrderedSignalInfo;    
using tSignalGroupInfo = axle::tSignalGroupInfo;    
using tPDUInfo = axle::tPDUInfo;    
using tFramePDUInfo = axle::tFramePDUInfo;    
using tFrameInfo = axle::tFrameInfo;    
using tCycleInfo = axle::tCycleInfo;    
using tClusterNameLst = axle::tClusterNameLst;    
using tECUNameLst = axle::tECUNameLst;    
using IFlexRayDatabase = axle::IFlexRayDatabase;    
} //namespace flexray
} //namespace sdk
} // namespace devicetb
} // namespace adtf