├── .gitignore
├── LICENSE.md
├── README.md
└── omodsim
    ├── byteorderutils.h
    ├── cmdlineparser.cpp
    ├── cmdlineparser.h
    ├── connectiondetails.h
    ├── controls
        ├── addressbasecombobox.cpp
        ├── addressbasecombobox.h
        ├── booleancombobox.cpp
        ├── booleancombobox.h
        ├── bytelisttextedit.cpp
        ├── bytelisttextedit.h
        ├── clickablelabel.cpp
        ├── clickablelabel.h
        ├── consoleoutput.cpp
        ├── consoleoutput.h
        ├── customframe.cpp
        ├── customframe.h
        ├── customlineedit.cpp
        ├── customlineedit.h
        ├── flowcontroltypecombobox.cpp
        ├── flowcontroltypecombobox.h
        ├── helpwidget.cpp
        ├── helpwidget.h
        ├── jscodeeditor.cpp
        ├── jscodeeditor.h
        ├── mainstatusbar.cpp
        ├── mainstatusbar.h
        ├── modbuslogwidget.cpp
        ├── modbuslogwidget.h
        ├── modbusmessagewidget.cpp
        ├── modbusmessagewidget.h
        ├── numericcombobox.cpp
        ├── numericcombobox.h
        ├── numericlineedit.cpp
        ├── numericlineedit.h
        ├── outputwidget.cpp
        ├── outputwidget.h
        ├── outputwidget.ui
        ├── paritytypecombobox.cpp
        ├── paritytypecombobox.h
        ├── pointtypecombobox.cpp
        ├── pointtypecombobox.h
        ├── runmodecombobox.cpp
        ├── runmodecombobox.h
        ├── scriptcontrol.cpp
        ├── scriptcontrol.h
        ├── scriptcontrol.ui
        ├── searchlineedit.cpp
        ├── searchlineedit.h
        ├── simulationmodecombobox.cpp
        └── simulationmodecombobox.h
    ├── datasimulator.cpp
    ├── datasimulator.h
    ├── dialogs
        ├── dialogabout.cpp
        ├── dialogabout.h
        ├── dialogabout.ui
        ├── dialogautosimulation.cpp
        ├── dialogautosimulation.h
        ├── dialogautosimulation.ui
        ├── dialogcoilsimulation.cpp
        ├── dialogcoilsimulation.h
        ├── dialogcoilsimulation.ui
        ├── dialogdisplaydefinition.cpp
        ├── dialogdisplaydefinition.h
        ├── dialogdisplaydefinition.ui
        ├── dialogforcemultiplecoils.cpp
        ├── dialogforcemultiplecoils.h
        ├── dialogforcemultiplecoils.ui
        ├── dialogforcemultipleregisters.cpp
        ├── dialogforcemultipleregisters.h
        ├── dialogforcemultipleregisters.ui
        ├── dialogmsgparser.cpp
        ├── dialogmsgparser.h
        ├── dialogmsgparser.ui
        ├── dialogprintsettings.cpp
        ├── dialogprintsettings.h
        ├── dialogprintsettings.ui
        ├── dialogscriptsettings.cpp
        ├── dialogscriptsettings.h
        ├── dialogscriptsettings.ui
        ├── dialogselectserviceport.cpp
        ├── dialogselectserviceport.h
        ├── dialogselectserviceport.ui
        ├── dialogsetuppresetdata.cpp
        ├── dialogsetuppresetdata.h
        ├── dialogsetuppresetdata.ui
        ├── dialogsetupserialport.cpp
        ├── dialogsetupserialport.h
        ├── dialogsetupserialport.ui
        ├── dialogwindowsmanager.cpp
        ├── dialogwindowsmanager.h
        ├── dialogwindowsmanager.ui
        ├── dialogwritecoilregister.cpp
        ├── dialogwritecoilregister.h
        ├── dialogwritecoilregister.ui
        ├── dialogwriteholdingregister.cpp
        ├── dialogwriteholdingregister.h
        ├── dialogwriteholdingregister.ui
        ├── dialogwriteholdingregisterbits.cpp
        ├── dialogwriteholdingregisterbits.h
        └── dialogwriteholdingregisterbits.ui
    ├── displaydefinition.h
    ├── docs
        ├── assets
        │   └── css
        │   │   ├── reset.css
        │   │   └── style.css
        ├── index.html
        ├── index_ru.html
        ├── jshelp.qhcp
        └── jshelp.qhp
    ├── enums.h
    ├── fonts
        └── firacode.ttf
    ├── formatutils.h
    ├── formmodsim.cpp
    ├── formmodsim.h
    ├── formmodsim.ui
    ├── htmldelegate.cpp
    ├── htmldelegate.h
    ├── jscompleter.cpp
    ├── jscompleter.h
    ├── jshighlighter.cpp
    ├── jshighlighter.h
    ├── jsobjects
        ├── console.cpp
        ├── console.h
        ├── script.cpp
        ├── script.h
        ├── server.cpp
        ├── server.h
        ├── storage.cpp
        └── storage.h
    ├── main.cpp
    ├── mainwindow.cpp
    ├── mainwindow.h
    ├── mainwindow.ui
    ├── menuconnect.cpp
    ├── menuconnect.h
    ├── modbusdataunitmap.cpp
    ├── modbusdataunitmap.h
    ├── modbusexception.h
    ├── modbusfunction.h
    ├── modbuslimits.h
    ├── modbusmessages
        ├── diagnostics.h
        ├── getcommeventcounter.h
        ├── getcommeventlog.h
        ├── maskwriteregister.h
        ├── modbusmessage.cpp
        ├── modbusmessage.h
        ├── modbusmessages.h
        ├── readcoils.h
        ├── readdiscreteinputs.h
        ├── readexceptionstatus.h
        ├── readfifoqueue.h
        ├── readfilerecord.h
        ├── readholdingregisters.h
        ├── readinputregisters.h
        ├── readwritemultipleregisters.h
        ├── reportserverid.h
        ├── writefilerecord.h
        ├── writemultiplecoils.h
        ├── writemultipleregisters.h
        ├── writesinglecoil.h
        └── writesingleregister.h
    ├── modbusmultiserver.cpp
    ├── modbusmultiserver.h
    ├── modbussimulationparams.h
    ├── modbuswriteparams.h
    ├── numericutils.h
    ├── omodsim.pro
    ├── qfixedsizedialog.cpp
    ├── qfixedsizedialog.h
    ├── qhexvalidator.cpp
    ├── qhexvalidator.h
    ├── qint64validator.cpp
    ├── qint64validator.h
    ├── qmodbusadu.h
    ├── qmodbusadurtu.h
    ├── qmodbusadutcp.h
    ├── qrange.h
    ├── quintvalidator.cpp
    ├── quintvalidator.h
    ├── recentfileactionlist.cpp
    ├── recentfileactionlist.h
    ├── res
        ├── actionAbout.png
        ├── actionBigEndian.png
        ├── actionBinary.png
        ├── actionConnect.png
        ├── actionCopy.png
        ├── actionCut.png
        ├── actionDblFloat.png
        ├── actionDefineData.png
        ├── actionDisconnect.png
        ├── actionFind.png
        ├── actionFloatingPt.png
        ├── actionHex.png
        ├── actionInt16.png
        ├── actionInt32.png
        ├── actionInt64.png
        ├── actionLittleEndian.png
        ├── actionNew.png
        ├── actionOpen.png
        ├── actionPaste.png
        ├── actionPrint.png
        ├── actionRedo.png
        ├── actionRunScript.png
        ├── actionSave.png
        ├── actionScriptSettings.png
        ├── actionShowData.png
        ├── actionShowScript.png
        ├── actionShowTraffic.png
        ├── actionStopScript.png
        ├── actionSwappedDbl.png
        ├── actionSwappedFP.png
        ├── actionSwappedInt32.png
        ├── actionSwappedInt64.png
        ├── actionSwappedUInt32.png
        ├── actionSwappedUInt64.png
        ├── actionUInt16.png
        ├── actionUInt32.png
        ├── actionUInt64.png
        ├── actionUndo.png
        ├── iconAbout.png
        ├── iconEnum.png
        ├── iconFunc.png
        ├── iconLandscape.png
        ├── iconPortrait.png
        ├── iconProp.png
        ├── license.txt
        ├── omodsim.ico
        ├── omodsim.png
        ├── pointEmpty.png
        └── pointGreen.png
    ├── resources.qrc
    ├── scriptsettings.h
    ├── serialportutils.h
    ├── translations
        ├── omodsim_ru.qm
        └── omodsim_ru.ts
    ├── windowactionlist.cpp
    └── windowactionlist.h


/.gitignore:
--------------------------------------------------------------------------------
 1 | # C++ objects and libs
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.a
 6 | *.la
 7 | *.lai
 8 | *.so
 9 | *.dll
10 | *.lib
11 | *.exe
12 | 
13 | # Qt-es
14 | object_script.*.Release
15 | object_script.*.Debug
16 | *_plugin_import.cpp
17 | /.qmake.cache
18 | /.qmake.stash
19 | /.qtc_clangd
20 | *.pro.user
21 | *.pro.user.*
22 | *.qbs.user
23 | *.qbs.user.*
24 | *.moc
25 | moc_*.cpp
26 | moc_*.h
27 | qrc_*.cpp
28 | ui_*.h
29 | *.qmlc
30 | *.jsc
31 | *.qch
32 | *.qhc
33 | Makefile*
34 | *build-*
35 | debug
36 | release
37 | 
38 | # Qt unit tests
39 | target_wrapper.*
40 | 
41 | # QtCreator
42 | *.autosave
43 | .qtc_clangd
44 | 
45 | # QtCreator Qml
46 | *.qmlproject.user
47 | *.qmlproject.user.*
48 | 
49 | # QtCreator CMake
50 | CMakeLists.txt.user*
51 | 
52 | .directory
53 | *.bat
54 | *.qmake.stash
55 | *.idx
56 | *.rc
57 | *.qtds
58 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Alexandr Ananev [mail@ananev.org]
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/omodsim/byteorderutils.h:
--------------------------------------------------------------------------------
 1 | #ifndef BYTEORDERUTILS_H
 2 | #define BYTEORDERUTILS_H
 3 | 
 4 | #include <QtEndian>
 5 | #include "enums.h"
 6 | 
 7 | ///
 8 | /// \brief toByteOrderValue
 9 | /// \param value
10 | /// \param order
11 | /// \return
12 | ///
13 | inline quint16 toByteOrderValue(quint16 value, ByteOrder order)
14 | {
15 |     switch(order)
16 |     {
17 |         case ByteOrder::BigEndian:
18 |             return qToBigEndian<quint16>(value);
19 | 
20 |         case ByteOrder::LittleEndian:
21 |             return qToLittleEndian<quint16>(value);
22 |     }
23 | 
24 |     return value;
25 | }
26 | 
27 | #endif // BYTEORDERUTILS_H
28 | 


--------------------------------------------------------------------------------
/omodsim/cmdlineparser.cpp:
--------------------------------------------------------------------------------
 1 | #include "cmdlineparser.h"
 2 | 
 3 | ///
 4 | /// \brief CmdLineParser::CmdLineParser
 5 | ///
 6 | CmdLineParser::CmdLineParser()
 7 | {
 8 |     QCommandLineOption helpOption(QStringList() << _help, tr("Displays this help."));
 9 |     addOption(helpOption);
10 | 
11 |     QCommandLineOption versionOption(QStringList() << _version, tr("Displays version information."));
12 |     addOption(versionOption);
13 | 
14 |     QCommandLineOption configOption(QStringList() << _config, tr("Setup test config file."), tr("file path"));
15 |     addOption(configOption);
16 | }
17 | 


--------------------------------------------------------------------------------
/omodsim/cmdlineparser.h:
--------------------------------------------------------------------------------
 1 | #ifndef CMDLINEPARSER_H
 2 | #define CMDLINEPARSER_H
 3 | 
 4 | #include <QCommandLineParser>
 5 | 
 6 | class CmdLineParser : public QCommandLineParser
 7 | {
 8 | public:
 9 |     explicit CmdLineParser();
10 | 
11 | public:
12 |     static constexpr const char* _help =    "help";
13 |     static constexpr const char* _version = "version";
14 |     static constexpr const char* _config =  "config";
15 | };
16 | 
17 | #endif // CMDLINEPARSER_H
18 | 


--------------------------------------------------------------------------------
/omodsim/controls/addressbasecombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include <QEvent>
 2 | #include "addressbasecombobox.h"
 3 | 
 4 | ///
 5 | /// \brief AddressBaseComboBox::AddressBaseComboBox
 6 | /// \param parent
 7 | ///
 8 | AddressBaseComboBox::AddressBaseComboBox(QWidget* parent)
 9 |     : QComboBox(parent)
10 | {
11 |     addItem(tr("0-based"), QVariant::fromValue(AddressBase::Base0));
12 |     addItem(tr("1-based"), QVariant::fromValue(AddressBase::Base1));
13 | 
14 |     connect(this, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &AddressBaseComboBox::on_currentIndexChanged);
15 | }
16 | 
17 | ///
18 | /// \brief AddressBaseComboBox::changeEvent
19 | /// \param event
20 | ///
21 | void AddressBaseComboBox::changeEvent(QEvent* event)
22 | {
23 |     if (event->type() == QEvent::LanguageChange)
24 |     {
25 |         for(int i = 0; i < count(); i++)
26 |         {
27 |             switch(itemData(i).value<AddressBase>())
28 |             {
29 |                 case AddressBase::Base0:
30 |                     setItemText(i, tr("0-based"));
31 |                 break;
32 | 
33 |                 case AddressBase::Base1:
34 |                     setItemText(i, tr("1-based"));
35 |                 break;
36 |             }
37 |         }
38 |     }
39 | 
40 |     QComboBox::changeEvent(event);
41 | }
42 | 
43 | ///
44 | /// \brief AddressBaseComboBox::currentAddressBase
45 | /// \return
46 | ///
47 | AddressBase AddressBaseComboBox::currentAddressBase() const
48 | {
49 |     return currentData().value<AddressBase>();
50 | }
51 | 
52 | ///
53 | /// \brief AddressBaseComboBox::setCurrentAddressBase
54 | /// \param pointType
55 | ///
56 | void AddressBaseComboBox::setCurrentAddressBase(AddressBase base)
57 | {
58 |     const auto idx = findData(QVariant::fromValue(base));
59 |     if(idx == currentIndex())
60 |     {
61 |         emit currentIndexChanged(idx);
62 |     }
63 |     else if(idx != -1)
64 |     {
65 |         setCurrentIndex(idx);
66 |     }
67 | }
68 | 
69 | ///
70 | /// \brief AddressBaseComboBox::on_currentIndexChanged
71 | /// \param index
72 | ///
73 | void AddressBaseComboBox::on_currentIndexChanged(int index)
74 | {
75 |     emit addressBaseChanged(itemData(index).value<AddressBase>());
76 | }
77 | 


--------------------------------------------------------------------------------
/omodsim/controls/addressbasecombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef ADDRESSBASECOMBOBOX_H
 2 | #define ADDRESSBASECOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | #include "enums.h"
 6 | 
 7 | ///
 8 | /// \brief The AddressBaseComboBox class
 9 | ///
10 | class AddressBaseComboBox : public QComboBox
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit AddressBaseComboBox(QWidget *parent = nullptr);
15 | 
16 |     AddressBase currentAddressBase() const;
17 |     void setCurrentAddressBase(AddressBase base);
18 | 
19 | signals:
20 |     void addressBaseChanged(AddressBase base);
21 | 
22 | protected:
23 |     void changeEvent(QEvent* event) override;
24 | 
25 | private slots:
26 |     void on_currentIndexChanged(int);
27 | };
28 | 
29 | #endif // ADDRESSBASECOMBOBOX_H
30 | 


--------------------------------------------------------------------------------
/omodsim/controls/booleancombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include "booleancombobox.h"
 2 | 
 3 | ///
 4 | /// \brief BooleanComboBox::BooleanComboBox
 5 | /// \param parent
 6 | ///
 7 | BooleanComboBox::BooleanComboBox(QWidget* parent)
 8 |     :QComboBox(parent)
 9 | {
10 |     addItem(tr("Disable"), false);
11 |     addItem(tr("Enable"), true);
12 | }
13 | 
14 | ///
15 | /// \brief BooleanComboBox::currentValue
16 | /// \return
17 | ///
18 | bool BooleanComboBox::currentValue() const
19 | {
20 |     return currentData().value<bool>();
21 | }
22 | 
23 | ///
24 | /// \brief BooleanComboBox::setCurrentValue
25 | /// \param value
26 | ///
27 | void BooleanComboBox::setCurrentValue(bool value)
28 | {
29 |     const auto idx = findData(value);
30 |     setCurrentIndex(idx);
31 | }
32 | 


--------------------------------------------------------------------------------
/omodsim/controls/booleancombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef BOOLEANCOMBOBOX_H
 2 | #define BOOLEANCOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | 
 6 | class BooleanComboBox: public QComboBox
 7 | {
 8 |     Q_OBJECT
 9 | public:
10 |     BooleanComboBox(QWidget* parent = nullptr);
11 | 
12 |     bool currentValue() const;
13 |     void setCurrentValue(bool value);
14 | };
15 | 
16 | #endif // BOOLEANCOMBOBOX_H
17 | 


--------------------------------------------------------------------------------
/omodsim/controls/bytelisttextedit.h:
--------------------------------------------------------------------------------
 1 | #ifndef BYTELISTTEXTEDIT_H
 2 | #define BYTELISTTEXTEDIT_H
 3 | 
 4 | #include <QValidator>
 5 | #include <QPlainTextEdit>
 6 | 
 7 | ///
 8 | /// \brief The ByteListTextEdit class
 9 | ///
10 | class ByteListTextEdit : public QPlainTextEdit
11 | {
12 |     Q_OBJECT
13 | 
14 | public:
15 |     enum InputMode
16 |     {
17 |         DecMode = 0,
18 |         HexMode
19 |     };
20 | 
21 |     explicit ByteListTextEdit(QWidget* parent = nullptr);
22 |     explicit ByteListTextEdit(InputMode mode, QWidget *parent = nullptr);
23 | 
24 |     QByteArray value() const;
25 |     void setValue(const QByteArray& value);
26 | 
27 |     InputMode inputMode() const;
28 |     void setInputMode(InputMode mode);
29 | 
30 |     QString text() const;
31 |     void setText(const QString& text);
32 | 
33 |     bool isEmpty() const {
34 |         return text().isEmpty();
35 |     }
36 | 
37 | signals:
38 |     void valueChanged(const QByteArray& value);
39 | 
40 | protected:
41 |     void focusOutEvent(QFocusEvent* e) override;
42 |     void keyPressEvent(QKeyEvent* e) override;
43 |     bool canInsertFromMimeData(const QMimeData* source) const override;
44 |     void insertFromMimeData(const QMimeData* source) override;
45 | 
46 | private slots:
47 |     void on_textChanged();
48 | 
49 | private:
50 |     void updateValue();
51 | 
52 | private:
53 |     InputMode _inputMode;
54 |     QByteArray _value;
55 |     QChar _separator;
56 |     QValidator* _validator;
57 | };
58 | 
59 | #endif // BYTELISTTEXTEDIT_H
60 | 


--------------------------------------------------------------------------------
/omodsim/controls/clickablelabel.cpp:
--------------------------------------------------------------------------------
 1 | #include "clickablelabel.h"
 2 | 
 3 | ///
 4 | /// \brief ClickableLabel::ClickableLabel
 5 | /// \param parent
 6 | /// \param f
 7 | ///
 8 | ClickableLabel::ClickableLabel(QWidget* parent, Qt::WindowFlags f)
 9 |     : QLabel(parent, f)
10 | {
11 | }
12 | 
13 | ///
14 | /// \brief ClickableLabel::mouseReleaseEvent
15 | /// \param event
16 | ///
17 | void ClickableLabel::mouseReleaseEvent(QMouseEvent* event)
18 | {
19 |     emit clicked();
20 |     QLabel::mouseReleaseEvent(event);
21 | }
22 | 


--------------------------------------------------------------------------------
/omodsim/controls/clickablelabel.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLICKABLELABEL_H
 2 | #define CLICKABLELABEL_H
 3 | 
 4 | #include <QLabel>
 5 | 
 6 | ///
 7 | /// \brief The ClickableLabel class
 8 | ///
 9 | class ClickableLabel : public QLabel
10 | {
11 |     Q_OBJECT
12 | 
13 | public:
14 |     explicit ClickableLabel(QWidget* parent = Q_NULLPTR, Qt::WindowFlags f = Qt::WindowFlags());
15 | 
16 | signals:
17 |     void clicked();
18 | 
19 | protected:
20 |     void mouseReleaseEvent(QMouseEvent* event);
21 | 
22 | };
23 | 
24 | #endif // CLICKABLELABEL_H
25 | 


--------------------------------------------------------------------------------
/omodsim/controls/consoleoutput.cpp:
--------------------------------------------------------------------------------
 1 | #include <QMenu>
 2 | #include "consoleoutput.h"
 3 | 
 4 | ///
 5 | /// \brief ConsoleOutput::ConsoleOutput
 6 | /// \param parent
 7 | ///
 8 | ConsoleOutput::ConsoleOutput(QWidget* parent)
 9 |     : QPlainTextEdit(parent)
10 | {
11 |     setReadOnly(true);
12 |     setUndoRedoEnabled(false);
13 | }
14 | 
15 | ///
16 | /// \brief ConsoleOutput::contextMenuEvent
17 | /// \param event
18 | ///
19 | void ConsoleOutput::contextMenuEvent(QContextMenuEvent* event)
20 | {
21 |     auto menu = new QMenu(this);
22 |     auto action = menu->addAction(tr("Clear"), this, [this]()
23 |     {
24 |         setPlainText(QString());
25 |     });
26 |     action->setEnabled(!toPlainText().isEmpty());
27 |     menu->exec(event->globalPos());
28 |     delete menu;
29 | }
30 | 


--------------------------------------------------------------------------------
/omodsim/controls/consoleoutput.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONSOLEOUTPUT_H
 2 | #define CONSOLEOUTPUT_H
 3 | 
 4 | #include <QPlainTextEdit>
 5 | 
 6 | ///
 7 | /// \brief The ConsoleOutput class
 8 | ///
 9 | class ConsoleOutput : public QPlainTextEdit
10 | {
11 |     Q_OBJECT
12 | public:
13 |     explicit ConsoleOutput(QWidget* parent = nullptr);
14 | 
15 | protected:
16 |     void contextMenuEvent(QContextMenuEvent* event);
17 | };
18 | 
19 | #endif // CONSOLEOUTPUT_H
20 | 


--------------------------------------------------------------------------------
/omodsim/controls/customframe.cpp:
--------------------------------------------------------------------------------
 1 | #include <QPainter>
 2 | #include "customframe.h"
 3 | 
 4 | ///
 5 | /// \brief CustomFrame::CustomFrame
 6 | /// \param parent
 7 | /// \param f
 8 | ///
 9 | CustomFrame::CustomFrame(QWidget* parent, Qt::WindowFlags f)
10 |     :QFrame(parent, f)
11 | {
12 | }
13 | 
14 | ///
15 | /// \brief CustomFrame::paintEvent
16 | /// \param e
17 | ///
18 | void CustomFrame::paintEvent(QPaintEvent* e)
19 | {
20 |     QPainter painter(this);
21 | 
22 |     QPen pen;
23 |     pen.setColor(palette().dark().color());
24 |     pen.setWidthF(0.5);
25 | 
26 |     auto oldPen = painter.pen();
27 |     painter.setPen(pen);
28 |     painter.setRenderHint(QPainter::Antialiasing);
29 |     painter.drawRect(rect().adjusted(1, 1, -1, -1));
30 |     painter.setPen(oldPen);
31 | 
32 |     QFrame::paintEvent(e);
33 | }
34 | 


--------------------------------------------------------------------------------
/omodsim/controls/customframe.h:
--------------------------------------------------------------------------------
 1 | #ifndef CUSTOMFRAME_H
 2 | #define CUSTOMFRAME_H
 3 | 
 4 | #include <QFrame>
 5 | 
 6 | ///
 7 | /// \brief The CustomFrame class
 8 | ///
 9 | class CustomFrame : public QFrame
