Implemented first version of Chm30Utility

CanDriver/core/CanDbSignal.cpp

@@ -0,0 +1,229 @@
+/*
+
+  Copyright (c) 2015, 2016 Hubert Denkmair <hubert@denkmair.de>
+
+  This file is part of cangaroo.
+
+  cangaroo is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 2 of the License, or
+  (at your option) any later version.
+
+  cangaroo is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with cangaroo.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "CanDbSignal.h"
+
+CanDbSignal::CanDbSignal(CanDbMessage *parent)
+  : _parent(parent),
+    _isUnsigned(false),
+    _isBigEndian(false),
+    _factor(1),
+    _offset(0),
+    _min(0),
+    _max(0),
+    _isMuxer(false),
+    _isMuxed(false),
+    _muxValue(0)
+{
+}
+
+QString CanDbSignal::name() const
+{
+    return _name;
+}
+
+void CanDbSignal::setName(const QString &name)
+{
+    _name = name;
+}
+
+uint8_t CanDbSignal::startBit() const
+{
+    return _startBit;
+}
+
+void CanDbSignal::setStartBit(uint8_t startBit)
+{
+    _startBit = startBit;
+}
+
+uint8_t CanDbSignal::length() const
+{
+    return _length;
+}
+
+void CanDbSignal::setLength(uint8_t length)
+{
+    _length = length;
+}
+
+QString CanDbSignal::comment() const
+{
+    return _comment;
+}
+
+void CanDbSignal::setComment(const QString &comment)
+{
+    _comment = comment;
+}
+
+QString CanDbSignal::getValueName(const uint64_t value) const
+{
+    if (_valueTable.contains(value)) {
+        return _valueTable[value];
+    } else {
+        return QString();
+    }
+}
+
+void CanDbSignal::setValueName(const uint64_t value, const QString &name)
+{
+    _valueTable[value] = name;
+}
+
+double CanDbSignal::convertRawValueToPhysical(const uint64_t rawValue)
+{
+    if (isUnsigned()) {
+        uint64_t v = rawValue;
+        return v * _factor + _offset;
+    } else {
+        // TODO check with DBC that actually contains signed values?!
+        int64_t v = (int64_t)(rawValue<<(64-_length));
+        v>>=(64-_length);
+        return v * _factor + _offset;
+
+    }
+}
+
+double CanDbSignal::extractPhysicalFromMessage(const CanMessage &msg)
+{
+    return convertRawValueToPhysical(extractRawDataFromMessage(msg));
+}
+
+double CanDbSignal::getFactor() const
+{
+    return _factor;
+}
+
+void CanDbSignal::setFactor(double factor)
+{
+    _factor = factor;
+}
+
+double CanDbSignal::getOffset() const
+{
+    return _offset;
+}
+
+void CanDbSignal::setOffset(double offset)
+{
+    _offset = offset;
+}
+
+double CanDbSignal::getMinimumValue() const
+{
+    return _min;
+}
+
+void CanDbSignal::setMinimumValue(double min)
+{
+    _min = min;
+}
+
+double CanDbSignal::getMaximumValue() const
+{
+    return _max;
+}
+
+void CanDbSignal::setMaximumValue(double max)
+{
+    _max = max;
+}
+
+QString CanDbSignal::getUnit() const
+{
+    return _unit;
+}
+
+void CanDbSignal::setUnit(const QString &unit)
+{
+    _unit = unit;
+}
+
+bool CanDbSignal::isUnsigned() const
+{
+    return _isUnsigned;
+}
+
+void CanDbSignal::setUnsigned(bool isUnsigned)
+{
+    _isUnsigned = isUnsigned;
+}
+bool CanDbSignal::isBigEndian() const
+{
+    return _isBigEndian;
+}
+
+void CanDbSignal::setIsBigEndian(bool isBigEndian)
+{
+    _isBigEndian = isBigEndian;
+}
+
+bool CanDbSignal::isMuxer() const
+{
+    return _isMuxer;
+}
+
+void CanDbSignal::setIsMuxer(bool isMuxer)
+{
+    _isMuxer = isMuxer;
+}
+
+bool CanDbSignal::isMuxed() const
+{
+    return _isMuxed;
+}
+
+void CanDbSignal::setIsMuxed(bool isMuxed)
+{
+    _isMuxed = isMuxed;
+}
+
+uint32_t CanDbSignal::getMuxValue() const
+{
+    return _muxValue;
+}
+
+void CanDbSignal::setMuxValue(const uint32_t &muxValue)
+{
+    _muxValue = muxValue;
+}
+
+bool CanDbSignal::isPresentInMessage(const CanMessage &msg)
+{
+    if ((_startBit + _length)>(8*msg.getLength())) {
+        return false;
+    }
+
+    if (!_isMuxed) { return true; }
+
+    CanDbSignal *muxer = _parent->getMuxer();
+    if (!muxer) { return false; }
+
+    return _muxValue == muxer->extractRawDataFromMessage(msg);
+}
+
+uint64_t CanDbSignal::extractRawDataFromMessage(const CanMessage &msg)
+{
+    return msg.extractRawSignal(startBit(), length(), isBigEndian());
+}
+
+