diff --git a/src/communication/datapoint.cpp b/src/communication/datapoint.cpp
new file mode 100644
index 00000000..b01f5736
--- /dev/null
+++ b/src/communication/datapoint.cpp
@@ -0,0 +1,72 @@
+#include "datapoint.h"
+
+DataPoint::DataPoint() : DataPoint(QString(), Device::cFirstDeviceId)
+{
+}
+
+DataPoint::DataPoint(QString const& address, deviceId_t deviceId) : _address(address), _deviceId(deviceId)
+{
+}
+
+QString DataPoint::address() const
+{
+    return _address;
+}
+
+deviceId_t DataPoint::deviceId() const
+{
+    return _deviceId;
+}
+
+QString DataPoint::description() const
+{
+    QString connStr = QString("device id %1").arg(deviceId());
+
+    return QString("%1, %2").arg(_address, connStr);
+}
+
+DataPoint& DataPoint::operator=(const DataPoint& dataPoint)
+{
+    // self-assignment guard
+    if (this == &dataPoint)
+    {
+        return *this;
+    }
+
+    _address = dataPoint.address();
+    _deviceId = dataPoint.deviceId();
+
+    // 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))
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+QDebug operator<<(QDebug debug, const DataPoint& dp)
+{
+    QDebugStateSaver saver(debug);
+
+    debug.nospace().noquote() << '[' << dp.description() << ']';
+
+    return debug;
+}
+
+QString DataPoint::dumpListToString(QList<DataPoint> const& list)
+{
+    QString str;
+    QDebug dStream(&str);
+
+    dStream << list;
+
+    return str;
+}
\ No newline at end of file
diff --git a/src/communication/datapoint.h b/src/communication/datapoint.h
new file mode 100644
index 00000000..bb1dffd8
--- /dev/null
+++ b/src/communication/datapoint.h
@@ -0,0 +1,37 @@
+#ifndef DATAPOINT_H
+#define DATAPOINT_H
+
+#include "models/device.h"
+#include <QDebug>
+#include <QString>
+
+class DataPoint
+{
+public:
+    DataPoint();
+    DataPoint(QString const& address, deviceId_t deviceId);
+
+    QString address() const;
+
+    deviceId_t deviceId() const;
+
+    QString description() const;
+
+    DataPoint(const DataPoint& copy) : _address{ copy.address() }, _deviceId{ copy.deviceId() }
+    {
+    }
+
+    DataPoint& operator=(const DataPoint& dataPoint);
+
+    friend bool operator==(const DataPoint& dp1, const DataPoint& dp2);
+
+    static QString dumpListToString(const QList<DataPoint>& list);
+
+private:
+    QString _address;
+    deviceId_t _deviceId;
+};
+
+QDebug operator<<(QDebug debug, const DataPoint& dp);
+
+#endif // DATAPOINT_H
diff --git a/src/communication/modbuspoll.cpp b/src/communication/modbuspoll.cpp
index 78fe1ec6..d53b1791 100644
--- a/src/communication/modbuspoll.cpp
+++ b/src/communication/modbuspoll.cpp
@@ -47,7 +47,7 @@ void ModbusPoll::initAdapter()
     _pAdapterClient->prepareAdapter(adapterPath);
 }
 
-void ModbusPoll::startCommunication(QList<ModbusRegister>& registerList)
+void ModbusPoll::startCommunication(QList<DataPoint>& registerList)
 {
     _registerList = registerList;
     _bPollActive = true;
@@ -119,16 +119,12 @@ void ModbusPoll::onDescribeResult(const QJsonObject& description)
     _pSettingsModel->updateAdapterFromDescribe("modbus", description);
 }
 
-QStringList ModbusPoll::buildRegisterExpressions(const QList<ModbusRegister>& registerList)
+QStringList ModbusPoll::buildRegisterExpressions(const QList<DataPoint>& registerList)
 {
     QStringList expressions;
-    for (const ModbusRegister& reg : registerList)
+    for (const DataPoint& reg : registerList)
     {
-        QString expr = QString("${%1 @ %2 : %3}")
-                         .arg(reg.address().fullAddress())
-                         .arg(reg.deviceId())
-                         .arg(ModbusDataType::typeString(reg.type()));
-        expressions.append(expr);
+        expressions.append(reg.address());
     }
     return expressions;
 }
diff --git a/src/communication/modbuspoll.h b/src/communication/modbuspoll.h
index 2e8eb9a2..4f1103a1 100644
--- a/src/communication/modbuspoll.h
+++ b/src/communication/modbuspoll.h
@@ -1,9 +1,9 @@
-#ifndef COMMUNICATION_MANAGER_H
-#define COMMUNICATION_MANAGER_H
+#ifndef MODBUSPOLL_H
+#define MODBUSPOLL_H
 
 #include "ProtocolAdapter/adapterclient.h"
 #include "ProtocolAdapter/adapterprocess.h"
-#include "communication/modbusregister.h"
+#include "communication/datapoint.h"
 #include "util/result.h"
 
 #include <QJsonObject>
@@ -21,7 +21,7 @@ class ModbusPoll : public QObject
     ~ModbusPoll();
 
     void initAdapter();