10 | {
11 |     Q_OBJECT
12 | public:
13 |     CustomFrame(QWidget* parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
14 | 
15 | protected:
16 |     void paintEvent(QPaintEvent *) override;
17 | };
18 | 
19 | #endif // CUSTOMFRAME_H
20 | 


--------------------------------------------------------------------------------
/omodsim/controls/customlineedit.cpp:
--------------------------------------------------------------------------------
 1 | #include "customlineedit.h"
 2 | 
 3 | ///
 4 | /// \brief CustomLineEdit::CustomLineEdit
 5 | /// \param parent
 6 | ///
 7 | CustomLineEdit::CustomLineEdit(QWidget *parent)
 8 |     :QLineEdit(parent)
 9 | {
10 | }
11 | 
12 | ///
13 | /// \brief CustomLineEdit::setText
14 | /// \param text
15 | ///
16 | void CustomLineEdit::setText(const QString& text)
17 | {
18 |     QLineEdit::setText(text);
19 |     emit textChanged(text);
20 | }
21 | 


--------------------------------------------------------------------------------
/omodsim/controls/customlineedit.h:
--------------------------------------------------------------------------------
 1 | #ifndef CUSTOMLINEEDIT_H
 2 | #define CUSTOMLINEEDIT_H
 3 | 
 4 | #include <QLineEdit>
 5 | 
 6 | ///
 7 | /// \brief The CustomLineEdit class
 8 | ///
 9 | class CustomLineEdit : public QLineEdit
10 | {
11 |     Q_OBJECT
12 | 
13 | public:
14 |     CustomLineEdit(QWidget *parent = nullptr);
15 |     void setText(const QString& text);
16 | };
17 | 
18 | #endif // CUSTOMLINEEDIT_H
19 | 


--------------------------------------------------------------------------------
/omodsim/controls/flowcontroltypecombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include "flowcontroltypecombobox.h"
 2 | 
 3 | ///
 4 | /// \brief FlowControlTypeComboBox::FlowControlTypeComboBox
 5 | /// \param parent
 6 | ///
 7 | FlowControlTypeComboBox::FlowControlTypeComboBox(QWidget* parent)
 8 |     :QComboBox(parent)
 9 | {
10 |     addItem(tr("NO CONTROL"), QSerialPort::NoFlowControl);
11 |     addItem(tr("HARDWARE (RTS/CTS)"), QSerialPort::HardwareControl);
12 |     addItem(tr("SOFTWARE (XON/XOFF)"), QSerialPort::SoftwareControl);
13 | }
14 | 
15 | ///
16 | /// \brief FlowControlTypeComboBox::currentFlowControl
17 | /// \return
18 | ///
19 | QSerialPort::FlowControl FlowControlTypeComboBox::currentFlowControl() const
20 | {
21 |     return currentData().value<QSerialPort::FlowControl>();
22 | }
23 | 
24 | ///
25 | /// \brief FlowControlTypeComboBox::setCurrentFlowControl
26 | /// \param fctrl
27 | ///
28 | void FlowControlTypeComboBox::setCurrentFlowControl(QSerialPort::FlowControl fctrl)
29 | {
30 |     const auto idx = findData(fctrl);
31 |     setCurrentIndex(idx);
32 | }
33 | 


--------------------------------------------------------------------------------
/omodsim/controls/flowcontroltypecombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef FLOWCONTROLTYPECOMBOBOX_H
 2 | #define FLOWCONTROLTYPECOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | #include <QSerialPort>
 6 | 
 7 | ///
 8 | /// \brief The FlowControlTypeComboBox class
 9 | ///
10 | class FlowControlTypeComboBox : public QComboBox
11 | {
12 |     Q_OBJECT
13 | 
14 | public:
15 |     FlowControlTypeComboBox(QWidget *parent = nullptr);
16 | 
17 |     QSerialPort::FlowControl currentFlowControl() const;
18 |     void setCurrentFlowControl(QSerialPort::FlowControl fctrl);
19 | };
20 | 
21 | #endif // FLOWCONTROLTYPECOMBOBOX_H
22 | 


--------------------------------------------------------------------------------
/omodsim/controls/helpwidget.cpp:
--------------------------------------------------------------------------------
 1 | #include <QEvent>
 2 | #include <QHelpContentWidget>
 3 | #include "helpwidget.h"
 4 | 
 5 | ///
 6 | /// \brief HelpWidget::HelpWidget
 7 | /// \param parent
 8 | ///
 9 | HelpWidget::HelpWidget(QWidget *parent)
10 |     : QTextBrowser(parent)
11 |     ,_helpEngine(nullptr)
12 | {
13 | }
14 | 
15 | ///
16 | /// \brief HelpWidget::~HelpWidget
17 | ///
18 | HelpWidget::~HelpWidget()
19 | {
20 | }
21 | 
22 | ///
23 | /// \brief SearchLineEdit::changeEvent
24 | /// \param event
25 | ///
26 | void HelpWidget::changeEvent(QEvent* event)
27 | {
28 |     if (event->type() == QEvent::LanguageChange)
29 |     {
30 |         setSource(QUrl(tr("qthelp://omodsim/doc/index.html")));
31 |     }
32 | 
33 |     QTextBrowser::changeEvent(event);
34 | }
35 | 
36 | ///
37 | /// \brief HelpWidget::loadResource
38 | /// \param type
39 | /// \param name
40 | /// \return
41 | ///
42 | QVariant HelpWidget::loadResource (int type, const QUrl& name)
43 | {
44 |     if (name.scheme() == "qthelp" && _helpEngine)
45 |         return QVariant(_helpEngine->fileData(name));
46 |     else
47 |         return QTextBrowser::loadResource(type, name);
48 | }
49 | 
50 | ///
51 | /// \brief HelpWidget::setHelp
52 | /// \param helpFile
53 | ///
54 | void HelpWidget::setHelp(const QString& helpFile)
55 | {
56 |     _helpEngine = QSharedPointer<QHelpEngine>(new QHelpEngine(helpFile, this));
57 |     _helpEngine->setupData();
58 | 
59 |     setSource(QUrl(tr("qthelp://omodsim/doc/index.html")));
60 | }
61 | 
62 | ///
63 | /// \brief HelpWidget::showHelp
64 | /// \param helpKey
65 | ///
66 | void HelpWidget::showHelp(const QString& helpKey)
67 | {
68 |     const auto url = QString(tr("qthelp://omodsim/doc/index.html#%1")).arg(helpKey.toLower());
69 |     setSource(QUrl(url));
70 | }
71 | 


--------------------------------------------------------------------------------
/omodsim/controls/helpwidget.h:
--------------------------------------------------------------------------------
 1 | #ifndef HELPWIDGET_H
 2 | #define HELPWIDGET_H
 3 | 
 4 | #include <QHelpEngine>
 5 | #include <QTextBrowser>
 6 | 
 7 | ///
 8 | /// \brief The HelpWidget class
 9 | ///
10 | class HelpWidget : public QTextBrowser
11 | {
12 |     Q_OBJECT
13 | 
14 | public:
15 |     explicit HelpWidget(QWidget *parent = nullptr);
16 |     ~HelpWidget();
17 | 
18 |     void setHelp(const QString& helpFile);
19 |     QVariant loadResource (int type, const QUrl& name) override;
20 | 
21 |     void showHelp(const QString& helpKey);
22 | 
23 | protected:
24 |     void changeEvent(QEvent* event) override;
25 | 
26 | private:
27 |     QSharedPointer<QHelpEngine> _helpEngine;
28 | };
29 | 
30 | #endif // HELPWIDGET_H
31 | 


--------------------------------------------------------------------------------
/omodsim/controls/jscodeeditor.h:
--------------------------------------------------------------------------------
 1 | #ifndef JSCODEEDITOR_H
 2 | #define JSCODEEDITOR_H
 3 | 
 4 | #include <QCompleter>
 5 | #include <QPlainTextEdit>
 6 | #include "jscompleter.h"
 7 | #include "jshighlighter.h"
 8 | 
 9 | ///
10 | /// \brief The JSCodeEditor class
11 | ///
12 | class JSCodeEditor : public QPlainTextEdit
13 | {
14 |     Q_OBJECT
15 | 
16 | public:
17 |     explicit JSCodeEditor(QWidget *parent = nullptr);
18 |     ~JSCodeEditor() override;
19 | 
20 |     void lineNumberAreaPaintEvent(QPaintEvent *event);
21 |     int lineNumberAreaWidth();
22 | 
23 |     void setForegroundColor(const QColor& clr);
24 |     void setBackgroundColor(const QColor& clr);
25 | 
26 |     bool isAutoCompleteEnabled() const;
27 |     void enableAutoComplete(bool enable);
28 | 
29 |     void search(const QString& text);
30 | 
31 | signals:
32 |     void helpContext(const QString& key);
33 | 
34 | protected:
35 |     void resizeEvent(QResizeEvent *event) override;
36 |     void keyPressEvent(QKeyEvent *e) override;
37 | 
38 | private slots:
39 |     void updateLineNumberAreaWidth(int newBlockCount);
40 |     void highlightCurrentLine();
41 |     void updateLineNumberArea(const QRect& rect, int dy);
42 |     void insertCompletion(const QString& completion);
43 | 
44 | private:
45 |     QString textUnderCursor() const;
46 | 
47 | private:
48 |     QColor _lineColor;
49 |     QWidget* _lineNumberArea;
50 |     JSHighlighter* _highlighter;
51 |     JSCompleter* _compliter;
52 | };
53 | 
54 | ///
55 | /// \brief The LineNumberArea class
56 | ///
57 | class LineNumberArea : public QWidget
58 | {
59 | public:
60 |     LineNumberArea(JSCodeEditor *editor)
61 |         : QWidget(editor)
62 |         ,_codeEditor(editor)
63 |     {
64 |     }
65 | 
66 |     QSize sizeHint() const override
67 |     {
68 |         return QSize(_codeEditor->lineNumberAreaWidth(), 0);
69 |     }
70 | 
71 | protected:
72 |     void paintEvent(QPaintEvent *event) override
73 |     {
74 |         _codeEditor->lineNumberAreaPaintEvent(event);
75 |     }
76 | 
77 | private:
78 |     JSCodeEditor* _codeEditor;
79 | };
80 | 
81 | #endif // JSCODEEDITOR_H
82 | 


--------------------------------------------------------------------------------
/omodsim/controls/mainstatusbar.cpp:
--------------------------------------------------------------------------------
  1 | #include <QEvent>
  2 | #include <QMdiSubWindow>
  3 | #include "mainstatusbar.h"
  4 | 
  5 | ///
  6 | /// \brief Parity_toString
  7 | /// \param parity
  8 | /// \return
  9 | ///
 10 | QString Parity_toString(QSerialPort::Parity parity)
 11 | {
 12 |     switch(parity)
 13 |     {
 14 |         case QSerialPort::NoParity:
 15 |         return MainStatusBar::tr("NONE");
 16 | 
 17 |         case QSerialPort::EvenParity:
 18 |         return MainStatusBar::tr("EVEN");
 19 | 
 20 |         case QSerialPort::OddParity:
 21 |         return MainStatusBar::tr("ODD");
 22 | 
 23 |         case QSerialPort::SpaceParity:
 24 |         return MainStatusBar::tr("SPACE");
 25 | 
 26 |         case QSerialPort::MarkParity:
 27 |         return MainStatusBar::tr("MARK");
 28 | 
 29 |         default:
 30 |         break;
 31 |     }
 32 | 
 33 |     return QString();
 34 | }
 35 | 
 36 | ///
 37 | /// \brief MainStatusBar::MainStatusBar
 38 | /// \param parent
 39 | ///
 40 | MainStatusBar::MainStatusBar(const ModbusMultiServer& server, QWidget* parent)
 41 |     : QStatusBar(parent)
 42 | {
 43 |     connect(&server, &ModbusMultiServer::connected, this, [&](const ConnectionDetails& cd)
 44 |     {
 45 |         auto label = new QLabel(this);
 46 |         label->setFrameShadow(QFrame::Sunken);
 47 |         label->setFrameShape(QFrame::Panel);
 48 |         label->setMinimumWidth(80);
 49 |         label->setProperty("ConnectionDetails", QVariant::fromValue(cd));
 50 | 
 51 |         updateConnectionInfo(label, cd);
 52 | 
 53 |         _labels.append(label);
 54 |         addPermanentWidget(label);
 55 |     });
 56 | 
 57 |     connect(&server, &ModbusMultiServer::disconnected, this, [&](const ConnectionDetails& cd)
 58 |     {
 59 |         for(auto&& label : _labels)
 60 |         {
 61 |             if(cd == label->property("ConnectionDetails").value<ConnectionDetails>())
 62 |             {
 63 |                 removeWidget(label);
 64 |                 _labels.removeOne(label);
 65 | 
 66 |                 break;
 67 |             }
 68 |         }
 69 |     });
 70 | }
 71 | 
 72 | ///
 73 | /// \brief MainStatusBar::~MainStatusBar
 74 | ///
 75 | MainStatusBar::~MainStatusBar()
 76 | {
 77 |     for(auto&& label : _labels)
 78 |         delete label;
 79 | }
 80 | 
 81 | ///
 82 | /// \brief MainStatusBar::changeEvent
 83 | /// \param event
 84 | ///
 85 | void MainStatusBar::changeEvent(QEvent* event)
 86 | {
 87 |     if (event->type() == QEvent::LanguageChange)
 88 |     {
 89 |         for(auto&& label : _labels)
 90 |         {
 91 |             const auto cd = label->property("ConnectionDetails").value<ConnectionDetails>();
 92 |             updateConnectionInfo(label, cd);
 93 |         }
 94 |     }
 95 | 
 96 |     QStatusBar::changeEvent(event);
 97 | }
 98 | 
 99 | ///
100 | /// \brief MainStatusBar::updateConnectionInfo
101 | /// \param label
102 | /// \param cd
103 | ///
104 | void MainStatusBar::updateConnectionInfo(QLabel* label, const ConnectionDetails& cd)
105 | {
106 |     switch(cd.Type)
107 |     {
108 |         case ConnectionType::Tcp:
109 |             label->setText(QString(tr("Modbus/TCP Srv %1:%2")).arg(cd.TcpParams.IPAddress, QString::number(cd.TcpParams.ServicePort)));
110 |         break;
111 | 
112 |         case ConnectionType::Serial:
113 |             label->setText(QString(tr("Port %1:%2:%3:%4:%5")).arg(cd.SerialParams.PortName,
114 |                                                                 QString::number(cd.SerialParams.BaudRate),
115 |                                                                 QString::number(cd.SerialParams.WordLength),
116 |                                                                 Parity_toString(cd.SerialParams.Parity),
117 |                                                                 QString::number(cd.SerialParams.StopBits)));
118 |         break;
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------
/omodsim/controls/mainstatusbar.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAINSTATUSBAR_H
 2 | #define MAINSTATUSBAR_H
 3 | 
 4 | #include <QLabel>
 5 | #include <QStatusBar>
 6 | #include "modbusmultiserver.h"
 7 | 
 8 | ///
 9 | /// \brief The MainStatusBar class
10 | ///
11 | class MainStatusBar : public QStatusBar
12 | {
13 |     Q_OBJECT
14 | public:
15 |     explicit MainStatusBar(const ModbusMultiServer& server, QWidget* parent = nullptr);
16 |     ~MainStatusBar();
17 | 
18 | protected:
19 |     void changeEvent(QEvent* event) override;
20 | 
21 | private:
22 |     void updateConnectionInfo(QLabel* label, const ConnectionDetails& cd);
23 | 
24 | private:
25 |     QList<QLabel*> _labels;
26 | };
27 | 
28 | #endif // MAINSTATUSBAR_H
29 | 


--------------------------------------------------------------------------------
/omodsim/controls/modbuslogwidget.h:
--------------------------------------------------------------------------------
 1 | #ifndef MODBUSLOGWIDGET_H
 2 | #define MODBUSLOGWIDGET_H
 3 | 
 4 | #include <QQueue>
 5 | #include <QListView>
 6 | #include "modbusmessage.h"
 7 | 
 8 | class ModbusLogWidget;
 9 | 
10 | ///
11 | /// \brief The ModbusLogModel class
12 | ///
13 | class  ModbusLogModel : public QAbstractListModel
14 | {
15 |     Q_OBJECT
16 | 
17 | public:
18 |     explicit ModbusLogModel(ModbusLogWidget* parent);
19 |     ~ModbusLogModel();
20 | 
21 |     int rowCount(const QModelIndex& parent = QModelIndex()) const override;
22 |     QVariant data(const QModelIndex& index, int role) const override;
23 | 
24 |     void clear();
25 |     void append(const ModbusMessage* data);
26 |     void update(){
27 |         emit dataChanged(index(0), index(_items.size() - 1));
28 |     }
29 | 
30 |     int rowLimit() const;
31 |     void setRowLimit(int val);
32 | 
33 | private:
34 |     void deleteItems();
35 | 
36 | private:
37 |     int _rowLimit = 30;
38 |     ModbusLogWidget* _parentWidget;
39 |     QQueue<const ModbusMessage*> _items;
40 | };
41 | 
42 | ///
43 | /// \brief The ModbusLogWidget class
44 | ///
45 | class ModbusLogWidget : public QListView
46 | {
47 |     Q_OBJECT
48 | public:
49 |     explicit ModbusLogWidget(QWidget* parent = nullptr);
50 | 
51 |     void clear();
52 | 
53 |     int rowCount() const;
54 |     QModelIndex index(int row);
55 | 
56 |     const ModbusMessage* addItem(const QModbusPdu& pdu, ModbusMessage::ProtocolType protocol, int deviceId, int transactionId, const QDateTime& timestamp, bool request);
57 |     const ModbusMessage* itemAt(const QModelIndex& index);
58 | 
59 |     DataDisplayMode dataDisplayMode() const;
60 |     void setDataDisplayMode(DataDisplayMode mode);
61 | 
62 |     int rowLimit() const;
63 |     void setRowLimit(int val);
64 | 
65 |     bool autoscroll() const;
66 |     void setAutoscroll(bool on);
67 | 
68 | protected:
69 |     void changeEvent(QEvent* event) override;
70 | 
71 | private:
72 |     bool _autoscroll;
73 |     DataDisplayMode _dataDisplayMode;
74 | };
75 | 
76 | #endif // MODBUSLOGWIDGET_H
77 | 


--------------------------------------------------------------------------------
/omodsim/controls/modbusmessagewidget.h:
--------------------------------------------------------------------------------
 1 | #ifndef MODBUSMESSAGEWIDGET_H
 2 | #define MODBUSMESSAGEWIDGET_H
 3 | 
 4 | #include <QListWidget>
 5 | #include "modbusmessage.h"
 6 | 
 7 | ///
 8 | /// \brief The ModbusMessageWidget class
 9 | ///
10 | class ModbusMessageWidget : public QListWidget
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit ModbusMessageWidget(QWidget *parent = nullptr);
15 | 
16 |     void clear();
17 | 
18 |     DataDisplayMode dataDisplayMode() const;
19 |     void setDataDisplayMode(DataDisplayMode mode);
20 | 
21 |     ByteOrder byteOrder() const;
22 |     void setByteOrder(ByteOrder order);
23 | 
24 |     const ModbusMessage* modbusMessage() const;
25 |     void setModbusMessage(const ModbusMessage* msg);
26 | 
27 |     bool showTimestamp() const;
28 |     void setShowTimestamp(bool on);
29 | 
30 |     void setStatusColor(const QColor& clr);
31 | 
32 | protected:
33 |     void changeEvent(QEvent* event) override;
34 | 
35 | private:
36 |     void update();
37 | 
38 | private:
39 |     QColor _statusClr;
40 |     ByteOrder _byteOrder;
41 |     DataDisplayMode _dataDisplayMode;
42 |     bool _showTimestamp;
43 |     const ModbusMessage* _mm;
44 | };
45 | 
46 | #endif // MODBUSMESSAGEWIDGET_H
47 | 


--------------------------------------------------------------------------------
/omodsim/controls/numericcombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include "numericcombobox.h"
 2 | 
 3 | ///
 4 | /// \brief NumericComboBox::NumericComboBox
 5 | /// \param parent
 6 | ///
 7 | NumericComboBox::NumericComboBox(QWidget* parent)
 8 |     :QComboBox(parent)
 9 | {
10 | }
11 | 
12 | ///
13 | /// \brief NumericComboBox::addValue
14 | /// \param value
15 | ///
16 | void NumericComboBox::addValue(int value)
17 | {
18 |     addItem(QString::number(value));
19 | }
20 | 
21 | ///
22 | /// \brief NumericComboBox::currentValue
23 | /// \return
24 | ///
25 | int NumericComboBox::currentValue() const
26 | {
27 |     return currentText().toInt();
28 | }
29 | 
30 | ///
31 | /// \brief NumericComboBox::setCurrentValue
32 | /// \param value
33 | ///
34 | void NumericComboBox::setCurrentValue(int value)
35 | {
36 |     const auto idx = findText(QString::number(value));
37 |     setCurrentIndex(idx);
38 | }
39 | 


--------------------------------------------------------------------------------
/omodsim/controls/numericcombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef NUMERICCOMBOBOX_H
 2 | #define NUMERICCOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | 
 6 | ///
 7 | /// \brief The NumericComboBox class
 8 | ///
 9 | class NumericComboBox : public QComboBox
10 | {
11 |     Q_OBJECT
12 | public:
13 |     explicit NumericComboBox(QWidget *parent = nullptr);
14 | 
15 |     void addValue(int value);
16 |     int currentValue() const;
17 |     void setCurrentValue(int value);
18 | };
19 | 
20 | #endif // NUMERICCOMBOBOX_H
21 | 


--------------------------------------------------------------------------------
/omodsim/controls/numericlineedit.h:
--------------------------------------------------------------------------------
 1 | #ifndef NUMERICLINEEDIT_H
 2 | #define NUMERICLINEEDIT_H
 3 | 
 4 | #include <QLineEdit>
 5 | #include "qrange.h"
 6 | 
 7 | class NumericLineEdit : public QLineEdit
 8 | {
 9 |     Q_OBJECT
10 |     Q_PROPERTY(InputMode inputMode READ inputMode WRITE setInputMode)
11 |     Q_PROPERTY(bool paddingZeroes READ paddingZeroes WRITE setPaddingZeroes)
12 | 
13 | public:
14 |     enum InputMode
15 |     {
16 |         Int32Mode = 0,
17 |         UInt32Mode,
18 |         HexMode,
19 |         FloatMode,
20 |         DoubleMode,
21 |         Int64Mode,
22 |         UInt64Mode
23 |     };
24 | 
25 |     explicit NumericLineEdit(QWidget* parent = nullptr);
26 |     explicit NumericLineEdit(InputMode mode, QWidget *parent = nullptr);
27 | 
28 |     template<typename T>
29 |     T value() const { return _value.value<T>(); }
30 | 
31 |     template<typename T>
32 |     void setValue(T value)
33 |     { internalSetValue(value); }
34 | 
35 |     bool paddingZeroes() const;
36 |     void setPaddingZeroes(bool on);
37 | 
38 |     template<typename T>
39 |     QRange<T> range() const
40 |     { return { _minValue.value<T>(), _maxValue.value<T>() }; }
41 | 
42 |     template<typename T>
43 |     void setInputRange(QRange<T> range)
44 |     { setInputRange(range.from(), range.to()); }
45 | 
46 |     template<typename T>
47 |     void setInputRange(T bottom, T top)
48 |     {
49 |         _minValue = QVariant::fromValue<T>(bottom);
50 |         _maxValue = QVariant::fromValue<T>(top);
51 |         emit rangeChanged(_minValue, _maxValue);
52 |     }
53 | 
54 |     InputMode inputMode() const;
55 |     void setInputMode(InputMode mode);
56 | 
57 |     void setText(const QString& text);
58 | 
59 | signals:
60 |     void valueChanged(const QVariant& value);
61 |     void rangeChanged(const QVariant& bottom, const QVariant& top);
62 | 
63 | protected:
64 |     void focusInEvent(QFocusEvent*) override;
65 |     void focusOutEvent(QFocusEvent*) override;
66 |     void keyPressEvent(QKeyEvent*) override;
67 | 
68 | private slots:
69 |     void on_editingFinished();
70 |     void on_textChanged(const QString& text);
71 |     void on_rangeChanged(const QVariant& bottom, const QVariant& top);
72 | 
73 | private:
74 |     void updateValue();
75 |     void internalSetValue(QVariant value);
76 | 
77 | private:
78 |     QVariant _value;
79 |     QVariant _minValue;
80 |     QVariant _maxValue;
81 |     InputMode _inputMode;
82 |     bool _paddingZeroes;
83 |     int _paddingZeroWidth;
84 | };
85 | 
86 | #endif // NUMERICLINEEDIT_H
87 | 


--------------------------------------------------------------------------------
/omodsim/controls/paritytypecombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include "paritytypecombobox.h"
 2 | 
 3 | ///
 4 | /// \brief ParityTypeComboBox::ParityTypeComboBox
 5 | /// \param parent
 6 | ///
 7 | ParityTypeComboBox::ParityTypeComboBox(QWidget* parent)
 8 |     :QComboBox(parent)
 9 | {
10 |     addItem(tr("ODD"), QSerialPort::OddParity);
11 |     addItem(tr("EVEN"), QSerialPort::EvenParity);
12 |     addItem(tr("NONE"), QSerialPort::NoParity);
13 | }
14 | 
15 | ///
16 | /// \brief ParityTypeComboBox::currentParity
17 | /// \return
18 | ///
19 | QSerialPort::Parity ParityTypeComboBox::currentParity() const
20 | {
21 |     return currentData().value<QSerialPort::Parity>();
22 | }
23 | 
24 | ///
25 | /// \brief ParityTypeComboBox::setCurrentParity
26 | /// \param parity
27 | ///
28 | void ParityTypeComboBox::setCurrentParity(QSerialPort::Parity parity)
29 | {
30 |     const auto idx = findData(parity);
31 |     setCurrentIndex(idx);
32 | }
33 | 


--------------------------------------------------------------------------------
/omodsim/controls/paritytypecombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef PARITYTYPECOMBOBOX_H
 2 | #define PARITYTYPECOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | #include <QSerialPort>
 6 | 
 7 | ///
 8 | /// \brief The ParityTypeComboBox class
 9 | ///
10 | class ParityTypeComboBox : public QComboBox
11 | {
12 |     Q_OBJECT
13 | public:
14 |     ParityTypeComboBox(QWidget *parent = nullptr);
15 | 
16 |     QSerialPort::Parity currentParity() const;
17 |     void setCurrentParity(QSerialPort::Parity parity);
18 | };
19 | 
20 | #endif // PARITYTYPECOMBOBOX_H
21 | 


--------------------------------------------------------------------------------
/omodsim/controls/pointtypecombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include "pointtypecombobox.h"
 2 | 
 3 | 
 4 | ///
 5 | /// \brief PointTypeComboBox::PointTypeComboBox
 6 | /// \param parent
 7 | ///
 8 | PointTypeComboBox::PointTypeComboBox(QWidget *parent)
 9 |     : QComboBox(parent)
10 | {
11 |     addItem("01: COIL STATUS", QModbusDataUnit::Coils);
12 |     addItem("02: INPUT STATUS", QModbusDataUnit::DiscreteInputs);
13 |     addItem("03: HOLDING REGISTER", QModbusDataUnit::HoldingRegisters);
14 |     addItem("04: INPUT REGISTER", QModbusDataUnit::InputRegisters);
15 | 
16 |     connect(this, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &PointTypeComboBox::on_currentIndexChanged);
17 | }
18 | 
19 | ///
20 | /// \brief PointTypeComboBox::currentPointType
21 | /// \return
22 | ///
23 | QModbusDataUnit::RegisterType PointTypeComboBox::currentPointType() const
24 | {
25 |     return currentData().value<QModbusDataUnit::RegisterType>();
26 | }
27 | 
28 | ///
29 | /// \brief PointTypeComboBox::setCurrentPointType
30 | /// \param pointType
31 | ///
32 | void PointTypeComboBox::setCurrentPointType(QModbusDataUnit::RegisterType pointType)
33 | {
34 |     const auto idx = findData(pointType);
35 |     setCurrentIndex(idx);
36 | }
37 | 
38 | ///
39 | /// \brief PointTypeComboBox::on_currentIndexChanged
40 | /// \param index
41 | ///
42 | void PointTypeComboBox::on_currentIndexChanged(int index)
43 | {
44 |     emit pointTypeChanged(itemData(index).value<QModbusDataUnit::RegisterType>());
45 | }
46 | 


--------------------------------------------------------------------------------
/omodsim/controls/pointtypecombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef POINTTYPECOMBOBOX_H
 2 | #define POINTTYPECOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | #include <QModbusDataUnit>
 6 | 
 7 | ///
 8 | /// \brief The PointTypeComboBox class
 9 | ///
10 | class PointTypeComboBox : public QComboBox
11 | {
12 |     Q_OBJECT
13 | public:
14 |     PointTypeComboBox(QWidget *parent = nullptr);
15 | 
16 |     QModbusDataUnit::RegisterType currentPointType() const;
17 |     void setCurrentPointType(QModbusDataUnit::RegisterType pointType);
18 | 
19 | signals:
20 |     void pointTypeChanged(QModbusDataUnit::RegisterType value);
21 | 
22 | private slots:
23 |     void on_currentIndexChanged(int);
24 | };
25 | 
26 | #endif // POINTTYPECOMBOBOX_H
27 | 


--------------------------------------------------------------------------------
/omodsim/controls/runmodecombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include <QEvent>
 2 | #include "runmodecombobox.h"
 3 | 
 4 | ///
 5 | /// \brief RunModeComboBox::RunModeComboBox
 6 | /// \param parent
 7 | ///
 8 | RunModeComboBox::RunModeComboBox(QWidget* parent)
 9 |     : QComboBox(parent)
10 | {
11 |     addItem(tr("Once"), QVariant::fromValue(RunMode::Once));
12 |     addItem(tr("Periodically"), QVariant::fromValue(RunMode::Periodically));
13 | 
14 |     setSizeAdjustPolicy(SizeAdjustPolicy::AdjustToContents);
15 |     connect(this, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RunModeComboBox::on_currentIndexChanged);
16 | }
17 | 
18 | ///
19 | /// \brief RunModeComboBox::changeEvent
20 | /// \param event
21 | ///
22 | void RunModeComboBox::changeEvent(QEvent* event)
23 | {
24 |     if (event->type() == QEvent::LanguageChange)
25 |     {
26 |         for(int i = 0; i < count(); i++)
27 |         {
28 |             switch(itemData(i).value<RunMode>())
29 |             {
30 |                 case RunMode::Once:
31 |                     setItemText(i, tr("Once"));
32 |                 break;
33 | 
34 |                 case RunMode::Periodically:
35 |                     setItemText(i, tr("Periodically"));
36 |                 break;
37 |             }
38 |         }
39 |     }
40 | 
41 |     QComboBox::changeEvent(event);
42 | }
43 | 
44 | ///
45 | /// \brief RunModeComboBox::currentRunMode
46 | /// \return
47 | ///
48 | RunMode RunModeComboBox::currentRunMode() const
49 | {
50 |     return currentData().value<RunMode>();
51 | }
52 | 
53 | ///
54 | /// \brief RunModeComboBox::setCurrentRunMode
55 | /// \param mode
56 | ///
57 | void RunModeComboBox::setCurrentRunMode(RunMode mode)
58 | {
59 |     const auto idx = findData(QVariant::fromValue(mode));
60 |     setCurrentIndex(idx);
61 | }
62 | 
63 | ///
64 | /// \brief RunModeComboBox::on_currentIndexChanged
65 | /// \param index
66 | ///
67 | void RunModeComboBox::on_currentIndexChanged(int index)
68 | {
69 |     emit runModeChanged(itemData(index).value<RunMode>());
70 | }
71 | 


--------------------------------------------------------------------------------
/omodsim/controls/runmodecombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef RUNMODECOMBOBOX_H
 2 | #define RUNMODECOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | #include "enums.h"
 6 | 
 7 | ///
 8 | /// \brief The RunModeComboBox class
 9 | ///
10 | class RunModeComboBox : public QComboBox
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit RunModeComboBox(QWidget *parent = nullptr);
15 | 
16 |     RunMode currentRunMode() const;
17 |     void setCurrentRunMode(RunMode mode);
18 | 
19 | protected:
20 |     void changeEvent(QEvent* event) override;
21 | 
22 | signals:
23 |     void runModeChanged(RunMode value);
24 | 
25 | private slots:
26 |     void on_currentIndexChanged(int);
27 | };
28 | 
29 | #endif // RUNMODECOMBOBOX_H
30 | 


--------------------------------------------------------------------------------
/omodsim/controls/scriptcontrol.h:
--------------------------------------------------------------------------------
 1 | #ifndef SCRIPTCONTROL_H
 2 | #define SCRIPTCONTROL_H
 3 | 
 4 | #include <QTimer>
 5 | #include <QJSEngine>
 6 | #include <QPlainTextEdit>
 7 | #include "console.h"
 8 | #include "script.h"
 9 | #include "storage.h"
10 | #include "server.h"
11 | 
12 | namespace Ui {
13 | class ScriptControl;
14 | }
15 | 
16 | ///
17 | /// \brief The ScriptControl class
18 | ///
19 | class ScriptControl : public QWidget
20 | {
21 |     Q_OBJECT
22 | 
23 |     friend QSettings& operator <<(QSettings& out, const ScriptControl* ctrl);
24 |     friend QSettings& operator >>(QSettings& in, ScriptControl* ctrl);
25 |     friend QDataStream& operator <<(QDataStream& out, const ScriptControl* ctrl);
26 |     friend QDataStream& operator >>(QDataStream& in, ScriptControl* ctrl);
27 | 
28 | public:  
29 |     explicit ScriptControl(QWidget *parent = nullptr);
30 |     ~ScriptControl();
31 | 
32 |     void setModbusMultiServer(ModbusMultiServer* server);
33 |     void setByteOrder(const ByteOrder* order);
34 |     void setAddressBase(AddressBase base);
35 | 
36 |     bool isAutoCompleteEnabled() const;
37 |     void enableAutoComplete(bool enable);
38 | 
39 |     QString script() const;
40 |     void setScript(const QString& text);
41 | 
42 |     QString searchText() const;
43 | 
44 |     bool isRunning() const;
45 | 
46 |     void setFocus();
47 | 
48 |     bool canUndo() const;
49 |     bool canRedo() const;
50 |     bool canPaste() const;
51 | 
52 | public slots:
53 |     void undo();
54 |     void redo();
55 |     void cut();
56 |     void copy();
57 |     void paste();
58 |     void selectAll();
59 |     void search(const QString& text);
60 |     void runScript(RunMode mode, int interval = 0);
61 |     void stopScript();
62 |     void showHelp(const QString& helpKey);
63 | 
64 | private slots:
65 |     bool executeScript();
66 | 
67 | private:
68 |     Ui::ScriptControl *ui;
69 | 
70 |     QTimer _timer;
71 |     QJSEngine _jsEngine;
72 |     QString _scriptCode;
73 |     QString _searchText;
74 | 
75 |     QSharedPointer<Script> _script;
76 |     QSharedPointer<Storage> _storage;
77 |     QSharedPointer<Server> _server;
78 |     QSharedPointer<console> _console;
79 | 
80 |     ByteOrder* _byteOrder = nullptr;
81 |     AddressBase _addressBase = AddressBase::Base1;
82 |     ModbusMultiServer* _mbMultiServer = nullptr;
83 | };
84 | 
85 | #endif // SCRIPTCONTROL_H
86 | 


--------------------------------------------------------------------------------
/omodsim/controls/scriptcontrol.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>ScriptControl</class>
  4 |  <widget class="QWidget" name="ScriptControl">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>725</width>
 10 |     <height>415</height>
 11 |    </rect>
 12 |   </property>
 13 |   <layout class="QHBoxLayout" name="horizontalLayout">
 14 |    <property name="leftMargin">
 15 |     <number>0</number>
 16 |    </property>
 17 |    <property name="topMargin">
 18 |     <number>0</number>
 19 |    </property>
 20 |    <property name="rightMargin">
 21 |     <number>0</number>
 22 |    </property>
 23 |    <property name="bottomMargin">
 24 |     <number>0</number>
 25 |    </property>
 26 |    <item>
 27 |     <widget class="QSplitter" name="verticalSplitter">
 28 |      <property name="orientation">
 29 |       <enum>Qt::Orientation::Horizontal</enum>
 30 |      </property>
 31 |      <widget class="QSplitter" name="horizontalSplitter">
 32 |       <property name="sizePolicy">
 33 |        <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
 34 |         <horstretch>5</horstretch>
 35 |         <verstretch>0</verstretch>
 36 |        </sizepolicy>
 37 |       </property>
 38 |       <property name="orientation">
 39 |        <enum>Qt::Orientation::Vertical</enum>
 40 |       </property>
 41 |       <widget class="JSCodeEditor" name="codeEditor">
 42 |        <property name="sizePolicy">
 43 |         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
 44 |          <horstretch>2</horstretch>
 45 |          <verstretch>4</verstretch>
 46 |         </sizepolicy>
 47 |        </property>
 48 |        <property name="plainText">
 49 |         <string>Script.onInit(()=&gt;{
 50 | 	Server.addressBase = AddressBase.Base1;
 51 | 	Server.onChange(Register.Holding, 1, (value)=&gt;
 52 | 	{
 53 | 		/* write your code on register value change */
 54 | 	});
 55 | 
 56 | 	/* write your init code here */
 57 | });</string>
 58 |        </property>
 59 |        <property name="tabStopDistance">
 60 |         <double>20.000000000000000</double>
 61 |        </property>
 62 |        <property name="placeholderText">
 63 |         <string/>
 64 |        </property>
 65 |       </widget>
 66 |       <widget class="ConsoleOutput" name="console">
 67 |        <property name="sizePolicy">
 68 |         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
 69 |          <horstretch>0</horstretch>
 70 |          <verstretch>1</verstretch>
 71 |         </sizepolicy>
 72 |        </property>
 73 |        <property name="undoRedoEnabled">
 74 |         <bool>false</bool>
 75 |        </property>
 76 |        <property name="readOnly">
 77 |         <bool>true</bool>
 78 |        </property>
 79 |       </widget>
 80 |      </widget>
 81 |      <widget class="HelpWidget" name="helpWidget">
 82 |       <property name="sizePolicy">
 83 |        <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
 84 |         <horstretch>2</horstretch>
 85 |         <verstretch>0</verstretch>
 86 |        </sizepolicy>
 87 |       </property>
 88 |      </widget>
 89 |     </widget>
 90 |    </item>
 91 |   </layout>
 92 |  </widget>
 93 |  <customwidgets>
 94 |   <customwidget>
 95 |    <class>JSCodeEditor</class>
 96 |    <extends>QPlainTextEdit</extends>
 97 |    <header>jscodeeditor.h</header>
 98 |   </customwidget>
 99 |   <customwidget>
100 |    <class>ConsoleOutput</class>
101 |    <extends>QPlainTextEdit</extends>
102 |    <header>consoleoutput.h</header>
103 |   </customwidget>
104 |   <customwidget>
105 |    <class>HelpWidget</class>
106 |    <extends>QTextBrowser</extends>
107 |    <header>helpwidget.h</header>
108 |   </customwidget>
109 |  </customwidgets>
110 |  <resources/>
111 |  <connections/>
112 | </ui>
113 | 


--------------------------------------------------------------------------------
/omodsim/controls/searchlineedit.cpp:
--------------------------------------------------------------------------------
 1 | #include <QEvent>
 2 | #include "searchlineedit.h"
 3 | 
 4 | ///
 5 | /// \brief SearchLineEdit::SearchLineEdit
 6 | /// \param parent
 7 | ///
 8 | SearchLineEdit::SearchLineEdit(QWidget* parent)
 9 |     :QLineEdit(parent)
10 | {
11 |     setPlaceholderText(tr("Type text to search..."));
12 |     setClearButtonEnabled(true);
13 |     setMaximumWidth(200);
14 | 
15 |     connect(this, &QLineEdit::textEdited, this, &SearchLineEdit::on_textEdited);
16 |     connect(this, &QLineEdit::returnPressed, this, &SearchLineEdit::on_returnPressed);
17 | }
18 | 
19 | ///
20 | /// \brief SearchLineEdit::changeEvent
21 | /// \param event
22 | ///
23 | void SearchLineEdit::changeEvent(QEvent* event)
24 | {
25 |     if (event->type() == QEvent::LanguageChange)
26 |     {
27 |         setPlaceholderText(tr("Type text to search..."));
28 |     }
29 | 
30 |     QLineEdit::changeEvent(event);
31 | }
32 | 
33 | ///
34 | /// \brief SearchLineEdit::on_returnPressed
35 | ///
36 | void SearchLineEdit::on_returnPressed()
37 | {
38 |     emit searchText(text());
39 | }
40 | 
41 | ///
42 | /// \brief SearchLineEdit::on_textEdited
43 | /// \param text
44 | ///
45 | void SearchLineEdit::on_textEdited(const QString& text)
46 | {
47 |     emit searchText(text);
48 | }
49 | 


--------------------------------------------------------------------------------
/omodsim/controls/searchlineedit.h:
--------------------------------------------------------------------------------
 1 | #ifndef SEARCHLINEEDIT_H
 2 | #define SEARCHLINEEDIT_H
 3 | 
 4 | #include <QLineEdit>
 5 | 
 6 | ///
 7 | /// \brief The SearchLineEdit class
 8 | ///
 9 | class SearchLineEdit : public QLineEdit
10 | {
11 |     Q_OBJECT
12 | public:
13 |     explicit SearchLineEdit(QWidget* parent = nullptr);
14 | 
15 | signals:
16 |     void searchText(const QString& text);
17 | 
18 | protected:
19 |     void changeEvent(QEvent* event) override;
20 | 
21 | private slots:
22 |     void on_returnPressed();
23 |     void on_textEdited(const QString& text);
24 | };
25 | 
26 | #endif // SEARCHLINEEDIT_H
27 | 


--------------------------------------------------------------------------------
/omodsim/controls/simulationmodecombobox.cpp:
--------------------------------------------------------------------------------
 1 | #include "simulationmodecombobox.h"
 2 | 
 3 | ///
 4 | /// \brief SimulationComboBox::SimulationComboBox
 5 | /// \param parent
 6 | ///
 7 | SimulationModeComboBox::SimulationModeComboBox(QWidget *parent)
 8 |     : QComboBox(parent)
 9 | {
10 |     connect(this, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &SimulationModeComboBox::on_currentIndexChanged);
11 | }
12 | 
13 | ///
14 | /// \brief SimulationModeComboBox::currentSimulationMode
15 | /// \return
16 | ///
17 | SimulationMode SimulationModeComboBox::currentSimulationMode() const
18 | {
19 |     return currentData().value<SimulationMode>();
20 | }
21 | 
22 | ///
23 | /// \brief SimulationModeComboBox::setCurrentSimulationMode
24 | /// \param mode
25 | ///
26 | void SimulationModeComboBox::setCurrentSimulationMode(SimulationMode mode)
27 | {
28 |     const auto idx = findData(QVariant::fromValue(mode));
29 |     setCurrentIndex(idx);
30 | }
31 | 
32 | ///
33 | /// \brief SimulationModeComboBox::setup
34 | /// \param type
35 | ///
36 | void SimulationModeComboBox::setup(QModbusDataUnit::RegisterType type)
37 | {
38 |     switch(type)
39 |     {
40 |         case QModbusDataUnit::Coils:
41 |         case QModbusDataUnit::DiscreteInputs:
42 |             addItem(tr("Random"), QVariant::fromValue(SimulationMode::Random));
43 |             addItem(tr("Toggle"), QVariant::fromValue(SimulationMode::Toggle));
44 |         break;
45 | 
46 |         case QModbusDataUnit::HoldingRegisters:
47 |         case QModbusDataUnit::InputRegisters:
48 |             addItem(tr("Random"), QVariant::fromValue(SimulationMode::Random));
49 |             addItem(tr("Increment"), QVariant::fromValue(SimulationMode::Increment));
50 |             addItem(tr("Decrement"), QVariant::fromValue(SimulationMode::Decrement));
51 |         break;
52 | 
53 |         default:
54 |         break;
55 |     }
56 | }
57 | 
58 | ///
59 | /// \brief SimulationModeComboBox::on_currentIndexChanged
60 | /// \param index
61 | ///
62 | void SimulationModeComboBox::on_currentIndexChanged(int index)
63 | {
64 |     emit simulationModeChanged(itemData(index).value<SimulationMode>());
65 | }
66 | 


--------------------------------------------------------------------------------
/omodsim/controls/simulationmodecombobox.h:
--------------------------------------------------------------------------------
 1 | #ifndef SIMULATIONMODECOMBOBOX_H
 2 | #define SIMULATIONMODECOMBOBOX_H
 3 | 
 4 | #include <QComboBox>
 5 | #include <QModbusDataUnit>
 6 | #include "enums.h"
 7 | 
 8 | class SimulationModeComboBox : public QComboBox
 9 | {
10 |     Q_OBJECT
11 | public:
12 |     explicit SimulationModeComboBox(QWidget *parent = nullptr);
13 | 
14 |     SimulationMode currentSimulationMode() const;
15 |     void setCurrentSimulationMode(SimulationMode mode);
16 | 
17 |     void setup(QModbusDataUnit::RegisterType type);
18 | 
19 | signals:
20 |     void simulationModeChanged(SimulationMode value);
21 | 
22 | private slots:
23 |     void on_currentIndexChanged(int);
24 | };
25 | 
26 | #endif // SIMULATIONMODECOMBOBOX_H
27 | 


--------------------------------------------------------------------------------
/omodsim/datasimulator.h:
--------------------------------------------------------------------------------
 1 | #ifndef DATASIMULATOR_H
 2 | #define DATASIMULATOR_H
 3 | 
 4 | #include <QTimer>
 5 | #include <QModbusDataUnit>
 6 | #include "modbussimulationparams.h"
 7 | 
 8 | typedef QMap<QPair<QModbusDataUnit::RegisterType, quint16>, ModbusSimulationParams> ModbusSimulationMap;
 9 | 
10 | ///
11 | /// \brief The DataSimulator class
12 | ///
13 | class DataSimulator : public QObject
14 | {
15 |     Q_OBJECT
16 | public:
17 |     explicit DataSimulator(QObject* parent = nullptr);
18 |     ~DataSimulator() override;
19 | 
20 |     void startSimulation(DataDisplayMode mode, QModbusDataUnit::RegisterType type, quint16 addr, const ModbusSimulationParams& params);
21 |     void stopSimulation(QModbusDataUnit::RegisterType type, quint16 addr);
22 |     void stopSimulations();
23 | 
24 |     void pauseSimulations();
25 |     void resumeSimulations();
26 |     void restartSimulations();
27 | 
28 |     ModbusSimulationParams simulationParams(QModbusDataUnit::RegisterType type, quint16 addr) const;
29 |     ModbusSimulationMap simulationMap() const;
30 | 
31 | signals:
32 |     void simulationStarted(QModbusDataUnit::RegisterType type, quint16 addr);
33 |     void simulationStopped(QModbusDataUnit::RegisterType type, quint16 addr);
34 |     void dataSimulated(DataDisplayMode mode, QModbusDataUnit::RegisterType type, quint16 addr, QVariant value);
35 | 
36 | private slots:
37 |     void on_timeout();
38 | 
39 | private:
40 |     void randomSimulation(DataDisplayMode mode, QModbusDataUnit::RegisterType type, quint16 addr, const RandomSimulationParams& params);
41 |     void incrementSimulation(DataDisplayMode mode, QModbusDataUnit::RegisterType type, quint16 addr, const IncrementSimulationParams& params);
42 |     void decrementSimailation(DataDisplayMode mode, QModbusDataUnit::RegisterType type, quint16 addr, const DecrementSimulationParams& params);
43 |     void toggleSimulation(QModbusDataUnit::RegisterType type, quint16 addr);
44 | 
45 | private:
46 |     QTimer _timer;
47 |     quint32 _elapsed;
48 |     const int _interval = 1000;
49 | 
50 |     struct SimulationParams {
51 |         DataDisplayMode Mode;
52 |         ModbusSimulationParams Params;
53 |         QVariant CurrentValue;
54 |     };
55 |     QMap<QPair<QModbusDataUnit::RegisterType, quint16>, SimulationParams> _simulationMap;
56 | };
57 | 
58 | #endif // DATASIMULATOR_H
59 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogabout.cpp:
--------------------------------------------------------------------------------
 1 | #include <QFile>
 2 | #include <QApplication>
 3 | #include <QPlainTextEdit>
 4 | #include "dialogabout.h"
 5 | #include "ui_dialogabout.h"
 6 | 
 7 | ///
 8 | /// \brief DialogAbout::DialogAbout
 9 | /// \param parent
10 | ///
11 | DialogAbout::DialogAbout(QWidget *parent) :
12 |     QFixedSizeDialog(parent),
13 |     ui(new Ui::DialogAbout)
14 | {
15 |     ui->setupUi(this);
16 |     setWindowTitle(QString(tr("About %1...")).arg(APP_NAME));
17 |     ui->labelName->setText(APP_NAME);
18 |     ui->labelVersion->setText(QString(tr("Version: %1")).arg(APP_VERSION));
19 |     ui->labelQtFramework->setText(QString(tr("• Qt %1 (build with version %2)")).arg(qVersion(), QT_VERSION_STR));
20 |     ui->labelFont->setText(tr("• Fira Code 6.2 Font"));
21 |     ui->tabWidget->setCurrentIndex(0);
22 | }
23 | 
24 | ///
25 | /// \brief DialogAbout::~DialogAbout
26 | ///
27 | DialogAbout::~DialogAbout()
28 | {
29 |     delete ui;
30 | }
31 | 
32 | ///
33 | /// \brief DialogAbout::on_labelLicense_clicked
34 | ///
35 | void DialogAbout::on_labelLicense_clicked()
36 | {
37 |     QString license;
38 |     QFile f(":/res/license.txt");
39 |     if(f.open(QFile::ReadOnly))
40 |         license = f.readAll();
41 | 
42 |     if(license.isEmpty())
43 |         return;
44 | 
45 |     auto dlg = new QDialog(this);
46 |     dlg->setAttribute(Qt::WA_DeleteOnClose, true);
47 |     dlg->setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint);
48 |     dlg->setWindowTitle(QString(tr("License Agreement - %1")).arg(APP_NAME));
49 |     dlg->resize({ 530, 415});
50 | 
51 |     auto buttonBox = new QDialogButtonBox(dlg);
52 |     buttonBox->setOrientation(Qt::Horizontal);
53 |     buttonBox->setStandardButtons(QDialogButtonBox::Close);
54 |     QObject::connect(buttonBox, SIGNAL(rejected()), dlg, SLOT(reject()));
55 | 
56 |     auto textEdit = new QPlainTextEdit(dlg);
57 |     textEdit->setReadOnly(true);
58 |     textEdit->setPlainText(license);
59 | 
60 |     auto layout = new QVBoxLayout(dlg);
61 |     layout->addWidget(textEdit);
62 |     layout->addWidget(buttonBox);
63 | 
64 |     dlg->setLayout(layout);
65 |     dlg->show();
66 | }
67 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogabout.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGABOUT_H
 2 | #define DIALOGABOUT_H
 3 | 
 4 | #include "qfixedsizedialog.h"
 5 | 
 6 | namespace Ui {
 7 | class DialogAbout;
 8 | }
 9 | 
