dbc_decoder.cpp

Go to the documentation of this file.

 
#include "dbc_decoder.h"
#include "j1939.h"
#include "signal_layout.h"
#include <cmath>
#include <stdexcept>
#include <unordered_set>
#include <utility>
 
std::shared_ptr<const DecodeFrame> DbcDecoder::FindFrame(const DecodeDatabase &database,
                                                         std::uint32_t canId,
                                                         bool isExtended) const {
    return ResolveFrame(database, canId, isExtended).definition;
}
 
PgnLookupResult DbcDecoder::ResolveFrame(const DecodeDatabase &database,
                                         std::uint32_t canId, bool isExtended) {
    const std::shared_ptr<const DecodeFrame> exact = database.FindFrame(FrameKey(canId, isExtended));
    if (exact)
        return {exact, false};
    if (!isExtended || canId > 0x1FFFFFFFU)
        return {};
    return database.FindFrameByPgn(ExtractJ1939Pgn(canId));
}
 
DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
                                     const RawCanFrame &frame) const {
    return DecodeImpl(database, frame, nullptr);
}
 
DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
                                     const RawCanFrame &frame,
                                     const std::vector<SignalKey> &selection) const {
    return DecodeImpl(database, frame, &selection);
}
 
DecodedFrameValue DbcDecoder::DecodeImpl(const DecodeDatabase &database,
                                         const RawCanFrame &frame,
                                         const std::vector<SignalKey> *selection) const {
    DecodedFrameValue result;
    result.key = FrameKey(frame.canId, frame.isExtended);
    const PgnLookupResult match = ResolveFrame(database, frame.canId, frame.isExtended);
    if (match.ambiguous) {
        result.status = FrameDecodeStatus::AmbiguousFrame;
        return result;
    }
    const std::shared_ptr<const DecodeFrame> definition = match.definition;
    if (definition == nullptr)
        return result;
    result.key = definition->GetKey();
 
    std::vector<const DecodeSignal *> selected;
    if (selection != nullptr) {
        selected.reserve(selection->size());
        std::unordered_set<SignalKey, SignalKeyHasher> keys;
        for (const SignalKey &key: *selection) {
            if (!(key.frame == result.key))
                throw std::invalid_argument("Selected signal belongs to another frame: " + key.name);
            if (!keys.insert(key).second)
                throw std::invalid_argument("Duplicate selected signal: " + key.name);
            const std::shared_ptr<const DecodeSignal> signal = database.FindSignal(key);
            if (!signal)
                throw std::invalid_argument("Unknown selected signal: " + key.name);
            selected.push_back(signal.get());
        }
    }
 
    result.definition = definition;
    result.valid = true;
    result.status = frame.data.size() < definition->dlc
                        ? FrameDecodeStatus::InsufficientPayload
                        : FrameDecodeStatus::Valid;
 
    const dbc_detail::MultiplexGraph &graph = database.GetMultiplexGraph(result.key);
    const std::size_t count = selection != nullptr ? selected.size() : definition->signals.size();
    result.signals.reserve(count);
    for (std::size_t index = 0U; index < count; ++index) {
        const DecodeSignal &signal = selection != nullptr ? *selected[index] : definition->signals[index];
        const std::size_t signalIndex = static_cast<std::size_t>(&signal - definition->signals.data());
        DecodedSignalValue decoded = DecodeOneSignal(signal, definition->dlc, frame,
                                                     ActivationStatus(signalIndex, *definition, frame, graph));
        if (!decoded.valid && decoded.status != SignalDecodeStatus::Inactive &&
            result.status == FrameDecodeStatus::Valid)
            result.status = FrameDecodeStatus::SignalErrors;
        decoded.definition = std::shared_ptr<const DecodeSignal>(definition, &signal);
        decoded.key = SignalKey(result.key, signal.name);
        result.signals.push_back(std::move(decoded));
    }
 
    return result;
}
 
bool DbcDecoder::IsValidDefinition(const DecodeSignal &signal, std::uint8_t dlc) {
    if ((signal.byteOrder != ByteOrder::Intel && signal.byteOrder != ByteOrder::Motorola) ||
        (signal.valueType != ValueType::Unsigned && signal.valueType != ValueType::Signed) ||
        (signal.multiplexing.role != MultiplexRole::Unconditional &&
         signal.multiplexing.role != MultiplexRole::Selector &&
         signal.multiplexing.role != MultiplexRole::Branch &&
         signal.multiplexing.role != MultiplexRole::BranchSelector))
        return false;
 
    return IsValidSignalLayout(signal.startBit, signal.length,
                              signal.byteOrder == ByteOrder::Intel, dlc);
}
 
