Refactor more modbus register

Author: jgeudens

src/communication/datapoint.cpp

@@ -2,12 +2,11 @@
 
 #include <bit>
 
-DataPoint::DataPoint() : DataPoint(QString(), Device::cFirstDeviceId, ModbusDataType::Type::UNSIGNED_16)
+DataPoint::DataPoint() : DataPoint(QString(), Device::cFirstDeviceId)
 {
 }
 
-DataPoint::DataPoint(QString const& address, deviceId_t deviceId, ModbusDataType::Type type)
-    : _address(address), _deviceId(deviceId), _type(type)
+DataPoint::DataPoint(QString const& address, deviceId_t deviceId) : _address(address), _deviceId(deviceId)
 {
 }
 
@@ -16,74 +15,16 @@ QString DataPoint::address() const
     return _address;
 }
 
-void DataPoint::setAddress(const QString& address)
-{
-    _address = address;
-}
-
 deviceId_t DataPoint::deviceId() const
 {
     return _deviceId;
 }
 
-void DataPoint::setDeviceId(deviceId_t deviceId)
-{
-    _deviceId = deviceId;
-}
-
-void DataPoint::setType(ModbusDataType::Type type)
-{
-    _type = type;
-}
-
-ModbusDataType::Type DataPoint::type() const
-{
-    return _type;
-}
-
 QString DataPoint::description() const
 {
     QString connStr = QString("device id %1").arg(deviceId());
 
-    return QString("%1, %2, %3").arg(_address, ModbusDataType::description(_type), connStr);
-}
-
-double DataPoint::processValue(uint16_t lowerRegister, uint16_t upperRegister, bool int32LittleEndian) const
-{
-    double processedResult = 0u;
-
-    if (ModbusDataType::isFloat(_type))
-    {
-        uint32_t combinedValue = convertEndianness(int32LittleEndian, lowerRegister, upperRegister);
-
-        processedResult = convertUint32ToFloat(combinedValue);
-    }
-    else if (ModbusDataType::is32Bit(_type))
-    {
-        uint32_t combinedValue = convertEndianness(int32LittleEndian, lowerRegister, upperRegister);
-
-        if (ModbusDataType::isUnsigned(_type))
-        {
-            processedResult = static_cast<double>(static_cast<quint32>(combinedValue));
-        }
-        else
-        {
-            processedResult = static_cast<double>(static_cast<qint32>(combinedValue));
-        }
-    }
-    else
-    {
-        if (ModbusDataType::isUnsigned(_type))
-        {
-            processedResult = static_cast<double>(static_cast<quint16>(lowerRegister));
-        }
-        else
-        {
-            processedResult = static_cast<double>(static_cast<qint16>(lowerRegister));
-        }
-    }
-
-    return processedResult;
+    return QString("%1, %2").arg(_address, connStr);
 }
 
 DataPoint& DataPoint::operator=(const DataPoint& dataPoint)
@@ -96,15 +37,14 @@ DataPoint& DataPoint::operator=(const DataPoint& dataPoint)
 
     _address = dataPoint.address();
     _deviceId = dataPoint.deviceId();
-    _type = dataPoint.type();
 
     // return the existing object so we can chain this operator
     return *this;
 }
 
 bool operator==(const DataPoint& dp1, const DataPoint& dp2)
 {
-    if ((dp1._address == dp2._address) && (dp1._deviceId == dp2._deviceId) && (dp1._type == dp2._type))
+    if ((dp1._address == dp2._address) && (dp1._deviceId == dp2._deviceId))
     {
         return true;
     }
@@ -131,36 +71,4 @@ QString DataPoint::dumpListToString(QList<DataPoint> list)
     dStream << list;
 
     return str;
-}
-
-uint32_t DataPoint::convertEndianness(bool bLittleEndian, quint16 value, quint16 nextValue) const
-{
-    uint32_t combinedValue;
-    if (bLittleEndian)
-    {
-        combinedValue = (static_cast<uint32_t>(nextValue) << 16) | value;
-    }
-    else
-    {
-        combinedValue = (static_cast<uint32_t>(value) << 16) | nextValue;
-    }
-
-    return combinedValue;
-}
-
-double DataPoint::convertUint32ToFloat(quint32 value) const
-{
-    const double doubleValue = std::bit_cast<float>(value);
-
-    switch (std::fpclassify(doubleValue))
-    {
-    case FP_INFINITE:
-    case FP_NAN:
-    case FP_ZERO:
-        return 0.0f;
-    case FP_NORMAL:
-    case FP_SUBNORMAL:
-    default:
-        return doubleValue;
-    }
-}
+}