10 | class DialogAbout : public QFixedSizeDialog
11 | {
12 |     Q_OBJECT
13 | 
14 | public:
15 |     explicit DialogAbout(QWidget *parent = nullptr);
16 |     ~DialogAbout();
17 | 
18 | private slots:
19 |     void on_labelLicense_clicked();
20 | 
21 | private:
22 |     Ui::DialogAbout *ui;
23 | };
24 | 
25 | #endif // DIALOGABOUT_H
26 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogautosimulation.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGAUTOSIMULATION_H
 2 | #define DIALOGAUTOSIMULATION_H
 3 | 
 4 | #include "qfixedsizedialog.h"
 5 | #include "modbussimulationparams.h"
 6 | 
 7 | namespace Ui {
 8 | class DialogAutoSimulation;
 9 | }
10 | 
11 | class DialogAutoSimulation : public QFixedSizeDialog
12 | {
13 |     Q_OBJECT
14 | 
15 | public:
16 |     explicit DialogAutoSimulation(DataDisplayMode mode, ModbusSimulationParams& params, QWidget *parent = nullptr);
17 |     ~DialogAutoSimulation();
18 | 
19 |     void accept() override;
20 | 
21 | private slots:
22 |     void on_checkBoxEnabled_toggled();
23 |     void on_comboBoxSimulationType_currentIndexChanged(int);
24 |     void on_lineEditLowLimit_valueChanged(const QVariant&);
25 |     void on_lineEditHighLimit_valueChanged(const QVariant&);
26 | 
27 | private:
28 |     void updateLimits();
29 | 
30 | private:
31 |     Ui::DialogAutoSimulation *ui;
32 | 
33 | private:
34 |     ModbusSimulationParams& _params;
35 |     DataDisplayMode _displayMode;
36 | };
37 | 
38 | #endif // DIALOGAUTOSIMULATION_H
39 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogcoilsimulation.cpp:
--------------------------------------------------------------------------------
 1 | #include <QPushButton>
 2 | #include "dialogcoilsimulation.h"
 3 | #include "ui_dialogcoilsimulation.h"
 4 | 
 5 | ///
 6 | /// \brief DialogCoilSimulation::DialogCoilSimulation
 7 | /// \param params
 8 | /// \param parent
 9 | ///
10 | DialogCoilSimulation::DialogCoilSimulation(ModbusSimulationParams& params, QWidget *parent)
11 |     : QFixedSizeDialog(parent)
12 |     , ui(new Ui::DialogCoilSimulation)
13 |     ,_params(params)
14 | {
15 |     ui->setupUi(this);
16 |     ui->checkBoxEnabled->setChecked(_params.Mode != SimulationMode::No);
17 |     ui->comboBoxSimulationType->setup(QModbusDataUnit::Coils);
18 | 
19 |     if(_params.Mode != SimulationMode::No)
20 |         ui->comboBoxSimulationType->setCurrentSimulationMode(_params.Mode);
21 |     else
22 |         ui->comboBoxSimulationType->setCurrentIndex(0);
23 | 
24 |     ui->lineEditInterval->setInputRange(1, 60000);
25 |     ui->lineEditInterval->setValue(_params.Interval);
26 |     on_checkBoxEnabled_toggled();
27 | }
28 | 
29 | ///
30 | /// \brief DialogCoilSimulation::~DialogCoilSimulation
31 | ///
32 | DialogCoilSimulation::~DialogCoilSimulation()
33 | {
34 |     delete ui;
35 | }
36 | 
37 | ///
38 | /// \brief DialogCoilSimulation::accept
39 | ///
40 | void DialogCoilSimulation::accept()
41 | {
42 |     if(ui->checkBoxEnabled->isChecked())
43 |     {
44 |         _params.Mode = ui->comboBoxSimulationType->currentSimulationMode();
45 |         _params.Interval = ui->lineEditInterval->value<int>();
46 | 
47 |         if(_params.Mode == SimulationMode::Random)
48 |             _params.RandomParams.Range = QRange<double>(0, 1);
49 |     }
50 |     else
51 |     {
52 |         _params.Mode = SimulationMode::No;
53 |     }
54 |     QFixedSizeDialog::accept();
55 | }
56 | 
57 | ///
58 | /// \brief DialogCoilSimulation::on_checkBoxEnabled_toggled
59 | ///
60 | void DialogCoilSimulation::on_checkBoxEnabled_toggled()
61 | {
62 |     const bool enabled = ui->checkBoxEnabled->isChecked();
63 |     ui->labelSimulationType->setEnabled(enabled);
64 |     ui->comboBoxSimulationType->setEnabled(enabled);
65 |     ui->labelInterval->setEnabled(enabled);
66 |     ui->lineEditInterval->setEnabled(enabled);
67 | }
68 | 
69 | ///
70 | /// \brief DialogCoilSimulation::on_comboBoxSimulationType_currentIndexChanged
71 | /// \param idx
72 | ///
73 | void DialogCoilSimulation::on_comboBoxSimulationType_currentIndexChanged(int idx)
74 | {
75 |     ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(idx != -1);
76 | }
77 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogcoilsimulation.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGCOILSIMULATION_H
 2 | #define DIALOGCOILSIMULATION_H
 3 | 
 4 | #include "qfixedsizedialog.h"
 5 | #include "modbussimulationparams.h"
 6 | 
 7 | namespace Ui {
 8 | class DialogCoilSimulation;
 9 | }
10 | 
11 | class DialogCoilSimulation : public QFixedSizeDialog
12 | {
13 |     Q_OBJECT
14 | 
15 | public:
16 |     explicit DialogCoilSimulation(ModbusSimulationParams& params, QWidget *parent = nullptr);
17 |     ~DialogCoilSimulation();
18 | 
19 |     void accept() override;
20 | 
21 | private slots:
22 |     void on_checkBoxEnabled_toggled();
23 |     void on_comboBoxSimulationType_currentIndexChanged(int);
24 | 
25 | private:
26 |     Ui::DialogCoilSimulation *ui;
27 | 
28 | private:
29 |     ModbusSimulationParams& _params;
30 | };
31 | 
32 | #endif // DIALOGCOILSIMULATION_H
33 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogdisplaydefinition.cpp:
--------------------------------------------------------------------------------
 1 | #include "modbuslimits.h"
 2 | #include "displaydefinition.h"
 3 | #include "dialogdisplaydefinition.h"
 4 | #include "ui_dialogdisplaydefinition.h"
 5 | 
 6 | ///
 7 | /// \brief DialogDisplayDefinition::DialogDisplayDefinition
 8 | /// \param dd
 9 | /// \param parent
10 | ///
11 | DialogDisplayDefinition::DialogDisplayDefinition(DisplayDefinition dd, QWidget* parent)
12 |     : QFixedSizeDialog(parent)
13 |     ,_displayDefinition(dd)
14 |     , ui(new Ui::DialogDisplayDefinition)
15 | {
16 |     ui->setupUi(this);
17 |     ui->lineEditPointAddress->setInputRange(ModbusLimits::addressRange(dd.ZeroBasedAddress));
18 |     ui->lineEditLength->setInputRange(ModbusLimits::lengthRange());
19 |     ui->lineEditSlaveAddress->setInputRange(ModbusLimits::slaveRange());
20 |     ui->lineEditLogLimit->setInputRange(4, 1000);
21 | 
22 |     ui->comboBoxAddressBase->setCurrentIndex(dd.ZeroBasedAddress ? 0 : 1);
23 |     ui->lineEditPointAddress->setValue(dd.PointAddress);
24 |     ui->lineEditSlaveAddress->setValue(dd.DeviceId);
25 |     ui->lineEditLength->setValue(dd.Length);
26 |     ui->lineEditLogLimit->setValue(dd.LogViewLimit);
27 |     ui->comboBoxPointType->setCurrentPointType(dd.PointType);
28 | 
29 |     ui->buttonBox->setFocus();
30 | }
31 | 
32 | ///
33 | /// \brief DialogDisplayDefinition::~DialogDisplayDefinition
34 | ///
35 | DialogDisplayDefinition::~DialogDisplayDefinition()
36 | {
37 |     delete ui;
38 | }
39 | 
40 | ///
41 | /// \brief DialogDisplayDefinition::accept
42 | ///
43 | void DialogDisplayDefinition::accept()
44 | {
45 |     _displayDefinition.DeviceId = ui->lineEditSlaveAddress->value<int>();
46 |     _displayDefinition.PointAddress = ui->lineEditPointAddress->value<int>();
47 |     _displayDefinition.PointType = ui->comboBoxPointType->currentPointType();
48 |     _displayDefinition.Length = ui->lineEditLength->value<int>();
49 |     _displayDefinition.LogViewLimit = ui->lineEditLogLimit->value<int>();
50 |     _displayDefinition.ZeroBasedAddress = (ui->comboBoxAddressBase->currentAddressBase() == AddressBase::Base0);
51 | 
52 |     QFixedSizeDialog::accept();
53 | }
54 | 
55 | 
56 | ///
57 | /// \brief DialogDisplayDefinition::on_comboBoxAddressBase_currentIndexChanged
58 | /// \param index
59 | ///
60 | void DialogDisplayDefinition::on_comboBoxAddressBase_addressBaseChanged(AddressBase base)
61 | {
62 |     const auto addr = ui->lineEditPointAddress->value<int>();
63 | 
64 |     ui->lineEditPointAddress->setInputRange(ModbusLimits::addressRange(base == AddressBase::Base0));
65 |     ui->lineEditPointAddress->setValue(base == AddressBase::Base1 ? qMax(1, addr + 1) : qMax(0, addr - 1));
66 | }
67 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogdisplaydefinition.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGDISPLAYDEFINITION_H
 2 | #define DIALOGDISPLAYDEFINITION_H
 3 | 
 4 | #include "enums.h"
 5 | #include "qfixedsizedialog.h"
 6 | #include "displaydefinition.h"
 7 | 
 8 | namespace Ui {
 9 | class DialogDisplayDefinition;
10 | }
11 | 
12 | ///
13 | /// \brief The DialogDisplayDefinition class
14 | ///
15 | class DialogDisplayDefinition : public QFixedSizeDialog
16 | {
17 |     Q_OBJECT
18 | 
19 | public:
20 |     explicit DialogDisplayDefinition(DisplayDefinition dd, QWidget* parent);
21 |     ~DialogDisplayDefinition();
22 | 
23 |     DisplayDefinition displayDefinition() const {
24 |         return _displayDefinition;
25 |     }
26 | 
27 |     void accept() override;
28 | 
29 | private slots:
30 |     void on_comboBoxAddressBase_addressBaseChanged(AddressBase base);
31 | 
32 | private:
33 |     DisplayDefinition _displayDefinition;
34 |     Ui::DialogDisplayDefinition *ui;
35 | };
36 | 
37 | #endif // DIALOGDISPLAYDEFINITION_H
38 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogforcemultiplecoils.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGFORCEMULTIPLECOILS_H
 2 | #define DIALOGFORCEMULTIPLECOILS_H
 3 | 
 4 | #include <QDialog>
 5 | #include <QTableWidgetItem>
 6 | #include <QModbusDataUnit>
 7 | #include "modbuswriteparams.h"
 8 | 
 9 | namespace Ui {
10 | class DialogForceMultipleCoils;
11 | }
12 | 
13 | class DialogForceMultipleCoils : public QDialog
14 | {
15 |     Q_OBJECT
16 | 
17 | public:
18 |     explicit DialogForceMultipleCoils(ModbusWriteParams& params, QModbusDataUnit::RegisterType type, int length, QWidget *parent = nullptr);
19 |     ~DialogForceMultipleCoils();
20 | 
21 |     void accept() override;
22 | 
23 | private slots:
24 |     void on_pushButton0_clicked();
25 |     void on_pushButton1_clicked();
26 |     void on_tableWidget_itemDoubleClicked(QTableWidgetItem *item);
27 | 
28 | private:
29 |     void updateTableWidget();
30 | 
31 | private:
32 |     Ui::DialogForceMultipleCoils *ui;
33 |     QVector<quint16> _data;
34 |     ModbusWriteParams& _writeParams;
35 |     QModbusDataUnit::RegisterType _type;
36 | };
37 | 
38 | #endif // DIALOGFORCEMULTIPLECOILS_H
39 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogforcemultipleregisters.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGFORCEMULTIPLEREGISTERS_H
 2 | #define DIALOGFORCEMULTIPLEREGISTERS_H
 3 | 
 4 | #include <QDialog>
 5 | #include <QTableWidgetItem>
 6 | #include <QModbusDataUnit>
 7 | #include "numericlineedit.h"
 8 | #include "modbuswriteparams.h"
 9 | 
10 | namespace Ui {
11 | class DialogForceMultipleRegisters;
12 | }
13 | 
14 | ///
15 | /// \brief The DialogForceMultipleRegisters class
16 | ///
17 | class DialogForceMultipleRegisters : public QDialog
18 | {
19 |     Q_OBJECT
20 | 
21 | public:
22 |     explicit DialogForceMultipleRegisters(ModbusWriteParams& params, QModbusDataUnit::RegisterType type, int length, QWidget *parent = nullptr);
23 |     ~DialogForceMultipleRegisters();
24 | 
25 |     void accept() override;
26 | 
27 | private slots:
28 |     void on_pushButton0_clicked();
29 |     void on_pushButtonRandom_clicked();
30 | 
31 | private:
32 |     void updateTableWidget();
33 |     QLineEdit* createLineEdit();
34 |     NumericLineEdit* createNumEdit(int idx);
35 | 
36 | private:
37 |     Ui::DialogForceMultipleRegisters *ui;
38 |     QVector<quint16> _data;
39 |     ModbusWriteParams& _writeParams;
40 |     QModbusDataUnit::RegisterType _type;
41 |     bool _hexView = false;
42 | };
43 | 
44 | #endif // DIALOGFORCEMULTIPLEREGISTERS_H
45 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogmsgparser.cpp:
--------------------------------------------------------------------------------
  1 | #include <QPushButton>
  2 | #include <QAbstractEventDispatcher>
  3 | #include "dialogmsgparser.h"
  4 | #include "ui_dialogmsgparser.h"
  5 | 
  6 | ///
  7 | /// \brief DialogMsgParser::DialogMsgParser
  8 | /// \param mode
  9 | /// \param protocol
 10 | /// \param parent
 11 | ///
 12 | DialogMsgParser::DialogMsgParser(DataDisplayMode mode, ModbusMessage::ProtocolType protocol, QWidget *parent)
 13 |     : QDialog(parent)
 14 |     , ui(new Ui::DialogMsgParser)
 15 |     ,_mm(nullptr)
 16 | {
 17 |     ui->setupUi(this);
 18 | 
 19 |     setWindowFlags(Qt::Dialog |
 20 |                    Qt::CustomizeWindowHint |
 21 |                    Qt::WindowTitleHint);
 22 | 
 23 |     ui->info->setShowTimestamp(false);
 24 |     ui->hexView->setCheckState(mode == DataDisplayMode::Hex ? Qt::Checked : Qt::Unchecked);
 25 |     ui->buttonRtu->setChecked(protocol == ModbusMessage::Rtu);
 26 |     ui->buttonTcp->setChecked(protocol == ModbusMessage::Tcp);
 27 | 
 28 |     auto dispatcher = QAbstractEventDispatcher::instance();
 29 |     connect(dispatcher, &QAbstractEventDispatcher::awake, this, &DialogMsgParser::on_awake);
 30 | }
 31 | 
 32 | ///
 33 | /// \brief DialogMsgParser::~DialogMsgParser
 34 | ///
 35 | DialogMsgParser::~DialogMsgParser()
 36 | {
 37 |     delete ui;
 38 |     if(_mm) delete _mm;
 39 | }
 40 | 
 41 | ///
 42 | /// \brief DialogMsgParser::changeEvent
 43 | /// \param event
 44 | ///
 45 | void DialogMsgParser::changeEvent(QEvent* event)
 46 | {
 47 |     if (event->type() == QEvent::LanguageChange)
 48 |     {
 49 |         ui->retranslateUi(this);
 50 |     }
 51 | 
 52 |     QDialog::changeEvent(event);
 53 | }
 54 | 
 55 | ///
 56 | /// \brief DialogMsgParser::on_awake
 57 | ///
 58 | void DialogMsgParser::on_awake()
 59 | {
 60 |     ui->pushButtonParse->setEnabled(!ui->bytesData->isEmpty());
 61 | }
 62 | 
 63 | ///
 64 | /// \brief DialogMsgParser::on_hexView_toggled
 65 | /// \param checked
 66 | ///
 67 | void DialogMsgParser::on_hexView_toggled(bool checked)
 68 | {
 69 |     ui->bytesData->setInputMode(checked ? ByteListTextEdit::HexMode : ByteListTextEdit::DecMode);
 70 |     ui->info->setDataDisplayMode(checked ? DataDisplayMode::Hex : DataDisplayMode::Decimal);
 71 | }
 72 | 
 73 | ///
 74 | /// \brief DialogMsgParser::on_bytesData_valueChanged
 75 | /// \param value
 76 | ///
 77 | void DialogMsgParser::on_bytesData_valueChanged(const QByteArray& value)
 78 | {
 79 |     if(value.size() < 3)
 80 |     {
 81 |         if(value.isEmpty())
 82 |             ui->info->clear();
 83 | 
 84 |         return;
 85 |     }
 86 | }
 87 | 
 88 | ///
 89 | /// \brief DialogMsgParser::on_pushButtonParse_clicked
 90 | ///
 91 | void DialogMsgParser::on_pushButtonParse_clicked()
 92 | {
 93 |     auto data = ui->bytesData->value();
 94 |     if(data.isEmpty()) return;
 95 | 
 96 |     auto protocol = ModbusMessage::Rtu;
 97 |     if(ui->buttonTcp->isChecked())
 98 |         protocol = ModbusMessage::Tcp;
 99 | 
100 |     if(_mm) delete _mm;
101 |     _mm = ModbusMessage::create(data, protocol, QDateTime::currentDateTime(), ui->request->isChecked());
102 |     ui->info->setModbusMessage(_mm);
103 | }
104 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogmsgparser.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGMSGPARSER_H
 2 | #define DIALOGMSGPARSER_H
 3 | 
 4 | #include <QDialog>
 5 | #include "enums.h"
 6 | #include "modbusmessage.h"
 7 | 
 8 | namespace Ui {
 9 | class DialogMsgParser;
10 | }
11 | 
12 | ///
13 | /// \brief The DialogMsgParser class
14 | ///
15 | class DialogMsgParser : public QDialog
16 | {
17 |     Q_OBJECT
18 | 
19 | public:
20 |     explicit DialogMsgParser(DataDisplayMode mode, ModbusMessage::ProtocolType protocol, QWidget *parent = nullptr);
21 |     ~DialogMsgParser();
22 | 
23 | protected:
24 |     void changeEvent(QEvent* event) override;
25 | 
26 | private slots:
27 |     void on_awake();
28 |     void on_hexView_toggled(bool);
29 |     void on_bytesData_valueChanged(const QByteArray& value);
30 |     void on_pushButtonParse_clicked();
31 | 
32 | private:
33 |     Ui::DialogMsgParser *ui;
34 |     const ModbusMessage* _mm;
35 | };
36 | 
37 | #endif // DIALOGMSGPARSER_H
38 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogprintsettings.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGPRINTSETTINGS_H
 2 | #define DIALOGPRINTSETTINGS_H
 3 | 
 4 | #include <QPrinter>
 5 | #include "qfixedsizedialog.h"
 6 | 
 7 | 
 8 | namespace Ui {
 9 | class DialogPrintSettings;
10 | }
11 | 
12 | struct PapeSource
13 | {
14 |     QString Name;
15 |     QPrinter::PaperSource Source;
16 | };
17 | 
18 | ///
19 | /// \brief The DialogPrintSettings class
20 | ///
21 | class DialogPrintSettings : public QFixedSizeDialog
22 |  {
23 |     Q_OBJECT
24 | 
25 | public:
26 |     explicit DialogPrintSettings(QPrinter* printer, QWidget *parent = nullptr);
27 |     ~DialogPrintSettings() override;
28 | 
29 |     void accept() override;
30 | 
31 | private slots:
32 |     void on_comboBoxPrinters_currentIndexChanged(int index);
33 |     void orientationChanged();
34 | 
35 | private:
36 |     QList<PapeSource> supportedPaperSources(const QPrinter* printer);
37 | 
38 | private:
39 |     Ui::DialogPrintSettings *ui;    
40 |     QPrinter* _printer;
41 | };
42 | 
43 | #endif // DIALOGPRINTSETTINGS_H
44 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogscriptsettings.cpp:
--------------------------------------------------------------------------------
 1 | #include "dialogscriptsettings.h"
 2 | #include "ui_dialogscriptsettings.h"
 3 | 
 4 | ///
 5 | /// \brief DialogScriptSettings::DialogScriptSettings
 6 | /// \param ss
 7 | /// \param parent
 8 | ///
 9 | DialogScriptSettings::DialogScriptSettings(ScriptSettings& ss, QWidget *parent)
