dbc_decoder.h

Go to the documentation of this file.

 
#ifndef DBC_DECODER_H
#define DBC_DECODER_H
 
#include <cstdint>
#include <variant>
#include <vector>
 
#include "decode_database.h"
 
struct RawCanFrame {
    std::uint32_t canId = 0U;       
    bool isExtended = false;        
    std::vector<std::uint8_t> data; 
    RawCanFrame() = default;
};
 
enum class SignalDecodeStatus {
    InvalidDefinition,
    InsufficientPayload,
    SelectorUnavailable,
    Inactive,
    Valid,
    PhysicalConversionFailed
};
 
enum class FrameDecodeStatus {
    UnknownFrame,
    InsufficientPayload,
    SignalErrors,
    Valid
};
 
struct DecodedSignalValue {
    std::shared_ptr<const DecodeSignal> definition; 
    SignalKey key;                                  
    RawSignalValue rawValue = std::uint64_t(0U);    
    double physicalValue = 0.0;                     
    bool valid = false;                             
    SignalDecodeStatus status = SignalDecodeStatus::InvalidDefinition;
 
    const std::string *GetValueDescription() const {
        return valid && definition ? FindValueDescription(definition->valueDescriptions, rawValue) : nullptr;
    }
 
    DecodedSignalValue() = default;
};
 
struct DecodedFrameValue {
    std::shared_ptr<const DecodeFrame> definition; 
    FrameKey key;                                  
    std::vector<DecodedSignalValue> signals;       
    bool valid = false;                            
    FrameDecodeStatus status = FrameDecodeStatus::UnknownFrame; 
    DecodedFrameValue() = default;
};
 
class DbcDecoder {
public:
    std::shared_ptr<const DecodeFrame> FindFrame(const DecodeDatabase &database,
                                                 std::uint32_t canId,
                                                 bool isExtended) const;
 
    DecodedFrameValue Decode(const DecodeDatabase &database,
                             const RawCanFrame &frame) const;
 
private:
    static bool IsValidDefinition(const DecodeSignal &signal, std::uint8_t dlc);
 
    struct SelectorState {
        const DecodeSignal *definition = nullptr;
        bool valid = false;
        bool available = false;
        std::uint64_t value = 0U;
    };
 
    static SelectorState ReadSelector(const DecodeFrame &definition, const RawCanFrame &frame);
    static DecodedSignalValue DecodeOneSignal(const DecodeSignal &signal,
                                              std::uint8_t dlc,
                                              const RawCanFrame &frame,
                                              const SelectorState &selector);
 
    static bool ExtractUnsigned(const std::vector<std::uint8_t> &data,
                                const DecodeSignal &signal,
                                std::uint64_t &value);
 
    static bool ExtractIntel(const std::vector<std::uint8_t> &data,
                             std::uint32_t startBit,
                             std::uint32_t length,
                             std::uint64_t &value);
 
    static bool ExtractMotorola(const std::vector<std::uint8_t> &data,
                                std::uint32_t startBit,
                                std::uint32_t length,
                                std::uint64_t &value);
 
    static std::int64_t SignExtend(std::uint64_t value, std::uint32_t bitLength);
};
 
#endif /* DBC_DECODER_H */