-    void startCommunication(QList<ModbusRegister>& registerList);
+    void startCommunication(QList<DataPoint>& registerList);
     void stopCommunication();
 
     bool isActive();
@@ -36,9 +36,9 @@ private slots:
     void onDescribeResult(const QJsonObject& description);
 
 private:
-    QStringList buildRegisterExpressions(const QList<ModbusRegister>& registerList);
+    QStringList buildRegisterExpressions(const QList<DataPoint>& registerList);
 
-    QList<ModbusRegister> _registerList;
+    QList<DataPoint> _registerList;
 
     bool _bPollActive;
     QTimer* _pPollTimer;
@@ -49,4 +49,4 @@ private slots:
     AdapterClient* _pAdapterClient;
 };
 
-#endif // COMMUNICATION_MANAGER_H
+#endif // MODBUSPOLL_H
diff --git a/src/communication/modbusregister.cpp b/src/communication/modbusregister.cpp
deleted file mode 100644
index 444cf781..00000000
--- a/src/communication/modbusregister.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-#include "modbusregister.h"
-
-#include <bit>
-
-ModbusRegister::ModbusRegister()
-    : ModbusRegister(ModbusAddress(0), Device::cFirstDeviceId, ModbusDataType::Type::UNSIGNED_16)
-{
-
-}
-
-ModbusRegister::ModbusRegister(ModbusAddress const& address, deviceId_t deviceId, ModbusDataType::Type type)
-    : _address(address), _deviceId(deviceId), _type(type)
-{
-
-}
-
-ModbusAddress ModbusRegister::address() const
-{
-    return _address;
-}
-
-void ModbusRegister::setAddress(ModbusAddress const& address)
-{
-    _address = address;
-}
-
-deviceId_t ModbusRegister::deviceId() const
-{
-    return _deviceId;
-}
-
-void ModbusRegister::setDeviceId(deviceId_t deviceId)
-{
-    _deviceId = deviceId;
-}
-
-void ModbusRegister::setType(ModbusDataType::Type type)
-{
-    _type = type;
-}
-
-ModbusDataType::Type ModbusRegister::type() const
-{
-    return _type;
-}
-
-QString ModbusRegister::description() const
-{
-    QString connStr = QString("device id %1").arg(deviceId());
-
-    return QString("%1, %2, %3").arg(address().toString(), ModbusDataType::description(_type), connStr);
-}
-
-double ModbusRegister::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;
-}
-
-ModbusRegister& ModbusRegister::operator= (const ModbusRegister& modbusRegister)
-{
-    // self-assignment guard
-    if (this == &modbusRegister)
-    {
-        return *this;
-    }
-
-    _address = modbusRegister.address();
-    _deviceId = modbusRegister.deviceId();
-    _type = modbusRegister.type();
-
-    // return the existing object so we can chain this operator
-    return *this;
-}
-
-bool operator== (const ModbusRegister& reg1, const ModbusRegister& reg2)
-{
-    if ((reg1._address == reg2._address) && (reg1._deviceId == reg2._deviceId) && (reg1._type == reg2._type))
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-QDebug operator<<(QDebug debug, const ModbusRegister &reg)
-{
-    QDebugStateSaver saver(debug);
-
-    debug.nospace().noquote() << '['
-                    << reg.description()
-                    << ']';
-
-    return debug;
-}
-
-QString ModbusRegister::dumpListToString(QList<ModbusRegister> list)
-{
-    QString str;
-    QDebug dStream(&str);
-
-    dStream << list;
-
-    return str;
-}
-
-uint32_t ModbusRegister::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 ModbusRegister::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;
-    }
-}
-
diff --git a/src/communication/modbusregister.h b/src/communication/modbusregister.h
deleted file mode 100644
index 39905200..00000000
--- a/src/communication/modbusregister.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef MODBUSREGISTER_H
-#define MODBUSREGISTER_H
-
-#include "models/device.h"
-#include "util/modbusaddress.h"
-#include "util/modbusdatatype.h"
-#include <QDebug>
-#include <QObject>
-
-class ModbusRegister
-{
-public:
-    ModbusRegister();
-    ModbusRegister(ModbusAddress const& address, deviceId_t deviceId, ModbusDataType::Type type);
-
-    ModbusAddress address() const;
-    void setAddress(ModbusAddress const& 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;
-
-    ModbusRegister(const ModbusRegister& copy)
-        : _address{ copy.address() }, _deviceId{ copy.deviceId() }, _type{ copy.type() }
-    {
-
-    }
-
-    ModbusRegister& operator= (const ModbusRegister& modbusRegister);
-
-    friend bool operator== (const ModbusRegister& reg1, const ModbusRegister& reg2);
-
-    static QString dumpListToString(QList<ModbusRegister> list);
-
-private:
-    uint32_t convertEndianness(bool bLittleEndian, quint16 value, quint16 nextValue) const;
-    double convertUint32ToFloat(quint32 value) const;
-
-    ModbusAddress _address;
-    deviceId_t _deviceId;
-    ModbusDataType::Type _type;
-};
-
-QDebug operator<<(QDebug debug, const ModbusRegister &reg);
-
-#endif // MODBUSREGISTER_H
diff --git a/src/datahandling/expressionparser.cpp b/src/datahandling/expressionparser.cpp
index e2c92349..89a67781 100644
--- a/src/datahandling/expressionparser.cpp
+++ b/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,15 +11,12 @@ ExpressionParser::ExpressionParser(QStringList& expressions)
     _findRegRegex.setPattern(ExpressionRegex::cMatchRegister);
     _findRegRegex.optimize();
 
-    _regParseRegex.setPattern(ExpressionRegex::cParseReg);
-    _regParseRegex.optimize();
-
     parseExpressions(expressions);
 }
 