10 |     : QFixedSizeDialog(parent)
11 |     , ui(new Ui::DialogScriptSettings)
12 |     ,_scriptSettings(ss)
13 | {
14 |     ui->setupUi(this);
15 |     ui->lineEditInterval->setInputRange(500, 10000);
16 |     ui->lineEditInterval->setValue(ss.Interval);
17 |     ui->comboBoxRunMode->setCurrentRunMode(ss.Mode);
18 |     ui->checkBoxAutoComplete->setChecked(ss.UseAutoComplete);
19 | }
20 | 
21 | ///
22 | /// \brief DialogScriptSettings::~DialogScriptSettings
23 | ///
24 | DialogScriptSettings::~DialogScriptSettings()
25 | {
26 |     delete ui;
27 | }
28 | 
29 | ///
30 | /// \brief DialogScriptSettings::accept
31 | ///
32 | void DialogScriptSettings::accept()
33 | {
34 |     _scriptSettings.Mode = ui->comboBoxRunMode->currentRunMode();
35 |     _scriptSettings.Interval = ui->lineEditInterval->value<int>();
36 |     _scriptSettings.UseAutoComplete = ui->checkBoxAutoComplete->isChecked();
37 | 
38 |     QFixedSizeDialog::accept();
39 | }
40 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogscriptsettings.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGSCRIPTSETTINGS_H
 2 | #define DIALOGSCRIPTSETTINGS_H
 3 | 
 4 | #include "scriptsettings.h"
 5 | #include "qfixedsizedialog.h"
 6 | 
 7 | 
 8 | namespace Ui {
 9 | class DialogScriptSettings;
10 | }
11 | 
12 | class DialogScriptSettings : public QFixedSizeDialog
13 | {
14 |     Q_OBJECT
15 | 
16 | public:
17 |     explicit DialogScriptSettings(ScriptSettings& ss, QWidget *parent = nullptr);
18 |     ~DialogScriptSettings();
19 | 
20 |     void accept() override;
21 | 
22 | private:
23 |     Ui::DialogScriptSettings *ui;
24 |     ScriptSettings& _scriptSettings;
25 | };
26 | 
27 | #endif // DIALOGSCRIPTSETTINGS_H
28 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogselectserviceport.cpp:
--------------------------------------------------------------------------------
 1 | #include <QNetworkInterface>
 2 | #include "dialogselectserviceport.h"
 3 | #include "ui_dialogselectserviceport.h"
 4 | 
 5 | ///
 6 | /// \brief DialogSelectServicePort::DialogSelectServicePort
 7 | /// \param port
 8 | /// \param parent
 9 | ///
10 | DialogSelectServicePort::DialogSelectServicePort(TcpConnectionParams& params, QWidget *parent)
11 |     : QFixedSizeDialog(parent)
12 |     , ui(new Ui::DialogSelectServicePort)
13 |     ,_params(params)
14 | {
15 |     ui->setupUi(this);
16 |     ui->lineEditPort->setInputRange(0, 65535);
17 |     ui->lineEditPort->setValue(params.ServicePort);
18 | 
19 |     ui->comboBoxIp->addItem("0.0.0.0");
20 |     for(auto&& nic : QNetworkInterface::allInterfaces())
21 |     {
22 |         if(!(nic.flags() & QNetworkInterface::IsRunning))
23 |         {
24 |             continue;
25 |         }
26 | 
27 |         for(auto&& entry : nic.addressEntries())
28 |         {
29 |             const auto addr = entry.ip();
30 | 
31 |             if(addr.isNull() || addr.isMulticast() || addr.protocol() != QAbstractSocket::IPv4Protocol)
32 |             {
33 |                 continue;
34 |             }
35 | 
36 |             ui->comboBoxIp->addItem(addr.toString());
37 |         }
38 |     }
39 | 
40 |     ui->comboBoxIp->setCurrentText(_params.IPAddress);
41 | }
42 | 
43 | ///
44 | /// \brief DialogSelectServicePort::~DialogSelectServicePort
45 | ///
46 | DialogSelectServicePort::~DialogSelectServicePort()
47 | {
48 |     delete ui;
49 | }
50 | 
51 | ///
52 | /// \brief DialogSelectServicePort::accept
53 | ///
54 | void DialogSelectServicePort::accept()
55 | {
56 |     _params.ServicePort = ui->lineEditPort->value<int>();
57 |     _params.IPAddress = ui->comboBoxIp->currentText();
58 |     QFixedSizeDialog::accept();
59 | }
60 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogselectserviceport.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGSELECTSERVICEPORT_H
 2 | #define DIALOGSELECTSERVICEPORT_H
 3 | 
 4 | #include "qfixedsizedialog.h"
 5 | #include "connectiondetails.h"
 6 | 
 7 | namespace Ui {
 8 | class DialogSelectServicePort;
 9 | }
10 | 
11 | class DialogSelectServicePort : public QFixedSizeDialog
12 | {
13 |     Q_OBJECT
14 | 
15 | public:
16 |     explicit DialogSelectServicePort(TcpConnectionParams& params, QWidget *parent = nullptr);
17 |     ~DialogSelectServicePort();
18 | 
19 |     void accept() override;
20 | 
21 | private:
22 |     Ui::DialogSelectServicePort *ui;
23 |     TcpConnectionParams& _params;
24 | };
25 | 
26 | #endif // DIALOGSELECTSERVICEPORT_H
27 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogselectserviceport.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>DialogSelectServicePort</class>
  4 |  <widget class="QDialog" name="DialogSelectServicePort">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>328</width>
 10 |     <height>116</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>Select Service IP Address and Port</string>
 15 |   </property>
 16 |   <layout class="QVBoxLayout" name="verticalLayout">
 17 |    <item>
 18 |     <layout class="QFormLayout" name="formLayout">
 19 |      <property name="labelAlignment">
 20 |       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
 21 |      </property>
 22 |      <item row="1" column="1">
 23 |       <widget class="NumericLineEdit" name="lineEditPort">
 24 |        <property name="sizePolicy">
 25 |         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
 26 |          <horstretch>0</horstretch>
 27 |          <verstretch>0</verstretch>
 28 |         </sizepolicy>
 29 |        </property>
 30 |        <property name="maximumSize">
 31 |         <size>
 32 |          <width>60</width>
 33 |          <height>16777215</height>
 34 |         </size>
 35 |        </property>
 36 |        <property name="text">
 37 |         <string>502</string>
 38 |        </property>
 39 |       </widget>
 40 |      </item>
 41 |      <item row="1" column="0">
 42 |       <widget class="QLabel" name="label">
 43 |        <property name="text">
 44 |         <string>Modbus/TCP Service Port</string>
 45 |        </property>
 46 |        <property name="alignment">
 47 |         <set>Qt::AlignCenter</set>
 48 |        </property>
 49 |       </widget>
 50 |      </item>
 51 |      <item row="0" column="1">
 52 |       <widget class="QComboBox" name="comboBoxIp"/>
 53 |      </item>
 54 |      <item row="0" column="0">
 55 |       <widget class="QLabel" name="label_2">
 56 |        <property name="text">
 57 |         <string>Service IP Address</string>
 58 |        </property>
 59 |       </widget>
 60 |      </item>
 61 |     </layout>
 62 |    </item>
 63 |    <item>
 64 |     <widget class="QDialogButtonBox" name="buttonBox">
 65 |      <property name="orientation">
 66 |       <enum>Qt::Horizontal</enum>
 67 |      </property>
 68 |      <property name="standardButtons">
 69 |       <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
 70 |      </property>
 71 |      <property name="centerButtons">
 72 |       <bool>true</bool>
 73 |      </property>
 74 |     </widget>
 75 |    </item>
 76 |   </layout>
 77 |  </widget>
 78 |  <customwidgets>
 79 |   <customwidget>
 80 |    <class>NumericLineEdit</class>
 81 |    <extends>QLineEdit</extends>
 82 |    <header>numericlineedit.h</header>
 83 |   </customwidget>
 84 |  </customwidgets>
 85 |  <resources/>
 86 |  <connections>
 87 |   <connection>
 88 |    <sender>buttonBox</sender>
 89 |    <signal>accepted()</signal>
 90 |    <receiver>DialogSelectServicePort</receiver>
 91 |    <slot>accept()</slot>
 92 |    <hints>
 93 |     <hint type="sourcelabel">
 94 |      <x>248</x>
 95 |      <y>254</y>
 96 |     </hint>
 97 |     <hint type="destinationlabel">
 98 |      <x>157</x>
 99 |      <y>274</y>
100 |     </hint>
101 |    </hints>
102 |   </connection>
103 |   <connection>
104 |    <sender>buttonBox</sender>
105 |    <signal>rejected()</signal>
106 |    <receiver>DialogSelectServicePort</receiver>
107 |    <slot>reject()</slot>
108 |    <hints>
109 |     <hint type="sourcelabel">
110 |      <x>316</x>
111 |      <y>260</y>
112 |     </hint>
113 |     <hint type="destinationlabel">
114 |      <x>286</x>
115 |      <y>274</y>
116 |     </hint>
117 |    </hints>
118 |   </connection>
119 |  </connections>
120 | </ui>
121 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogsetuppresetdata.cpp:
--------------------------------------------------------------------------------
 1 | #include "modbuslimits.h"
 2 | #include "dialogsetuppresetdata.h"
 3 | #include "ui_dialogsetuppresetdata.h"
 4 | 
 5 | ///
 6 | /// \brief DialogSetupPresetData::DialogSetupPresetData
 7 | /// \param params
 8 | /// \param pointType
 9 | /// \param parent
10 | ///
11 | DialogSetupPresetData::DialogSetupPresetData(SetupPresetParams& params,  QModbusDataUnit::RegisterType pointType, QWidget *parent) :
12 |      QFixedSizeDialog(parent)
13 |     , ui(new Ui::DialogSetupPresetData)
14 |     ,_params(params)
15 | {
16 |     ui->setupUi(this);
17 |     ui->lineEditAddress->setInputRange(ModbusLimits::addressRange(params.ZeroBasedAddress));
18 |     ui->lineEditNumberOfPoints->setInputRange(ModbusLimits::lengthRange());
19 |     ui->lineEditAddress->setValue(params.PointAddress);
20 |     ui->lineEditNumberOfPoints->setValue(params.Length);
21 | 
22 |     switch(pointType)
23 |     {
24 |         case QModbusDataUnit::Coils:
25 |             setWindowTitle(tr("PRESET COILS"));
26 |         break;
27 |         case QModbusDataUnit::DiscreteInputs:
28 |              setWindowTitle(tr("PRESET DISCRETE INPUTS"));
29 |         break;
30 |         case QModbusDataUnit::InputRegisters:
31 |             setWindowTitle(tr("PRESET INPUT REGISTERS"));
32 |         break;
33 |         case QModbusDataUnit::HoldingRegisters:
34 |             setWindowTitle(tr("PRESET HOLDING REGISTERS"));
35 |         break;
36 |         default:
37 |         break;
38 |     }
39 | 
40 |     ui->buttonBox->setFocus();
41 | }
42 | 
43 | ///
44 | /// \brief DialogSetupPresetData::~DialogSetupPresetData
45 | ///
46 | DialogSetupPresetData::~DialogSetupPresetData()
47 | {
48 |     delete ui;
49 | }
50 | 
51 | 
52 | ///
53 | /// \brief DialogSetupPresetData::accept
54 | ///
55 | void DialogSetupPresetData::accept()
56 | {
57 |     _params.PointAddress = ui->lineEditAddress->value<int>();
58 |     _params.Length = ui->lineEditNumberOfPoints->value<int>();
59 |     QFixedSizeDialog::accept();
60 | }
61 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogsetuppresetdata.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGSETUPPRESETDATA_H
 2 | #define DIALOGSETUPPRESETDATA_H
 3 | 
 4 | #include <QModbusDataUnit>
 5 | #include "qfixedsizedialog.h"
 6 | 
 7 | struct SetupPresetParams
 8 | {
 9 |     quint16 PointAddress;
10 |     quint16 Length;
11 |     bool ZeroBasedAddress;
12 | };
13 | 
14 | namespace Ui {
15 | class DialogSetupPresetData;
16 | }
17 | 
18 | ///
19 | /// \brief The DialogSetupPresetData class
20 | ///
21 | class DialogSetupPresetData : public QFixedSizeDialog
22 | {
23 |     Q_OBJECT
24 | 
25 | public:
26 |     explicit DialogSetupPresetData(SetupPresetParams& params, QModbusDataUnit::RegisterType pointType, QWidget *parent = nullptr);
27 |     ~DialogSetupPresetData();
28 | 
29 |     void accept() override;
30 | 
31 | private:
32 |     Ui::DialogSetupPresetData *ui;
33 |     SetupPresetParams& _params;
34 | };
35 | 
36 | #endif // DIALOGSETUPPRESETDATA_H
37 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogsetupserialport.cpp:
--------------------------------------------------------------------------------
 1 | #include "dialogsetupserialport.h"
 2 | #include "ui_dialogsetupserialport.h"
 3 | 
 4 | ///
 5 | /// \brief DialogSetupSerialPort::DialogSetupSerialPort
 6 | /// \param params
 7 | /// \param parent
 8 | ///
 9 | DialogSetupSerialPort::DialogSetupSerialPort(SerialConnectionParams& params, QWidget *parent)
10 |     : QFixedSizeDialog(parent)
11 |     , ui(new Ui::DialogSetupSerialPort)
12 |     ,_serialParams(params)
13 | {
14 |     ui->setupUi(this);
15 |     ui->comboBoxFlowControl->setCurrentIndex(-1);
16 |     ui->comboBoxBaudRate->setCurrentValue(_serialParams.BaudRate);
17 |     ui->comboBoxWordLength->setCurrentValue(_serialParams.WordLength);
18 |     ui->comboBoxParity->setCurrentParity(_serialParams.Parity);
19 |     ui->comboBoxStopBits->setCurrentValue(_serialParams.StopBits);
20 |     ui->comboBoxFlowControl->setCurrentFlowControl(_serialParams.FlowControl);
21 |     ui->comboBoxDTRControl->setCurrentValue(_serialParams.SetDTR);
22 |     ui->comboBoxRTSControl->setCurrentValue(_serialParams.SetRTS);
23 |     setWindowTitle(QString("%1 %2").arg(windowTitle(), _serialParams.PortName));
24 | }
25 | 
26 | ///
27 | /// \brief DialogSetupSerialPort::~DialogSetupSerialPort
28 | ///
29 | DialogSetupSerialPort::~DialogSetupSerialPort()
30 | {
31 |     delete ui;
32 | }
33 | 
34 | ///
35 | /// \brief DialogSetupSerialPort::accept
36 | ///
37 | void DialogSetupSerialPort::accept()
38 | {
39 |     _serialParams.BaudRate = (QSerialPort::BaudRate)ui->comboBoxBaudRate->currentValue();
40 |     _serialParams.WordLength = (QSerialPort::DataBits)ui->comboBoxWordLength->currentValue();
41 |     _serialParams.Parity = ui->comboBoxParity->currentParity();
42 |     _serialParams.StopBits = (QSerialPort::StopBits)ui->comboBoxStopBits->currentValue();
43 |     _serialParams.FlowControl = ui->comboBoxFlowControl->currentFlowControl();
44 |     _serialParams.SetDTR = ui->comboBoxDTRControl->currentValue();
45 |     _serialParams.SetRTS = ui->comboBoxRTSControl->currentValue();
46 |     QFixedSizeDialog::accept();
47 | }
48 | 
49 | ///
50 | /// \brief DialogConnectionDetails::on_comboBoxFlowControl_currentIndexChanged
51 | ///
52 | void DialogSetupSerialPort::on_comboBoxFlowControl_currentIndexChanged(int)
53 | {
54 |     const auto fc = ui->comboBoxFlowControl->currentFlowControl();
55 |     ui->comboBoxRTSControl->setEnabled(fc != QSerialPort::HardwareControl);
56 | }
57 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogsetupserialport.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGSETUPSERIALPORT_H
 2 | #define DIALOGSETUPSERIALPORT_H
 3 | 
 4 | #include "qfixedsizedialog.h"
 5 | #include "connectiondetails.h"
 6 | 
 7 | namespace Ui {
 8 | class DialogSetupSerialPort;
 9 | }
10 | 
11 | class DialogSetupSerialPort : public QFixedSizeDialog
12 | {
13 |     Q_OBJECT
14 | 
15 | public:
16 |     explicit DialogSetupSerialPort(SerialConnectionParams& params, QWidget *parent = nullptr);
17 |     ~DialogSetupSerialPort();
18 | 
19 |     void accept() override;
20 | 
21 | private slots:
22 |     void on_comboBoxFlowControl_currentIndexChanged(int);
23 | 
24 | private:
25 |     Ui::DialogSetupSerialPort *ui;
26 | 
27 | private:
28 |     SerialConnectionParams& _serialParams;
29 | };
30 | 
31 | #endif // DIALOGSETUPSERIALPORT_H
32 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwindowsmanager.cpp:
--------------------------------------------------------------------------------
  1 | #include <QAction>
  2 | #include <QAbstractEventDispatcher>
  3 | #include "dialogwindowsmanager.h"
  4 | #include "ui_dialogwindowsmanager.h"
  5 | 
  6 | ///
  7 | /// \brief DialogWindowsManager::DialogWindowsManager
  8 | /// \param actions
  9 | /// \param saveAction
 10 | /// \param parent
 11 | ///
 12 | DialogWindowsManager::DialogWindowsManager(const QList<QAction*>& actions, QAction* saveAction, QWidget *parent) :
 13 |       QDialog(parent)
 14 |     , ui(new Ui::DialogWindowsManager)
 15 |     ,_saveAction(saveAction)
 16 |     ,_windowActions(actions)
 17 | {
 18 |     ui->setupUi(this);
 19 | 
 20 |     setWindowFlags(Qt::Dialog |
 21 |                    Qt::CustomizeWindowHint |
 22 |                    Qt::WindowTitleHint);
 23 | 
 24 |     for(auto&& a : _windowActions)
 25 |     {
 26 |         const auto wnd = a->data().value<QMdiSubWindow*>();
 27 |         if(!wnd) continue;
 28 | 
 29 |         auto item = new QListWidgetItem(wnd->windowTitle(), ui->listWidget);
 30 |         item->setData(Qt::UserRole, QVariant::fromValue(a));
 31 |         ui->listWidget->addItem(item);
 32 | 
 33 |         if(wnd->property("isActive").toBool())
 34 |             ui->listWidget->setCurrentItem(item);
 35 | 
 36 |     }
 37 | 
 38 |     connect(QAbstractEventDispatcher::instance(), &QAbstractEventDispatcher::awake, this, [this]
 39 |     {
 40 |         const auto item = ui->listWidget->currentItem();
 41 |         ui->pushButtonActivate->setEnabled(item != nullptr);
 42 |         ui->pushButtonClose->setEnabled(item != nullptr);
 43 |         ui->pushButtonSave->setEnabled(item != nullptr && _saveAction != nullptr);
 44 |     });
 45 | }
 46 | 
 47 | ///
 48 | /// \brief DialogWindowsManager::~DialogWindowsManager
 49 | ///
 50 | DialogWindowsManager::~DialogWindowsManager()
 51 | {
 52 |     delete ui;
 53 | }
 54 | 
 55 | ///
 56 | /// \brief DialogWindowsManager::activateWindow
 57 | /// \param item
 58 | ///
 59 | void DialogWindowsManager::activateWindow(QListWidgetItem *item)
 60 | {
 61 |     if(!item) return;
 62 | 
 63 |     const auto action = item->data(Qt::UserRole).value<QAction*>();
 64 |     if(action) action->trigger();
 65 | }
 66 | 
 67 | ///
 68 | /// \brief DialogWindowsManager::on_listWidget_itemDoubleClicked
 69 | ///
 70 | void DialogWindowsManager::on_listWidget_itemDoubleClicked(QListWidgetItem*)
 71 | {
 72 |     ui->pushButtonActivate->click();
 73 | }
 74 | 
 75 | ///
 76 | /// \brief DialogWindowsManager::on_pushButtonActivate_clicked
 77 | ///
 78 | void DialogWindowsManager::on_pushButtonActivate_clicked()
 79 | {
 80 |     activateWindow(ui->listWidget->currentItem());
 81 |     close();
 82 | }
 83 | 
 84 | ///
 85 | /// \brief DialogWindowsManager::on_pushButtonSave_clicked
 86 | ///
 87 | void DialogWindowsManager::on_pushButtonSave_clicked()
 88 | {
 89 |     if(_saveAction)
 90 |     {
 91 |         activateWindow(ui->listWidget->currentItem());
 92 |         _saveAction->trigger();
 93 |     }
 94 | }
 95 | 
 96 | ///
 97 | /// \brief DialogWindowsManager::on_pushButtonClose_clicked
 98 | ///
 99 | void DialogWindowsManager::on_pushButtonClose_clicked()
100 | {
101 |     auto item = ui->listWidget->currentItem();
102 |     if(!item) return;
103 | 
104 |     const auto action = item->data(Qt::UserRole).value<QAction*>();
105 |     if(!action) return;
106 | 
107 |     auto wnd = action->data().value<QMdiSubWindow*>();
108 |     if(!wnd) return;
109 | 
110 |     wnd->close();
111 |     delete item;
112 | }
113 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwindowsmanager.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGWINDOWSMANAGER_H
 2 | #define DIALOGWINDOWSMANAGER_H
 3 | 
 4 | #include <QDialog>
 5 | #include <QMdiSubWindow>
 6 | #include <QListWidgetItem>
 7 | 
 8 | namespace Ui {
 9 | class DialogWindowsManager;
10 | }
11 | 
12 | ///
13 | /// \brief The DialogWindowsManager class
14 | ///
15 | class DialogWindowsManager : public QDialog
16 | {
17 |     Q_OBJECT
18 | 
19 | public:
20 |     explicit DialogWindowsManager(const QList<QAction*>& actions, QAction* saveAction, QWidget *parent = nullptr);
21 |     ~DialogWindowsManager();
22 | 
23 | private slots:
24 |     void on_pushButtonActivate_clicked();
25 |     void on_pushButtonSave_clicked();
26 |     void on_pushButtonClose_clicked();
27 |     void on_listWidget_itemDoubleClicked(QListWidgetItem *item);
28 | 
29 | private:
30 |     void activateWindow(QListWidgetItem *item);
31 | 
32 | private:
33 |     Ui::DialogWindowsManager *ui;
34 | 
35 | private:
36 |     QAction* _saveAction;
37 |     QList<QAction*> _windowActions;
38 | };
39 | 
40 | #endif // DIALOGWINDOWSMANAGER_H
41 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwindowsmanager.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>DialogWindowsManager</class>
  4 |  <widget class="QDialog" name="DialogWindowsManager">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>335</width>
 10 |     <height>204</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>Windows</string>
 15 |   </property>
 16 |   <layout class="QHBoxLayout" name="horizontalLayout">
 17 |    <item>
 18 |     <widget class="QListWidget" name="listWidget">
 19 |      <property name="editTriggers">
 20 |       <set>QAbstractItemView::NoEditTriggers</set>
 21 |      </property>
 22 |     </widget>
 23 |    </item>
 24 |    <item>
 25 |     <layout class="QVBoxLayout" name="verticalLayout">
 26 |      <item>
 27 |       <widget class="QPushButton" name="pushButtonActivate">
 28 |        <property name="text">
 29 |         <string>Activate</string>
 30 |        </property>
 31 |       </widget>
 32 |      </item>
 33 |      <item>
 34 |       <widget class="QPushButton" name="pushButtonSave">
 35 |        <property name="text">
 36 |         <string>Save</string>
 37 |        </property>
 38 |       </widget>
 39 |      </item>
 40 |      <item>
 41 |       <widget class="QPushButton" name="pushButtonClose">
 42 |        <property name="text">
 43 |         <string>Close</string>
 44 |        </property>
 45 |       </widget>
 46 |      </item>
 47 |      <item>
 48 |       <spacer name="verticalSpacer">
 49 |        <property name="orientation">
 50 |         <enum>Qt::Vertical</enum>
 51 |        </property>
 52 |        <property name="sizeHint" stdset="0">
 53 |         <size>
 54 |          <width>20</width>
 55 |          <height>40</height>
 56 |         </size>
 57 |        </property>
 58 |       </spacer>
 59 |      </item>
 60 |      <item>
 61 |       <widget class="QDialogButtonBox" name="buttonBox">
 62 |        <property name="sizePolicy">
 63 |         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
 64 |          <horstretch>0</horstretch>
 65 |          <verstretch>0</verstretch>
 66 |         </sizepolicy>
 67 |        </property>
 68 |        <property name="orientation">
 69 |         <enum>Qt::Vertical</enum>
 70 |        </property>
 71 |        <property name="standardButtons">
 72 |         <set>QDialogButtonBox::Ok</set>
 73 |        </property>
 74 |       </widget>
 75 |      </item>
 76 |     </layout>
 77 |    </item>
 78 |   </layout>
 79 |  </widget>
 80 |  <resources/>
 81 |  <connections>
 82 |   <connection>
 83 |    <sender>buttonBox</sender>
 84 |    <signal>accepted()</signal>
 85 |    <receiver>DialogWindowsManager</receiver>
 86 |    <slot>accept()</slot>
 87 |    <hints>
 88 |     <hint type="sourcelabel">
 89 |      <x>248</x>
 90 |      <y>254</y>
 91 |     </hint>
 92 |     <hint type="destinationlabel">
 93 |      <x>157</x>
 94 |      <y>274</y>
 95 |     </hint>
 96 |    </hints>
 97 |   </connection>
 98 |   <connection>
 99 |    <sender>buttonBox</sender>
100 |    <signal>rejected()</signal>
101 |    <receiver>DialogWindowsManager</receiver>
102 |    <slot>reject()</slot>
103 |    <hints>
104 |     <hint type="sourcelabel">
105 |      <x>316</x>
106 |      <y>260</y>
107 |     </hint>
108 |     <hint type="destinationlabel">
109 |      <x>286</x>
110 |      <y>274</y>
111 |     </hint>
112 |    </hints>
113 |   </connection>
114 |  </connections>
115 | </ui>
116 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwritecoilregister.cpp:
--------------------------------------------------------------------------------
 1 | #include "modbuslimits.h"
 2 | #include "dialogcoilsimulation.h"
 3 | #include "dialogwritecoilregister.h"
 4 | #include "ui_dialogwritecoilregister.h"
 5 | 
 6 | ///
 7 | /// \brief DialogWriteCoilRegister::DialogWriteCoilRegister
 8 | /// \param writeParams
 9 | /// \param simParams