SignalDecodeStatus DbcDecoder::ActivationStatus(std::size_t index,
                                                const DecodeFrame &definition,
                                                const RawCanFrame &frame,
                                                const dbc_detail::MultiplexGraph &graph) {
    // Inspect ancestors from the root so inactive paths never require child bytes.
    std::vector<std::size_t> path;
    while (graph.parents[index] != definition.signals.size()) {
        path.push_back(index);
        index = graph.parents[index];
    }
    for (std::vector<std::size_t>::const_reverse_iterator it = path.rbegin(); it != path.rend(); ++it) {
        const DecodeSignal &selector = definition.signals[graph.parents[*it]];
        std::uint64_t value = 0U;
        if (!ExtractUnsigned(frame.data, selector, value))
            return SignalDecodeStatus::SelectorUnavailable;
        if (!graph.Matches(*it, value))
            return SignalDecodeStatus::Inactive;
    }
    return SignalDecodeStatus::Valid;
}
 
DecodedSignalValue DbcDecoder::DecodeOneSignal(const DecodeSignal &signal,
                                               std::uint8_t dlc,
                                               const RawCanFrame &frame,
                                               SignalDecodeStatus activation) {
    DecodedSignalValue decoded;
    std::uint64_t unsignedValue = 0U;
 
    if (!IsValidDefinition(signal, dlc))
        return decoded;
    if (activation != SignalDecodeStatus::Valid) {
        decoded.status = activation;
        return decoded;
    }
    if (!ExtractUnsigned(frame.data, signal, unsignedValue)) {
        decoded.status = SignalDecodeStatus::InsufficientPayload;
        return decoded;
    }
 
    if (signal.valueType == ValueType::Signed)
        decoded.rawValue = SignExtend(unsignedValue, signal.length);
    else
        decoded.rawValue = unsignedValue;
 
    double numericValue;
    if (const std::int64_t *signedValue = std::get_if<std::int64_t>(&decoded.rawValue))
        numericValue = static_cast<double>(*signedValue);
    else
        numericValue = static_cast<double>(std::get<std::uint64_t>(decoded.rawValue));
    decoded.physicalValue = numericValue * signal.factor + signal.offset;
    if (!std::isfinite(decoded.physicalValue)) {
        decoded.status = SignalDecodeStatus::PhysicalConversionFailed;
        return decoded;
    }
    decoded.valid = true;
    decoded.status = SignalDecodeStatus::Valid;
 
    return decoded;
}
 
bool DbcDecoder::ExtractUnsigned(const std::vector<std::uint8_t> &data,
                                 const DecodeSignal &signal,
                                 std::uint64_t &value) {
    if ((signal.length == 0U) || (signal.length > 64U))
        return false;
 
    if (signal.byteOrder == ByteOrder::Intel)
        return ExtractIntel(data, signal.startBit, signal.length, value);
 
    return ExtractMotorola(data, signal.startBit, signal.length, value);
}
 
bool DbcDecoder::ExtractIntel(const std::vector<std::uint8_t> &data,
                              std::uint32_t startBit,
                              std::uint32_t length,
                              std::uint64_t &value) {
    value = 0U;
 
    for (std::uint32_t bitIndex = 0U; bitIndex < length; ++bitIndex) {
        const std::uint64_t absoluteBit = std::uint64_t(startBit) + bitIndex;
        const std::uint64_t byteIndex = absoluteBit / 8U;
        const std::uint32_t bitInByte = absoluteBit % 8U;
 
        if (byteIndex >= data.size())
            return false;
 
        const std::uint64_t bitValue =
                (static_cast<std::uint64_t>((data[byteIndex] >> bitInByte) & 0x01U) << bitIndex);
 
        value |= bitValue;
    }
 
    return true;
}
 
bool DbcDecoder::ExtractMotorola(const std::vector<std::uint8_t> &data,
                                 std::uint32_t startBit,
                                 std::uint32_t length,
                                 std::uint64_t &value) {
    /*
   * DBC Motorola bit numbering:
   * - startBit points to the most significant bit of the signal
   * - inside a byte, bit numbering goes 7..0
   * - crossing byte boundary moves to the next byte, bit 7
   * Example: a signal starting at 7 follows 7..0, 15..8, 23..16.
   */
 
    value = 0U;
 
    std::size_t byteIndex = startBit / 8U;
    std::uint32_t bitInByte = startBit % 8U;
 
    for (std::uint32_t bitIndex = 0U; bitIndex < length; ++bitIndex) {
        if (byteIndex >= data.size())
            return false;
 
        value <<= 1U;
        value |= static_cast<std::uint64_t>((data[byteIndex] >> bitInByte) & 0x01U);
 
        if (bitInByte == 0U) {
            ++byteIndex;
            bitInByte = 7U;
        } else
            --bitInByte;
    }
 
    return true;
}
 
std::int64_t DbcDecoder::SignExtend(std::uint64_t value, std::uint32_t bitLength) {
    if ((bitLength == 0U) || (bitLength > 64U))
        return 0;
 
    const std::uint64_t signMask = std::uint64_t(1U) << (bitLength - 1U);
    const std::uint64_t valueMask = (bitLength == 64U)
                                            ? ~std::uint64_t(0U)
                                            : (std::uint64_t(1U) << bitLength) - 1U;
    value &= valueMask;
 
    if ((value & signMask) == 0U)
        return static_cast<std::int64_t>(value);
 
    // The complemented magnitude fits int64_t, including for INT64_MIN.
    return -1 - static_cast<std::int64_t>((~value) & valueMask);
}