-void ExpressionParser::modbusRegisters(QList<ModbusRegister>& registerList)
+void ExpressionParser::dataPoints(QList<DataPoint>& dataPointList)
 {
-    registerList = _modbusRegisters;
+    dataPointList = _dataPoints;
 }
 
 void ExpressionParser::processedExpressions(QStringList& expressionList)
@@ -30,15 +27,15 @@ void ExpressionParser::processedExpressions(QStringList& expressionList)
 void ExpressionParser::parseExpressions(QStringList& expressions)
 {
     _processedExpressions.clear();
-    _modbusRegisters.clear();
+    _dataPoints.clear();
 
-    for(const QString &expression: std::as_const(expressions))
+    for (const QString& expression : std::as_const(expressions))
     {
         _processedExpressions.append(processExpression(expression));
     }
 }
 
-QString ExpressionParser::processExpression(QString const & graphExpr)
+QString ExpressionParser::processExpression(QString const& graphExpr)
 {
     QString resultExpr = graphExpr;
     QRegularExpressionMatchIterator i = _findRegRegex.globalMatch(resultExpr);
@@ -56,10 +53,10 @@ QString ExpressionParser::processExpression(QString const & graphExpr)
         {
             QString regDef = match.captured(0);
 
-            ModbusRegister modbusReg;
-            if (processRegisterExpression(regDef, modbusReg))
+            DataPoint dataPoint;
+            if (processRegisterExpression(regDef, dataPoint))
             {
-                QString regFunc = constructInternalRegisterFunction(modbusReg, regDef.size());
+                QString regFunc = constructInternalRegisterFunction(dataPoint, regDef.size());
                 resultExpr.replace(regDef, regFunc);
             }
         }
@@ -68,48 +65,46 @@ QString ExpressionParser::processExpression(QString const & graphExpr)
     return resultExpr;
 }
 
-bool ExpressionParser::processRegisterExpression(QString regExpr, ModbusRegister& modbusReg)
+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, modbusReg);
-        bRet = bRet && parseDeviceId(strDeviceId, modbusReg);
-        bRet = bRet && parseType(strType, modbusReg);
+        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(ModbusRegister const & modbusReg, int size)
+QString ExpressionParser::constructInternalRegisterFunction(DataPoint const& dataPoint, int size)
 {
     quint32 idx;
-    if (_modbusRegisters.contains(modbusReg))
+    if (_dataPoints.contains(dataPoint))
     {
-        idx = _modbusRegisters.indexOf(modbusReg);
+        idx = _dataPoints.indexOf(dataPoint);
     }
     else
     {
-        _modbusRegisters.append(modbusReg);
-        idx = _modbusRegisters.size() - 1;
+        _dataPoints.append(dataPoint);
+        idx = _dataPoints.size() - 1;
     }
 
     /* Add dummy whitespaces to make sure positions in internal representations match visible expressions */
@@ -119,68 +114,3 @@ QString ExpressionParser::constructInternalRegisterFunction(ModbusRegister const
 
     return QString(_cRegisterFunctionTemplate).arg(idx).arg(spaces);
 }
-
-bool ExpressionParser::parseAddress(QString strAddr, ModbusRegister& modbusReg)
-{
-    bool bRet = false;
-
-    if (strAddr.isEmpty())
-    {
-        /* Required field */
-        bRet = false;
-        qCWarning(scopeComm) << QString("No address specified");
-    }
-    else
-    {
-        bRet = true;
-        modbusReg.setAddress(ModbusAddress(strAddr));
-    }
-
-    return bRet;
-}
-
-bool ExpressionParser::parseDeviceId(QString strDeviceId, ModbusRegister& modbusReg)
-{
-    bool bRet = false;
-
-    if (strDeviceId.isEmpty())
-    {
-        /* Keep default */
-        bRet = true;
-    }
-    else
-    {
-        auto deviceId = strDeviceId.toUInt(&bRet);
-        if (bRet)
-        {
-            modbusReg.setDeviceId(deviceId);
-        }
-        else
-        {
-            qCWarning(scopeComm) << QString("Parsing device \"%1\" failed").arg(strDeviceId);
-        }
-    }
-
-    return bRet;
-}
-
-bool ExpressionParser::parseType(QString strType, ModbusRegister& modbusReg)
-{
-    bool bRet;
-    bool bOk;
-    ModbusDataType::Type type = ModbusDataType::convertString(strType, bOk);
-
-    if (bOk)
-    {
-        modbusReg.setType(type);
-        bRet = true;
-    }
-    else
-    {
-        bRet = false;
-        qCWarning(scopeComm) << QString("Unknown type \"%1\"").arg(strType);
-    }
-
-    return bRet;
-}
-
diff --git a/src/datahandling/expressionparser.h b/src/datahandling/expressionparser.h
index 333a6a9c..441c94de 100644
--- a/src/datahandling/expressionparser.h
+++ b/src/datahandling/expressionparser.h
@@ -1,7 +1,7 @@
 #ifndef EXPRESSIONPARSER_H
 #define EXPRESSIONPARSER_H
 
-#include "communication/modbusregister.h"
+#include "communication/datapoint.h"
 #include <QRegularExpression>
 #include <QStringList>
 
@@ -11,29 +11,22 @@ class ExpressionParser : public QObject
 public:
     explicit ExpressionParser(QStringList& expressions);
 
-    void modbusRegisters(QList<ModbusRegister>& registerList);
+    void dataPoints(QList<DataPoint>& dataPointList);
     void processedExpressions(QStringList& expressionList);
 
 private:
-
     void parseExpressions(QStringList& expressions);
 
-    bool parseAddress(QString strAddr, ModbusRegister& modbusReg);
-    bool parseDeviceId(QString strDeviceId, ModbusRegister& modbusReg);
-    bool parseType(QString strType, ModbusRegister& modbusReg);
-
-    QString processExpression(QString const & expr);
-    bool processRegisterExpression(QString regExpr, ModbusRegister &modbusReg);
-    QString constructInternalRegisterFunction(ModbusRegister const & modbusReg, int size);
+    QString processExpression(QString const& expr);
+    bool processRegisterExpression(QString regExpr, DataPoint& dataPoint);
+    QString constructInternalRegisterFunction(DataPoint const& dataPoint, int size);
 
     QStringList _processedExpressions;
-    QList<ModbusRegister> _modbusRegisters;
+    QList<DataPoint> _dataPoints;
 
     QRegularExpression _findRegRegex;
-    QRegularExpression _regParseRegex;
 
     static const QString _cRegisterFunctionTemplate;
-
 };
 
 #endif // EXPRESSIONPARSER_H