src/communication/datapoint.h

@@ -2,7 +2,6 @@
 #define DATAPOINT_H
 
 #include "models/device.h"
-#include "util/modbusdatatype.h"
 #include <QDebug>
 #include <QObject>
 #include <QString>
@@ -11,22 +10,15 @@ class DataPoint
 {
 public:
     DataPoint();
-    DataPoint(QString const& address, deviceId_t deviceId, ModbusDataType::Type type);
+    DataPoint(QString const& address, deviceId_t deviceId);
 
     QString address() const;
-    void setAddress(const QString& address);
 
     deviceId_t deviceId() const;
-    void setDeviceId(deviceId_t deviceId);
-
-    void setType(ModbusDataType::Type type);
-    ModbusDataType::Type type() const;
 
     QString description() const;
 
-    double processValue(uint16_t lowerRegister, uint16_t upperRegister, bool int32LittleEndian) const;
-
-    DataPoint(const DataPoint& copy) : _address{ copy.address() }, _deviceId{ copy.deviceId() }, _type{ copy.type() }
+    DataPoint(const DataPoint& copy) : _address{ copy.address() }, _deviceId{ copy.deviceId() }
     {
     }
 
@@ -37,12 +29,8 @@ class DataPoint
     static QString dumpListToString(QList<DataPoint> list);
 
 private:
-    uint32_t convertEndianness(bool bLittleEndian, quint16 value, quint16 nextValue) const;
-    double convertUint32ToFloat(quint32 value) const;
-
     QString _address;
     deviceId_t _deviceId;
-    ModbusDataType::Type _type;
 };
 
 QDebug operator<<(QDebug debug, const DataPoint& dp);

src/communication/modbuspoll.cpp

@@ -124,9 +124,7 @@ QStringList ModbusPoll::buildRegisterExpressions(const QList<DataPoint>& registe
     QStringList expressions;
     for (const DataPoint& reg : registerList)
     {
-        QString expr =
-          QString("${%1 @ %2 : %3}").arg(reg.address()).arg(reg.deviceId()).arg(ModbusDataType::typeString(reg.type()));
-        expressions.append(expr);
+        expressions.append(reg.address());
     }
     return expressions;
 }

src/datahandling/expressionparser.cpp

@@ -1,7 +1,7 @@
 #include "expressionparser.h"
 
+#include "models/device.h"
 #include "util/expressionregex.h"
-#include "util/modbusdatatype.h"
 #include "util/scopelogging.h"
 
 const QString ExpressionParser::_cRegisterFunctionTemplate = "r(%1%2)";
@@ -11,9 +11,6 @@ ExpressionParser::ExpressionParser(QStringList& expressions)
     _findRegRegex.setPattern(ExpressionRegex::cMatchRegister);
     _findRegRegex.optimize();
 
-    _regParseRegex.setPattern(ExpressionRegex::cParseReg);
-    _regParseRegex.optimize();
-
     parseExpressions(expressions);
 }
 