10 | /// \param parent
11 | ///
12 | DialogWriteCoilRegister::DialogWriteCoilRegister(ModbusWriteParams& writeParams, ModbusSimulationParams& simParams, QWidget *parent)
13 |     : QFixedSizeDialog(parent)
14 |     , ui(new Ui::DialogWriteCoilRegister)
15 |     ,_writeParams(writeParams)
16 |     ,_simParams(simParams)
17 | {
18 |     ui->setupUi(this);
19 |     ui->lineEditAddress->setInputRange(ModbusLimits::addressRange(writeParams.ZeroBasedAddress));
20 |     ui->lineEditAddress->setValue(_writeParams.Address);
21 |     ui->radioButtonOn->setChecked(_writeParams.Value.toBool());
22 |     ui->radioButtonOff->setChecked(!_writeParams.Value.toBool());
23 |     ui->buttonBox->setFocus();
24 | 
25 |     if(simParams.Mode != SimulationMode::No)
26 |     {
27 |         QLabel* iconLabel = new QLabel(ui->pushButtonSimulation);
28 |         iconLabel->setPixmap(QIcon(":/res/pointGreen.png").pixmap(4, 4));
29 |         iconLabel->setAttribute(Qt::WA_TransparentForMouseEvents, true);
30 | 
31 |         QLabel* textLabel = new QLabel(ui->pushButtonSimulation->text(), ui->pushButtonSimulation);
32 |         textLabel->setAlignment(Qt::AlignCenter);
33 |         textLabel->setAttribute(Qt::WA_TransparentForMouseEvents, true);
34 | 
35 |         auto layout = new QHBoxLayout(ui->pushButtonSimulation);
36 |         layout->setContentsMargins(4,0,4,0);
37 |         layout->addWidget(iconLabel);
38 |         layout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
39 |         layout->addWidget(textLabel);
40 |         layout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
41 | 
42 |         ui->pushButtonSimulation->setText(QString());
43 |         ui->pushButtonSimulation->setLayout(layout);
44 |     }
45 | }
46 | 
47 | ///
48 | /// \brief DialogWriteCoilRegister::~DialogWriteCoilRegister
49 | ///
50 | DialogWriteCoilRegister::~DialogWriteCoilRegister()
51 | {
52 |     delete ui;
53 | }
54 | 
55 | ///
56 | /// \brief DialogWriteCoilRegister::accept
57 | ///
58 | void DialogWriteCoilRegister::accept()
59 | {
60 |     _writeParams.Address = ui->lineEditAddress->value<int>();
61 |     _writeParams.Value = ui->radioButtonOn->isChecked();
62 | 
63 |     QFixedSizeDialog::accept();
64 | }
65 | 
66 | ///
67 | /// \brief DialogWriteCoilRegister::on_pushButtonSimulation_clicked
68 | ///
69 | void DialogWriteCoilRegister::on_pushButtonSimulation_clicked()
70 | {
71 |     DialogCoilSimulation dlg(_simParams, this);
72 |     if(dlg.exec() == QDialog::Accepted) done(2);
73 | }
74 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwritecoilregister.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGWRITECOILREGISTER_H
 2 | #define DIALOGWRITECOILREGISTER_H
 3 | 
 4 | #include "qfixedsizedialog.h"
 5 | #include "modbuswriteparams.h"
 6 | #include "modbussimulationparams.h"
 7 | 
 8 | namespace Ui {
 9 | class DialogWriteCoilRegister;
10 | }
11 | 
12 | ///
13 | /// \brief The DialogWriteCoilRegister class
14 | ///
15 | class DialogWriteCoilRegister : public QFixedSizeDialog
16 | {
17 |     Q_OBJECT
18 | 
19 | public:
20 |     explicit DialogWriteCoilRegister(ModbusWriteParams& writeParams, ModbusSimulationParams& simParams, QWidget *parent = nullptr);
21 |     ~DialogWriteCoilRegister();
22 | 
23 |     void accept() override;
24 | 
25 | private slots:
26 |     void on_pushButtonSimulation_clicked();
27 | 
28 | private:
29 |     Ui::DialogWriteCoilRegister *ui;
30 | 
31 | private:
32 |     ModbusWriteParams& _writeParams;
33 |     ModbusSimulationParams& _simParams;
34 | };
35 | 
36 | #endif // DIALOGWRITECOILREGISTER_H
37 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwriteholdingregister.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGWRITEHOLDINGREGISTER_H
 2 | #define DIALOGWRITEHOLDINGREGISTER_H
 3 | 
 4 | #include "modbuswriteparams.h"
 5 | #include "modbussimulationparams.h"
 6 | #include "qfixedsizedialog.h"
 7 | 
 8 | namespace Ui {
 9 | class DialogWriteHoldingRegister;
10 | }
11 | 
12 | ///
13 | /// \brief The DialogWriteHoldingRegister class
14 | ///
15 | class DialogWriteHoldingRegister : public QFixedSizeDialog
16 | {
17 |     Q_OBJECT
18 | 
19 | public:
20 |     explicit DialogWriteHoldingRegister(ModbusWriteParams& writeParams, ModbusSimulationParams& simParams, QWidget *parent = nullptr);
21 |     ~DialogWriteHoldingRegister();
22 | 
23 |     void accept() override;
24 | 
25 | private slots:
26 |     void on_pushButtonSimulation_clicked();
27 | 
28 | private:
29 |     Ui::DialogWriteHoldingRegister *ui;
30 | 
31 | private:
32 |     ModbusWriteParams& _writeParams;
33 |     ModbusSimulationParams& _simParams;
34 | };
35 | 
36 | #endif // DIALOGWRITEHOLDINGREGISTER_H
37 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwriteholdingregisterbits.cpp:
--------------------------------------------------------------------------------
 1 | #include <QBitArray>
 2 | #include "modbuslimits.h"
 3 | #include "dialogwriteholdingregisterbits.h"
 4 | #include "ui_dialogwriteholdingregisterbits.h"
 5 | 
 6 | ///
 7 | /// \brief DialogWriteHoldingRegisterBits::DialogWriteHoldingRegisterBits
 8 | /// \param params
 9 | /// \param parent
10 | ///
11 | DialogWriteHoldingRegisterBits::DialogWriteHoldingRegisterBits(ModbusWriteParams& params, QWidget *parent) :
12 |       QFixedSizeDialog(parent)
13 |     , ui(new Ui::DialogWriteHoldingRegisterBits)
14 |     ,_writeParams(params)
15 | {
16 |     ui->setupUi(this);
17 |     ui->lineEditAddress->setInputRange(ModbusLimits::addressRange(params.ZeroBasedAddress));
18 |     ui->lineEditAddress->setValue(params.Address);
19 | 
20 |     quint16 value = params.Value.toUInt();
21 |     for (int i = 0; i < 16; i++)
22 |     {
23 |         auto ctrl = findChild<QCheckBox*>(QString("checkBox%1").arg(i));
24 |         if(ctrl) ctrl->setChecked(value >> i & 1);
25 |     }
26 |     ui->buttonBox->setFocus();
27 | }
28 | 
29 | ///
30 | /// \brief DialogWriteHoldingRegisterBits::~DialogWriteHoldingRegisterBits
31 | ///
32 | DialogWriteHoldingRegisterBits::~DialogWriteHoldingRegisterBits()
33 | {
34 |     delete ui;
35 | }
36 | 
37 | ///
38 | /// \brief DialogWriteHoldingRegisterBits::accept
39 | ///
40 | void DialogWriteHoldingRegisterBits::accept()
41 | {
42 |     quint16 value = 0;
43 |     for (int i = 0; i < 16; i++)
44 |     {
45 |         auto ctrl = findChild<QCheckBox*>(QString("checkBox%1").arg(i));
46 |         if(ctrl) value |= ctrl->isChecked() << i;
47 |     }
48 |     _writeParams.Value = value;
49 |     _writeParams.Address = ui->lineEditAddress->value<int>();
50 | 
51 |     QFixedSizeDialog::accept();
52 | }
53 | 


--------------------------------------------------------------------------------
/omodsim/dialogs/dialogwriteholdingregisterbits.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOGWRITEHOLDINGREGISTERBITS_H
 2 | #define DIALOGWRITEHOLDINGREGISTERBITS_H
 3 | 
 4 | #include "qfixedsizedialog.h"
 5 | #include "modbuswriteparams.h"
 6 | 
 7 | namespace Ui {
 8 | class DialogWriteHoldingRegisterBits;
 9 | }
10 | 
11 | class DialogWriteHoldingRegisterBits : public QFixedSizeDialog
12 | {
13 |     Q_OBJECT
14 | 
15 | public:
16 |     explicit DialogWriteHoldingRegisterBits(ModbusWriteParams& params, QWidget *parent = nullptr);
17 |     ~DialogWriteHoldingRegisterBits();
18 | 
19 |     void accept() override;
20 | 
21 | private:
22 |     Ui::DialogWriteHoldingRegisterBits *ui;
23 |     ModbusWriteParams& _writeParams;
24 | };
25 | 
26 | #endif // DIALOGWRITEHOLDINGREGISTERBITS_H
27 | 


--------------------------------------------------------------------------------
/omodsim/displaydefinition.h:
--------------------------------------------------------------------------------
 1 | #ifndef DISPLAYDEFINITION_H
 2 | #define DISPLAYDEFINITION_H
 3 | 
 4 | #include <QSettings>
 5 | #include <QModbusDataUnit>
 6 | #include "modbuslimits.h"
 7 | 
 8 | ///
 9 | /// \brief The DisplayDefinition struct
10 | ///
11 | struct DisplayDefinition
12 | {
13 |     quint8 DeviceId = 1;
14 |     quint16 PointAddress = 1;
15 |     QModbusDataUnit::RegisterType PointType = QModbusDataUnit::HoldingRegisters;
16 |     quint16 Length = 100;
17 |     quint16 LogViewLimit = 30;
18 |     bool ZeroBasedAddress = false;
19 | 
20 |     void normalize()
21 |     {
22 |         DeviceId = qMax<quint8>(ModbusLimits::slaveRange().from(), DeviceId);
23 |         PointAddress = qMax<quint16>(ModbusLimits::addressRange(ZeroBasedAddress).from(), PointAddress);
24 |         PointType = qBound(QModbusDataUnit::DiscreteInputs, PointType, QModbusDataUnit::HoldingRegisters);
25 |         Length = qBound<quint16>(ModbusLimits::lengthRange().from(), Length, ModbusLimits::lengthRange().to());
26 |         LogViewLimit = qBound<quint16>(4, LogViewLimit, 1000);
27 |     }
28 | };
29 | Q_DECLARE_METATYPE(DisplayDefinition)
30 | 
31 | ///
32 | /// \brief operator <<
33 | /// \param out
34 | /// \param dd
35 | /// \return
36 | ///
37 | inline QSettings& operator <<(QSettings& out, const DisplayDefinition& dd)
38 | {
39 |     out.setValue("DisplayDefinition/DeviceId",          dd.DeviceId);
40 |     out.setValue("DisplayDefinition/PointAddress",      dd.PointAddress);
41 |     out.setValue("DisplayDefinition/PointType",         dd.PointType);
42 |     out.setValue("DisplayDefinition/Length",            dd.Length);
43 |     out.setValue("DisplayDefinition/LogViewLimit",      dd.LogViewLimit);
44 |     out.setValue("DisplayDefinition/ZeroBasedAddress",  dd.ZeroBasedAddress);
45 | 
46 |     return out;
47 | }
48 | 
49 | ///
50 | /// \brief operator >>
51 | /// \param in
52 | /// \param dd
53 | /// \return
54 | ///
55 | inline QSettings& operator >>(QSettings& in, DisplayDefinition& dd)
56 | {
57 |     dd.DeviceId = in.value("DisplayDefinition/DeviceId", 1).toUInt();
58 |     dd.PointAddress = in.value("DisplayDefinition/PointAddress", 1).toUInt();
59 |     dd.PointType = (QModbusDataUnit::RegisterType)in.value("DisplayDefinition/PointType", 4).toUInt();
60 |     dd.Length = in.value("DisplayDefinition/Length", 100).toUInt();
61 |     dd.LogViewLimit = in.value("DisplayDefinition/LogViewLimit", 30).toUInt();
62 |     dd.ZeroBasedAddress = in.value("DisplayDefinition/ZeroBasedAddress").toBool();
63 | 
64 |     dd.normalize();
65 |     return in;
66 | }
67 | 
68 | #endif // DISPLAYDEFINITION_H
69 | 


--------------------------------------------------------------------------------
/omodsim/docs/assets/css/reset.css:
--------------------------------------------------------------------------------
 1 | /* http://meyerweb.com/eric/tools/css/reset/ 
 2 |    v2.0 | 20110126
 3 |    License: none (public domain)
 4 | */
 5 | 
 6 | html, body, div, span, applet, object, iframe,
 7 | h1, h2, h3, h4, h5, h6, p, blockquote, pre,
 8 | a, abbr, acronym, address, big, cite, code,
 9 | del, dfn, em, ins, kbd, q, s, samp,
10 | small, strike, strong, sub, sup, tt, var,
11 | b, u, i, center,
12 | dl, dt, dd, ol, ul, li,
13 | fieldset, form, label, legend,
14 | article, aside, canvas, details, embed, 
15 | figure, figcaption, footer, header, hgroup, 
16 | menu, nav, output, ruby, section, summary,
17 | time, mark, audio, video {
18 | 	margin: 0;
19 | 	padding: 0;
20 | 	border: 0;
21 | 	font-size: 100%;
22 | 	font: inherit;
23 | 	vertical-align: baseline;
24 | }
25 | img {
26 | 	padding: 0;
27 | 	border: 0;
28 | 	font-size: 100%;
29 | 	font: inherit;
30 | }
31 | table, caption, tbody, tfoot, thead, tr, th, td {
32 | 	margin: 0;
33 | 	font-size: 100%;
34 | 	font: inherit;
35 | }
36 | /* HTML5 display-role reset for older browsers */
37 | article, aside, details, figcaption, figure, 
38 | footer, header, hgroup, menu, nav, section {
39 | 	display: block;
40 | }
41 | blockquote, q {
42 | 	quotes: none;
43 | }
44 | blockquote:before, blockquote:after,
45 | q:before, q:after {
46 | 	content: '';
47 | 	content: none;
48 | }


--------------------------------------------------------------------------------
/omodsim/docs/assets/css/style.css:
--------------------------------------------------------------------------------
 1 | h1.title {
 2 |     /* top | right | bottom | left */
 3 |     margin: 1.5em 0 .5em .5em;
 4 |     padding: .25em;
 5 |     font-weight: 600;
 6 |     flex: 1;
 7 | }
 8 | h2, p.h2 {
 9 |     padding: .2em;
10 |     margin: 1.5em 0 1.2em .3em;
11 |     font-weight: 600;
12 | }
13 | h3 {
14 |     margin: 1.5em 0 1.5em .25em;
15 | }
16 | p {
17 |     margin: 1em 0 1em .5em;
18 | }
19 | strong{
20 |     font-weight: 800;
21 | }
22 | sub {
23 |     vertical-align: sub;
24 |     font-size: smaller;
25 | }
26 | a:link {
27 |     color: #007330;
28 |     text-decoration: none;
29 |     text-align: left;
30 | }
31 | a > strong{
32 |     font-weight: 800;
33 |     font-size: large;
34 | }
35 | ul li, ol li {
36 |     margin-bottom: 0.5em;
37 | }
38 | ul > li {
39 |     list-style-type: disc;
40 | }
41 | li {
42 |     list-style: inside;
43 |     text-align: left;
44 | }
45 | li.object{
46 |     list-style: none;
47 | }
48 | 
49 | ul.level2 {
50 |     margin-bottom: 1em;
51 | }
52 | ul.level2 li {
53 |     margin-left: -1.9em;
54 | }
55 | code {
56 |     font-family: Courier, monospace;
57 |     font-weight: 400;
58 |     color: #007330;
59 |     padding: 0.125em 0.25em;
60 |     width: fit-content;
61 | }
62 | .article-header h1{
63 |     font-weight: 600;
64 | }
65 |    


--------------------------------------------------------------------------------
/omodsim/docs/jshelp.qhcp:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8" ?> 
 2 | <QHelpCollectionProject version="1.0">
 3 |     <docFiles>
 4 |         <generate>
 5 |             <file>
 6 |                 <input>jshelp.qhp</input>
 7 |                 <output>jshelp.qch</output>
 8 |             </file>
 9 |         </generate>
10 |         <register>
11 |             <file>jshelp.qch</file>
12 |         </register>
13 |     </docFiles>
14 | </QHelpCollectionProject>


--------------------------------------------------------------------------------
/omodsim/docs/jshelp.qhp:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8" ?>
 2 | <QtHelpProject version="1.0">
 3 |     <namespace>omodsim</namespace>
 4 |     <virtualFolder>doc</virtualFolder>
 5 |     <filterSection>
 6 |         <toc/>
 7 |         <files>
 8 |             <file>assets/css/*.css</file>
 9 |             <file>*.html</file>
10 |         </files>
11 |     </filterSection>
12 | </QtHelpProject>
13 | 


--------------------------------------------------------------------------------
/omodsim/fonts/firacode.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/fonts/firacode.ttf


--------------------------------------------------------------------------------
/omodsim/htmldelegate.cpp:
--------------------------------------------------------------------------------
 1 | #include <QPainter>
 2 | #include <QApplication>
 3 | #include <QTextDocument>
 4 | #include <QStyleOptionViewItem>
 5 | #include <QAbstractTextDocumentLayout>
 6 | #include "htmldelegate.h"
 7 | 
 8 | ///
 9 | /// \brief HtmlDelegate::HtmlDelegate
10 | /// \param parent
11 | ///
12 | HtmlDelegate::HtmlDelegate(QObject* parent)
13 |     : QStyledItemDelegate(parent)
14 | {
15 | }
16 | 
17 | ///
18 | /// \brief HtmlDelegate::paint
19 | /// \param painter
20 | /// \param option
21 | /// \param index
22 | ///
23 | void HtmlDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
24 | {
25 |     QStyleOptionViewItem opt = option;
26 |     initStyleOption(&opt, index);
27 | 
28 |     if (opt.text.isEmpty()) {
29 |         // This is nothing this function is supposed to handle
30 |         QStyledItemDelegate::paint(painter, option, index);
31 | 
32 |         return;
33 |     }
34 | 
35 |     QStyle *style = opt.widget? opt.widget->style() : QApplication::style();
36 | 
37 |     QTextOption textOption;
38 |     textOption.setWrapMode(opt.features & QStyleOptionViewItem::WrapText ? QTextOption::WordWrap
39 |                                                                          : QTextOption::ManualWrap);
40 |     textOption.setTextDirection(opt.direction);
41 | 
42 |     QTextDocument doc;
43 |     doc.setHtml(opt.text);
44 |     doc.setDocumentMargin(2);
45 |     doc.setDefaultFont(opt.font);
46 |     doc.setDefaultTextOption(textOption);
47 |     doc.setTextWidth(opt.rect.width());
48 | 
49 |     /// Painting item without text
50 |     opt.text = QString();
51 |     style->drawControl(QStyle::CE_ItemViewItem, &opt, painter);
52 | 
53 |     QAbstractTextDocumentLayout::PaintContext ctx;
54 | 
55 |     // Highlighting text if item is selected
56 |     if (opt.state & QStyle::State_Selected)
57 |         ctx.palette.setColor(QPalette::Text, opt.palette.color(QPalette::Active, QPalette::HighlightedText));
58 | 
59 |     QRect textRect = style->subElementRect(QStyle::SE_ItemViewItemText, &opt);
60 |     painter->save();
61 |     painter->translate(textRect.topLeft());
62 |     painter->setClipRect(textRect.translated(-textRect.topLeft()));
63 |     doc.documentLayout()->draw(painter, ctx);
64 |     painter->restore();
65 | }
66 | 
67 | ///
68 | /// \brief HtmlDelegate::sizeHint
69 | /// \param option
70 | /// \param index
71 | /// \return
72 | ///
73 | QSize HtmlDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
74 | {
75 |     QStyleOptionViewItem opt = option;
76 |     initStyleOption(&opt, index);
77 | 
78 |     if (opt.text.isEmpty()) {
79 |         // This is nothing this function is supposed to handle
80 |         return QStyledItemDelegate::sizeHint(option, index);
81 |     }
82 | 
83 |     QTextDocument doc;
84 |     doc.setHtml(opt.text);
85 |     doc.setDocumentMargin(2);
86 |     doc.setDefaultFont(opt.font);
87 | 
88 |     if(opt.features & QStyleOptionViewItem::WrapText)
89 |         doc.setTextWidth(opt.rect.width());
90 | 
91 |     return QSize(doc.idealWidth(), doc.size().height());
92 | }
93 | 


--------------------------------------------------------------------------------
/omodsim/htmldelegate.h:
--------------------------------------------------------------------------------
 1 | #ifndef HTMLDELEGATE_H
 2 | #define HTMLDELEGATE_H
 3 | 
 4 | #include <QStyledItemDelegate>
 5 | 
 6 | ///
 7 | /// \brief The HtmlDelegate class
 8 | ///
 9 | class HtmlDelegate : public QStyledItemDelegate
10 | {
11 | public:
12 |     ///
13 |     /// \brief HtmlDelegate
14 |     /// \param parent
15 |     ///
16 |     explicit HtmlDelegate(QObject* parent = nullptr);
17 | 
18 | protected:
19 |     void paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const;
20 |     QSize sizeHint ( const QStyleOptionViewItem & option, const QModelIndex & index ) const;
21 | };
22 | 
23 | #endif // HTMLDELEGATE_H
24 | 


--------------------------------------------------------------------------------
/omodsim/jscompleter.h:
--------------------------------------------------------------------------------
 1 | #ifndef JSCOMPLETER_H
 2 | #define JSCOMPLETER_H
 3 | 
 4 | #include <QIcon>
 5 | #include <QCompleter>
 6 | #include <QAbstractItemModel>
 7 | 
 8 | ///
 9 | /// \brief The JSCompleterModel class
10 | ///
11 | class JSCompleterModel : public QAbstractListModel
12 | {
13 | public:
14 |     explicit JSCompleterModel(QObject *parent = nullptr);
15 | 
16 |     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
17 |     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
18 |     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
19 | 
20 |     QString completionKey() const;
21 |     void setCompletionKey(const QString& key);
22 | 
23 | private:
24 |     QIcon _iconProp;
25 |     QIcon _iconFunc;
26 |     QIcon _iconEnum;
27 |     QString _completionKey;
28 | };
29 | 
30 | ///
31 | /// \brief The JSCompleter class
32 | ///
33 | class JSCompleter : public QCompleter
34 | {
35 | public:
36 |     explicit JSCompleter(QWidget* parent = nullptr);
37 | 
38 |     QString completionKey() const;
39 |     void setCompletionKey(const QString& key);
40 | };
41 | 
42 | #endif // JSCOMPLETER_H
43 | 


--------------------------------------------------------------------------------
/omodsim/jshighlighter.h:
--------------------------------------------------------------------------------
 1 | #ifndef JSHIGHLIGHTER_H
 2 | #define JSHIGHLIGHTER_H
 3 | 
 4 | #include <QTextDocument>
 5 | #include <QSyntaxHighlighter>
 6 | 
 7 | #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 8 | #include <QStringView>
 9 | #endif
10 | 
11 | using LanguageData = QMultiHash<char, QLatin1String>;
12 | 
13 | class JSHighlighter : public QSyntaxHighlighter
14 | {
15 |     Q_OBJECT
16 | 
17 | public:
18 |     enum Token {
19 |         CodeBlock,
20 |         CodeKeyWord,
21 |         CodeString,
22 |         CodeComment,
23 |         CodeType,
24 |         CodeOther,
25 |         CodeNumLiteral,
26 |         CodeBuiltIn,
27 |     };
28 |     Q_ENUM(Token)
29 | 
30 |     explicit JSHighlighter(QTextDocument* parent = nullptr);
31 | 
32 | protected:
33 |     void highlightBlock(const QString &text) override;
34 | 
35 | private:
36 | private:
37 |     void highlightSyntax(const QString &text);
38 |     Q_REQUIRED_RESULT int highlightNumericLiterals(const QString &text, int i);
39 |     Q_REQUIRED_RESULT int highlightStringLiterals(const QChar strType, const QString &text, int i);
40 | 
41 |     /**
42 |      * @brief returns true if c is octal
43 |      * @param c the char being checked
44 |      * @returns true if the number is octal, false otherwise
45 |      */
46 |     Q_REQUIRED_RESULT static constexpr inline bool isOctal(const char c) {
47 |         return (c >= '0' && c <= '7');
48 |     }
49 | 
50 |     /**
51 |      * @brief returns true if c is hex
52 |      * @param c the char being checked
53 |      * @returns true if the number is hex, false otherwise
54 |      */
55 |     Q_REQUIRED_RESULT static constexpr inline bool isHex(const char c) {
56 |         return (
57 |             (c >= '0' && c <= '9') ||
58 |             (c >= 'a' && c <= 'f') ||
59 |             (c >= 'A' && c <= 'F')
60 |         );
61 |     }
62 | 
63 |     void initFormats();
64 | 
65 | #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
66 |     static inline QStringView strMidRef(const QString& str, qsizetype position, qsizetype n = -1)
67 |     {
68 |         return QStringView(str).mid(position, n);
69 |     }
70 | #else
71 |     static inline QStringRef strMidRef(const QString& str, int position, int n = -1)
72 |     {
73 |         return str.midRef(position, n);
74 |     }
75 | #endif
76 | 
77 |     QHash<Token, QTextCharFormat> _formats;
78 | 
79 | private:
80 |     static LanguageData keywords;
81 |     static LanguageData types;
82 |     static LanguageData literals;
83 |     static LanguageData builtin;
84 |     static LanguageData other;
85 | };
86 | 
87 | #endif // JSHIGHLIGHTER_H
88 | 


--------------------------------------------------------------------------------
/omodsim/jsobjects/console.cpp:
--------------------------------------------------------------------------------
 1 | #include <QTextCharFormat>
 2 | #include "console.h"
 3 | 
 4 | ///
 5 | /// \brief console::console
 6 | /// \param doc
 7 | ///
 8 | console::console(QPlainTextEdit* edit)
 9 |     : _edit(edit)
10 | {
11 |     _edit->setFont(QFont("Fira Code"));
12 |     _edit->setTabStopDistance(_edit->fontMetrics().horizontalAdvance(' ') * 2);
13 |     setBackgroundColor(Qt::white);
14 | }
15 | 
16 | ///
17 | /// \brief console::clear
18 | ///
19 | void console::clear()
20 | {
21 |     _edit->setPlainText(QString());
22 | }
23 | 
24 | ///
25 | /// \brief console::log
26 | /// \param msg
27 | ///
28 | void console::log(const QString& msg)
29 | {
30 |     QTextCharFormat fmt;
31 |     fmt.setForeground(Qt::black);
32 |     _edit->mergeCurrentCharFormat(fmt);
33 | 
34 |     addText(msg);
35 | }
36 | 
37 | ///
38 | /// \brief console::debug
39 | /// \param msg
40 | ///
41 | void console::debug(const QString& msg)
42 | {
43 |     log(msg);
44 | }
45 | 
46 | ///
47 | /// \brief console::warning
48 | /// \param msg
49 | ///
50 | void console::warning(const QString& msg)
51 | {
52 |     QTextCharFormat fmt;
53 |     fmt.setForeground(Qt::yellow);
54 |     _edit->mergeCurrentCharFormat(fmt);
55 | 
56 |     addText(msg);
57 | }
58 | 
59 | ///
60 | /// \brief console::error
61 | /// \param msg
62 | ///
63 | void console::error(const QString& msg)
64 | {
65 |     QTextCharFormat fmt;
66 |     fmt.setForeground(Qt::red);
67 |     _edit->mergeCurrentCharFormat(fmt);
68 | 
69 |     addText(msg);
70 | }
71 | 
72 | ///
73 | /// \brief console::addText
74 | /// \param text
75 | ///
76 | void console::addText(const QString& text)
77 | {
78 |     _edit->insertPlainText(QString(_edit->toPlainText().isEmpty() ? ">>\t%1" : "\n>>\t%1").arg(text));
79 |     _edit->moveCursor(QTextCursor::End);
80 | }
81 | 
82 | ///
83 | /// \brief console::setBackgroundColor
84 | /// \param clr
85 | ///
86 | void console::setBackgroundColor(const QColor& clr)
87 | {
88 |     auto pal = _edit->palette();
89 |     pal.setColor(QPalette::Base, clr);
90 |     pal.setColor(QPalette::Window, clr);
91 |     _edit->setPalette(pal);
92 | }
93 | 
94 | 


--------------------------------------------------------------------------------
/omodsim/jsobjects/console.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONSOLE_H
 2 | #define CONSOLE_H
 3 | 
 4 | #include <QObject>
 5 | #include <QPlainTextEdit>
 6 | 
 7 | ///
 8 | /// \brief The console class
 9 | ///
10 | class console : public QObject
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit console(QPlainTextEdit* edit);
15 | 
16 |     Q_INVOKABLE void clear();
17 |     Q_INVOKABLE void log(const QString& msg);
18 |     Q_INVOKABLE void debug(const QString& msg);
19 |     Q_INVOKABLE void warning(const QString& msg);
20 |     Q_INVOKABLE void error(const QString& msg);
21 | 
22 | private:
23 |     void addText(const QString& text);
24 |     void setBackgroundColor(const QColor& clr);
25 | 
26 | private:
27 |     QPlainTextEdit* _edit;
28 | };
29 | 
30 | #endif // CONSOLE_H
31 | 


--------------------------------------------------------------------------------
/omodsim/jsobjects/script.cpp:
--------------------------------------------------------------------------------
 1 | #include <QTimer>
 2 | #include <QJSValue>
 3 | #include <QJSEngine>
 4 | #include "script.h"
 5 | 
 6 | ///
 7 | /// \brief Script::Script
 8 | /// \param period
 9 | /// \param parent
10 | ///
11 | Script::Script(int period, QObject* parent)
12 |     : QObject(parent)
13 |     ,_period(period)
14 | {
15 | }
16 | 
17 | ///
18 | /// \brief Script::stop
19 | ///
20 | void Script::stop()
21 | {
22 |     emit stopped();
23 | }
24 | 
25 | ///
26 | /// \brief Script::run
27 | /// \param jsEngine
28 | /// \param script
29 | /// \return
30 | ///
31 | QJSValue Script::run(QJSEngine& jsEngine, const QString& script)
32 | {
33 |     _runCount++;
34 |     return jsEngine.evaluate(script);
35 | }
36 | 
37 | ///
38 | /// \brief Script::onInit
39 | /// \param func
40 | ///
41 | void Script::onInit(const QJSValue& func)
42 | {
43 |     if(!func.isCallable())
44 |         return;
45 | 
46 |     if(_runCount == 1)
47 |         const_cast<QJSValue&>(func).call();
48 | }
49 | 
50 | ///
51 | /// \brief Script::setTimeout
52 | /// \param func
53 | /// \param timeout
54 | ///
55 | void Script::setTimeout(const QJSValue& func, int timeout)
56 | {
57 |     if(!func.isCallable())
58 |        return;
59 | 
60 |     QTimer::singleShot(timeout, this, [func]
61 |     {
62 |         const_cast<QJSValue&>(func).call();
63 |     });
64 | }
65 | 
66 | ///
67 | /// \brief Script::runCount
68 | /// \return
69 | ///
70 | int Script::runCount() const
71 | {
72 |     return _runCount;
73 | }
74 | 
75 | ///
76 | /// \brief Script::period
77 | /// \return
78 | ///
79 | int Script::period() const
80 | {
81 |     return _period;
82 | }
83 | 


--------------------------------------------------------------------------------
/omodsim/jsobjects/script.h:
--------------------------------------------------------------------------------
 1 | #ifndef SCRIPT_H
 2 | #define SCRIPT_H
 3 | 
 4 | #include <QObject>
 5 | #include <QJSValue>
 6 | 
 7 | ///
 8 | /// \brief The Script class
 9 | ///
10 | class Script : public QObject
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit Script(int period, QObject* parent = nullptr);
15 | 
16 |     Q_PROPERTY(int runCount READ runCount CONSTANT);
17 |     Q_PROPERTY(int  period READ period CONSTANT)
18 |     Q_INVOKABLE void stop();
19 |     Q_INVOKABLE void onInit(const QJSValue& func);
20 |     Q_INVOKABLE void setTimeout(const QJSValue& func, int timeout);
21 | 
22 |     int runCount() const;
23 |     int period() const;
24 | 
25 |     QJSValue run(QJSEngine& jsEngine, const QString& script);
26 | 
27 | signals:
28 |     void stopped();
29 | 
30 | private:
31 |     int _period;
32 |     int _runCount = 0;
33 | };
34 | 
35 | #endif // SCRIPT_H
36 | 