diff --git a/src/datahandling/graphdatahandler.cpp b/src/datahandling/graphdatahandler.cpp
index 91628682..4e63ec6e 100644
--- a/src/datahandling/graphdatahandler.cpp
+++ b/src/datahandling/graphdatahandler.cpp
@@ -11,28 +11,28 @@
  * \param[in]     pGraphDataModel   Graph data model
  * \param[out]    registerList      List of modbus registers
  */
-void GraphDataHandler::setupExpressions(GraphDataModel* pGraphDataModel, QList<ModbusRegister>& registerList)
+void GraphDataHandler::setupExpressions(GraphDataModel* pGraphDataModel, QList<DataPoint>& registerList)
 {
     QStringList exprList;
-    QList<ModbusRegister> regList;
+    QList<DataPoint> regList;
 
     pGraphDataModel->activeGraphIndexList(&_activeIndexList);
-    for(quint16 graphIdx: std::as_const(_activeIndexList))
+    for (quint16 graphIdx : std::as_const(_activeIndexList))
     {
         exprList.append(pGraphDataModel->expression(graphIdx));
     }
 
     ExpressionParser exprParser(exprList);
-    exprParser.modbusRegisters(regList);
+    exprParser.dataPoints(regList);
 
-    qCInfo(scopeComm) << "Active registers: " << ModbusRegister::dumpListToString(regList);
+    qCInfo(scopeComm) << "Active registers: " << DataPoint::dumpListToString(regList);
 
     QStringList processedExpList;
     exprParser.processedExpressions(processedExpList);
 
     _valueParsers.clear();
 
-    for(const QString &expr: std::as_const(processedExpList))
+    for (const QString& expr : std::as_const(processedExpList))
     {
         _valueParsers.append(QMuParser(expr));
     }
@@ -98,6 +98,3 @@ void GraphDataHandler::handleRegisterData(ResultDoubleList results)
 
     emit graphDataReady(registerList);
 }
-
-
-
diff --git a/src/datahandling/graphdatahandler.h b/src/datahandling/graphdatahandler.h
index 17f42321..8ee1fa00 100644
--- a/src/datahandling/graphdatahandler.h
+++ b/src/datahandling/graphdatahandler.h
@@ -1,11 +1,11 @@
 #ifndef GRAPHDATAHANDLER_H
 #define GRAPHDATAHANDLER_H
 
-#include "communication/modbusregister.h"
+#include "communication/datapoint.h"
 #include "datahandling/qmuparser.h"
 #include "util/result.h"
 
-//Forward declaration
+// Forward declaration
 class GraphDataModel;
 
 class GraphDataHandler : public QObject
@@ -14,7 +14,7 @@ class GraphDataHandler : public QObject
 public:
     GraphDataHandler() = default;
 
-    void setupExpressions(GraphDataModel* pGraphDataModel, QList<ModbusRegister>& registerList);
+    void setupExpressions(GraphDataModel* pGraphDataModel, QList<DataPoint>& registerList);
 
     QString expressionParseMsg(qint32 exprIdx) const;
     qint32 expressionErrorPos(qint32 exprIdx) const;
@@ -27,7 +27,6 @@ public slots:
     void graphDataReady(ResultDoubleList resultList);
 
 private:
-
     QList<quint16> _activeIndexList;
     QList<QMuParser> _valueParsers;
 };
