Merge remote-tracking branch 'origin/graph_simulation'

Author: jgeudens

CMakeLists.txt

@@ -46,6 +46,8 @@ SET(APP_SRCS
     ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/mainwindow.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/registerdatamodel.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/incgraph.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/sinegraph.cpp
 
     ${CMAKE_CURRENT_SOURCE_DIR}/src/mainwindow.ui
 

src/incgraph.cpp

@@ -0,0 +1,39 @@
+#include "incgraph.h"
+#include <QtMath>
+
+IncGraph::IncGraph(TestSlaveData *pSlaveData, QObject *parent)
+    : QObject{parent}
+{
+    _pSlaveData = pSlaveData;
+    _bIncEnabled = false;
+    _periodMs = 1000;
+
+    connect(&_tickTimer, &QTimer::timeout, this, QOverload<>::of(&IncGraph::timerTick));
+    _tickTimer.start(_periodMs);
+}
+
+void IncGraph::setState(bool bState)
+{
+    _bIncEnabled = bState;
+}
+
+void IncGraph::setRegisters(uint32_t start, uint32_t count)
+{
+    _start = start;
+    _count = count;
+}
+
+void IncGraph::timerTick()
+{
+    if (_bIncEnabled)
+    {
+        for(uint32_t idx = 0; idx < _count; idx++)
+        {
+            quint32 regAddr = _start + idx;
+            quint16 value = _pSlaveData->registerValue(regAddr) + 1;
+            _pSlaveData->setRegisterValue(regAddr, value);
+        }
+    }
+
+    _tickTimer.start(_periodMs);
+}

src/incgraph.h

@@ -0,0 +1,32 @@
+#ifndef INCGRAPH_H
+#define INCGRAPH_H
+
+#include <QObject>
+#include <QTimer>
+#include "testslavedata.h"
+
+class IncGraph : public QObject
+{
+    Q_OBJECT
+public:
+    explicit IncGraph(TestSlaveData *pSlaveData, QObject *parent = nullptr);
+
+    void setRegisters(uint32_t start, uint32_t count);
+    void setState(bool bState);
+
+private slots:
+    void timerTick();
+
+private:
+
+    bool _bIncEnabled;
+    QTimer _tickTimer;
+    quint32 _periodMs;
+
+    uint32_t _start;
+    uint32_t _count;
+
+    TestSlaveData *_pSlaveData;
+};
+
+#endif // INCGRAPH_H

src/mainwindow.cpp

@@ -15,11 +15,11 @@ MainWindow::MainWindow(QWidget *parent) :
     _pSlaveData = new TestSlaveData();
     _pSlaveModbus = new TestSlaveModbus(_pSlaveData);
 
-    QList<uint> registerList = QList<uint>() << 0 << 1 << 2 << 3 << 4;
-    _pSlaveData->setRegisterState(registerList, true);
-
     _pRegisterDataModel = new RegisterDataModel(_pSlaveData);
 
+    _pIncGraph = new IncGraph(_pSlaveData);
+    _pSineGraph = new SineGraph(_pSlaveData);
+
     connect(_pSlaveData, &TestSlaveData::dataChanged, _pRegisterDataModel, &RegisterDataModel::handleDataChange);
 
     connect(_pUi->btnListen, &QPushButton::clicked, this, &MainWindow::onConnectClicked);
@@ -57,12 +57,11 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(_pSlaveModbus, &TestSlaveModbus::requestProcessed, this, &MainWindow::handleRequestProcessed);
 
     /** Auto increment **/
-    connect(&_autoIncTimer, &QTimer::timeout, this, &MainWindow::handleAutoIncTick);
-    _autoIncTimer.start(1000);
     _bAutoInc = false;
     connect(_pUi->checkAutoIncrement, &QCheckBox::stateChanged, this,
         [=](int state){
             _bAutoInc = (state == Qt::Checked);
+            _pIncGraph->setState(_bAutoInc);
         });
 
     /** Setup registerView **/
@@ -73,16 +72,23 @@ MainWindow::MainWindow(QWidget *parent) :
     /* Don't stretch columns, resize to contents */
     _pUi->tblRegData->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
 
+    QList<uint> registerList = QList<uint>() << 0 << 1 << 2 << 3 << 4;
+    _pSlaveData->setRegisterState(registerList, true);
+
+    _pIncGraph->setRegisters(0, 10);
+
+    _pSlaveData->setRegisterState(10, true);
+    _pSineGraph->setRegister(10);
+    _pSineGraph->setPeriod(10000);
+
     QString windowCaption;
-    windowCaption = QString("ModbusTestSlave");
+    windowCaption = QString("ModbusTestSim");
 
     setWindowTitle(windowCaption);
 }
 
 MainWindow::~MainWindow()
 {
-    _autoIncTimer.stop();
-
     if (_pSlaveModbus)
     {
         _pSlaveModbus->disconnectDevice();
@@ -139,14 +145,6 @@ void MainWindow::onStateChanged(QModbusDevice::State state)
     _pUi->btnDisconnect->setEnabled(connected);
 }
 
-void MainWindow::handleAutoIncTick()
-{
-    if (_bAutoInc)
-    {
-        _pSlaveData->incrementAllEnabledRegisters();
-    }
-}
-
 void MainWindow::handleRequestProcessed()
 {
     if (_bErrorOnce)

src/mainwindow.h

@@ -2,13 +2,14 @@
 #define MAINWINDOW_H
 
 #include <QMainWindow>
-#include <QTimer>
 #include <QButtonGroup>
 
 #include "testslavemodbus.h"
 #include "testslavedata.h"
 
 #include "registerdatamodel.h"
+#include "incgraph.h"
+#include "sinegraph.h"
 
 namespace Ui {
 class MainWindow;
@@ -30,18 +31,19 @@ private slots:
     void handleDeviceError(QModbusDevice::Error newError);
     void onStateChanged(QModbusDevice::State state);
 
-    void handleAutoIncTick();
     void handleRequestProcessed();
 
 private:
 
     Ui::MainWindow *_pUi;
 
-    QTimer _autoIncTimer;
     bool _bAutoInc;
 
     bool _bErrorOnce;
 
+    IncGraph* _pIncGraph;
+    SineGraph* _pSineGraph;
+
     QButtonGroup _exceptionGroup;
     QButtonGroup _errorRecurrenceGroup;
 

src/mainwindow.ui

@@ -221,7 +221,7 @@
          <item row="0" column="0">
           <widget class="QCheckBox" name="checkAutoIncrement">
            <property name="text">
-            <string>Auto increment data (1/sec)</string>
+            <string>Auto increment data (1/sec) (first 10 registers)</string>
            </property>
           </widget>
          </item>

src/sinegraph.cpp

@@ -0,0 +1,46 @@
+#include "sinegraph.h"
+#include <QtMath>
+
+SineGraph::SineGraph(TestSlaveData *pSlaveData, QObject *parent)
+    : QObject{parent}
+{
+    _currentTick = 0;
+    _tickTime = 1;
+    _periodMs = 1000;
+    _pSlaveData = pSlaveData;
+
+    _address = 10;
+
+    connect(&_tickTimer, &QTimer::timeout, this, QOverload<>::of(&SineGraph::timerTick));
+    _tickTimer.start(_tickTime);
+}
+
+void SineGraph::timerTick()
+{
+    _currentTick++;
+    _currentTick = _currentTick >= _periodMs ? 0: _currentTick;
+
+    const double angle = (2 * M_PI) * _currentTick / _periodMs;
+    double value = sin(angle)
+            + sin(3 * angle) / 3
+            + sin(5 * angle) / 5
+            + sin(7 * angle) / 7
+            + sin(9 * angle) / 9
+            + sin(11 * angle) / 11
+            + sin(13 * angle) / 13;
+
+    _pSlaveData->setRegisterValue(_address, value * 1000);
+
+    _tickTimer.start(_tickTime);
+}
+
+void SineGraph::setPeriod(uint32_t period)
+{
+    _currentTick = 0;
+    _periodMs = period;
+}
+
+void SineGraph::setRegister(uint32_t address)
+{
+    _address = address;
+}

src/sinegraph.h

@@ -0,0 +1,35 @@
+#ifndef SINEGRAPH_H
+#define SINEGRAPH_H
+
+#include <QObject>
+#include <QTimer>
+#include "testslavedata.h"
+
+class SineGraph : public QObject
+{
+    Q_OBJECT
+public:
+    explicit SineGraph(TestSlaveData *pSlaveData, QObject *parent = nullptr);
+
+    void setPeriod(uint32_t period);
+    void setRegister(uint32_t address);
+
+signals:
+    void valueUpdate();
+
+private slots:
+    void timerTick();
+
+private:
+
+    QTimer _tickTimer;
+    quint32 _tickTime;
+    quint32 _currentTick;
+    quint32 _periodMs;
+
+    uint32_t _address;
+    TestSlaveData *_pSlaveData;
+
+};
+
+#endif // SINEGRAPH_H

testslave/testslavedata.cpp

@@ -85,16 +85,3 @@ quint16 TestSlaveData::registerValue(uint registerAddress)
 
     return 0;
 }
-
-void TestSlaveData::incrementAllEnabledRegisters()
-{
-    for(uint idx = 0u; idx < _registerList.size(); idx++)
-    {
-        if (_registerList[idx].bState)
-        {
-            _registerList[idx].value++;
-        }
-    }
-
-    emit dataChanged();
-}

testslave/testslavedata.h

@@ -22,8 +22,6 @@ class TestSlaveData : public QObject
     bool registerState(uint registerAddress);
     quint16 registerValue(uint registerAddress);
 
-    void incrementAllEnabledRegisters();
-
 signals:
     void dataChanged();