--------------------------------------------------------------------------------
/omodsim/jsobjects/server.h:
--------------------------------------------------------------------------------
 1 | #ifndef SERVER_H
 2 | #define SERVER_H
 3 | 
 4 | #include <QObject>
 5 | #include <QJSValue>
 6 | #include "modbusmultiserver.h"
 7 | 
 8 | namespace Register
 9 | {
10 |     Q_NAMESPACE
11 |     enum class Type {
12 |         DiscreteInputs = 1,
13 |         Coils,
14 |         Input,
15 |         Holding
16 |     };
17 |     Q_ENUM_NS(Type)
18 | }
19 | Q_DECLARE_METATYPE(Register::Type)
20 | 
21 | namespace Address
22 | {
23 |     Q_NAMESPACE
24 |     enum class Base {
25 |         Base0 = 0,
26 |         Base1
27 |     };
28 |     Q_ENUM_NS(Base)
29 | }
30 | Q_DECLARE_METATYPE(Address::Base)
31 | 
32 | ///
33 | /// \brief The Modbus Server class
34 | ///
35 | class Server : public QObject
36 | {
37 |     Q_OBJECT
38 | 
39 | public:
40 |     explicit Server(ModbusMultiServer* server, const ByteOrder* order, AddressBase base);
41 |     ~Server() override;
42 | 
43 |     Q_PROPERTY(Address::Base addressBase READ addressBase WRITE setAddressBase);
44 | 
45 |     Address::Base addressBase() const;
46 | 
47 |     Q_INVOKABLE quint16 readHolding(quint16 address) const;
48 |     Q_INVOKABLE void writeHolding(quint16 address, quint16 value);
49 | 
50 |     Q_INVOKABLE quint16 readInput(quint16 address) const;
51 |     Q_INVOKABLE void writeInput(quint16 address, quint16 value);
52 | 
53 |     Q_INVOKABLE bool readDiscrete(quint16 address) const;
54 |     Q_INVOKABLE void writeDiscrete(quint16 address, bool value);
55 | 
56 |     Q_INVOKABLE bool readCoil(quint16 address) const;
57 |     Q_INVOKABLE void writeCoil(quint16 address, bool value);
58 | 
59 |     Q_INVOKABLE qint32 readInt32(Register::Type reg, quint16 address, bool swapped) const;
60 |     Q_INVOKABLE void writeInt32(Register::Type reg, quint16 address, qint32 value, bool swapped);
61 | 
62 |     Q_INVOKABLE quint32 readUInt32(Register::Type reg, quint16 address, bool swapped) const;
63 |     Q_INVOKABLE void writeUInt32(Register::Type reg, quint16 address, quint32 value, bool swapped);
64 | 
65 |     Q_INVOKABLE qint64 readInt64(Register::Type reg, quint16 address, bool swapped) const;
66 |     Q_INVOKABLE void writeInt64(Register::Type reg, quint16 address, qint64 value, bool swapped);
67 | 
68 |     Q_INVOKABLE quint64 readUInt64(Register::Type reg, quint16 address, bool swapped) const;
69 |     Q_INVOKABLE void writeUInt64(Register::Type reg, quint16 address, quint64 value, bool swapped);
70 | 
71 |     Q_INVOKABLE float readFloat(Register::Type reg, quint16 address, bool swapped) const;
72 |     Q_INVOKABLE void writeFloat(Register::Type reg, quint16 address, float value, bool swapped);
73 | 
74 |     Q_INVOKABLE double readDouble(Register::Type reg, quint16 address, bool swapped) const;
75 |     Q_INVOKABLE void writeDouble(Register::Type reg, quint16 address, double value, bool swapped);
76 | 
77 |     Q_INVOKABLE void onChange(Register::Type reg, quint16 address, const QJSValue& func);
78 | 
79 | public slots:
80 |     void setAddressBase(Address::Base base);
81 | 
82 | private slots:
83 |     void on_dataChanged(const QModbusDataUnit& data);
84 | 
85 | private:
86 |     Address::Base _addressBase;
87 |     const ByteOrder* _byteOrder;
88 |     ModbusMultiServer* _mbMultiServer;
89 |     QMap<QPair<Register::Type, quint16>, QJSValue> _mapOnChange;
90 | };
91 | 
92 | #endif // SERVER_H
93 | 


--------------------------------------------------------------------------------
/omodsim/jsobjects/storage.cpp:
--------------------------------------------------------------------------------
 1 | #include "storage.h"
 2 | 
 3 | ///
 4 | /// \brief Storage::Storage
 5 | /// \param parent
 6 | ///
 7 | Storage::Storage()
 8 | {
 9 | }
10 | 
11 | ///
12 | /// \brief Storage::length
13 | /// \return
14 | ///
15 | int Storage::length() const
16 | {
17 |     return _storage.size();
18 | }
19 | 
20 | ///
21 | /// \brief Storage::key
22 | /// \param index
23 | /// \return
24 | ///
25 | QJSValue Storage::key(int index) const
26 | {
27 |     const auto it = std::next(_storage.constBegin(), index);
28 |     if(it != _storage.end()) return *it;
29 |     else return QJSValue(QJSValue::NullValue);
30 | }
31 | 
32 | ///
33 | /// \brief Storage::getItem
34 | /// \param key
35 | /// \return
36 | ///
37 | QJSValue Storage::getItem(const QString& key) const
38 | {
39 |     const auto it  = _storage.find(key);
40 |     if(it != _storage.end()) return *it;
41 |     else return QJSValue(QJSValue::NullValue);
42 | }
43 | 
44 | ///
45 | /// \brief Storage::setItem
46 | /// \param key
47 | /// \param value
48 | ///
49 | void Storage::setItem(const QString& key, const QJSValue& value)
50 | {
51 |     _storage[key] = value;
52 | }
53 | 
54 | ///
55 | /// \brief Storage::removeItem
56 | /// \param key
57 | ///
58 | void Storage::removeItem(const QString& key)
59 | {
60 |     _storage.remove(key);
61 | }
62 | 
63 | ///
64 | /// \brief Storage::clear
65 | ///
66 | void Storage::clear()
67 | {
68 |     _storage.clear();
69 | }
70 | 


--------------------------------------------------------------------------------
/omodsim/jsobjects/storage.h:
--------------------------------------------------------------------------------
 1 | #ifndef STORAGE_H
 2 | #define STORAGE_H
 3 | 
 4 | #include <QMap>
 5 | #include <QObject>
 6 | #include <QJSValue>
 7 | 
 8 | ///
 9 | /// \brief The Storage class
10 | ///
11 | class Storage : public QObject
12 | {
13 |     Q_OBJECT
14 | public:
15 |     Q_INVOKABLE explicit Storage();
16 | 
17 |     Q_PROPERTY(int length READ length CONSTANT);
18 | 
19 |     Q_INVOKABLE QJSValue key(int index) const;
20 |     Q_INVOKABLE QJSValue getItem(const QString& key) const;
21 |     Q_INVOKABLE void setItem(const QString& key, const QJSValue& value);
22 |     Q_INVOKABLE void removeItem(const QString& key);
23 |     Q_INVOKABLE void clear();
24 | 
25 |     int length() const;
26 | 
27 | private:
28 |     QMap<QString, QJSValue> _storage;
29 | };
30 | 
31 | #endif // STORAGE_H
32 | 


--------------------------------------------------------------------------------
/omodsim/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <QApplication>
 2 | #include <QFontDatabase>
 3 | #include "mainwindow.h"
 4 | #include "cmdlineparser.h"
 5 | 
 6 | ///
 7 | /// \brief showVersion
 8 | ///
 9 | static inline void showVersion()
10 | {
11 |     const auto version = QString("%1\n").arg(APP_VERSION);
12 |     fputs(qPrintable(version), stdout);
13 | }
14 | 
15 | ///
16 | /// \brief showHelp
17 | /// \param helpText
18 | ///
19 | static inline void showHelp(const QString& helpText)
20 | {
21 |     fputs(qPrintable(helpText), stdout);
22 | }
23 | 
24 | ///
25 | /// \brief showErrorMessage
26 | /// \param message
27 | ///
28 | static void showErrorMessage(const QString &message)
29 | {
30 |     fputs(qPrintable(message), stderr);
31 | }
32 | 
33 | ///
34 | /// \brief main
35 | /// \param argc
36 | /// \param argv
37 | /// \return
38 | ///
39 | int main(int argc, char *argv[])
40 | {
41 |     QApplication a(argc, argv);
42 |     a.setApplicationName(APP_NAME);
43 |     a.setApplicationVersion(APP_VERSION);
44 |     QFontDatabase::addApplicationFont(":/fonts/firacode.ttf");
45 | 
46 |     CmdLineParser parser;
47 |     if(!parser.parse(a.arguments()))
48 |     {
49 |         showErrorMessage(parser.errorText() + QLatin1Char('\n'));
50 |         return EXIT_FAILURE;
51 |     }
52 | 
53 |     if(parser.isSet(CmdLineParser::_version))
54 |     {
55 |         showVersion();
56 |         return EXIT_SUCCESS;
57 |     }
58 | 
59 |     if(parser.isSet(CmdLineParser::_help))
60 |     {
61 |         showHelp(parser.helpText());
62 |         return EXIT_SUCCESS;
63 |     }
64 | 
65 |     QString cfg;
66 |     if(parser.isSet(CmdLineParser::_config))
67 |     {
68 |         cfg = parser.value(CmdLineParser::_config);
69 |     }
70 | 
71 |     MainWindow w;
72 |     if(!cfg.isEmpty())
73 |     {
74 |         w.loadConfig(cfg);
75 |     }
76 |     w.show();
77 | 
78 |     return a.exec();
79 | }
80 | 


--------------------------------------------------------------------------------
/omodsim/menuconnect.h:
--------------------------------------------------------------------------------
 1 | #ifndef MENUCONNECT_H
 2 | #define MENUCONNECT_H
 3 | 
 4 | #include <QMenu>
 5 | #include "enums.h"
 6 | #include "modbusmultiserver.h"
 7 | 
 8 | class MenuConnect : public QMenu
 9 | {
10 |     Q_OBJECT
11 | public:
12 |     enum MenuType
13 |     {
14 |         ConnectMenu = 0,
15 |         DisconnectMenu
16 |     };
17 | 
18 |     explicit MenuConnect(MenuType type, ModbusMultiServer& server, QWidget *parent = nullptr);
19 | 
20 |     bool canConnect(const ConnectionDetails& cd);
21 |     void updateConnectionDetails(const QList<ConnectionDetails>& conns);
22 | 
23 | signals:
24 |     void connectAction(ConnectionDetails& cd);
25 |     void disconnectAction(ConnectionType type, const QString& port);
26 | 
27 | protected:
28 |     void changeEvent(QEvent* event) override;
29 | 
30 | private:
31 |     void addAction(const QString& text, ConnectionType type, const QString& port);
32 | 
33 | private:
34 |     MenuType _menuType;
35 |     ModbusMultiServer& _mbMultiServer;
36 |     QMap<QAction*, ConnectionDetails> _connectionDetailsMap;
37 | };
38 | 
39 | #endif // MENUCONNECT_H
40 | 


--------------------------------------------------------------------------------
/omodsim/modbusdataunitmap.h:
--------------------------------------------------------------------------------
 1 | #ifndef MODBUSDATAUNITMAP_H
 2 | #define MODBUSDATAUNITMAP_H
 3 | 
 4 | #include <QModbusDataUnit>
 5 | 
 6 | ///
 7 | /// \brief The ModbusDataUnitMap class
 8 | ///
 9 | class ModbusDataUnitMap
10 | {
11 | public:
12 |     explicit ModbusDataUnitMap();
13 | 
14 |     void addUnitMap(int id, QModbusDataUnit::RegisterType pointType, quint16 pointAddress, quint16 length);
15 |     void removeUnitMap(int id);
16 | 
17 |     void setData(const QModbusDataUnit& data);
18 |     QModbusDataUnit getData(QModbusDataUnit::RegisterType pointType, quint16 pointAddress, quint16 length) const;
19 | 
20 |     QModbusDataUnitMap::ConstIterator begin();
21 |     QModbusDataUnitMap::Iterator end();
22 | 
23 |     operator QModbusDataUnitMap(){
24 |         return _modbusDataUnitMap;
25 |     }
26 | 
27 | private:
28 |     void updateDataUnitMap();
29 | 
30 | private:
31 |     QMap<int, QModbusDataUnit> _dataUnits;
32 |     QModbusDataUnitMap _modbusDataUnitMap;
33 |     QModbusDataUnitMap _modbusDataUnitGlobalMap;
34 | };
35 | 
36 | 
37 | #endif // MODBUSDATAUNITMAP_H
38 | 


--------------------------------------------------------------------------------
/omodsim/modbusexception.h:
--------------------------------------------------------------------------------
 1 | #ifndef MODBUSEXCEPTION_H
 2 | #define MODBUSEXCEPTION_H
 3 | 
 4 | #include <QModbusPdu>
 5 | 
 6 | ///
 7 | /// \brief The ModbusException class
 8 | ///
 9 | class ModbusException
10 | {
11 | public:
12 |     explicit ModbusException(QModbusPdu::ExceptionCode code)
13 |         :_code(code)
14 |     {
15 |     }
16 | 
17 |     operator int() const
18 |     {
19 |         return _code;
20 |     }
21 | 
22 |     operator QString() const
23 |     {
24 |         QString desc;
25 |         switch (_code)
26 |         {
27 |             case QModbusPdu::IllegalFunction:
28 |                 desc = "ILLEGAL FUNCTION";
29 |             break;
30 |             case QModbusPdu::IllegalDataAddress:
31 |                 desc = "ILLEGAL DATA ADDRESS";
32 |             break;
33 |             case QModbusPdu::IllegalDataValue:
34 |                 desc = "ILLEGAL DATA VALUE";
35 |             break;
36 |             case QModbusPdu::ServerDeviceFailure:
37 |                 desc = "SERVER DEVICE FAILURE";
38 |             break;
39 |             case QModbusPdu::Acknowledge:
40 |                 desc = "ACKNOWLEDGE";
41 |             break;
42 |             case QModbusPdu::ServerDeviceBusy:
43 |                 desc = "SERVER DEVICE BUSY";
44 |             break;
45 |             case QModbusPdu::NegativeAcknowledge:
46 |                 desc = "NEGATIVE ACKNOWLEDGEMENT";
47 |             break;
48 |             case QModbusPdu::MemoryParityError:
49 |                 desc = "MEMORY PARITY ERROR";
50 |             break;
51 |             case QModbusPdu::GatewayPathUnavailable:
52 |                 desc = "GATEWAY PATH UNAVAILABLE";
53 |             break;
54 |             case QModbusPdu::GatewayTargetDeviceFailedToRespond:
55 |                 desc = "GATEWAY TARGET DEVICE FAILED TO RESPOND";
56 |             break;
57 |             case QModbusPdu::ExtendedException:
58 |                 desc = "EXTENDED EXCEPTION";
59 |             break;
60 |         }
61 |         return desc;
62 |     }
63 | 
64 | private:
65 |     QModbusPdu::ExceptionCode _code;
66 | };
67 | 
68 | #endif // MODBUSEXCEPTION_H
69 | 


--------------------------------------------------------------------------------
/omodsim/modbuslimits.h:
--------------------------------------------------------------------------------
 1 | #ifndef MODBUSLIMITS_H
 2 | #define MODBUSLIMITS_H
 3 | 
 4 | #include "qrange.h"
 5 | 
 6 | class ModbusLimits final
 7 | {
 8 | public:
 9 |     static QRange<int> addressRange(bool zeroBased = false)  { return { (zeroBased ? 0 : 1), 65535 }; }
10 |     static QRange<int> lengthRange()   { return { 1, 200   }; }
11 |     static QRange<int> slaveRange()    { return { 1, 255   }; }
12 | };
13 | 
14 | #endif // MODBUSLIMITS_H
15 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/diagnostics.h:
--------------------------------------------------------------------------------
  1 | #ifndef DIAGNOSTICS_H
  2 | #define DIAGNOSTICS_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The DiagnosticsRequest class
  8 | ///
  9 | class DiagnosticsRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief DiagnosticsRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     DiagnosticsRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::Diagnostics);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief DiagnosticsRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     DiagnosticsRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::Diagnostics);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() && dataSize() > 2;
 43 |     }
 44 | 
 45 | 
 46 |     ///
 47 |     /// \brief subfunc
 48 |     /// \return
 49 |     ///
 50 |     quint16 subfunc() const {
 51 |         return makeUInt16(ModbusMessage::at(1), ModbusMessage::at(0), ByteOrder::LittleEndian);
 52 |     }
 53 | 
 54 |     ///
 55 |     /// \brief data
 56 |     /// \return
 57 |     ///
 58 |     QByteArray data() const {
 59 |         return ModbusMessage::data(2);
 60 |     }
 61 | };
 62 | 
 63 | ///
 64 | /// \brief The DiagnosticsResponse class
 65 | ///
 66 | class DiagnosticsResponse : public ModbusMessage
 67 | {
 68 | public:
 69 |     ///
 70 |     /// \brief DiagnosticsResponse
 71 |     /// \param pdu
 72 |     /// \param protocol
 73 |     /// \param deviceId
 74 |     /// \param timestamp
 75 |     ///
 76 |     DiagnosticsResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 77 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 78 |     {
 79 |         Q_ASSERT(functionCode() == QModbusPdu::Diagnostics);
 80 |     }
 81 | 
 82 |     ///
 83 |     /// \brief DiagnosticsResponse
 84 |     /// \param data
 85 |     /// \param protocol
 86 |     /// \param timestamp
 87 |     ///
 88 |     DiagnosticsResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 89 |         : ModbusMessage(data, protocol, timestamp, false)
 90 |     {
 91 |         Q_ASSERT(functionCode() == QModbusPdu::Diagnostics);
 92 |     }
 93 | 
 94 |     ///
 95 |     /// \brief isValid
 96 |     /// \return
 97 |     ///
 98 |     bool isValid() const override {
 99 |         return ModbusMessage::isValid() && dataSize() > 2;
100 |     }
101 | 
102 |     ///
103 |     /// \brief subfunc
104 |     /// \return
105 |     ///
106 |     quint16 subfunc() const {
107 |         return makeUInt16(ModbusMessage::at(1), ModbusMessage::at(0), ByteOrder::LittleEndian);
108 |     }
109 | 
110 |     ///
111 |     /// \brief data
112 |     /// \return
113 |     ///
114 |     QByteArray data() const {
115 |         return ModbusMessage::data(2);
116 |     }
117 | };
118 | 
119 | #endif // DIAGNOSTICS_H
120 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/getcommeventcounter.h:
--------------------------------------------------------------------------------
 1 | #ifndef GETCOMMEVENTCOUNTER_H
 2 | #define GETCOMMEVENTCOUNTER_H
 3 | 
 4 | #include "modbusmessage.h"
 5 | 
 6 | ///
 7 | /// \brief The GetCommEventCounterRequest class
 8 | ///
 9 | class GetCommEventCounterRequest : public ModbusMessage
10 | {
11 | public:
12 |     ///
13 |     /// \brief GetCommEventCounterRequest
14 |     /// \param pdu
15 |     /// \param protocol
16 |     /// \param deviceId
17 |     /// \param timestamp
18 |     ///
19 |     GetCommEventCounterRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
21 |     {
22 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventCounter);
23 |     }
24 | 
25 |     ///
26 |     /// \brief GetCommEventCounterRequest
27 |     /// \param data
28 |     /// \param protocol
29 |     /// \param timestamp
30 |     ///
31 |     GetCommEventCounterRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
32 |         : ModbusMessage(data, protocol, timestamp, true)
33 |     {
34 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventCounter);
35 |     }
36 | };
37 | 
38 | ///
39 | /// \brief The GetCommEventCounterResponse class
40 | ///
41 | class GetCommEventCounterResponse : public ModbusMessage
42 | {
43 | public:
44 |     ///
45 |     /// \brief GetCommEventCounterResponse
46 |     /// \param pdu
47 |     /// \param protocol
48 |     /// \param deviceId
49 |     /// \param timestamp
50 |     ///
51 |     GetCommEventCounterResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
52 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
53 |     {
54 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventCounter);
55 |     }
56 | 
57 |     ///
58 |     /// \brief GetCommEventCounterResponse
59 |     /// \param data
60 |     /// \param protocol
61 |     /// \param timestamp
62 |     ///
63 |     GetCommEventCounterResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
64 |         : ModbusMessage(data, protocol, timestamp, false)
65 |     {
66 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventCounter);
67 |     }
68 | 
69 |     ///
70 |     /// \brief isValid
71 |     /// \return
72 |     ///
73 |     bool isValid() const override {
74 |         return ModbusMessage::isValid() && dataSize() == 4;
75 |     }
76 | 
77 |     ///
78 |     /// \brief status
79 |     /// \return
80 |     ///
81 |     quint16 status() const {
82 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
83 |     }
84 | 
85 |     ///
86 |     /// \brief eventCount
87 |     /// \return
88 |     ///
89 |     quint16 eventCount() const {
90 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
91 |     }
92 | };
93 | 
94 | #endif // GETCOMMEVENTCOUNTER_H
95 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/getcommeventlog.h:
--------------------------------------------------------------------------------
  1 | #ifndef GETCOMMEVENTLOG_H
  2 | #define GETCOMMEVENTLOG_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The GetCommEventLogRequest class
  8 | ///
  9 | class GetCommEventLogRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief GetCommEventLogRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     GetCommEventLogRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventLog);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief GetCommEventLogRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     GetCommEventLogRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventLog);
 35 |     }
 36 | };
 37 | 
 38 | ///
 39 | /// \brief The GetCommEventLogResponse class
 40 | ///
 41 | class GetCommEventLogResponse : public ModbusMessage
 42 | {
 43 | public:
 44 |     ///
 45 |     /// \brief GetCommEventLogResponse
 46 |     /// \param pdu
 47 |     /// \param protocol
 48 |     /// \param deviceId
 49 |     /// \param timestamp
 50 |     ///
 51 |     GetCommEventLogResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 52 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 53 |     {
 54 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventLog);
 55 |     }
 56 | 
 57 |     ///
 58 |     /// \brief GetCommEventLogResponse
 59 |     /// \param data
 60 |     /// \param protocol
 61 |     /// \param timestamp
 62 |     ///
 63 |     GetCommEventLogResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 64 |         : ModbusMessage(data, protocol, timestamp, false)
 65 |     {
 66 |         Q_ASSERT(functionCode() == QModbusPdu::GetCommEventLog);
 67 |     }
 68 | 
 69 |     ///
 70 |     /// \brief isValid
 71 |     /// \return
 72 |     ///
 73 |     bool isValid() const override {
 74 |         return ModbusMessage::isValid() &&
 75 |                byteCount() > 0 &&
 76 |                byteCount() == events().size() - 6;
 77 |     }
 78 | 
 79 |     ///
 80 |     /// \brief byteCount
 81 |     /// \return
 82 |     ///
 83 |     quint8 byteCount() const {
 84 |         return at(0);
 85 |     }
 86 | 
 87 |     ///
 88 |     /// \brief status
 89 |     /// \return
 90 |     ///
 91 |     quint16 status() const {
 92 |         return makeUInt16(at(2), at(1), ByteOrder::LittleEndian);
 93 |     }
 94 | 
 95 |     ///
 96 |     /// \brief eventCount
 97 |     /// \return
 98 |     ///
 99 |     quint16 eventCount() const {
100 |         return makeUInt16(at(4), at(3), ByteOrder::LittleEndian);
101 |     }
102 | 
103 |     ///
104 |     /// \brief messageCount
105 |     /// \return
106 |     ///
107 |     quint16 messageCount() const {
108 |         return makeUInt16(at(6), at(5), ByteOrder::LittleEndian);
109 |     }
110 | 
111 |     ///
112 |     /// \brief events
113 |     /// \return
114 |     ///
115 |     QByteArray events() const {
116 |         return data(7);
117 |     }
118 | };
119 | 
120 | #endif // GETCOMMEVENTLOG_H
121 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/modbusmessages.h:
--------------------------------------------------------------------------------
 1 | #include "modbusmessage.h"
 2 | #include "readcoils.h"
 3 | #include "readdiscreteinputs.h"
 4 | #include "readholdingregisters.h"
 5 | #include "readinputregisters.h"
 6 | #include "writesinglecoil.h"
 7 | #include "writesingleregister.h"
 8 | #include "readexceptionstatus.h"
 9 | #include "diagnostics.h"
10 | #include "getcommeventcounter.h"
11 | #include "getcommeventlog.h"
12 | #include "writemultiplecoils.h"
13 | #include "writemultipleregisters.h"
14 | #include "reportserverid.h"
15 | #include "readfilerecord.h"
16 | #include "writefilerecord.h"
17 | #include "maskwriteregister.h"
18 | #include "readwritemultipleregisters.h"
19 | #include "readfifoqueue.h"
20 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/readcoils.h:
--------------------------------------------------------------------------------
  1 | #ifndef READCOILS_H
  2 | #define READCOILS_H
  3 | 
  4 | #include "numericutils.h"
  5 | #include "modbusmessage.h"
  6 | 
  7 | ///
  8 | /// \brief The ReadCoilsRequest class
  9 | ///
 10 | class ReadCoilsRequest : public ModbusMessage
 11 | {
 12 | public:
 13 |     ///
 14 |     /// \brief ReadCoilsRequest
 15 |     /// \param pdu
 16 |     /// \param protocol
 17 |     /// \param deviceId
 18 |     /// \param timestamp
 19 |     ///
 20 |     ReadCoilsRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 21 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 22 |     {
 23 |         Q_ASSERT(functionCode() == QModbusPdu::ReadCoils);
 24 |     }
 25 | 
 26 |     ///
 27 |     /// \brief ReadCoilsRequest
 28 |     /// \param data
 29 |     /// \param protocol
 30 |     /// \param timestamp
 31 |     ///
 32 |     ReadCoilsRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 33 |         : ModbusMessage(data, protocol, timestamp, true)
 34 |     {
 35 |         Q_ASSERT(functionCode() == QModbusPdu::ReadCoils);
 36 |     }
 37 | 
 38 |     ///
 39 |     /// \brief isValid
 40 |     /// \return
 41 |     ///
 42 |     bool isValid() const override {
 43 |         return ModbusMessage::isValid() &&
 44 |                length() >= 1 && length() <= 0x7D0;
 45 |     }
 46 | 
 47 |     ///
 48 |     /// \brief startAddress
 49 |     /// \return
 50 |     ///
 51 |     quint16 startAddress() const {
 52 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
 53 |     }
 54 | 
 55 |     ///
 56 |     /// \brief length
 57 |     /// \return
 58 |     ///
 59 |     quint16 length() const {
 60 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
 61 |     }
 62 | };
 63 | 
 64 | ///
 65 | /// \brief The ReadCoilsResponse class
 66 | ///
 67 | class ReadCoilsResponse : public ModbusMessage
 68 | {
 69 | public:
 70 |     ///
 71 |     /// \brief ReadCoilsResponse
 72 |     /// \param pdu
 73 |     /// \param protocol
 74 |     /// \param deviceId
 75 |     /// \param timestamp
 76 |     ///
 77 |     ReadCoilsResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 78 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 79 |     {
 80 |         Q_ASSERT(functionCode() == QModbusPdu::ReadCoils);
 81 |     }
 82 | 
 83 |     ///
 84 |     /// \brief ReadCoilsResponse
 85 |     /// \param data
 86 |     /// \param protocol
 87 |     /// \param timestamp
 88 |     ///
 89 |     ReadCoilsResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 90 |         : ModbusMessage(data, protocol, timestamp, false)
 91 |     {
 92 |         Q_ASSERT(functionCode() == QModbusPdu::ReadCoils);
 93 |     }
 94 | 
 95 |     ///
 96 |     /// \brief isValid
 97 |     /// \return
 98 |     ///
 99 |     bool isValid() const override {
100 |         return ModbusMessage::isValid() &&
101 |                byteCount() > 0 &&
102 |                (byteCount() == coilStatus().size() || byteCount() == coilStatus().size() - 1);
103 |     }
104 | 
105 |     ///
106 |     /// \brief byteCount
107 |     /// \return
108 |     ///
109 |     quint8 byteCount() const {
110 |         return at(0);
111 |     }
112 | 
113 |     ///
114 |     /// \brief coilStatus
115 |     /// \return
116 |     ///
117 |     QByteArray coilStatus() const {
118 |         return data(1);
119 |     }
120 | };
121 | 
122 | #endif // READCOILS_H
123 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/readdiscreteinputs.h:
--------------------------------------------------------------------------------
  1 | #ifndef READDISCRETEINPUTS_H
  2 | #define READDISCRETEINPUTS_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The ReadDiscreteInputsRequest class
  8 | ///
  9 | class ReadDiscreteInputsRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief ReadDiscreteInputsRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     ReadDiscreteInputsRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::ReadDiscreteInputs);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief ReadDiscreteInputsRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     ReadDiscreteInputsRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::ReadDiscreteInputs);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() &&
 43 |                length() >= 1 && length() <= 0x7D0;
 44 |     }
 45 | 
 46 |     ///
 47 |     /// \brief startAddress
 48 |     /// \return
 49 |     ///
 50 |     quint16 startAddress() const {
 51 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
 52 |     }
 53 | 
 54 |     ///
 55 |     /// \brief length
 56 |     /// \return
 57 |     ///
 58 |     quint16 length() const {
 59 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
 60 |     }
 61 | };
 62 | 
 63 | ///
 64 | /// \brief The ReadDiscreteInputsResponse class
 65 | ///
 66 | class ReadDiscreteInputsResponse : public ModbusMessage
 67 | {
 68 | public:
 69 |     ///
 70 |     /// \brief ReadDiscreteInputsResponse
 71 |     /// \param pdu
 72 |     /// \param protocol
 73 |     /// \param deviceId
 74 |     /// \param timestamp
 75 |     ///
 76 |     ReadDiscreteInputsResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 77 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 78 |     {
 79 |         Q_ASSERT(functionCode() == QModbusPdu::ReadDiscreteInputs);
 80 |     }
 81 | 
 82 |     ///
 83 |     /// \brief ReadDiscreteInputsResponse
 84 |     /// \param data
 85 |     /// \param protocol
 86 |     /// \param timestamp
 87 |     ///
 88 |     ReadDiscreteInputsResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 89 |         : ModbusMessage(data, protocol, timestamp, false)
 90 |     {
 91 |         Q_ASSERT(functionCode() == QModbusPdu::ReadDiscreteInputs);
 92 |     }
 93 | 
 94 |     ///
 95 |     /// \brief isValid
 96 |     /// \return
 97 |     ///
 98 |     bool isValid() const override {
 99 |         return ModbusMessage::isValid() &&
100 |                byteCount() > 0 &&
101 |                (byteCount() == inputStatus().size() || byteCount() == inputStatus().size() - 1);
102 |     }
103 | 
104 |     ///
105 |     /// \brief byteCount
106 |     /// \return
107 |     ///
108 |     quint8 byteCount() const {
109 |         return at(0);
110 |     }
111 | 
112 |     ///
113 |     /// \brief inputStatus
114 |     /// \return
115 |     ///
116 |     QByteArray inputStatus() const {
117 |         return data(1);
118 |     }
119 | };
120 | 
121 | #endif // READDISCRETEINPUTS_H
122 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/readexceptionstatus.h:
--------------------------------------------------------------------------------
 1 | #ifndef READEXCEPTIONSTATUS_H
 2 | #define READEXCEPTIONSTATUS_H
 3 | 
 4 | #include "modbusmessage.h"
 5 | 
 6 | ///
 7 | /// \brief The ReadExceptionStatusRequest class
 8 | ///
 9 | class ReadExceptionStatusRequest : public ModbusMessage