diff --git a/src/dialogs/mainwindow.cpp b/src/dialogs/mainwindow.cpp
index ef153650..2211758d 100644
--- a/src/dialogs/mainwindow.cpp
+++ b/src/dialogs/mainwindow.cpp
@@ -480,7 +480,7 @@ void MainWindow::startScope()
 
         clearData();
 
-        QList<ModbusRegister> registerList;
+        QList<DataPoint> registerList;
         _pGraphDataHandler->setupExpressions(_pGraphDataModel, registerList);
 
         _pModbusPoll->startCommunication(registerList);
diff --git a/src/util/expressionchecker.cpp b/src/util/expressionchecker.cpp
index 1294e517..ba35e81c 100644
--- a/src/util/expressionchecker.cpp
+++ b/src/util/expressionchecker.cpp
@@ -12,12 +12,12 @@ void ExpressionChecker::setExpression(QString expr)
     _localGraphDataModel.add();
     _localGraphDataModel.setExpression(0, expr);
 
-    QList<ModbusRegister> registerList;
+    QList<DataPoint> registerList;
     _graphDataHandler.setupExpressions(&_localGraphDataModel, registerList);
 
     _expectedDeviceIdList.clear();
     _descriptions.clear();
-    for (ModbusRegister const& reg : std::as_const(registerList))
+    for (DataPoint const& reg : std::as_const(registerList))
     {
         _descriptions.append(reg.description());
 
diff --git a/tests/datahandling/tst_expressionparser.cpp b/tests/datahandling/tst_expressionparser.cpp
index c76eede8..e68b492b 100644
--- a/tests/datahandling/tst_expressionparser.cpp
+++ b/tests/datahandling/tst_expressionparser.cpp
@@ -5,11 +5,8 @@
 
 #include <QTest>
 
-using Type = ModbusDataType::Type;
-
 void TestExpressionParser::init()
 {
-
 }
 
 void TestExpressionParser::cleanup()
@@ -18,241 +15,217 @@ void TestExpressionParser::cleanup()
 
 void TestExpressionParser::singleRegister()
 {
-    auto input = QStringList() <<           "${45332}";
-    auto expExpressions = QStringList() <<  "r(0    )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto input = QStringList() << "${45332}";
+    auto expExpressions = QStringList() << "r(0    )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterConn()
 {
-    auto input = QStringList() <<           "${45332@2}";
-    auto expExpressions = QStringList() <<  "r(0      )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId + 1, Type::UNSIGNED_16);
+    auto input = QStringList() << "${45332@2}";
+    auto expExpressions = QStringList() << "r(0      )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332@2}", Device::cFirstDeviceId + 1);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterSigned()
 {
-    auto input = QStringList() <<           "${45332: s16b}";
-    auto expExpressions = QStringList() <<  "r(0          )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId, Type::SIGNED_16);
+    auto input = QStringList() << "${45332: s16b}";
+    auto expExpressions = QStringList() << "r(0          )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332: s16b}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterSigned32()
 {
-    auto input = QStringList() <<           "${45332: s32b}";
-    auto expExpressions = QStringList() <<  "r(0          )";
+    auto input = QStringList() << "${45332: s32b}";
+    auto expExpressions = QStringList() << "r(0          )";
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId, Type::SIGNED_32);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332: s32b}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterFloat32()
 {
-    auto input = QStringList() <<           "${45332: f32b}";
-    auto expExpressions = QStringList() <<  "r(0          )";
+    auto input = QStringList() << "${45332: f32b}";
+    auto expExpressions = QStringList() << "r(0          )";
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId, Type::FLOAT_32);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332: f32b}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterExplicitCoil()
 {
-    auto input = QStringList() <<           "${c50000} + ${c100@2}";
-    auto expExpressions = QStringList() <<  "r(0     ) + r(1     )";
+    auto input = QStringList() << "${c50000} + ${c100@2}";
+    auto expExpressions = QStringList() << "r(0     ) + r(1     )";
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress("c50000"), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress("c100"), Device::cFirstDeviceId + 1, Type::UNSIGNED_16);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${c50000}", Device::cFirstDeviceId)
+                                            << DataPoint("${c100@2}", Device::cFirstDeviceId + 1);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterExplicitDiscreteInput()
 {
-    auto input = QStringList() <<           "${d50000@2} + ${d100}";
-    auto expExpressions = QStringList() <<  "r(0       ) + r(1   )";
+    auto input = QStringList() << "${d50000@2} + ${d100}";
+    auto expExpressions = QStringList() << "r(0       ) + r(1   )";
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress("d50000"), Device::cFirstDeviceId + 1, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress("d100"), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${d50000@2}", Device::cFirstDeviceId + 1)
+                                            << DataPoint("${d100}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterExplicitHolding()
 {
-    auto input = QStringList() <<           "${h50000: f32b} + ${h100@2}";
-    auto expExpressions = QStringList() <<  "r(0           ) + r(1     )";
+    auto input = QStringList() << "${h50000: f32b} + ${h100@2}";
+    auto expExpressions = QStringList() << "r(0           ) + r(1     )";
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress("h50000"), Device::cFirstDeviceId, Type::FLOAT_32)
-                              << ModbusRegister(ModbusAddress("h100"), Device::cFirstDeviceId + 1, Type::UNSIGNED_16);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${h50000: f32b}", Device::cFirstDeviceId)
+                                            << DataPoint("${h100@2}", Device::cFirstDeviceId + 1);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterExplicitInput()
 {
-    auto input = QStringList() <<           "${i50000@2} + ${i100}";
-    auto expExpressions = QStringList() <<  "r(0       ) + r(1   )";
+    auto input = QStringList() << "${i50000@2} + ${i100}";
+    auto expExpressions = QStringList() << "r(0       ) + r(1   )";
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress("i50000"), Device::cFirstDeviceId + 1, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress("i100"), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${i50000@2}", Device::cFirstDeviceId + 1)
+                                            << DataPoint("${i100}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::singleRegisterConnType()
 {
-    auto input = QStringList() <<           "${45332@2: s32b}";
-    auto expExpressions = QStringList() <<  "r(0            )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId + 1, Type::SIGNED_32);
+    auto input = QStringList() << "${45332@2: s32b}";
+    auto expExpressions = QStringList() << "r(0            )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332@2: s32b}", Device::cFirstDeviceId + 1);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::multiRegisters()
 {
-    auto input = QStringList() <<           "${45332} + ${45333}" << "${45334}";
-    auto expExpressions = QStringList() <<  "r(0    ) + r(1    )" << "r(2    )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(45333), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(45334), Device::cFirstDeviceId, Type::UNSIGNED_16);
-
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    auto input = QStringList() << "${45332} + ${45333}" << "${45334}";
+    auto expExpressions = QStringList() << "r(0    ) + r(1    )" << "r(2    )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332}", Device::cFirstDeviceId)
+                                            << DataPoint("${45333}", Device::cFirstDeviceId)
+                                            << DataPoint("${45334}", Device::cFirstDeviceId);
+
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::multiRegistersDuplicate()
 {
-    auto input = QStringList() <<           "${45332} + ${45333}" << "${45332}";
-    auto expExpressions = QStringList() <<  "r(0    ) + r(1    )" << "r(0    )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(45333), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto input = QStringList() << "${45332} + ${45333}" << "${45332}";
+    auto expExpressions = QStringList() << "r(0    ) + r(1    )" << "r(0    )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332}", Device::cFirstDeviceId)
+                                            << DataPoint("${45333}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::failure()
 {
     auto input = QStringList() << "${}";
-    auto expModbusRegisters = QList<ModbusRegister>();
+    auto expDataPoints = QList<DataPoint>();
     auto expExpressions = QStringList() << "${}";
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::failureMulti()
 {
-    auto input = QStringList() <<           "${}" << "${45331}";
-    auto expExpressions = QStringList() <<  "${}" << "r(0    )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45331), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto input = QStringList() << "${}" << "${45331}";
+    auto expExpressions = QStringList() << "${}" << "r(0    )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45331}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::combinations()
 {
-    auto input = QStringList() <<           "${45332@2: s32b} + ${45330} + 2";
-    auto expExpressions = QStringList() <<  "r(0            ) + r(1    ) + 2";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId + 1, Type::SIGNED_32)
-                              << ModbusRegister(ModbusAddress(45330), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto input = QStringList() << "${45332@2: s32b} + ${45330} + 2";
+    auto expExpressions = QStringList() << "r(0            ) + r(1    ) + 2";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332@2: s32b}", Device::cFirstDeviceId + 1)
+                                            << DataPoint("${45330}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::explicitDefaults()
 {
-    auto input = QStringList() <<           "${40001@1} + ${40002:16b}";
-    auto expExpressions = QStringList() <<  "r(0      ) + r(1        )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(40001), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(40002), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto input = QStringList() << "${40001@1} + ${40002:16b}";
+    auto expExpressions = QStringList() << "r(0      ) + r(1        )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${40001@1}", Device::cFirstDeviceId)
+                                            << DataPoint("${40002:16b}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::sameRegisterDifferentType()
 {
-    auto input = QStringList() <<           "${40001@1} + ${40001:s16b}";
-    auto expExpressions = QStringList() <<  "r(0      ) + r(1         )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(40001), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(40001), Device::cFirstDeviceId, Type::SIGNED_16);
+    auto input = QStringList() << "${40001@1} + ${40001:s16b}";
+    auto expExpressions = QStringList() << "r(0      ) + r(1         )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${40001@1}", Device::cFirstDeviceId)
+                                            << DataPoint("${40001:s16b}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::spaces()
 {
-    auto input = QStringList() <<           "${45332   @2: 32b   } + ${  45330  }";
-    auto expExpressions = QStringList() <<  "r(0                 ) + r(1        )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId + 1, Type::UNSIGNED_32)
-                              << ModbusRegister(ModbusAddress(45330), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto input = QStringList() << "${45332   @2: 32b   } + ${  45330  }";
+    auto expExpressions = QStringList() << "r(0                 ) + r(1        )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332   @2: 32b   }", Device::cFirstDeviceId + 1)
+                                            << DataPoint("${  45330  }", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::newlines()
 {
-    auto input = QStringList() <<           "${45332@2:32b} \n + 1 + \n + ${45330}";
-    auto expExpressions = QStringList() <<  "r(0          ) \n + 1 + \n + r(1    )";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(45332), Device::cFirstDeviceId + 1, Type::UNSIGNED_32)
-                              << ModbusRegister(ModbusAddress(45330), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto input = QStringList() << "${45332@2:32b} \n + 1 + \n + ${45330}";
+    auto expExpressions = QStringList() << "r(0          ) \n + 1 + \n + r(1    )";
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${45332@2:32b}", Device::cFirstDeviceId + 1)
+                                            << DataPoint("${45330}", Device::cFirstDeviceId);
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::constant()
 {
     auto input = QStringList() << "2";
-    auto expModbusRegisters = QList<ModbusRegister>();
+    auto expDataPoints = QList<DataPoint>();
     auto expExpressions = QStringList() << "2";
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
 void TestExpressionParser::manyRegisters()
 {
     auto input = QStringList() << "${0}" << "${1}"
-                                << "${2}" << "${3}"
-                                << "${4}" << "${5}"
-                                << "${6}" << "${7}"
-                                << "${8}" << "${9}"
-                                << "${10}" << "${11}";
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(0), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(1), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(2), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(3), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(4), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(5), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(6), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(7), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(8), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(9), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(10), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(11), Device::cFirstDeviceId, Type::UNSIGNED_16);
+                               << "${2}" << "${3}"
+                               << "${4}" << "${5}"
+                               << "${6}" << "${7}"
+                               << "${8}" << "${9}"
+                               << "${10}" << "${11}";
+    auto expDataPoints = QList<DataPoint>()
+                         << DataPoint("${0}", Device::cFirstDeviceId) << DataPoint("${1}", Device::cFirstDeviceId)
+                         << DataPoint("${2}", Device::cFirstDeviceId) << DataPoint("${3}", Device::cFirstDeviceId)
+                         << DataPoint("${4}", Device::cFirstDeviceId) << DataPoint("${5}", Device::cFirstDeviceId)
+                         << DataPoint("${6}", Device::cFirstDeviceId) << DataPoint("${7}", Device::cFirstDeviceId)
+                         << DataPoint("${8}", Device::cFirstDeviceId) << DataPoint("${9}", Device::cFirstDeviceId)
+                         << DataPoint("${10}", Device::cFirstDeviceId) << DataPoint("${11}", Device::cFirstDeviceId);
     auto expExpressions = QStringList() << "r(0)" << "r(1)"
                                         << "r(2)" << "r(3)"
                                         << "r(4)" << "r(5)"
@@ -260,19 +233,21 @@ void TestExpressionParser::manyRegisters()
                                         << "r(8)" << "r(9)"
                                         << "r(10)" << "r(11)";
 
-    verifyParsing(input, expModbusRegisters, expExpressions);
+    verifyParsing(input, expDataPoints, expExpressions);
 }
 
-void TestExpressionParser::verifyParsing(QStringList exprList, QList<ModbusRegister> &expectedRegisters, QStringList &expectedExpression)
+void TestExpressionParser::verifyParsing(QStringList exprList,
+                                         QList<DataPoint>& expectedDataPoints,
+                                         QStringList& expectedExpression)
 {
-    QList<ModbusRegister> actualModbusRegisters;
+    QList<DataPoint> actualDataPoints;
     QStringList actualExpressionList;
 
     ExpressionParser parser(exprList);
-    parser.modbusRegisters(actualModbusRegisters);
+    parser.dataPoints(actualDataPoints);
     parser.processedExpressions(actualExpressionList);
 
-    QVERIFY(actualModbusRegisters == expectedRegisters);
+    QVERIFY(actualDataPoints == expectedDataPoints);
     QVERIFY(actualExpressionList == expectedExpression);
 }
 
diff --git a/tests/datahandling/tst_expressionparser.h b/tests/datahandling/tst_expressionparser.h
index 9717c837..b6fd4004 100644
--- a/tests/datahandling/tst_expressionparser.h
+++ b/tests/datahandling/tst_expressionparser.h
@@ -1,9 +1,11 @@
+#ifndef TEST_EXPRESSIONPARSER_H
+#define TEST_EXPRESSIONPARSER_H
 
-#include "communication/modbusregister.h"
+#include "communication/datapoint.h"
 
 #include <QObject>
 
-class TestExpressionParser: public QObject
+class TestExpressionParser : public QObject
 {
     Q_OBJECT
 private slots:
@@ -32,8 +34,9 @@ private slots:
     void constant();
     void manyRegisters();
 
-    void verifyParsing(QStringList exprList, QList<ModbusRegister> &expectedRegisters, QStringList &expectedExpression);
+    void verifyParsing(QStringList exprList, QList<DataPoint>& expectedDataPoints, QStringList& expectedExpression);
 
 private:
-
 };
+
+#endif // TEST_EXPRESSIONPARSER_H
\ No newline at end of file
diff --git a/tests/datahandling/tst_graphdatahandler.cpp b/tests/datahandling/tst_graphdatahandler.cpp
index 644d5ff4..3560501a 100644
--- a/tests/datahandling/tst_graphdatahandler.cpp
+++ b/tests/datahandling/tst_graphdatahandler.cpp
@@ -11,7 +11,6 @@
 
 Q_DECLARE_METATYPE(Result<quint16>);
 
-using Type = ModbusDataType::Type;
 using State = ResultState::State;
 
 void TestGraphDataHandler::init()
@@ -36,16 +35,15 @@ void TestGraphDataHandler::registerList()
 
     CommunicationHelpers::addExpressionsToModel(_pGraphDataModel, exprList);
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(40001), Device::cFirstDeviceId + 1, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(40001), Device::cFirstDeviceId, Type::UNSIGNED_16)
-                              << ModbusRegister(ModbusAddress(40002), Device::cFirstDeviceId, Type::SIGNED_32);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${40001@2}", Device::cFirstDeviceId + 1)
+                                            << DataPoint("${40001}", Device::cFirstDeviceId)
+                                            << DataPoint("${40002:s32b}", Device::cFirstDeviceId);
 
     GraphDataHandler dataHandler;
-    QList<ModbusRegister> registerList;
+    QList<DataPoint> registerList;
     dataHandler.setupExpressions(_pGraphDataModel, registerList);
 
-    QCOMPARE(expModbusRegisters, registerList);
+    QCOMPARE(expDataPoints, registerList);
 }
 
 void TestGraphDataHandler::error_data()
@@ -78,7 +76,7 @@ void TestGraphDataHandler::error()
     CommunicationHelpers::addExpressionsToModel(_pGraphDataModel, exprList);
 
     GraphDataHandler dataHandler;
-    QList<ModbusRegister> registerList;
+    QList<DataPoint> registerList;
     dataHandler.setupExpressions(_pGraphDataModel, registerList);
 
     auto regResults = ResultDoubleList() << ResultDouble(1, State::SUCCESS);
@@ -97,7 +95,7 @@ void TestGraphDataHandler::sameRegisterDifferentType()
     CommunicationHelpers::addExpressionsToModel(_pGraphDataModel, exprList);
 
     GraphDataHandler dataHandler;
-    QList<ModbusRegister> registerList;
+    QList<DataPoint> registerList;
     dataHandler.setupExpressions(_pGraphDataModel, registerList);
     auto regResults = ResultDoubleList() << ResultDouble(1, State::SUCCESS) << ResultDouble(1, State::SUCCESS);
     dataHandler.handleRegisterData(regResults);
@@ -126,13 +124,12 @@ void TestGraphDataHandler::manyInactiveRegisters()
     _pGraphDataModel->setExpression(9, "${40003}");
     _pGraphDataModel->setActive(9, false);
 
-    auto expModbusRegisters = QList<ModbusRegister>()
-                              << ModbusRegister(ModbusAddress(40002), Device::cFirstDeviceId, Type::UNSIGNED_16);
+    auto expDataPoints = QList<DataPoint>() << DataPoint("${40002}", Device::cFirstDeviceId);
 
     GraphDataHandler dataHandler;
-    QList<ModbusRegister> registerList;
+    QList<DataPoint> registerList;
     dataHandler.setupExpressions(_pGraphDataModel, registerList);
-    QCOMPARE(expModbusRegisters, registerList);
+    QCOMPARE(expDataPoints, registerList);
 }
 
 void TestGraphDataHandler::graphData()
@@ -163,7 +160,7 @@ void TestGraphDataHandler::graphDataTwice()
     QList<QVariant> rawRegData;
     GraphDataHandler dataHandler;
 
-    QList<ModbusRegister> registerList;
+    QList<DataPoint> registerList;
     dataHandler.setupExpressions(_pGraphDataModel, registerList);
 
     QSignalSpy spyDataReady(&dataHandler, &GraphDataHandler::graphDataReady);
@@ -201,7 +198,7 @@ void TestGraphDataHandler::graphData_fail()
 void TestGraphDataHandler::doHandleRegisterData(ResultDoubleList& modbusResults, QList<QVariant>& actRawData)
 {
     GraphDataHandler dataHandler;
-    QList<ModbusRegister> registerList;
+    QList<DataPoint> registerList;
     dataHandler.setupExpressions(_pGraphDataModel, registerList);
 
     QSignalSpy spyDataReady(&dataHandler, &GraphDataHandler::graphDataReady);
diff --git a/tests/util/tst_expressionchecker.cpp b/tests/util/tst_expressionchecker.cpp
index 50412381..3651c13b 100644
--- a/tests/util/tst_expressionchecker.cpp
+++ b/tests/util/tst_expressionchecker.cpp
@@ -10,7 +10,6 @@ using State = ResultState::State;
 
 void TestExpressionChecker::init()
 {
-
 }
 
 void TestExpressionChecker::cleanup()
@@ -28,8 +27,8 @@ void TestExpressionChecker::dataIsPrimed()
 
     QStringList descriptions;
     checker.descriptions(descriptions);
-    auto expDescriptions = QStringList() << "holding register, 0, unsigned 16-bit, device id 1"
-                                         << "holding register, 1, unsigned 16-bit, device id 1";
+    auto expDescriptions = QStringList() << "${40001}, device id 1"
+                                         << "${40002}, device id 1";
     QCOMPARE(descriptions, expDescriptions);
 
     QCOMPARE(checker.requiredValueCount(), 2);