@@ -70,33 +67,31 @@ QString ExpressionParser::processExpression(QString const& graphExpr)
 
 bool ExpressionParser::processRegisterExpression(QString regExpr, DataPoint& dataPoint)
 {
-    bool bRet = false;
-
-    QRegularExpressionMatch match = _regParseRegex.match(regExpr);
-
-    QString strAddress;
-    QString strDeviceId;
-    QString strType;
+    static const QRegularExpression regParseRegex(ExpressionRegex::cParseReg);
+    QRegularExpressionMatch match = regParseRegex.match(regExpr);
 
-    if (match.hasMatch())
+    if (!match.hasMatch())
     {
-        strAddress = match.captured(1);
-        strDeviceId = match.captured(2);
-        strType = match.captured(3);
-
-        bRet = true;
-        bRet = bRet && parseAddress(strAddress, dataPoint);
-        bRet = bRet && parseDeviceId(strDeviceId, dataPoint);
-        bRet = bRet && parseType(strType, dataPoint);
+        qCWarning(scopeComm) << QString("Part of expression evaluation parsing failed (\"%1\")").arg(regExpr);
+        return false;
     }
-    else
+
+    const QString strDeviceId = match.captured(2);
+
+    deviceId_t deviceId = Device::cFirstDeviceId;
+    if (!strDeviceId.isEmpty())
     {
-        auto msg = QString("Part of expression evaluation parsing failed (\"%1\")").arg(regExpr);
-        qCWarning(scopeComm) << msg;
-        bRet = false;
+        bool ok;
+        deviceId = strDeviceId.toUInt(&ok);
+        if (!ok)
+        {
+            qCWarning(scopeComm) << QString("Parsing device \"%1\" failed").arg(strDeviceId);
+            return false;
+        }
     }
 
-    return bRet;
+    dataPoint = DataPoint(regExpr, deviceId);
+    return true;
 }
 
 QString ExpressionParser::constructInternalRegisterFunction(DataPoint const& dataPoint, int size)
@@ -119,67 +114,3 @@ QString ExpressionParser::constructInternalRegisterFunction(DataPoint const& dat
 
     return QString(_cRegisterFunctionTemplate).arg(idx).arg(spaces);
 }
-
-bool ExpressionParser::parseAddress(QString strAddr, DataPoint& dataPoint)
-{
-    bool bRet = false;
-
-    if (strAddr.isEmpty())
-    {
-        /* Required field */
-        bRet = false;
-        qCWarning(scopeComm) << QString("No address specified");
-    }
-    else
-    {
-        bRet = true;
-        dataPoint.setAddress(strAddr);
-    }
-
-    return bRet;
-}
-
-bool ExpressionParser::parseDeviceId(QString strDeviceId, DataPoint& dataPoint)
-{
-    bool bRet = false;
-
-    if (strDeviceId.isEmpty())
-    {
-        /* Keep default */
-        bRet = true;
-    }
-    else
-    {
-        auto deviceId = strDeviceId.toUInt(&bRet);
-        if (bRet)
-        {
-            dataPoint.setDeviceId(deviceId);
-        }
-        else
-        {
-            qCWarning(scopeComm) << QString("Parsing device \"%1\" failed").arg(strDeviceId);
-        }
-    }
-
-    return bRet;
-}
-
-bool ExpressionParser::parseType(QString strType, DataPoint& dataPoint)
-{
-    bool bRet;
-    bool bOk;
-    ModbusDataType::Type type = ModbusDataType::convertString(strType, bOk);
-
-    if (bOk)
-    {
-        dataPoint.setType(type);
-        bRet = true;
-    }
-    else
-    {
-        bRet = false;
-        qCWarning(scopeComm) << QString("Unknown type \"%1\"").arg(strType);
-    }
-
-    return bRet;
-}

src/datahandling/expressionparser.h

@@ -17,10 +17,6 @@ class ExpressionParser : public QObject
 private:
     void parseExpressions(QStringList& expressions);
 
-    bool parseAddress(QString strAddr, DataPoint& dataPoint);
-    bool parseDeviceId(QString strDeviceId, DataPoint& dataPoint);
-    bool parseType(QString strType, DataPoint& dataPoint);
-
     QString processExpression(QString const& expr);
     bool processRegisterExpression(QString regExpr, DataPoint& dataPoint);
     QString constructInternalRegisterFunction(DataPoint const& dataPoint, int size);
@@ -29,7 +25,6 @@ class ExpressionParser : public QObject
     QList<DataPoint> _dataPoints;
 
     QRegularExpression _findRegRegex;
-    QRegularExpression _regParseRegex;
 
     static const QString _cRegisterFunctionTemplate;
 };