10 | {
11 | public:
12 |     ///
13 |     /// \brief ReadExceptionStatusRequest
14 |     /// \param pdu
15 |     /// \param protocol
16 |     /// \param deviceId
17 |     /// \param timestamp
18 |     ///
19 |     ReadExceptionStatusRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
21 |     {
22 |         Q_ASSERT(functionCode() == QModbusPdu::ReadExceptionStatus);
23 |     }
24 | 
25 |     ///
26 |     /// \brief ReadExceptionStatusRequest
27 |     /// \param data
28 |     /// \param protocol
29 |     /// \param timestamp
30 |     ///
31 |     ReadExceptionStatusRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
32 |         : ModbusMessage(data, protocol, timestamp, true)
33 |     {
34 |         Q_ASSERT(functionCode() == QModbusPdu::ReadExceptionStatus);
35 |     }
36 | };
37 | 
38 | ///
39 | /// \brief The ReadExceptionStatusResponse class
40 | ///
41 | class ReadExceptionStatusResponse : public ModbusMessage
42 | {
43 | public:
44 |     ///
45 |     /// \brief ReadExceptionStatusResponse
46 |     /// \param pdu
47 |     /// \param protocol
48 |     /// \param deviceId
49 |     /// \param timestamp
50 |     ///
51 |     ReadExceptionStatusResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
52 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
53 |     {
54 |         Q_ASSERT(functionCode() == QModbusPdu::ReadExceptionStatus);
55 |     }
56 | 
57 |     ///
58 |     /// \brief ReadExceptionStatusResponse
59 |     /// \param data
60 |     /// \param protocol
61 |     /// \param timestamp
62 |     ///
63 |     ReadExceptionStatusResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
64 |         : ModbusMessage(data, protocol, timestamp, false)
65 |     {
66 |         Q_ASSERT(functionCode() == QModbusPdu::ReadExceptionStatus);
67 |     }
68 | 
69 |     ///
70 |     /// \brief isValid
71 |     /// \return
72 |     ///
73 |     bool isValid() const override {
74 |         return ModbusMessage::isValid() && dataSize() == 1;
75 |     }
76 | 
77 |     ///
78 |     /// \brief outputData
79 |     /// \return
80 |     ///
81 |     quint8 outputData() const {
82 |         return at(0);
83 |     }
84 | };
85 | 
86 | #endif // READEXCEPTIONSTATUS_H
87 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/readfifoqueue.h:
--------------------------------------------------------------------------------
  1 | #ifndef READFIFOQUEUE_H
  2 | #define READFIFOQUEUE_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The ReadFifoQueueRequest class
  8 | ///
  9 | class ReadFifoQueueRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief ReadFifoQueueRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     ReadFifoQueueRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFifoQueue);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief ReadFifoQueueRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     ReadFifoQueueRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFifoQueue);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() && dataSize() == 2;
 43 |     }
 44 | 
 45 |     ///
 46 |     /// \brief fifoAddress
 47 |     /// \return
 48 |     ///
 49 |     quint16 fifoAddress() const {
 50 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
 51 |     }
 52 | };
 53 | 
 54 | ///
 55 | /// \brief The ReadFifoQueueResponse class
 56 | ///
 57 | class ReadFifoQueueResponse : public ModbusMessage
 58 | {
 59 | public:
 60 |     ///
 61 |     /// \brief ReadFifoQueueResponse
 62 |     /// \param pdu
 63 |     /// \param protocol
 64 |     /// \param deviceId
 65 |     /// \param timestamp
 66 |     ///
 67 |     ReadFifoQueueResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 68 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 69 |     {
 70 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFifoQueue);
 71 |     }
 72 | 
 73 |     ///
 74 |     /// \brief ReadFifoQueueResponse
 75 |     /// \param data
 76 |     /// \param protocol
 77 |     /// \param timestamp
 78 |     ///
 79 |     ReadFifoQueueResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 80 |         : ModbusMessage(data, protocol, timestamp, false)
 81 |     {
 82 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFifoQueue);
 83 |     }
 84 | 
 85 |     ///
 86 |     /// \brief isValid
 87 |     /// \return
 88 |     ///
 89 |     bool isValid() const override {
 90 |         return ModbusMessage::isValid() &&
 91 |                fifoCount() <= 31 &&
 92 |                fifoCount() == fifoValue().size();
 93 |     }
 94 | 
 95 |     ///
 96 |     /// \brief byteCount
 97 |     /// \return
 98 |     ///
 99 |     quint16 byteCount() const {
100 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
101 |     }
102 | 
103 |     ///
104 |     /// \brief fifoCount
105 |     /// \return
106 |     ///
107 |     quint16 fifoCount() const {
108 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
109 |     }
110 | 
111 |     ///
112 |     /// \brief fifoValue
113 |     /// \return
114 |     ///
115 |     QByteArray fifoValue() const {
116 |         return  data(4);
117 |     }
118 | };
119 | 
120 | #endif // READFIFOQUEUE_H
121 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/readfilerecord.h:
--------------------------------------------------------------------------------
  1 | #ifndef READFILERECORD_H
  2 | #define READFILERECORD_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The ReadFileRecordRequest class
  8 | ///
  9 | class ReadFileRecordRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief ReadFileRecordRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     ReadFileRecordRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFileRecord);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief ReadFileRecordRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     ReadFileRecordRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFileRecord);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() &&
 43 |                byteCount() >= 0x07 && byteCount() <= 0xF5;
 44 |     }
 45 | 
 46 |     ///
 47 |     /// \brief byteCount
 48 |     /// \return
 49 |     ///
 50 |     quint8 byteCount() const {
 51 |         return ModbusMessage::at(0);
 52 |     }
 53 | 
 54 |     ///
 55 |     /// \brief data
 56 |     /// \return
 57 |     ///
 58 |     QByteArray data() const {
 59 |         return  ModbusMessage::data(1);
 60 |     }
 61 | };
 62 | 
 63 | ///
 64 | /// \brief The ReadFileRecordResponse class
 65 | ///
 66 | class ReadFileRecordResponse : public ModbusMessage
 67 | {
 68 | public:
 69 |     ///
 70 |     /// \brief ReadFileRecordResponse
 71 |     /// \param pdu
 72 |     /// \param protocol
 73 |     /// \param deviceId
 74 |     /// \param timestamp
 75 |     ///
 76 |     ReadFileRecordResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 77 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 78 |     {
 79 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFileRecord);
 80 |     }
 81 | 
 82 |     ///
 83 |     /// \brief ReadFileRecordResponse
 84 |     /// \param data
 85 |     /// \param protocol
 86 |     /// \param timestamp
 87 |     ///
 88 |     ReadFileRecordResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 89 |         : ModbusMessage(data, protocol, timestamp, false)
 90 |     {
 91 |         Q_ASSERT(functionCode() == QModbusPdu::ReadFileRecord);
 92 |     }
 93 | 
 94 |     ///
 95 |     /// \brief isValid
 96 |     /// \return
 97 |     ///
 98 |     bool isValid() const override {
 99 |         return ModbusMessage::isValid() &&
100 |                byteCount() >= 0x07 && byteCount() <= 0xF5;;
101 |     }
102 | 
103 |     ///
104 |     /// \brief byteCount
105 |     /// \return
106 |     ///
107 |     quint8 byteCount() const {
108 |         return ModbusMessage::at(0);
109 |     }
110 | 
111 |     ///
112 |     /// \brief data
113 |     /// \return
114 |     ///
115 |     QByteArray data() const {
116 |         return  ModbusMessage::data(1);
117 |     }
118 | };
119 | 
120 | #endif // READFILERECORD_H
121 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/readholdingregisters.h:
--------------------------------------------------------------------------------
  1 | #ifndef READHOLDINGREGISTERS_H
  2 | #define READHOLDINGREGISTERS_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The ReadHoldingRegistersRequest class
  8 | ///
  9 | class ReadHoldingRegistersRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief ReadHoldingRegistersRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     ReadHoldingRegistersRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::ReadHoldingRegisters);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief ReadHoldingRegistersRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     ReadHoldingRegistersRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::ReadHoldingRegisters);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() &&
 43 |                length() >= 1 && length() <= 0x7D;
 44 |     }
 45 | 
 46 |     ///
 47 |     /// \brief startAddress
 48 |     /// \return
 49 |     ///
 50 |     quint16 startAddress() const {
 51 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
 52 |     }
 53 | 
 54 |     ///
 55 |     /// \brief length
 56 |     /// \return
 57 |     ///
 58 |     quint16 length() const {
 59 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
 60 |     }
 61 | };
 62 | 
 63 | ///
 64 | /// \brief The ReadHoldingRegistersResponse class
 65 | ///
 66 | class ReadHoldingRegistersResponse : public ModbusMessage
 67 | {
 68 | public:
 69 |     ///
 70 |     /// \brief ReadHoldingRegistersResponse
 71 |     /// \param pdu
 72 |     /// \param protocol
 73 |     /// \param deviceId
 74 |     /// \param timestamp
 75 |     ///
 76 |     ReadHoldingRegistersResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 77 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 78 |     {
 79 |         Q_ASSERT(functionCode() == QModbusPdu::ReadHoldingRegisters);
 80 |     }
 81 | 
 82 |     ///
 83 |     /// \brief ReadHoldingRegistersResponse
 84 |     /// \param data
 85 |     /// \param protocol
 86 |     /// \param timestamp
 87 |     ///
 88 |     ReadHoldingRegistersResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 89 |         : ModbusMessage(data, protocol, timestamp, false)
 90 |     {
 91 |         Q_ASSERT(functionCode() == QModbusPdu::ReadHoldingRegisters);
 92 |     }
 93 | 
 94 |     ///
 95 |     /// \brief isValid
 96 |     /// \return
 97 |     ///
 98 |     bool isValid() const override {
 99 |         return ModbusMessage::isValid() &&
100 |                byteCount() > 0 &&
101 |                byteCount() == registerValue().size();
102 |     }
103 | 
104 |     ///
105 |     /// \brief byteCount
106 |     /// \return
107 |     ///
108 |     quint8 byteCount() const {
109 |         return at(0);
110 |     }
111 | 
112 |     ///
113 |     /// \brief registerValue
114 |     /// \return
115 |     ///
116 |     QByteArray registerValue() const {
117 |         return data(1);
118 |     }
119 | };
120 | 
121 | #endif // READHOLDINGREGISTERS_H
122 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/readinputregisters.h:
--------------------------------------------------------------------------------
  1 | #ifndef READINPUTREGISTERS_H
  2 | #define READINPUTREGISTERS_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The ReadInputRegistersRequest class
  8 | ///
  9 | class ReadInputRegistersRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief ReadInputRegistersRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     ReadInputRegistersRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::ReadInputRegisters);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief ReadInputRegistersRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     ReadInputRegistersRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::ReadInputRegisters);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() &&
 43 |                length() >= 1 && length() <= 0x7D;
 44 |     }
 45 | 
 46 |     ///
 47 |     /// \brief startAddress
 48 |     /// \return
 49 |     ///
 50 |     quint16 startAddress() const {
 51 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
 52 |     }
 53 | 
 54 |     ///
 55 |     /// \brief length
 56 |     /// \return
 57 |     ///
 58 |     quint16 length() const {
 59 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
 60 |     }
 61 | };
 62 | 
 63 | ///
 64 | /// \brief The ReadInputRegistersResponse class
 65 | ///
 66 | class ReadInputRegistersResponse : public ModbusMessage
 67 | {
 68 | public:
 69 |     ///
 70 |     /// \brief ReadInputRegistersResponse
 71 |     /// \param pdu
 72 |     /// \param protocol
 73 |     /// \param deviceId
 74 |     /// \param timestamp
 75 |      ///
 76 |     ReadInputRegistersResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 77 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 78 |     {
 79 |         Q_ASSERT(functionCode() == QModbusPdu::ReadInputRegisters);
 80 |     }
 81 | 
 82 |     ///
 83 |     /// \brief ReadInputRegistersResponse
 84 |     /// \param data
 85 |     /// \param protocol
 86 |     /// \param timestamp
 87 |     ///
 88 |     ReadInputRegistersResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 89 |         : ModbusMessage(data, protocol, timestamp, false)
 90 |     {
 91 |         Q_ASSERT(functionCode() == QModbusPdu::ReadInputRegisters);
 92 |     }
 93 | 
 94 |     ///
 95 |     /// \brief isValid
 96 |     /// \return
 97 |     ///
 98 |     bool isValid() const override {
 99 |         return ModbusMessage::isValid() &&
100 |                byteCount() > 0 &&
101 |                byteCount() == registerValue().size();
102 |     }
103 | 
104 |     ///
105 |     /// \brief byteCount
106 |     /// \return
107 |     ///
108 |     quint8 byteCount() const {
109 |         return at(0);
110 |     }
111 | 
112 |     ///
113 |     /// \brief registerValue
114 |     /// \return
115 |     ///
116 |     QByteArray registerValue() const {
117 |         return data(1);
118 |     }
119 | };
120 | 
121 | #endif // READINPUTREGISTERS_H
122 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/reportserverid.h:
--------------------------------------------------------------------------------
 1 | #ifndef REPORTSERVERID_H
 2 | #define REPORTSERVERID_H
 3 | 
 4 | #include "modbusmessage.h"
 5 | 
 6 | ///
 7 | /// \brief The ReportServerIdRequest class
 8 | ///
 9 | class ReportServerIdRequest : public ModbusMessage
10 | {
11 | public:
12 |     ///
13 |     /// \brief ReportServerIdRequest
14 |     /// \param pdu
15 |     /// \param protocol
16 |     /// \param deviceId
17 |     /// \param timestamp
18 |     ///
19 |     ReportServerIdRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
21 |     {
22 |         Q_ASSERT(functionCode() == QModbusPdu::ReportServerId);
23 |     }
24 | 
25 |     ///
26 |     /// \brief ReportServerIdRequest
27 |     /// \param data
28 |     /// \param protocol
29 |     /// \param timestamp
30 |     ///
31 |     ReportServerIdRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
32 |         : ModbusMessage(data, protocol, timestamp, true)
33 |     {
34 |         Q_ASSERT(functionCode() == QModbusPdu::ReportServerId);
35 |     }
36 | };
37 | 
38 | ///
39 | /// \brief The ReportServerIdResponse class
40 | ///
41 | class ReportServerIdResponse : public ModbusMessage
42 | {
43 | public:
44 |     ///
45 |     /// \brief ReportServerIdResponse
46 |     /// \param pdu
47 |     /// \param protocol
48 |     /// \param deviceId
49 |     /// \param timestamp
50 |     ///
51 |     ReportServerIdResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
52 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
53 |     {
54 |         Q_ASSERT(functionCode() == QModbusPdu::ReportServerId);
55 |     }
56 | 
57 |     ///
58 |     /// \brief ReportServerIdResponse
59 |     /// \param data
60 |     /// \param protocol
61 |     /// \param timestamp
62 |     ///
63 |     ReportServerIdResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
64 |         : ModbusMessage(data, protocol, timestamp, false)
65 |     {
66 |         Q_ASSERT(functionCode() == QModbusPdu::ReportServerId);
67 |     }
68 | 
69 |     ///
70 |     /// \brief isValid
71 |     /// \return
72 |     ///
73 |     bool isValid() const override {
74 |         return ModbusMessage::isValid() && dataSize() > 1;
75 |     }
76 | 
77 |     ///
78 |     /// \brief byteCount
79 |     /// \return
80 |     ///
81 |     quint8 byteCount() const {
82 |         return ModbusMessage::at(0);
83 |     }
84 | 
85 |     ///
86 |     /// \brief data
87 |     /// \return
88 |     ///
89 |     QByteArray data() const {
90 |         return  ModbusMessage::data(1);
91 |     }
92 | };
93 | 
94 | #endif // REPORTSERVERID_H
95 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/writefilerecord.h:
--------------------------------------------------------------------------------
  1 | #ifndef WRITEFILERECORD_H
  2 | #define WRITEFILERECORD_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The WriteFileRecordRequest class
  8 | ///
  9 | class WriteFileRecordRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief WriteFileRecordRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     WriteFileRecordRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::WriteFileRecord);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief WriteFileRecordRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     WriteFileRecordRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::WriteFileRecord);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() &&
 43 |                length() >= 0x09 &&
 44 |                length() <= 0xFB;
 45 |     }
 46 | 
 47 |     ///
 48 |     /// \brief length
 49 |     /// \return
 50 |     ///
 51 |     quint8 length() const {
 52 |         return ModbusMessage::at(0);
 53 |     }
 54 | 
 55 |     ///
 56 |     /// \brief data
 57 |     /// \return
 58 |     ///
 59 |     QByteArray data() const {
 60 |         return  ModbusMessage::data(1);
 61 |     }
 62 | };
 63 | 
 64 | ///
 65 | /// \brief The WriteFileRecordResponse class
 66 | ///
 67 | class WriteFileRecordResponse : public ModbusMessage
 68 | {
 69 | public:
 70 |     ///
 71 |     /// \brief WriteFileRecordResponse
 72 |     /// \param pdu
 73 |     /// \param protocol
 74 |     /// \param deviceId
 75 |     /// \param timestamp
 76 |     ///
 77 |     WriteFileRecordResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 78 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 79 |     {
 80 |         Q_ASSERT(functionCode() == QModbusPdu::WriteFileRecord);
 81 |     }
 82 | 
 83 |     ///
 84 |     /// \brief WriteFileRecordResponse
 85 |     /// \param data
 86 |     /// \param protocol
 87 |     /// \param timestamp
 88 |     ///
 89 |     WriteFileRecordResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 90 |         : ModbusMessage(data, protocol, timestamp, false)
 91 |     {
 92 |         Q_ASSERT(functionCode() == QModbusPdu::WriteFileRecord);
 93 |     }
 94 | 
 95 |     ///
 96 |     /// \brief isValid
 97 |     /// \return
 98 |     ///
 99 |     bool isValid() const override {
100 |         return ModbusMessage::isValid() &&
101 |                length() >= 0x09 &&
102 |                length() <= 0xFB;
103 |     }
104 | 
105 |     ///
106 |     /// \brief length
107 |     /// \return
108 |     ///
109 |     quint8 length() const {
110 |         return ModbusMessage::at(0);
111 |     }
112 | 
113 |     ///
114 |     /// \brief data
115 |     /// \return
116 |     ///
117 |     QByteArray data() const {
118 |         return  ModbusMessage::data(1);
119 |     }
120 | };
121 | 
122 | #endif // WRITEFILERECORD_H
123 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/writesinglecoil.h:
--------------------------------------------------------------------------------
  1 | #ifndef WRITESINGLECOIL_H
  2 | #define WRITESINGLECOIL_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The WriteSingleCoilRequest class
  8 | ///
  9 | class WriteSingleCoilRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief WriteSingleCoilRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     WriteSingleCoilRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleCoil);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief WriteSingleCoilRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     WriteSingleCoilRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleCoil);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() &&
 43 |                (value() == 0 || value() == 0xFF00);
 44 |     }
 45 | 
 46 |     ///
 47 |     /// \brief address
 48 |     /// \return
 49 |     ///
 50 |     quint16 address() const {
 51 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
 52 |     }
 53 | 
 54 |     ///
 55 |     /// \brief value
 56 |     /// \return
 57 |     ///
 58 |     quint16 value() const {
 59 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
 60 |     }
 61 | };
 62 | 
 63 | ///
 64 | /// \brief The WriteSingleCoilResponse class
 65 | ///
 66 | class WriteSingleCoilResponse : public ModbusMessage
 67 | {
 68 | public:
 69 |     ///
 70 |     /// \brief WriteSingleCoilResponse
 71 |     /// \param pdu
 72 |     /// \param protocol
 73 |     /// \param deviceId
 74 |     /// \param timestamp
 75 |     ///
 76 |     WriteSingleCoilResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 77 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 78 |     {
 79 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleCoil);
 80 |     }
 81 | 
 82 |     ///
 83 |     /// \brief WriteSingleCoilResponse
 84 |     /// \param data
 85 |     /// \param protocol
 86 |     /// \param timestamp
 87 |     ///
 88 |     WriteSingleCoilResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 89 |         : ModbusMessage(data, protocol, timestamp, false)
 90 |     {
 91 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleCoil);
 92 |     }
 93 | 
 94 |     ///
 95 |     /// \brief isValid
 96 |     /// \return
 97 |     ///
 98 |     bool isValid() const override {
 99 |         return ModbusMessage::isValid() &&
100 |                (value() == 0 || value() == 0xFF00);
101 |     }
102 | 
103 |     ///
104 |     /// \brief address
105 |     /// \return
106 |     ///
107 |     quint16 address() const {
108 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
109 |     }
110 | 
111 |     ///
112 |     /// \brief value
113 |     /// \return
114 |     ///
115 |     quint16 value() const {
116 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
117 |     }
118 | };
119 | 
120 | #endif // WRITESINGLECOIL_H
121 | 


--------------------------------------------------------------------------------
/omodsim/modbusmessages/writesingleregister.h:
--------------------------------------------------------------------------------
  1 | #ifndef WRITESINGLEREGISTER_H
  2 | #define WRITESINGLEREGISTER_H
  3 | 
  4 | #include "modbusmessage.h"
  5 | 
  6 | ///
  7 | /// \brief The WriteSingleRegisterRequest class
  8 | ///
  9 | class WriteSingleRegisterRequest : public ModbusMessage
 10 | {
 11 | public:
 12 |     ///
 13 |     /// \brief WriteSingleRegisterRequest
 14 |     /// \param pdu
 15 |     /// \param protocol
 16 |     /// \param deviceId
 17 |     /// \param timestamp
 18 |     ///
 19 |     WriteSingleRegisterRequest(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 20 |         : ModbusMessage(pdu, protocol, deviceId, timestamp, true)
 21 |     {
 22 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleRegister);
 23 |     }
 24 | 
 25 |     ///
 26 |     /// \brief WriteSingleRegisterRequest
 27 |     /// \param data
 28 |     /// \param protocol
 29 |     /// \param timestamp
 30 |     ///
 31 |     WriteSingleRegisterRequest(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 32 |         : ModbusMessage(data, protocol, timestamp, true)
 33 |     {
 34 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleRegister);
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief isValid
 39 |     /// \return
 40 |     ///
 41 |     bool isValid() const override {
 42 |         return ModbusMessage::isValid() && dataSize() == 4;
 43 |     }
 44 | 
 45 |     ///
 46 |     /// \brief address
 47 |     /// \return
 48 |     ///
 49 |     quint16 address() const {
 50 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
 51 |     }
 52 | 
 53 |     ///
 54 |     /// \brief value
 55 |     /// \return
 56 |     ///
 57 |     quint16 value() const {
 58 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
 59 |     }
 60 | };
 61 | 
 62 | ///
 63 | /// \brief The WriteSingleRegisterResponse class
 64 | ///
 65 | class WriteSingleRegisterResponse : public ModbusMessage
 66 | {
 67 | public:
 68 |     ///
 69 |     /// \brief WriteSingleRegisterResponse
 70 |     /// \param pdu
 71 |     /// \param protocol
 72 |     /// \param deviceId
 73 |     /// \param timestamp
 74 |     ///
 75 |     WriteSingleRegisterResponse(const QModbusPdu& pdu, ProtocolType protocol, int deviceId, const QDateTime& timestamp)
 76 |         :ModbusMessage(pdu, protocol, deviceId, timestamp, false)
 77 |     {
 78 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleRegister);
 79 |     }
 80 | 
 81 |     ///
 82 |     /// \brief WriteSingleRegisterResponse
 83 |     /// \param data
 84 |     /// \param protocol
 85 |     /// \param timestamp
 86 |     ///
 87 |     WriteSingleRegisterResponse(const QByteArray& data, ProtocolType protocol, const QDateTime& timestamp)
 88 |         : ModbusMessage(data, protocol, timestamp, false)
 89 |     {
 90 |         Q_ASSERT(functionCode() == QModbusPdu::WriteSingleRegister);
 91 |     }
 92 | 
 93 |     ///
 94 |     /// \brief isValid
 95 |     /// \return
 96 |     ///
 97 |     bool isValid() const override {
 98 |         return ModbusMessage::isValid() && dataSize() == 4;
 99 |     }
100 | 
101 |     ///
102 |     /// \brief address
103 |     /// \return
104 |     ///
105 |     quint16 address() const {
106 |         return makeUInt16(at(1), at(0), ByteOrder::LittleEndian);
107 |     }
108 | 
109 |     ///
110 |     /// \brief value
111 |     /// \return
112 |     ///
113 |     quint16 value() const {
114 |         return makeUInt16(at(3), at(2), ByteOrder::LittleEndian);
115 |     }
116 | };
117 | 
118 | #endif // WRITESINGLEREGISTER_H
119 | 


--------------------------------------------------------------------------------
/omodsim/modbuswriteparams.h:
--------------------------------------------------------------------------------
 1 | #ifndef MODBUSWRITEPARAMS_H
 2 | #define MODBUSWRITEPARAMS_H
 3 | 
 4 | #include <QVariant>
 5 | #include "enums.h"
 6 | 
 7 | ///
 8 | /// \brief The ModbusWriteParams class
 9 | ///
10 | struct ModbusWriteParams
11 | {
12 |     quint16 Address;
13 |     QVariant Value;
14 |     DataDisplayMode DisplayMode;
15 |     ByteOrder Order;
16 |     bool ZeroBasedAddress;
17 | };
18 | Q_DECLARE_METATYPE(ModbusWriteParams)
19 | 
20 | ///
21 | /// \brief The ModbusMaskWriteParams class
22 | ///
23 | struct ModbusMaskWriteParams
24 | {
25 |     quint16 Address;
26 |     quint16 AndMask;
27 |     quint16 OrMask;
28 |     bool ZeroBasedAddress;
29 | };
30 | Q_DECLARE_METATYPE(ModbusMaskWriteParams)
31 | 
32 | #endif // MODBUSWRITEPARAMS_H
33 | 


--------------------------------------------------------------------------------
/omodsim/qfixedsizedialog.cpp:
--------------------------------------------------------------------------------
 1 | #include "qfixedsizedialog.h"
 2 | 
 3 | ///
 4 | /// \brief QFixedSizeDialog::QFixedSizeDialog
 5 | /// \param parent
 6 | /// \param f
 7 | ///
 8 | QFixedSizeDialog::QFixedSizeDialog(QWidget *parent, Qt::WindowFlags f)
 9 |     :QDialog(parent, f)
10 | {
11 |     setWindowFlags(Qt::Dialog |
12 |                    Qt::CustomizeWindowHint |
13 |                    Qt::WindowTitleHint);
14 | }
15 | 
16 | ///
17 | /// \brief QFixedSizeDialog::showEvent
18 | /// \param e
19 | ///
20 | void QFixedSizeDialog::showEvent(QShowEvent* e)
21 | {
22 |     QDialog::showEvent(e);
23 |     setFixedSize(sizeHint());
24 | }
25 | 


--------------------------------------------------------------------------------
/omodsim/qfixedsizedialog.h:
--------------------------------------------------------------------------------
 1 | #ifndef QFIXEDSIZEDIALOG_H
 2 | #define QFIXEDSIZEDIALOG_H
 3 | 
 4 | #include <QDialog>
 5 | 
 6 | ///
 7 | /// \brief The QFixedSizeDialog class
 8 | ///
 9 | class QFixedSizeDialog : public QDialog
10 | {
11 |     Q_OBJECT
12 | 
13 | public:
14 |     QFixedSizeDialog(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
15 | 
16 | protected:
17 |     void showEvent(QShowEvent* e) override;
18 | };
19 | 
20 | #endif // QFIXEDSIZEDIALOG_H
21 | 


--------------------------------------------------------------------------------
/omodsim/qhexvalidator.cpp:
--------------------------------------------------------------------------------
 1 | #include "qhexvalidator.h"
 2 | 
 3 | ///
 4 | /// \brief QHexValidator::QHexValidator
 5 | /// \param parent
 6 | ///
 7 | QHexValidator::QHexValidator(QObject *parent)
 8 |     : QIntValidator{parent}
 9 | {
10 | }
11 | 
12 | QHexValidator::QHexValidator(int bottom, int top, QObject* parent)
13 |     : QIntValidator(bottom, top, parent)
14 | {
15 | }
16 | 
17 | ///
18 | /// \brief QHexValidator::validate
19 | /// \param input
20 | /// \return
21 | ///
22 | QHexValidator::State QHexValidator::validate(QString& input, int&) const
23 | {
24 |     bool ok = false;
25 |     input.toInt(&ok, 16);
26 | 
27 |     if (ok || input.isEmpty())
28 |     {
29 |         return QValidator::Acceptable;
30 |     }
31 | 
32 |     return QValidator::Invalid;
33 | }
34 | 


--------------------------------------------------------------------------------
/omodsim/qhexvalidator.h:
--------------------------------------------------------------------------------
 1 | #ifndef QHEXVALIDATOR_H
 2 | #define QHEXVALIDATOR_H
 3 | 
 4 | #include <QValidator>
 5 | 
 6 | ///
 7 | /// \brief The QHexValidator class
 8 | ///
 9 | class QHexValidator : public QIntValidator
10 | {
11 | public:
12 |     explicit QHexValidator(QObject *parent = nullptr);
13 |     QHexValidator(int bottom, int top, QObject* parent = nullptr);
14 | 
15 |     State validate(QString &, int &) const override;
16 | };
17 | 
18 | #endif // QHEXVALIDATOR_H
19 | 


--------------------------------------------------------------------------------
/omodsim/qint64validator.cpp:
--------------------------------------------------------------------------------
 1 | #include "qint64validator.h"
 2 | 
 3 | ///
 4 | /// \brief QInt64Validator::QInt64Validator
 5 | /// \param parent
 6 | ///
 7 | QInt64Validator::QInt64Validator(QObject *parent)
 8 |     : QValidator{parent}
 9 |     ,_bottom(0)
10 |     ,_top(UINT_MAX)
11 | {
12 | }
13 | 
14 | ///
15 | /// \brief QInt64Validator::QInt64Validator
16 | /// \param bottom
17 | /// \param top
18 | /// \param parent
19 | ///
20 | QInt64Validator::QInt64Validator(qint64 bottom, qint64 top, QObject *parent)
21 |     : QValidator(parent)
22 |     ,_bottom(bottom)
23 |     ,_top(top)
24 | {
25 | 
26 | }
27 | 
28 | ///
29 | /// \brief QInt64Validator::validate
30 | /// \return
31 | ///
32 | QValidator::State QInt64Validator::validate(QString& input, int &) const
33 | {
34 |     bool ok = false;
35 |     const auto value = input.toLongLong(&ok, 10);
36 | 
37 |     if (ok && value >=_bottom && value <=_top )
38 |     {
39 |         return QValidator::Acceptable;
40 |     }
41 | 
42 |     return QValidator::Invalid;
43 | }
44 | 


--------------------------------------------------------------------------------
/omodsim/qint64validator.h:
--------------------------------------------------------------------------------
 1 | #ifndef QINT64VALIDATOR_H
 2 | #define QINT64VALIDATOR_H
 3 | 
 4 | #include <QValidator>
 5 | #include <QObject>
 6 | 
 7 | ///
 8 | /// \brief The QInt64Validator class
 9 | ///
10 | class QInt64Validator : public QValidator
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit QInt64Validator(QObject *parent = nullptr);
15 |     QInt64Validator(qint64 bottom, qint64 top, QObject *parent = nullptr);
16 | 
17 |     State validate(QString &, int &) const override;
18 | 
19 | private:
20 |     qint64 _bottom;
21 |     qint64 _top;
22 | };
23 | 
24 | #endif // QINT64VALIDATOR_H
25 | 


--------------------------------------------------------------------------------
/omodsim/qmodbusadu.h:
--------------------------------------------------------------------------------
 1 | #ifndef QMODBUSADU_H
 2 | #define QMODBUSADU_H
 3 | 
 4 | #include <QModbusPdu>
 5 | #include <QByteArray>
 6 | 
 7 | ///
 8 | /// \brief The QModbusAdu class
 9 | ///
10 | class QModbusAdu
11 | {
12 | public:
13 |     ///
14 |     /// \brief QModbusAdu
15 |     /// \param type
16 |     /// \param data
17 |     ///
18 |     explicit QModbusAdu() = default;
19 |     virtual ~QModbusAdu() = default;
20 | 
21 |     ///
22 |     /// \brief isValid
23 |     /// \return
24 |     ///
25 |     virtual bool isValid() const = 0;
26 | 
27 |     ///
28 |     /// \brief rawData
29 |     /// \return
30 |     ///
31 |     QByteArray rawData() const { return _data; }
32 | 
33 |     ///
34 |     /// \brief setRawData
35 |     /// \param data
36 |     ///
37 |     virtual void setRawData(const QByteArray& data)  = 0;
38 | 
39 |     ///
40 |     /// \brief serverAddress
41 |     /// \return
42 |     ///
43 |     virtual quint8 serverAddress() const  = 0;
44 | 
45 |     ///
46 |     /// \brief functionCode
47 |     /// \return
48 |     ///
49 |     QModbusPdu::FunctionCode functionCode() const {
50 |         return _pdu.functionCode();
51 |     }
52 | 
53 |     ///
54 |     /// \brief exceptionCode
55 |     /// \return
56 |     ///
57 |     QModbusPdu::ExceptionCode exceptionCode() const {
58 |         return _pdu.exceptionCode();
59 |     }
60 | 
61 |     ///
62 |     /// \brief isException
63 |     /// \return
64 |     ///
65 |     bool isException() const {
66 |         return _pdu.isException();
67 |     }
68 | 
69 |     ///
70 |     /// \brief pdu
71 |     /// \return
72 |     ///
73 |     const QModbusPdu& pdu() const {
74 |         return _pdu;
75 |     }
76 | 
77 | protected:
78 |     QByteArray _data;
79 |     QModbusPdu _pdu;
80 | };
81 | 
82 | #endif // QMODBUSADU_H
83 | 


--------------------------------------------------------------------------------
/omodsim/qmodbusadurtu.h:
--------------------------------------------------------------------------------
  1 | #ifndef QMODBUSADURTU_H
  2 | #define QMODBUSADURTU_H
  3 | 
  4 | #include "qmodbusadu.h"
  5 | #include "numericutils.h"
  6 | 
  7 | ///
  8 | /// \brief The QModbusAduRtu class
  9 | ///
 10 | class QModbusAduRtu : public QModbusAdu
 11 | {
 12 | public:
 13 |     explicit QModbusAduRtu(const QByteArray& rawData)
 14 |         : QModbusAdu()
 15 |     {
 16 |         setRawData(rawData);
 17 |     }
 18 | 
 19 |     ///
 20 |     /// \brief isValid
 21 |     /// \return
 22 |     ///
 23 |     bool isValid() const override {
 24 |         return matchingChecksum() && _pdu.isValid();
 25 |     }
 26 | 
 27 |     ///
 28 |     /// \brief setRawData
 29 |     /// \param data
 30 |     ///
 31 |     void setRawData(const QByteArray& data) override {
 32 |         _data = data;
 33 |         _pdu.setFunctionCode(QModbusPdu::FunctionCode((quint8)_data[1]));
 34 |         _pdu.setData(_data.mid(2, _data.size() - 4));
 35 |     }
 36 | 
 37 |     ///
 38 |     /// \brief serverAddress
 39 |     /// \return
 40 |     ///
 41 |     quint8 serverAddress() const override {
 42 |         return quint8(_data[0]);
 43 |     }
 44 | 
 45 |     ///
 46 |     /// \brief checksum
 47 |     /// \return
 48 |     ///
 49 |     quint16 checksum() const {
 50 |         return makeUInt16(_data[_data.size() - 1], _data[_data.size() - 2], ByteOrder::LittleEndian);
 51 |     }
 52 | 
 53 |     ///
 54 |     /// \brief calcChecksum
 55 |     /// \return
 56 |     ///
 57 |     quint16 calcChecksum() const {
 58 |         const auto size = _data.size() - 2; // two bytes, CRC
 59 |         const auto data = _data.left(size);
 60 |         return calculateCRC(data, size);
 61 |     }
 62 | 
 63 |     ///
 64 |     /// \brief matchingChecksum
 65 |     /// \return
 66 |     ///
 67 |     bool matchingChecksum() const {
 68 |         return checksum() == calcChecksum();
 69 |     }
 70 | 
 71 |     inline static quint16 calculateCRC(const char* data, qint32 len){
 72 |         quint16 crc = 0xFFFF;
 73 |         while (len--) {
 74 |             const quint8 c = *data++;
 75 |             for (qint32 i = 0x01; i & 0xFF; i <<= 1) {
 76 |                 bool bit = crc & 0x8000;
 77 |                 if (c & i)
 78 |                     bit = !bit;
 79 |                 crc <<= 1;
 80 |                 if (bit)
 81 |                     crc ^= 0x8005;
 82 |             }
 83 |             crc &= 0xFFFF;
 84 |         }
 85 |         crc = crc_reflect(crc & 0xFFFF, 16) ^ 0x0000;
 86 |         return (crc >> 8) | (crc << 8); // swap bytes
 87 |     }
 88 | 
 89 | private:
 90 |     inline static quint16 crc_reflect(quint16 data, qint32 len){
 91 |         quint16 ret = data & 0x01;
 92 |         for (qint32 i = 1; i < len; i++) {
 93 |             data >>= 1;
 94 |             ret = (ret << 1) | (data & 0x01);
 95 |         }
 96 |         return ret;
 97 |     }
 98 | };
 99 | 
100 | #endif // QMODBUSADURTU_H
101 | 


--------------------------------------------------------------------------------
/omodsim/qmodbusadutcp.h:
--------------------------------------------------------------------------------
 1 | #ifndef QMODBUSADUTCP_H
 2 | #define QMODBUSADUTCP_H
 3 | 
 4 | #include "qmodbusadu.h"
 5 | #include "numericutils.h"
 6 | 
 7 | ///
 8 | /// \brief The QModbusAduTcp class
 9 | ///
10 | class QModbusAduTcp : public QModbusAdu
11 | {
12 | public:
13 |     explicit QModbusAduTcp(const QByteArray& rawData)
14 |         : QModbusAdu()
15 |     {
16 |         setRawData(rawData);
17 |     }
18 | 
19 |     ///
20 |     /// \brief isValid
21 |     /// \return
22 |     ///
23 |     bool isValid() const override {
24 |         return _pdu.isValid() && length() == _pdu.size() + 1;
25 |     }
26 | 
27 |     ///
28 |     /// \brief setRawData
29 |     /// \param data
30 |     ///
31 |     void setRawData(const QByteArray& data) override {
32 |         _data = data;
33 |         _pdu.setFunctionCode(QModbusPdu::FunctionCode((quint8)_data[7]));
34 |         _pdu.setData(_data.mid(8));
35 |     }
36 | 
37 |     ///
38 |     /// \brief transactionId
39 |     /// \return
40 |     ///
41 |     quint16 transactionId() const {
42 |         return makeUInt16(_data[1], _data[0], ByteOrder::LittleEndian);
43 |     }
44 | 
45 |     ///
46 |     /// \brief setTransactionId
47 |     /// \param id
48 |     ///
49 |     void setTransactionId(quint16 id) {
50 |         quint8 lo,hi;
51 |         breakUInt16(id, lo, hi, ByteOrder::LittleEndian);
52 |         _data[1] = lo; _data[0] = hi;
53 |     }
54 | 
55 |     ///
56 |     /// \brief protocolId
57 |     /// \return
58 |     ///
59 |     quint16 protocolId() const {
60 |         return makeUInt16(_data[3], _data[2], ByteOrder::LittleEndian);
61 |     }
62 | 
63 |     ///
64 |     /// \brief length
65 |     /// \return
66 |     ///
67 |     quint16 length() const {
68 |         return makeUInt16(_data[5], _data[4], ByteOrder::LittleEndian);
69 |     }
70 | 
71 |     ///
72 |     /// \brief serverAddress
73 |     /// \return
74 |     ///
75 |     quint8 serverAddress() const override {
76 |         return quint8(_data[6]);
77 |     }
78 | 
79 | };
80 | 
81 | #endif // QMODBUSADUTCP_H
82 | 


--------------------------------------------------------------------------------
/omodsim/qrange.h:
--------------------------------------------------------------------------------
 1 | #ifndef QRANGE_H
 2 | #define QRANGE_H
 3 | 
 4 | #include <limits>
 5 | #include <QDataStream>
 6 | 
 7 | ///
 8 | /// \brief The QRange class
 9 | ///
10 | template<class T>
11 | class QRange
12 | {
13 | 
14 |     friend QDataStream& operator <<(QDataStream& out, const QRange<double>& range);
15 |     friend QDataStream& operator >>(QDataStream& in, QRange<double>& range);
16 | 
17 | public:
18 |     ///
19 |     /// \brief QRange
20 |     ///
21 |     explicit QRange()
22 |     {
23 |         _from = std::numeric_limits<T>::min();
24 |         _to = std::numeric_limits<T>::max();
25 |     }
26 | 
27 |     ///
28 |     /// \brief QRange
29 |     /// \param from
30 |     /// \param to
31 |     ///
32 |     QRange(T from, T to)
33 |     {
34 |         _from = from;
35 |         _to = to;
36 |     }
37 | 
38 |     ///
39 |     /// \brief from
40 |     /// \return
41 |     ///
42 |     T from() const { return _from;}
43 | 
44 |     ///
45 |     /// \brief to
46 |     /// \return
47 |     ///
48 |     T to() const { return _to; };
49 | 
50 |     ///
51 |     /// \brief contains
52 |     /// \param num
53 |     /// \return
54 |     ///
55 |     bool contains(T num) const
56 |     {
57 |         return num >= _from && num <= _to;
58 |     }
59 | 
60 | private:
61 |     T _from;
62 |     T _to;
63 | };
64 | 
65 | ///
66 | /// \brief operator <<
67 | /// \param out
68 | /// \param range
69 | /// \return
70 | ///
71 | inline QDataStream& operator <<(QDataStream& out, const QRange<double>& range)
72 | {
73 |     out << range.from();
74 |     out << range.to();
75 |     return out;
76 | }
77 | 
78 | ///
79 | /// \brief operator >>
80 | /// \param in
81 | /// \param range
82 | /// \return
83 | ///
84 | inline QDataStream& operator >>(QDataStream& in, QRange<double>& range)
85 | {
86 |     in >> range._from;
87 |     in >> range._to;
88 |     return in;
89 | }
90 | 
91 | #endif // QRANGE_H
92 | 


--------------------------------------------------------------------------------
/omodsim/quintvalidator.cpp:
--------------------------------------------------------------------------------
 1 | #include "quintvalidator.h"
 2 | 
 3 | ///
 4 | /// \brief QUIntValidator::QUIntValidator
 5 | /// \param parent
 6 | ///
 7 | QUIntValidator::QUIntValidator(QObject *parent)
 8 |     : QValidator{parent}
 9 |     ,_bottom(0)
10 |     ,_top(UINT_MAX)
11 | {
12 | }
13 | 
14 | ///
15 | /// \brief QUIntValidator::QUIntValidator
16 | /// \param bottom
17 | /// \param top
18 | /// \param parent
19 | ///
20 | QUIntValidator::QUIntValidator(quint64 bottom, quint64 top, QObject *parent)
21 |     : QValidator(parent)
22 |     ,_bottom(bottom)
23 |     ,_top(top)
24 | {
25 | 
26 | }
27 | 
28 | ///
29 | /// \brief QUIntValidator::validate
30 | /// \return
31 | ///
32 | QValidator::State QUIntValidator::validate(QString& input, int &) const
33 | {
34 |     bool ok = false;
35 |     const auto value = input.toULongLong(&ok, 10);
36 | 
37 |     if (ok && value >=_bottom && value <=_top )
38 |     {
39 |         return QValidator::Acceptable;
40 |     }
41 | 
42 |     return QValidator::Invalid;
43 | }
44 | 


--------------------------------------------------------------------------------
/omodsim/quintvalidator.h:
--------------------------------------------------------------------------------
 1 | #ifndef QUINTVALIDATOR_H
 2 | #define QUINTVALIDATOR_H
 3 | 
 4 | #include <QValidator>
 5 | #include <QObject>
 6 | 
 7 | ///
 8 | /// \brief The QUIntValidator class
 9 | ///
10 | class QUIntValidator : public QValidator
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit QUIntValidator(QObject *parent = nullptr);
15 |     QUIntValidator(quint64 bottom, quint64 top, QObject *parent = nullptr);
16 | 
17 |     State validate(QString &, int &) const override;
18 | 
19 | private:
20 |     quint64 _bottom;
21 |     quint64 _top;
22 | };
23 | 
24 | #endif // QUINTVALIDATOR_H
25 | 


--------------------------------------------------------------------------------
/omodsim/recentfileactionlist.h:
--------------------------------------------------------------------------------
 1 | #ifndef RECENTFILEACTIONLIST_H
 2 | #define RECENTFILEACTIONLIST_H
 3 | 
 4 | #include <QMenu>
 5 | 
 6 | ///
 7 | /// \brief The RecentFileActionList class
 8 | ///
 9 | class RecentFileActionList : public QObject
10 | {
11 |     Q_OBJECT
12 | 
13 | public:
14 |     explicit RecentFileActionList(QMenu* menu, QAction* placeholder);
15 |     ~RecentFileActionList() override;
16 | 
17 |     bool isEmpty() const;
18 | 
19 |     void addRecentFile(const QString& filename);
20 |     void removeRecentFile(const QString& filename);
21 | 
22 | signals:
23 |     void triggered(const QString& filename);
24 | 
25 | private:
26 |     void updateMenu();
27 | 
28 | private:
29 |     QMenu* _menu;
30 |     QAction* _placeholder;
31 |     QAction* _placeinserter;
32 |     QList<QAction*> _actionList;
33 | };
34 | 
35 | #endif // RECENTFILEACTIONLIST_H
36 | 


--------------------------------------------------------------------------------
/omodsim/res/actionAbout.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionAbout.png


--------------------------------------------------------------------------------
/omodsim/res/actionBigEndian.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionBigEndian.png


--------------------------------------------------------------------------------
/omodsim/res/actionBinary.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionBinary.png


--------------------------------------------------------------------------------
/omodsim/res/actionConnect.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionConnect.png


--------------------------------------------------------------------------------
/omodsim/res/actionCopy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionCopy.png


--------------------------------------------------------------------------------
/omodsim/res/actionCut.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionCut.png


--------------------------------------------------------------------------------
/omodsim/res/actionDblFloat.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionDblFloat.png


--------------------------------------------------------------------------------
/omodsim/res/actionDefineData.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionDefineData.png


--------------------------------------------------------------------------------
/omodsim/res/actionDisconnect.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionDisconnect.png


--------------------------------------------------------------------------------
/omodsim/res/actionFind.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionFind.png


--------------------------------------------------------------------------------
/omodsim/res/actionFloatingPt.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionFloatingPt.png


--------------------------------------------------------------------------------
/omodsim/res/actionHex.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionHex.png


--------------------------------------------------------------------------------
/omodsim/res/actionInt16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionInt16.png


--------------------------------------------------------------------------------
/omodsim/res/actionInt32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionInt32.png


--------------------------------------------------------------------------------
/omodsim/res/actionInt64.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionInt64.png


--------------------------------------------------------------------------------
/omodsim/res/actionLittleEndian.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionLittleEndian.png


--------------------------------------------------------------------------------
/omodsim/res/actionNew.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionNew.png


--------------------------------------------------------------------------------
/omodsim/res/actionOpen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionOpen.png


--------------------------------------------------------------------------------
/omodsim/res/actionPaste.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionPaste.png


--------------------------------------------------------------------------------
/omodsim/res/actionPrint.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionPrint.png


--------------------------------------------------------------------------------
/omodsim/res/actionRedo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionRedo.png


--------------------------------------------------------------------------------
/omodsim/res/actionRunScript.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionRunScript.png


--------------------------------------------------------------------------------
/omodsim/res/actionSave.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionSave.png


--------------------------------------------------------------------------------
/omodsim/res/actionScriptSettings.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionScriptSettings.png


--------------------------------------------------------------------------------
/omodsim/res/actionShowData.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionShowData.png


--------------------------------------------------------------------------------
/omodsim/res/actionShowScript.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionShowScript.png


--------------------------------------------------------------------------------
/omodsim/res/actionShowTraffic.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionShowTraffic.png


--------------------------------------------------------------------------------
/omodsim/res/actionStopScript.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionStopScript.png


--------------------------------------------------------------------------------
/omodsim/res/actionSwappedDbl.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionSwappedDbl.png


--------------------------------------------------------------------------------
/omodsim/res/actionSwappedFP.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionSwappedFP.png


--------------------------------------------------------------------------------
/omodsim/res/actionSwappedInt32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionSwappedInt32.png


--------------------------------------------------------------------------------
/omodsim/res/actionSwappedInt64.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionSwappedInt64.png


--------------------------------------------------------------------------------
/omodsim/res/actionSwappedUInt32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionSwappedUInt32.png


--------------------------------------------------------------------------------
/omodsim/res/actionSwappedUInt64.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionSwappedUInt64.png


--------------------------------------------------------------------------------
/omodsim/res/actionUInt16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionUInt16.png


--------------------------------------------------------------------------------
/omodsim/res/actionUInt32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionUInt32.png


--------------------------------------------------------------------------------
/omodsim/res/actionUInt64.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionUInt64.png


--------------------------------------------------------------------------------
/omodsim/res/actionUndo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/actionUndo.png


--------------------------------------------------------------------------------
/omodsim/res/iconAbout.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/iconAbout.png


--------------------------------------------------------------------------------
/omodsim/res/iconEnum.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/iconEnum.png


--------------------------------------------------------------------------------
/omodsim/res/iconFunc.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/iconFunc.png


--------------------------------------------------------------------------------
/omodsim/res/iconLandscape.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/iconLandscape.png


--------------------------------------------------------------------------------
/omodsim/res/iconPortrait.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/iconPortrait.png


--------------------------------------------------------------------------------
/omodsim/res/iconProp.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/iconProp.png


--------------------------------------------------------------------------------
/omodsim/res/license.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright 2024 Alexandr Ananev [mail@ananev.org]
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | 
 7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 8 | 
 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | 


--------------------------------------------------------------------------------
/omodsim/res/omodsim.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/omodsim.ico


--------------------------------------------------------------------------------
/omodsim/res/omodsim.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/omodsim.png


--------------------------------------------------------------------------------
/omodsim/res/pointEmpty.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/pointEmpty.png


--------------------------------------------------------------------------------
/omodsim/res/pointGreen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/res/pointGreen.png


--------------------------------------------------------------------------------
/omodsim/resources.qrc:
--------------------------------------------------------------------------------
 1 | <RCC>
 2 |     <qresource prefix="/">
 3 |         <file>res/license.txt</file>
 4 |         <file>res/actionBinary.png</file>
 5 |         <file>res/actionDblFloat.png</file>
 6 |         <file>res/actionFloatingPt.png</file>
 7 |         <file>res/actionHex.png</file>
 8 |         <file>res/actionSwappedDbl.png</file>
 9 |         <file>res/actionSwappedFP.png</file>
10 |         <file>res/actionAbout.png</file>
11 |         <file>res/actionNew.png</file>
12 |         <file>res/actionOpen.png</file>
13 |         <file>res/actionPrint.png</file>
14 |         <file>res/actionShowData.png</file>
15 |         <file>res/actionShowTraffic.png</file>
16 |         <file>res/iconLandscape.png</file>
17 |         <file>res/iconPortrait.png</file>
18 |         <file>res/actionConnect.png</file>
19 |         <file>res/actionDisconnect.png</file>
20 |         <file>res/actionSave.png</file>
21 |         <file>res/actionDefineData.png</file>
22 |         <file>res/omodsim.png</file>
23 |         <file>res/iconAbout.png</file>
24 |         <file>translations/omodsim_ru.qm</file>
25 |         <file>res/actionBigEndian.png</file>
26 |         <file>res/actionLittleEndian.png</file>
27 |         <file>res/actionShowScript.png</file>
28 |         <file>fonts/firacode.ttf</file>
29 |         <file>res/actionRunScript.png</file>
30 |         <file>res/actionStopScript.png</file>
31 |         <file>res/iconFunc.png</file>
32 |         <file>res/iconProp.png</file>
33 |         <file>res/actionScriptSettings.png</file>
34 |         <file>res/pointEmpty.png</file>
35 |         <file>res/pointGreen.png</file>
36 |         <file>res/actionCopy.png</file>
37 |         <file>res/actionCut.png</file>
38 |         <file>res/actionFind.png</file>
39 |         <file>res/actionPaste.png</file>
40 |         <file>res/actionRedo.png</file>
41 |         <file>res/actionUndo.png</file>
42 |         <file>res/iconEnum.png</file>
43 |         <file>res/actionInt16.png</file>
44 |         <file>res/actionInt32.png</file>
45 |         <file>res/actionInt64.png</file>
46 |         <file>res/actionSwappedInt32.png</file>
47 |         <file>res/actionSwappedInt64.png</file>
48 |         <file>res/actionSwappedUInt32.png</file>
49 |         <file>res/actionSwappedUInt64.png</file>
50 |         <file>res/actionUInt16.png</file>
51 |         <file>res/actionUInt32.png</file>
52 |         <file>res/actionUInt64.png</file>
53 |     </qresource>
54 | </RCC>
55 | 


--------------------------------------------------------------------------------
/omodsim/scriptsettings.h:
--------------------------------------------------------------------------------
 1 | #ifndef SCRIPTSETTINGS_H
 2 | #define SCRIPTSETTINGS_H
 3 | 
 4 | #include <QDataStream>
 5 | #include "enums.h"
 6 | 
 7 | ///
 8 | /// \brief The ScriptSettings struct
 9 | ///
10 | struct ScriptSettings
11 | {
12 |     RunMode Mode = RunMode::Periodically;
13 |     uint Interval = 1000;
14 |     bool UseAutoComplete = true;
15 | 
16 |     void normalize()
17 |     {
18 |         Mode = qBound(RunMode::Once, Mode, RunMode::Periodically);
19 |         Interval = qBound(500U, Interval, 10000U);
20 |     }
21 | };
22 | Q_DECLARE_METATYPE(ScriptSettings)
23 | 
24 | ///
25 | /// \brief operator <<
26 | /// \param out
27 | /// \param ss
28 | /// \return
29 | ///
30 | inline QSettings& operator <<(QSettings& out, const ScriptSettings& ss)
31 | {
32 |     out.setValue("ScriptSettings/RunMode",          (int)ss.Mode);
33 |     out.setValue("ScriptSettings/Interval",         ss.Interval);
34 |     out.setValue("ScriptSettings/UseAutoComplete",  ss.UseAutoComplete);
35 | 
36 |     return out;
37 | }
38 | 
39 | ///
40 | /// \brief operator >>
41 | /// \param in
42 | /// \param ss
43 | /// \return
44 | ///
45 | inline QSettings& operator >>(QSettings& in, ScriptSettings& ss)
46 | {
47 |     ss.Mode = (RunMode)in.value("ScriptSettings/RunMode").toInt();
48 |     ss.Interval = in.value("ScriptSettings/Interval", 1000).toUInt();
49 |     ss.UseAutoComplete = in.value("ScriptSettings/UseAutoComplete", true).toBool();
50 | 
51 |     ss.normalize();
52 |     return in;
53 | }
54 | 
55 | ///
56 | /// \brief operator <<
57 | /// \param out
58 | /// \param ss
59 | /// \return
60 | ///
61 | inline QDataStream& operator <<(QDataStream& out, const ScriptSettings& ss)
62 | {
63 |     out << ss.Mode;
64 |     out << ss.Interval;
65 |     out << ss.UseAutoComplete;
66 | 
67 |     return out;
68 | }
69 | 
70 | ///
71 | /// \brief operator >>
72 | /// \param in
73 | /// \param ss
74 | /// \return
75 | ///
76 | inline QDataStream& operator >>(QDataStream& in, ScriptSettings& ss)
77 | {
78 |     in >> ss.Mode;
79 |     in >> ss.Interval;
80 |     in >> ss.UseAutoComplete;
81 | 
82 |     return in;
83 | }
84 | 
85 | #endif // SCRIPTSETTINGS_H
86 | 


--------------------------------------------------------------------------------
/omodsim/serialportutils.h:
--------------------------------------------------------------------------------
 1 | #ifndef SERIALPORTUTILS_H
 2 | #define SERIALPORTUTILS_H
 3 | 
 4 | #include <QSerialPortInfo>
 5 | #include <QRegularExpression>
 6 | 
 7 | ///
 8 | /// \brief getAvailableSerialPorts
 9 | /// \return
10 | ///
11 | inline QStringList getAvailableSerialPorts()
12 | {
13 |     QStringList ports;
14 |     for(auto&& port: QSerialPortInfo::availablePorts())
15 |         ports << port.portName();
16 | 
17 |     static QRegularExpression re( "[^\\d]");
18 |     std::sort(ports.begin(), ports.end(), [](QString p1, QString p2)
19 |               {
20 |                   return p1.remove(re).toInt() < p2.remove(re).toInt();
21 |               });
22 | 
23 |     return ports;
24 | }
25 | 
26 | #endif // SERIALPORTUTILS_H
27 | 


--------------------------------------------------------------------------------
/omodsim/translations/omodsim_ru.qm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sanny32/OpenModSim/f7cb79cbbadda3a4db6f5f98f03b8af3bd2d3316/omodsim/translations/omodsim_ru.qm


--------------------------------------------------------------------------------
/omodsim/windowactionlist.cpp:
--------------------------------------------------------------------------------
  1 | #include "windowactionlist.h"
  2 | 
  3 | ///
  4 | /// \brief WindowActionList::WindowActionList
  5 | /// \param menu
  6 | ///
  7 | WindowActionList::WindowActionList(QMenu* menu, QAction* placeHolder)
  8 |     : QObject{menu}
  9 |     ,_menu(menu)
 10 |     ,_placeHolder(placeHolder)
 11 | {
 12 |     _placeHolder->setVisible(false);
 13 | }
 14 | 
 15 | ///
 16 | /// \brief WindowActionList::isEmpty
 17 | /// \return
 18 | ///
 19 | bool WindowActionList::isEmpty() const
 20 | {
 21 |     return _actionList.isEmpty();
 22 | }
 23 | 
 24 | ///
 25 | /// \brief WindowActionList::actionList
 26 | /// \return
 27 | ///
 28 | QList<QAction*> WindowActionList::actionList() const
 29 | {
 30 |     return _actionList;
 31 | }
 32 | 
 33 | ///
 34 | /// \brief WindowActionList::addWindow
 35 | /// \param wnd
 36 | ///
 37 | void WindowActionList::addWindow(QMdiSubWindow* wnd)
 38 | {
 39 |     if(!wnd) return;
 40 | 
 41 |     for(auto&& a : _actionList)
 42 |     {
 43 |         if(wnd == a->data().value<QMdiSubWindow*>()) return;
 44 |     }
 45 | 
 46 |     auto activateAction = new QAction(_menu);
 47 |     activateAction->setData(QVariant::fromValue(wnd));
 48 |     activateAction->setCheckable(true);
 49 | 
 50 |     connect(activateAction, &QAction::triggered, this, [this, wnd](bool)
 51 |     {
 52 |         emit triggered(wnd);
 53 |     });
 54 | 
 55 |     _actionList.append(activateAction);
 56 |     _menu->insertAction(_placeHolder, activateAction);
 57 | 
 58 |     updateMenu();
 59 | }
 60 | 
 61 | ///
 62 | /// \brief WindowActionList::removeWindow
 63 | /// \param wnd
 64 | ///
 65 | void WindowActionList::removeWindow(QMdiSubWindow* wnd)
 66 | {
 67 |     if(!wnd) return;
 68 | 
 69 |     QAction* activateAction = nullptr;
 70 |     for(auto&& a : _actionList)
 71 |     {
 72 |         if(wnd == a->data().value<QMdiSubWindow*>())
 73 |         {
 74 |             activateAction = a;
 75 |             break;
 76 |         }
 77 |     }
 78 | 
 79 |     if(!activateAction) return;
 80 | 
 81 |     _actionList.removeOne(activateAction);
 82 |     _menu->removeAction(activateAction);
 83 | 
 84 |     updateMenu();
 85 | }
 86 | 
 87 | ///
 88 | /// \brief WindowActionList::update
 89 | ///
 90 | void WindowActionList::update()
 91 | {
 92 |     updateMenu();
 93 | }
 94 | 
 95 | ///
 96 | /// \brief WindowActionList::updateMenu
 97 | ///
 98 | void WindowActionList::updateMenu()
 99 | {
100 |     int i = 0, ci = 0;
101 |     const bool largeList = _actionList.size() > 9;
102 |     for(auto&& a: _actionList)
103 |     {
104 |         const auto wnd = a->data().value<QMdiSubWindow*>();
105 |         if(!wnd) continue;
106 | 
107 |         a->setChecked(wnd->property("isActive").toBool());
108 |         a->setVisible(++i < 10 || a->isChecked());
109 | 
110 |         if(a->isChecked()) ci = i;
111 |         if(largeList) _actionList[8]->setVisible(ci < 10);
112 | 
113 |         const int num = (i < 10) ? i : (a->isChecked() ? 9 : i);
114 |         a->setText(QString("%1 %2").arg(QString::number(num), wnd->windowTitle()));
115 |     }
116 | 
117 |     _placeHolder->setVisible(largeList);
118 | }
119 | 


--------------------------------------------------------------------------------
/omodsim/windowactionlist.h:
--------------------------------------------------------------------------------
 1 | #ifndef WINDOWACTIONLIST_H
 2 | #define WINDOWACTIONLIST_H
 3 | 
 4 | #include <QMenu>
 5 | #include <QMdiSubWindow>
 6 | 
 7 | ///
 8 | /// \brief The WindowActionList class
 9 | ///
10 | class WindowActionList : public QObject
11 | {
12 |     Q_OBJECT
13 | public:
14 |     explicit WindowActionList(QMenu* menu, QAction* placeHolder);
15 | 
16 |     bool isEmpty() const;
17 |     QList<QAction*> actionList() const;
18 | 
19 |     void addWindow(QMdiSubWindow* wnd);
20 |     void removeWindow(QMdiSubWindow* wnd);
21 | 
22 |     void update();
23 | 
24 | signals:
25 |     void triggered(QMdiSubWindow* wnd);
26 | 
27 | private:
28 |     void updateMenu();
29 | 
30 | private:
31 |     QMenu* _menu;
32 |     QAction* _placeHolder;
33 |     QList<QAction*> _actionList;
34 | };
35 | 
36 | #endif // WINDOWACTIONLIST_H
37 | 


--------------------------------------------------------------------------------