├── QModbusTool.ico
├── resources.qrc
├── QModbusTool_en_US.ts
├── PLUGIN.md
├── metadata_structs.cpp
├── write_event.h
├── QModbusTool.pro
├── inputs_display.cpp
├── main.cpp
├── inputs_display.h
├── exceptions.cpp
├── exceptions.h
├── coils_display.h
├── configure_trend_line.h
├── configure_trend.h
├── metadata_structs.h
├── coils_display.cpp
├── holding_register_display.h
├── metadata_wrapper.h
├── csv_importer.h
├── base_dialog.h
├── base_dialog.cpp
├── configure_trend.ui
├── trend_line.cpp
├── trend_line.h
├── README.md
├── metadata.h
├── modbusthread.h
├── configure_trend.cpp
├── configure_trend_line.cpp
├── trend_window.h
├── mainwindow.ui
├── metadata_wrapper.cpp
├── scheduler.h
├── holding_register_display.cpp
├── register_display.h
├── mainwindow.h
├── modbusthread.cpp
├── configure_trend_line.ui
├── scheduler.cpp
├── csv_importer.cpp
└── trend_window.cpp


/QModbusTool.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KB3HNS/QModbusTool/HEAD/QModbusTool.ico


--------------------------------------------------------------------------------
/resources.qrc:
--------------------------------------------------------------------------------
1 | <RCC>
2 |     <qresource prefix="/">
3 |         <file>QModbusTool.ico</file>
4 |     </qresource>
5 | </RCC>
6 | 


--------------------------------------------------------------------------------
/QModbusTool_en_US.ts:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <!DOCTYPE TS>
3 | <TS version="2.1" language="QModbusTool_en_US"></TS>
4 | 


--------------------------------------------------------------------------------
/PLUGIN.md:
--------------------------------------------------------------------------------
 1 | ## QModbusTool - A QT Based Modbus Client
 2 | The application has the ability to query the connected device for certain metadata items that pertain to a register including:
 3 | 
 4 | * Register minimum and maximum values
 5 | * Register default value
 6 | * Register encoding (signed, unsigned, bits, bytes, etc)
 7 | * A brief text string describing the register
 8 | 
 9 | Some manufactures provide the ability to read some, or all of this data through the use of non-standard or application specific Modbus function codes.  Modbus its self (unlike other industrial protocols) does not provide a standard mechanism for accessing this type of data.  Because in many cases this functionality is greatly helpful some manufacturers have implemented their own proprietary methods for accessing this type of information.
10 | QModbusTool was written to allow manufacturer-defined meta data querying implementations.
11 | 
12 | To make the interface as versatile as possible the interface has been broken up into 5 sections:
13 | 
14 | 1. Create request instance for a register.
15 | 2. Encode the outgoing request.
16 | 3. Decode the incoming response.
17 | 4. Extract various sections returning optional responses if specific element is unsupported.
18 | 5. Dispose of the previously created instance.
19 | 
20 | ### Getting started
21 | Review the available documentation in the header "[metadata.h][1]" for interface specification.  The application expects the file called "mod\_plugin.so" to be located in the same directory as the application its self.  This behavior can be modified in `metadata_wrapper.cpp`.
22 | The plugin is a singleton wrapper that is initialized during start-up shortly before rendering the main window.  The poll scheduling logic has a special priority dedicated to just retrieving register metadata.  
23 | 
24 | [1]: metadata.h
25 | 


--------------------------------------------------------------------------------
/metadata_structs.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file metadata_structs.cpp
 3 |  * \brief Containers and definitions used by the program for metadata
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  */
25 | 
26 | //  c++ includes
27 | /* -none- */
28 | 
29 | // C includes
30 | /* -none- */
31 | 
32 | // project includes
33 | #include "metadata_structs.h"  //  local include
34 | #include "metadata_wrapper.h"  //  MetadataWrapper
35 | #include <metadata.h>  //  modbus_plugin: DATA_BUFFER_REQUIRED_SIZE
36 | 
37 | 
38 | Metadata::Metadata(const quint16 reg_num, void *const instance, const quint8 fc) :
39 |     register_number{reg_num},
40 |     label{},
41 |     encoding{RegisterEncoding::ENCODING_UNKNOWN},
42 |     min(false),
43 |     max(false),
44 |     dflt(false),
45 |     function_code{qint8(fc)},
46 |     m_request_instance{instance},
47 |     m_request(DATA_BUFFER_REQUIRED_SIZE)
48 | {
49 | }
50 | 
51 | 
52 | Metadata::~Metadata()
53 | {
54 |     auto inst = MetadataWrapper::get_instance();
55 |     inst->dispose_metadata(this);
56 | }
57 | 


--------------------------------------------------------------------------------
/write_event.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file write_event.h
 3 |  * \brief Write requests shared object.
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  */
25 | 
26 | #ifndef WRITE_EVENT_H
27 | #define WRITE_EVENT_H
28 | 
29 | //  c++ includes
30 | #include <vector>  //  std::vector
31 | #include <QTypeInfo>  //  quint8, quint16
32 | 
33 | // C includes
34 | /* -none- */
35 | 
36 | // project includes
37 | /* -none- */
38 | 
39 | 
40 | // /////////////////////////////////////////////////////////////////////////////
41 | // Forward declarations
42 | // /////////////////////////////////////////////////////////////////////////////
43 | class BaseDialog;
44 | 
45 | 
46 | /**
47 |  * \brief Structure outlining a write request
48 |  */
49 | struct WriteRequest {
50 |     BaseDialog *requester; /**< Request source */
51 | 
52 |     quint8 node; /**< Send request to node */
53 | 
54 |     quint16 first_register; /**< Starting register number (eg: 42, 40023) */
55 | 
56 |     std::vector<quint16> values; /**< List of values to be written */
57 | };
58 | 
59 | 
60 | #endif // WRITE_EVENT_H
61 | 


--------------------------------------------------------------------------------
/QModbusTool.pro:
--------------------------------------------------------------------------------
 1 | QT       += core gui xml
 2 | 
 3 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
 4 | 
 5 | CONFIG += c++17
 6 | QMAKE_CXXFLAGS += -std=c++17 -Wextra -Wpedantic
 7 | 
 8 | # You can make your code fail to compile if it uses deprecated APIs.
 9 | # In order to do so, uncomment the following line.
10 | DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
11 | DEFINES += QCUSTOMPLOT_USE_OPENGL  # enable OpenGL accelleration for trend
12 | 
13 | SOURCES += \
14 |     coils_display.cpp \
15 |     exceptions.cpp \
16 |     holding_register_display.cpp \
17 |     main.cpp \
18 |     mainwindow.cpp \
19 |     modbusthread.cpp \
20 |     register_display.cpp \
21 |     scheduler.cpp \
22 |     metadata_wrapper.cpp \
23 |     metadata_structs.cpp \
24 |     inputs_display.cpp \
25 |     csv_importer.cpp \
26 |     trend_window.cpp \
27 |     base_dialog.cpp \
28 |     trend_line.cpp \
29 |     configure_trend_line.cpp \
30 |     configure_trend.cpp
31 | 
32 | HEADERS += \
33 |     coils_display.h \
34 |     exceptions.h \
35 |     holding_register_display.h \
36 |     mainwindow.h \
37 |     modbusthread.h \
38 |     register_display.h \
39 |     scheduler.h \
40 |     write_event.h \
41 |     metadata_wrapper.h \
42 |     metadata_structs.h \
43 |     inputs_display.h \
44 |     csv_importer.h \
45 |     trend_window.h \
46 |     base_dialog.h \
47 |     trend_line.h \
48 |     configure_trend_line.h \
49 |     configure_trend.h
50 | 
51 | FORMS += \
52 |     mainwindow.ui \
53 |     configure_trend_line.ui \
54 |     configure_trend.ui
55 | 
56 | TRANSLATIONS += \
57 |     QModbusTool_en_US.ts
58 | 
59 | LIBS += \
60 |     -L/usr/local/lib -lmodbus -ldl -lqtcsv -lqcustomplot
61 | 
62 | INCLUDEPATH += \
63 |     /usr/local/include
64 | 
65 | # Default rules for deployment.
66 | qnx: target.path = /tmp/$${TARGET}/bin
67 | else: unix:!android: target.path = /opt/$${TARGET}/bin
68 | !isEmpty(target.path): INSTALLS += target
69 | 
70 | RC_ICONS = QModbusTool.ico
71 | 
72 | RESOURCES += \
73 |     resources.qrc
74 | 


--------------------------------------------------------------------------------
/inputs_display.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file inputs_display.cpp
 3 |  * \brief [Digital] Inputs display window
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  */
25 | 
26 | //  c++ includes
27 | /* -none- */
28 | 
29 | // C includes
30 | /* -none- */
31 | 
32 | // project includes
33 | #include "inputs_display.h"  //  local include
34 | 
35 | 
36 | InputsDisplay::InputsDisplay(QWidget *parent, const quint16 base_reg, const quint16 count, const quint8 uid)
37 |     : RegisterDisplay(parent, base_reg, count, uid)
38 | {
39 | }
40 | 
41 | 
42 | bool InputsDisplay::load_configuration_parameters(const QDomElement &node)
43 | {
44 |     auto reg = node.attribute("register").toUInt();
45 |     if (reg <= 10000 || reg >= 20000) {
46 |         return false;
47 |     }
48 | 
49 |     return RegisterDisplay::load_configuration_parameters(node);
50 | }
51 | 
52 | 
53 | QString InputsDisplay::get_object_name() const
54 | {
55 |     return "InputsDisplay";
56 | }
57 | 
58 | 
59 | void InputsDisplay::updateRegisterValue(const size_t index, const QString &value)
60 | {
61 |     static_cast<void>(value);
62 |     const auto wvalue = (m_raw_values[index] > 0 ? QString("1") : QString("0"));
63 |     RegisterDisplay::updateRegisterValue(index, wvalue);
64 | }
65 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file main.cpp
 3 |  * \brief Application entry point
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  *
25 |  *
26 |  * \section DESCRIPTION
27 |  *
28 |  * QModbusTool is a general-purpose modbus polling system based on libmodbus.
29 |  * QModbusTool is intended to be a straight-forward implementation of a modbus
30 |  * viewer supporting session and register set save and restore as well as
31 |  * simple poll-driven trending.  QModbusTool has been release under the GPL-2
32 |  * license and includes properietary decoding logic for polling metadata.  A
33 |  * proprietary license may be available by contacting the author:
34 |  * Andrew Buettner: leeloo <at> cletis <dot> net
35 |  */
36 | 
37 | //  c++ includes
38 | #include <QApplication>  //  QApplication
39 | 
40 | // C includes
41 | /* -none- */
42 | 
43 | // project includes
44 | #include "mainwindow.h"  //  MainWindow
45 | 
46 | 
47 | /**
48 |  * \brief Main entry point
49 |  *
50 |  * @param argc standard argument
51 |  * @param argv standard argument
52 |  *
53 |  * @return exit code at exit
54 |  */
55 | int main(int argc, char *argv[])
56 | {
57 |     QApplication a(argc, argv);
58 |     MainWindow w;
59 |     w.show();
60 |     return a.exec();
61 | }
62 | 


--------------------------------------------------------------------------------
/inputs_display.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file inputs_display.h
 3 |  * \brief [Digital] Inputs display window
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  *
25 |  * \section DESCRIPTION
26 |  *
27 |  * Derivitave of RegisterDisplay for interacting with Coils (0,000 series
28 |  * Modbus registers).
29 |  */
30 | 
31 | #ifndef INPUTS_DISPLAY_H
32 | #define INPUTS_DISPLAY_H
33 | 
34 | 
35 | //  c++ includes
36 | /* -none- */
37 | 
38 | // C includes
39 | /* -none- */
40 | 
41 | // project includes
42 | #include "register_display.h"  //  RegisterDisplay
43 | 
44 | 
45 | class InputsDisplay : public RegisterDisplay
46 | {
47 |     Q_OBJECT
48 | 
49 | public:
50 | 
51 |     /**
52 |      * \brief constructor
53 |      * @param parent parent QObject owner
54 |      * @param base_reg first register number
55 |      * @param count number of registers to poll
56 |      * @param uid device ID, unit ID, node of server to poll
57 |      */
58 |     InputsDisplay(QWidget *parent, const quint16 base_reg, const quint16 count=32, const quint8 uid=0);
59 | 
60 |     virtual QString get_object_name() const override;
61 |     virtual bool load_configuration_parameters(const QDomElement &node) override;
62 | 
63 | protected:
64 |     virtual void updateRegisterValue(const size_t index, const QString &value) override;
65 | 
66 | };
67 | 
68 | #endif // INPUTS_DISPLAY_H
69 | 


--------------------------------------------------------------------------------
/exceptions.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file exceptions.cpp
 3 |  * \brief Exceptions used throughout the application
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  */
25 | 
26 | //  c++ includes
27 | #include <QStringBuilder>  //  operator %
28 | 
29 | // C includes
30 | /* -none- */
31 | 
32 | // project includes
33 | #include "exceptions.h"  //  local include
34 | 
35 | 
36 | AppException::AppException(const QString &reason) :
37 |     QException(),
38 |     text(reason)
39 | {
40 | }
41 | 
42 | 
43 | AppException::operator QString () const
44 | {
45 |     return text;
46 | }
47 | 
48 | 
49 | AppException* AppException::clone() const
50 | {
51 |     return new AppException(*this);
52 | }
53 | 
54 | 
55 | void AppException::raise() const
56 | {
57 |     throw *this;
58 | }
59 | 
60 | 
61 | const char* AppException::what() const noexcept
62 | {
63 |     return text.toLocal8Bit();
64 | }
65 | 
66 | 
67 | FileLoadException::FileLoadException(const QString &reason, const QString &filename) :
68 |     AppException(reason % QString(": ") % filename)
69 | {
70 | }
71 | 
72 | 
73 | FileLoadException::FileLoadException(const QString &reason, const QString &filename, const size_t line) :
74 |     AppException(reason %
75 |                  QString(": ") %
76 |                  filename %
77 |                  QChar('@') %
78 |                  QString::number(line))
79 | {
80 | }
81 | 


--------------------------------------------------------------------------------
/exceptions.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file exceptions.h
 3 |  * \brief Exceptions used throughout the application
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  */
25 | 
26 | #ifndef EXCEPTIONS_H
27 | #define EXCEPTIONS_H
28 | 
29 | //  c++ includes
30 | #include <QString>  //  QString
31 | #include <QException>  //  QException
32 | 
33 | // C includes
34 | /* -none- */
35 | 
36 | // project includes
37 | /* -none- */
38 | 
39 | 
40 | /**
41 |  * \brief Base class for all exceptions thrown by the application logic
42 |  */
43 | class AppException : public QException
44 | {
45 | public:
46 | 
47 |     /**
48 |      * \brief constructor
49 |      * @param reason Reason that the exception was thrown.
50 |      */
51 |     AppException(const QString &reason);
52 | 
53 |     /**
54 |      * \brief Convert to a QString
55 |      * @return String representation of this exception
56 |      */
57 |     operator QString () const;
58 | 
59 |     AppException* clone() const override;
60 | 
61 |     void raise() const override;
62 | 
63 |     const char* what() const noexcept override;
64 | 
65 | private:
66 |     const QString text;
67 | };
68 | 
69 | 
70 | /**
71 |  * \brief Exception thrown during file loading
72 |  */
73 | class FileLoadException : public AppException
74 | {
75 | public:
76 | 
77 |     /**
78 |      * \brief constructor
79 |      * @param reason Reason that the exception was thrown.
80 |      * @param filename name of file being parsed
81 |      */
82 |     FileLoadException(const QString &reason, const QString &filename);
83 | 
84 |     /**
85 |      * \brief constructor including line number
86 |      * @param reason Reason that the exception was thrown.
87 |      * @param filename name of file being parsed
88 |      * @param line line number error encountered
89 |      */
90 |     FileLoadException(const QString &reason, const QString &filename, const size_t line);
91 | };
92 | 
93 | 
94 | #endif // EXCEPTIONS_H
95 | 


--------------------------------------------------------------------------------
/coils_display.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * \file coils_display.h
 3 |  * \brief Coils display window
 4 |  * \copyright
 5 |  * 2021 Andrew Buettner (ABi)
 6 |  *
 7 |  * \section LICENSE
 8 |  *
 9 |  * QModbusTool - A QT Based Modbus Client
10 |  *
11 |  * This program is free software; you can redistribute it and/or
12 |  * modify it under the terms of the GNU General Public License
13 |  * as published by the Free Software Foundation; either version 2
14 |  * of the License, or (at your option) any later version.
15 |  *
16 |  * This program is distributed in the hope that it will be useful,
17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 |  *  GNU General Public License for more details.
20 |  *
21 |  * You should have received a copy of the GNU General Public License
22 |  * along with this program; if not, write to the Free Software
23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24 |  *
25 |  * \section DESCRIPTION
26 |  *
27 |  * Derivitave of RegisterDisplay for interacting with Coils (0,000 series
28 |  * Modbus registers).
29 |  */
30 | 
31 | #ifndef COILSDISPLAY_H
32 | #define COILSDISPLAY_H
33 | 
34 | //  c++ includes
35 | #include <unordered_map>  //  std::unordered_map
36 | 
37 | // C includes
38 | /* -none- */
39 | 
40 | // project includes
41 | #include "register_display.h"  //  RegisterDisplay
42 | 
43 | 
44 | /**
45 |  * \brief Holding Registers windows
46 |  */
47 | class CoilsDisplay : public RegisterDisplay
48 | {
49 |     Q_OBJECT
50 | 
51 | public:
52 |     /**
53 |      * \brief constructor
54 |      * @param parent parent QObject owner
55 |      * @param base_reg first register number
56 |      * @param count number of registers to poll
57 |      * @param uid device ID, unit ID, node of server to poll
58 |      */
59 |     CoilsDisplay(QWidget *parent, const quint16 base_reg, const quint16 count=32, const quint8 uid=0);
60 | 
61 |     virtual QString get_object_name() const override;
62 |     virtual bool load_configuration_parameters(const QDomElement &node) override;
63 | 
64 | protected:
65 |     virtual void updateRegisterValue(const size_t index, const QString &value) override;
66 |     virtual QWidget* create_value_widget(const quint16 index, const bool initial) override;
67 |     virtual QString get_display_value(const size_t index) const override;
68 |     [[nodiscard]] virtual QString get_register_number_text(const quint16 reg_number) override;
69 | 
70 | private slots:
71 |     /**
72 |      * \brief Signal when a user has toggled a checkbox (write request).
73 |      * @param index register index in window
74 |      */
75 |     void on_checkbox_checked(quint16 index);
76 | 
77 |     /**
78 |      * \brief Signal that a control has been destroted.
79 |      * @param register_widget widget reference
80 |      * @param index register index in window
81 |      */
82 |     void on_register_destroyed(QWidget *register_widget, const quint16 index);
83 | 
84 | private:
85 |     std::unordered_map<quint16, bool> m_remote_state;
86 | 
87 | };
88 | 
89 | #endif // COILSDISPLAY_H
90 | 


--------------------------------------------------------------------------------
/configure_trend_line.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file configure_trend_line.h
  3 |  * \brief Trend configuration dialog box
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * Configure a trend.
 28 |  */
 29 | 
 30 | #ifndef CONFIGURE_TREND_LINE_H
 31 | #define CONFIGURE_TREND_LINE_H
 32 | 
 33 | //  c++ includes
 34 | #include <QColor>  //  QColor
 35 | 
 36 | // C includes
 37 | /* -none- */
 38 | 
 39 | // project includes
 40 | #include "base_dialog.h"  //  BaseDialog
 41 | #include "ui_configure_trend_line.h"  //  Ui::ConfigureTrendDialog
 42 | #include "trend_line.h"  //  TrendLine
 43 | #include "trend_window.h"  //  TrendWindow
 44 | 
 45 | 
 46 | /**
 47 |  * @brief The ConfigureTrendLine class
 48 |  */
 49 | class ConfigureTrendLine : public BaseDialog
 50 | {
 51 |     Q_OBJECT
 52 | 
 53 | public:
 54 | 
 55 |     /**
 56 |      * @brief "new" trend constructor
 57 |      * @param parent parent window
 58 |      */
 59 |     ConfigureTrendLine(TrendWindow *const parent);
 60 | 
 61 |     /**
 62 |      * @brief "Update existing trend" constructor
 63 |      * @param parent trend to update
 64 |      */
 65 |     ConfigureTrendLine(TrendLine *const parent);
 66 | 
 67 |     /**
 68 |      * @brief create_trend
 69 |      * \note
 70 |      * Only to be called once the dialog is complete.
 71 |      *
 72 |      * @throw AppException if a line is already associated
 73 |      * @return Trend based on the current configuration
 74 |      */
 75 |     [[nodiscard]] TrendLine* create_trend();
 76 | 
 77 |     /**
 78 |      * @brief get the key (IE node<<16|reg)
 79 |      */
 80 |     operator quint32() const;
 81 | 
 82 |     virtual ~ConfigureTrendLine() override;
 83 | 
 84 | protected:
 85 |     virtual void setupUi() final override;
 86 | 
 87 | private slots:
 88 | 
 89 |     void on_Accept_pressed();
 90 |     void on_Cancel_pressed();
 91 |     void on_Delete_pressed();
 92 |     void on_ColorButton_pressed();
 93 | 
 94 | private:
 95 | 
 96 |     void update_color_labels();
 97 | 
 98 |     Ui::ConfigureTrendDialog *const m_ui;
 99 |     QColor m_display_color;
100 |     TrendWindow *const m_parent;
101 |     TrendLine *m_trend;
102 | };
103 | 
104 | 
105 | #endif // CONFIGURE_TREND_LINE_H
106 | 


--------------------------------------------------------------------------------
/configure_trend.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file configure_trend.h
  3 |  * \brief Trend graph configuration dialog box
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * Configure the trend graph.
 28 |  */
 29 | 
 30 | #ifndef CONFIGURE_TREND_H
 31 | #define CONFIGURE_TREND_H
 32 | 
 33 | //  c++ includes
 34 | #include <utility>  //  std::pair
 35 | #include <optional>  //  std::optional
 36 | 
 37 | // C includes
 38 | /* -none- */
 39 | 
 40 | // project includes
 41 | #include "base_dialog.h"  //  BaseDialog
 42 | #include "ui_configure_trend.h"  //  Ui::ConfigureTrend
 43 | 
 44 | 
 45 | /**
 46 |  * @brief Dialog box presenting the graph configuration options.
 47 |  */
 48 | class ConfigureTrend : public BaseDialog
 49 | {
 50 |     Q_OBJECT
 51 | 
 52 | public:
 53 | 
 54 |     /**
 55 |      * @brief constructor
 56 |      * @param parent parent widget
 57 |      * @param min graph minimum
 58 |      * @param max graph maximum
 59 |      * @param n_points number of points in graph
 60 |      */
 61 |     ConfigureTrend(QWidget *const parent,
 62 |                    const double min,
 63 |                    const double max,
 64 |                    const int n_points);
 65 | 
 66 |     /**
 67 |      * @brief Get min and max values.
 68 |      * @return min,max specified in controls
 69 |      */
 70 |     [[nodiscard]] std::pair<double, double> get_min_max() const;
 71 | 
 72 |     /**
 73 |      * @brief Get the number of points from the control.
 74 |      * @return Number of points.  Null (no value) if the value hasn't changed.
 75 |      */
 76 |     [[nodiscard]] std::optional<int> get_num_points() const;
 77 | 
 78 |     /**
 79 |      * @brief Get the "Use fixed limits" status.
 80 |      */
 81 |     operator bool() const;
 82 | 
 83 |     virtual void accept() override;
 84 | 
 85 |     virtual ~ConfigureTrend() override;
 86 | 
 87 | protected:
 88 |     virtual void setupUi() final override;
 89 | 
 90 | private slots:
 91 | 
 92 |     /**
 93 |      * @brief Action taken when the History Size control is edited.
 94 |      */
 95 |     void on_HistoryInput_textEdited();
 96 | 
 97 | private:
 98 |     Ui::ConfigureTrend *const m_ui;
 99 |     const int m_initial_points;
100 |     const double m_initial_min;
101 |     const double m_initial_max;
102 |     bool m_first_edit;
103 | };
104 | 
105 | #endif // CONFIGURE_TREND_H
106 | 


--------------------------------------------------------------------------------
/metadata_structs.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file metadata_structs.h
  3 |  * \brief Containers and definitions used by the program for metadata
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | #ifndef METADATA_STRUCTS_H
 27 | #define METADATA_STRUCTS_H
 28 | 
 29 | //  c++ includes
 30 | #include <QtCore>  //  quint8 and friends
 31 | #include <optional>  //  std::optional
 32 | #include <memory>  //  std::shared_ptr
 33 | 
 34 | // C includes
 35 | /* -none- */
 36 | 
 37 | // project includes
 38 | /* -none- */
 39 | 
 40 | 
 41 | // /////////////////////////////////////////////////////////////////////////////
 42 | // Forward declarations
 43 | // /////////////////////////////////////////////////////////////////////////////
 44 | class BaseDialog;
 45 | 
 46 | 
 47 | /**
 48 |  * \brief Encoding types recognized in the proprietary "read metadata" request
 49 |  * \note
 50 |  * These must match definition in project
 51 |  */
 52 | enum RegisterEncoding : qint8 {
 53 |     ENCODING_NONE=0,
 54 |     ENCODING_UINT16,
 55 |     ENCODINT_INT16,
 56 |     ENCODING_SIGNED_BYTES,
 57 |     ENCODING_BYTES,
 58 |     ENCODING_BITS,
 59 |     ENCODING_USER,
 60 |     ENCODING_UNKNOWN
 61 | };
 62 | 
 63 | 
 64 | /**
 65 |  * \brief All data that can be returned by querying the register metadata
 66 |  */
 67 | class Metadata {
 68 |     friend class MetadataWrapper;
 69 | 
 70 | public:
 71 |     /**
 72 |      * \brief default constructor
 73 |      * \note
 74 |      * This function shall only be called by the Metadata wrapper
 75 |      *
 76 |      * @param reg_num Register number
 77 |      * @param instance plugin instance value
 78 |      * @param fc function code
 79 |      */
 80 |     Metadata(const quint16 reg_num, void *const instance, const quint8 fc);
 81 |     Metadata(const Metadata&) = delete;
 82 | 
 83 |     const quint16 register_number; /**< Register numer */
 84 |     QString label; /**< Brief discription */
 85 |     RegisterEncoding encoding; /**< Data encoding method */
 86 |     std::optional<qint32> min; /**< Minimum allowed range */
 87 |     std::optional<qint32> max; /**< Maximum allowed range */
 88 |     std::optional<qint32> dflt; /**< register default value */
 89 |     const qint8 function_code; /**< function code of the request */
 90 | 
 91 |     ~Metadata();
 92 | 
 93 | private:
 94 |     void *const m_request_instance;
 95 |     std::vector<quint8> m_request;
 96 | 
 97 | };
 98 | 
 99 | 
100 | /**
101 |  * \brief State tracking of a sequence of metadata requests
102 |  */
103 | struct WindowMetadataRequest {
104 |     quint16 current_register; /**< Currently polled register */
105 |     quint16 last_register; /**< Last register to be polled in sequence */
106 |     quint8 node; /**< Node to poll */
107 |     BaseDialog *requester; /**< Pointer to window requesting */
108 |     std::shared_ptr<Metadata> request = nullptr; /**< Pointer to container */
109 | };
110 | 
111 | 
112 | #endif // METADATA_STRUCTS_H
113 | 


--------------------------------------------------------------------------------
/coils_display.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file coils_display.cpp
  3 |  * \brief Coils display window
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | //  c++ includes
 27 | #include <QCheckBox>  //  QCheckBox
 28 | #include <QStringBuilder>  //  operator%
 29 | 
 30 | // C includes
 31 | /* -none- */
 32 | 
 33 | // project includes
 34 | #include "coils_display.h"  //  local include
 35 | 
 36 | 
 37 | CoilsDisplay::CoilsDisplay(QWidget *parent, const quint16 base_reg, const quint16 count, const quint8 uid)
 38 |     :RegisterDisplay(parent, base_reg, count, uid),
 39 |       m_remote_state()
 40 | {
 41 | 
 42 | }
 43 | 
 44 | 
 45 | void CoilsDisplay::updateRegisterValue(const size_t index, const QString &value)
 46 | {
 47 |     static_cast<void>(value);
 48 |     auto widget = dynamic_cast<QCheckBox*>(m_register_values[index]);
 49 |     auto bvalue = (m_raw_values[index] > 0);
 50 |     m_remote_state[quint16(index + m_starting_register)] = bvalue;
 51 |     widget->setChecked(bvalue);
 52 | }
 53 | 
 54 | 
 55 | QWidget* CoilsDisplay::create_value_widget(const quint16 index, const bool initial)
 56 | {
 57 |     static_cast<void>(initial);
 58 |     auto widget = new QCheckBox(this);
 59 |     connect(widget, &QCheckBox::stateChanged, this, [=](int state) {
 60 |         static_cast<void>(state);
 61 |         on_checkbox_checked(index);
 62 |     });
 63 |     connect(widget, &QCheckBox::destroyed, this, [=](QWidget *w=nullptr) {
 64 |         static_cast<void>(w);
 65 |         on_register_destroyed(widget, index);
 66 |     });
 67 |     return widget;
 68 | }
 69 | 
 70 | 
 71 | void CoilsDisplay::on_checkbox_checked(quint16 index)
 72 | {
 73 |     const auto checkbox = dynamic_cast<QCheckBox*>(m_register_values[index]);
 74 |     const auto a = m_remote_state[index + m_starting_register];
 75 |     const auto b = checkbox->isChecked();
 76 |     if (a != b) {
 77 |         WriteRequest req{};
 78 |         req.first_register = m_starting_register + index;
 79 |         req.node = m_node;
 80 |         req.values = {quint16(b)};
 81 |         req.requester = this;
 82 |         emit write_requested(req);
 83 |     }
 84 | }
 85 | 
 86 | 
 87 | void CoilsDisplay::on_register_destroyed(QWidget *register_widget, const quint16 index)
 88 | {
 89 |     static_cast<void>(register_widget);
 90 |     static_cast<void>(index);
 91 | }
 92 | 
 93 | 
 94 | QString CoilsDisplay::get_object_name() const
 95 | {
 96 |     return "CoilsDisplay";
 97 | }
 98 | 
 99 | 
100 | bool CoilsDisplay::load_configuration_parameters(const QDomElement &node)
101 | {
102 |     const auto reg = node.attribute("register").toUInt();
103 |     if (reg >= 10000) {
104 |         return false;
105 |     }
106 | 
107 |     return RegisterDisplay::load_configuration_parameters(node);
108 | }
109 | 
110 | 
111 | QString CoilsDisplay::get_display_value(const size_t index) const
112 | {
113 |     auto widget = dynamic_cast<QCheckBox*>(m_register_values[index]);
114 |     return (widget->isChecked() ? "1" : "0");
115 | }
116 | 
117 | QString CoilsDisplay::get_register_number_text(const quint16 reg_number)
118 | {
119 |     const auto base_text = RegisterDisplay::get_register_number_text(reg_number);
120 |     const auto padding = QString(5 - base_text.size(), QChar('0'));
121 |     return padding % base_text;
122 | }
123 | 


--------------------------------------------------------------------------------
/holding_register_display.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file holding_register_display.h
  3 |  * \brief Holding Registers window
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * Derivitave of Register Display for interacting with the Holding Registers
 28 |  * (40,000 series)
 29 |  */
 30 | 
 31 | #ifndef HOLDINGREGISTERDISPLAY_H
 32 | #define HOLDINGREGISTERDISPLAY_H
 33 | 
 34 | //  c++ includes
 35 | #include <QTimer>  //  QTimer
 36 | #include <vector>  //  std::vector
 37 | 
 38 | // C includes
 39 | /* -none- */
 40 | 
 41 | // project includes
 42 | #include "register_display.h"  //  RegisterDisplay
 43 | 
 44 | 
 45 | /**
 46 |  * \brief Holding Registers windows
 47 |  */
 48 | class HoldingRegisterDisplay : public RegisterDisplay
 49 | {
 50 |     Q_OBJECT
 51 | 
 52 | public:
 53 | 
 54 |     /**
 55 |      * \brief constructor
 56 |      * @param parent parent QObject owner
 57 |      * @param base_reg first register number
 58 |      * @param count number of registers to poll
 59 |      * @param uid device ID, unit ID, node of server to poll
 60 |      */
 61 |     HoldingRegisterDisplay(QWidget *parent, const quint16 base_reg, const quint16 count=32, const quint8 uid=0);
 62 | 
 63 |     virtual QString get_object_name() const override;
 64 |     virtual bool load_configuration_parameters(const QDomElement &node) override;
 65 | 
 66 | protected:
 67 | 
 68 |     /**
 69 |      * \brief Encode display string to raw unsigned 16 value(s)
 70 |      * @param value String value
 71 |      * @param encoding Register's encoding
 72 |      * @return list of values to build as a write request
 73 |      */
 74 |     [[nodiscard]] virtual std::vector<quint16> encode_register(const QString &value,
 75 |                                                                const RegisterEncoding encoding) const;
 76 | 
 77 |     virtual void updateRegisterValue(const size_t index, const QString &value) override;
 78 |     virtual QWidget* create_value_widget(const quint16 index, const bool initial) override;
 79 |     virtual QString get_display_value(const size_t index) const override;
 80 |     virtual void setupUi() override;
 81 | 
 82 | private slots:
 83 |     /**
 84 |      * \brief Signal that a register text box is active for editing.
 85 |      * @param index register index in window
 86 |      */
 87 |     void on_register_textEdited(const quint16 index);
 88 | 
 89 |     /**
 90 |      * \brief Signal that enter has been pressed on a text box (write request).
 91 |      * @param index register index in window
 92 |      */
 93 |     void on_register_returnPressed(const quint16 index);
 94 | 
 95 |     /**
 96 |      * \brief Signal that a text box is no longer being edited.
 97 |      * @param index register index in window
 98 |      */
 99 |     void on_register_editingFinished(const quint16 index);
100 | 
101 |     /**
102 |      * \brief Signal that a control has been destroted.
103 |      * @param register_widget widget reference
104 |      * @param index register index in window
105 |      */
106 |     void on_register_destroyed(QWidget *const register_widget, const quint16 index);
107 | 
108 |     /**
109 |      * \brief Signal that the edit idle timer has expired.
110 |      */
111 |     void on_timer_expired();
112 | 
113 | private:
114 |     int m_active_index=-1;
115 |     QTimer *const m_activity_timer;
116 | 
117 | };
118 | 
119 | #endif // HOLDINGREGISTERDISPLAY_H
120 | 


--------------------------------------------------------------------------------
/metadata_wrapper.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file metadata_wrapper.h
  3 |  * \brief Wrapper singleton around the Read Metadata plugin shared object.
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * The MetadataWrapper class is a singleton class providing access the
 28 |  * metadata modbus plugin (non-GPL).  It also provides safe abstraction so
 29 |  * functionality isn't lost (aside from the data its self) if the plugin isn't
 30 |  * present.  It also allows for easy replacement with another interface that
 31 |  * can provide the same information.
 32 |  */
 33 | 
 34 | #ifndef METADATA_WRAPPER_H
 35 | #define METADATA_WRAPPER_H
 36 | 
 37 | 
 38 | //  c++ includes
 39 | #include <QtCore>  // QObject
 40 | #include <QPair>  //  QPair
 41 | #include <QLibrary>  //  QLibrary
 42 | #include <string_view>  //  std::string_view
 43 | #include <vector>  //  std::vector
 44 | #include <memory>  //  std::shared_ptr
 45 | #include <string>  //  std::string
 46 | 
 47 | // C includes
 48 | /* -none- */
 49 | 
 50 | // project includes
 51 | #include "metadata_structs.h"  //  Metadata
 52 | 
 53 | 
 54 | /**
 55 |  * \brief State-aware wrapper around the metadata modbus plugin
 56 |  */
 57 | class MetadataWrapper : protected QObject
 58 | {
 59 |     Q_OBJECT
 60 | //    friend class Metadata;
 61 | 
 62 | public:
 63 | 
 64 |     /**
 65 |      * \brief Test if the library has been successfully loaded
 66 |      * @return ``true`` if loaded, ``false`` otherwise
 67 |      */
 68 |     [[nodiscard]] bool loaded() const;
 69 | 
 70 |     /**
 71 |      * \brief Generate request container
 72 |      * @param reg_number Request metadata for this register number
 73 |      * @return Metadata container
 74 |      */
 75 |     [[nodiscard]] std::shared_ptr<Metadata> create_request(const quint16 reg_number);
 76 | 
 77 |     /**
 78 |      * \brief Generate an outgoing request PDU
 79 |      * @param request Request container
 80 |      * @return raw PDU (length and data pointer)
 81 |      */
 82 |     [[nodiscard]] QPair<const quint8*, quint8> encode_request(std::shared_ptr<Metadata> request);
 83 | 
 84 |     /**
 85 |      * \brief Decode a response PDU
 86 |      * @param request Request container (updated)
 87 |      * @param data response PDU
 88 |      */
 89 |     void decode_response(std::shared_ptr<Metadata> request, const std::vector<quint8> &data);
 90 | 
 91 |     /**
 92 |      * \brief This class is a singleton, get the instance.
 93 |      * @return Singleton instance
 94 |      */
 95 |     static MetadataWrapper* get_instance();
 96 | 
 97 |     /**
 98 |      * \brief Dispose metadata during destructor
 99 |      * \note
100 |      * This function is only called by the MetaData object, and only during
101 |      * destruction.  It is responsible for instructing the plugin to free
102 |      * internal resources.
103 |      *
104 |      * @param m pointer to metadata object
105 |      */
106 |     void dispose_metadata(const Metadata *const m);
107 | 
108 |     virtual ~MetadataWrapper();
109 | 
110 | private:
111 | 
112 |     /**
113 |      * \brief constructor
114 |      * @param lib_path Path to the shared object
115 |      */
116 |     MetadataWrapper(const QString &lib_path);
117 | 
118 |     /**
119 |      * \fn decode_labels, decode_defaults, decode_encoding, decode_limits
120 |      * \brief Internal decoder functions
121 |      * @param request pointer to request instance
122 |      */
123 |     void decode_labels(Metadata *const request);
124 |     void decode_defaults(Metadata *const request);
125 |     void decode_encoding(Metadata *const request);
126 |     void decode_limits(Metadata *const request);
127 | 
128 |     QLibrary *const m_dll_reference;
129 | //    void *m_dll_reference = nullptr;
130 | };
131 | 
132 | #endif // METADATA_WRAPPER_H
133 | 


--------------------------------------------------------------------------------
/csv_importer.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file csv_importer.h
  3 |  * \brief Import CSV data interactive modal dialog.
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * A complex dialog to allow the user to select columns containing data and
 28 |  * import them.
 29 |  */
 30 | 
 31 | #ifndef CSV_IMPORTER_H
 32 | #define CSV_IMPORTER_H
 33 | 
 34 | //  c++ includes
 35 | #include <QList>  //  QList
 36 | #include <QStringList>  //  QStringList
 37 | #include <QGridLayout>  //  QGridLayout
 38 | #include <QTableWidget>  //  QTableWidget
 39 | #include <QPushButton>  //  QPushButton
 40 | #include <QComboBox>  //  QComboBox
 41 | #include <QCheckBox>  //  QCheckBox
 42 | #include <QSpinBox>  //  QSpinBox
 43 | #include <vector>  //  std::vector
 44 | #include <array>  //  std::array
 45 | #include <tuple>  //  std::tuple
 46 | #include <utility>  //  std::pair
 47 | 
 48 | // C includes
 49 | /* -none- */
 50 | 
 51 | // project includes
 52 | #include "base_dialog.h"
 53 | 
 54 | 
 55 | /**
 56 |  * \brief Field data configured by this dialog box.
 57 |  */
 58 | using FieldData = std::tuple<size_t, size_t, ssize_t, bool>;
 59 | 
 60 | 
 61 | /**
 62 |  * \brief Field -> data mapping in ``FieldData`` tuple
 63 |  */
 64 | enum TestFields : size_t {
 65 |     REG_NUMBER=0,
 66 |     REG_VALUE,
 67 |     NODE_ID,
 68 |     HEADER_ROW
 69 | };
 70 | 
 71 | 
 72 | /**
 73 |  * \brief CSV Data Import Selection
 74 |  */
 75 | class CsvImporter : public BaseDialog
 76 | {
 77 |     Q_OBJECT
 78 | 
 79 | public:
 80 | 
 81 |     /**
 82 |      * \brief constructor
 83 |      * @param parent parent QObject owner
 84 |      * @param all_data Data decoded by the CSV parser
 85 |      */
 86 |     CsvImporter(QWidget *parent, const QList<QStringList> &all_data);
 87 | 
 88 |     /**
 89 |      * \brief Get the configuration specified.
 90 |      * @throws AppException if the dialog is not "finished"
 91 |      * @return tuple representing fields \sa TestFields
 92 |      */
 93 |     [[nodiscard]] const FieldData get_config() const;
 94 | 
 95 | private slots:
 96 | 
 97 |     /**
 98 |      * \brief OK Button clicked - verify input
 99 |      */
100 |     void on_ok_clicked();
101 | 
102 |     /**
103 |      * \brief Use fixed node checked / unchecked
104 |      */
105 |     void on_single_node_checked(int status);
106 | 
107 |     /**
108 |      * \brief First row contains headers checked / unchecked
109 |      */
110 |     void on_header_row_checked(int status);
111 | 
112 |     /**
113 |      * \brief Attempt to automatically deduce fields from input
114 |      * \note
115 |      * Made a slot so it can be directly invoked from a QTimer::singleShot
116 |      */
117 |     void attempt_autoconfig();
118 | 
119 | private:
120 | 
121 |     /**
122 |      * \brief Initialize the UI components.
123 |      */
124 |     void setupUi() override;
125 | 
126 |     /**
127 |      * \brief Called when a column header is checked/unchecked.
128 |      * @param checkbox Widget that generated the event
129 |      * @param column column that has been updated
130 |      */
131 |     void on_column_checked(const QCheckBox *const checkbox, const size_t column);
132 | 
133 | 
134 |     bool m_is_valid = false;
135 |     QTableWidget *const m_preview_table;
136 |     QWidget *const m_grid_container;
137 |     QGridLayout *const m_control_grid;
138 |     QPushButton *const m_ok;
139 |     QPushButton *const m_cancel;
140 |     QCheckBox *const m_first_row_headers;
141 |     QCheckBox *const m_fixed_node;
142 |     QSpinBox *const m_node_select;
143 | 
144 |     /**
145 |      * \var m_test_text
146 |      * Contains the first few rows of data in column-major order.
147 |      */
148 |     std::vector<std::array<QString, 5>> m_test_text;
149 |     std::vector<std::pair<QComboBox*, QCheckBox*>> m_role_selection;
150 | 
151 |     /* Order must match that in the tuple */
152 |     const QStringList m_options;
153 | 
154 |     /* Only updated when ok clicked is successful */
155 |     FieldData m_config;
156 | };
157 | 
158 | #endif // CSV_IMPORTER_H
159 | 


--------------------------------------------------------------------------------
/base_dialog.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file base_dialog.h
  3 |  * \brief Base class for most screens
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * This class acts as a base class for many of the modal windows used in the
 28 |  * project.  It specifically provides some basic definitions needed to interact
 29 |  * with the scheduler as well as delayed widget population.
 30 |  */
 31 | 
 32 | #ifndef BASE_DIALOG_H
 33 | #define BASE_DIALOG_H
 34 | 
 35 | //  c++ includes
 36 | #include <QDialog>  //  QDialog
 37 | #include <QResizeEvent>  //  QResizeEvent
 38 | #include <QVBoxLayout>  //  QVBoxLayout
 39 | #include <QAbstractButton>  //  QAbstractButton
 40 | #include <QStyle>  //  QStyle
 41 | 
 42 | // C includes
 43 | /* -none- */
 44 | 
 45 | // project includes
 46 | #include "write_event.h"  //  WriteRequest
 47 | #include "metadata_structs.h"  //  WindowMetadataRequest
 48 | #include "modbusthread.h"  //  ModbusThread
 49 | 
 50 | 
 51 | /**
 52 |  * \brief Modal window
 53 |  */
 54 | class BaseDialog : public QDialog
 55 | {
 56 |     Q_OBJECT
 57 | 
 58 | public:
 59 | 
 60 |     /**
 61 |      * \brief constructor
 62 |      * @param parent parent QObject owner
 63 |      * @param create_layout set ``false`` to omit creating the top QVBoxLayout
 64 |      */
 65 |     BaseDialog(QWidget *const parent, const bool create_layout=true);
 66 | 
 67 |     void add_icon_to_button(QAbstractButton *const button,
 68 |                             const QStyle::StandardPixmap icon_name) const;
 69 | 
 70 |     /**
 71 |      * \brief Set metadata callback from scheduler
 72 |      * @param metadata Metadata returned from poller
 73 |      * @param node Node (slave ID) that was polled
 74 |      */
 75 |     virtual void set_metadata(std::shared_ptr<Metadata> metadata, const quint8 node);
 76 | 
 77 |     /**
 78 |      * \brief Callback from scheduler to poll register data (1-poll)
 79 |      * @param engine Modbus connection
 80 |      */
 81 |     virtual void poll_register_set(ModbusThread *const engine);
 82 | 
 83 | public slots:
 84 | 
 85 |     /**
 86 |      * \brief Signal to update a register value.
 87 |      * @param reg register number
 88 |      * @param value raw register value
 89 |      * @param unit_id node / unit ID polled
 90 |      */
 91 |     virtual void on_new_value(const quint16 reg, const quint16 value, const quint8 unit_id);
 92 | 
 93 |     /**
 94 |      * \brief Signal that a modbus exception occurred.
 95 |      * @param requester request source associated with the exception
 96 |      * @param exception exception text
 97 |      */
 98 |     virtual void on_exception_status(BaseDialog *requester, const QString exception);
 99 | 
100 | signals:
101 | 
102 |     /**
103 |      * \brief Emit that the window has been closed.
104 |      * @param window this window
105 |      */
106 |     void window_closed(BaseDialog *window);
107 | 
108 |     /**
109 |      * \brief Emit that the window has been shown for the first time.
110 |      * @param window this window
111 |      */
112 |     void window_first_display(BaseDialog *window);
113 | 
114 |     /**
115 |      * \brief Emit data write request.
116 |      * @param req write request structure
117 |      */
118 |     void write_requested(WriteRequest req);
119 | 
120 |     /**
121 |      * \brief Emit read metadata request.
122 |      * @param req read metadata request structure
123 |      */
124 |     void metadata_requested(WindowMetadataRequest req);
125 | 
126 | protected:
127 | 
128 |     /**
129 |      * \brief Initialize the UI components.
130 |      */
131 |     virtual void setupUi() = 0;
132 | 
133 |     virtual void showEvent(QShowEvent *evt) override;
134 |     virtual void resizeEvent(QResizeEvent *evt) override;
135 |     virtual void closeEvent(QCloseEvent *evt) override;
136 | 
137 |     QVBoxLayout *const m_top_layout; /**< Window layout control */
138 |     bool m_debug_resize = false;  /*< derived classes may change this to print window sizes */
139 | 
140 | private:
141 |     bool m_first_display;
142 |     bool m_emit_close;
143 | };
144 | 
145 | 
146 | #endif // BASE_DIALOG_H
147 | 


--------------------------------------------------------------------------------
/base_dialog.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file base_dialog.cpp
  3 |  * \brief Base class for most screens
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | 
 27 | //  c++ includes
 28 | #include <QDebug>  //  qDebug
 29 | #include <QIcon>  //  QIcon
 30 | 
 31 | // C includes
 32 | /* -none- */
 33 | 
 34 | // project includes
 35 | #include "base_dialog.h"  //  local include
 36 | #include "exceptions.h"
 37 | 
 38 | 
 39 | BaseDialog::BaseDialog(QWidget *const parent, const bool create_layout) :
 40 |     QDialog(parent),
 41 |     m_top_layout{(create_layout ? new QVBoxLayout(this) : nullptr)},
 42 |     m_first_display{true},
 43 |     m_emit_close{true}
 44 | {
 45 |     if (create_layout) {
 46 |         setLayout(m_top_layout);
 47 |     }
 48 | 
 49 |     connect(this, &BaseDialog::rejected, this, [=]() {
 50 |         if (m_emit_close) {
 51 |             m_emit_close = false;
 52 |             emit window_closed(this);
 53 |         }
 54 |     });
 55 | 
 56 |     //  Solution found at:
 57 |     // https://stackoverflow.com/questions/42655988/adjust-title-position-in-a-qgroupbox-using-style-sheets
 58 |     // To the Qt developers:  Why the   ~ [ H 3 1 ! ] ~   is this not the
 59 |     // default and where the   ~ [ F * * * ] ~   is this documented?
 60 |     //  I mean, come on!  Scroll area has a frame by default which no one uses,
 61 |     // but this requires this long of a string to be consistent with every
 62 |     // other WM out there?  Really?
 63 |     setStyleSheet("QGroupBox{"
 64 |                       "font: bold;"
 65 |                       "border: 1px solid silver;"
 66 |                       "border-radius: 6px;"
 67 |                       "margin-top: 6px;} "
 68 |                   "QGroupBox::title{"
 69 |                       "subcontrol-origin: margin;"
 70 |                       "left: 7px;"
 71 |                       "top: -5px;"
 72 |                       "padding: 0px 5px 0px 5px}");
 73 | 
 74 |     auto icon = QIcon(":/QModbusTool.ico");
 75 |     setWindowIcon(icon);
 76 | }
 77 | 
 78 | 
 79 | void BaseDialog::showEvent(QShowEvent *evt)
 80 | {
 81 |     if (m_first_display) {
 82 |         m_first_display = false;
 83 |         setupUi();
 84 |         emit window_first_display(this);
 85 |     }
 86 |     QDialog::showEvent(evt);
 87 | }
 88 | 
 89 | 
 90 | void BaseDialog::resizeEvent(QResizeEvent *evt)
 91 | {
 92 |     QDialog::resizeEvent(evt);
 93 |     if (m_debug_resize) {
 94 |         const auto size = evt->size();
 95 |         qDebug() << size.width() << ',' << size.height();
 96 |     }
 97 | }
 98 | 
 99 | 
100 | void BaseDialog::closeEvent(QCloseEvent *evt)
101 | {
102 |     QDialog::closeEvent(evt);
103 |     if (m_emit_close) {
104 |         m_emit_close = false;
105 |         emit window_closed(this);
106 |     }
107 | }
108 | 
109 | 
110 | void BaseDialog::add_icon_to_button(QAbstractButton *const button,
111 |                                     const QStyle::StandardPixmap icon_name) const
112 | {
113 |     //  As far as I'm concerned, the fact that I need to do this is a bug in QT.
114 |     // https://forum.learnpyqt.com/t/are-there-any-built-in-qicons/185/2
115 |     auto style = button->style();
116 |     auto icon = style->standardIcon(icon_name);
117 |     button->setIcon(icon);
118 | }
119 | 
120 | 
121 | void BaseDialog::on_new_value(const quint16 reg, const quint16 value, const quint8 unit_id)
122 | {
123 |     static_cast<void>(reg);
124 |     static_cast<void>(value);
125 |     static_cast<void>(unit_id);
126 | }
127 | 
128 | 
129 | void BaseDialog::on_exception_status(BaseDialog *requester, const QString exception)
130 | {
131 |     static_cast<void>(requester);
132 |     static_cast<void>(exception);
133 | }
134 | 
135 | 
136 | void BaseDialog::set_metadata(std::shared_ptr<Metadata> metadata, const quint8 node)
137 | {
138 |     static_cast<void>(metadata);
139 |     static_cast<void>(node);
140 |     throw AppException("Metadata not configured in this object");
141 | }
142 | 
143 | 
144 | void BaseDialog::poll_register_set(ModbusThread *const engine)
145 | {
146 |     static_cast<void>(engine);
147 |     throw AppException("Polling not configured in this object");
148 | }
149 | 


--------------------------------------------------------------------------------
/configure_trend.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>ConfigureTrend</class>
  4 |  <widget class="QDialog" name="ConfigureTrend">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>472</width>
 10 |     <height>181</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>Configure Graph</string>
 15 |   </property>
 16 |   <property name="windowIcon">
 17 |    <iconset resource="resources.qrc">
 18 |     <normaloff>:/QModbusTool.ico</normaloff>:/QModbusTool.ico</iconset>
 19 |   </property>
 20 |   <widget class="QDialogButtonBox" name="buttonBox">
 21 |    <property name="geometry">
 22 |     <rect>
 23 |      <x>290</x>
 24 |      <y>130</y>
 25 |      <width>171</width>
 26 |      <height>32</height>
 27 |     </rect>
 28 |    </property>
 29 |    <property name="orientation">
 30 |     <enum>Qt::Horizontal</enum>
 31 |    </property>
 32 |    <property name="standardButtons">
 33 |     <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
 34 |    </property>
 35 |   </widget>
 36 |   <widget class="QGroupBox" name="groupBox">
 37 |    <property name="geometry">
 38 |     <rect>
 39 |      <x>20</x>
 40 |      <y>10</y>
 41 |      <width>261</width>
 42 |      <height>161</height>
 43 |     </rect>
 44 |    </property>
 45 |    <property name="title">
 46 |     <string>Graph Setup</string>
 47 |    </property>
 48 |    <widget class="QWidget" name="gridLayoutWidget">
 49 |     <property name="geometry">
 50 |      <rect>
 51 |       <x>10</x>
 52 |       <y>50</y>
 53 |       <width>241</width>
 54 |       <height>97</height>
 55 |      </rect>
 56 |     </property>
 57 |     <layout class="QGridLayout" name="gridLayout">
 58 |      <property name="spacing">
 59 |       <number>6</number>
 60 |      </property>
 61 |      <item row="0" column="0">
 62 |       <widget class="QLabel" name="label">
 63 |        <property name="text">
 64 |         <string>Graph Minimum:</string>
 65 |        </property>
 66 |       </widget>
 67 |      </item>
 68 |      <item row="1" column="1">
 69 |       <widget class="QLineEdit" name="MaxInput">
 70 |        <property name="text">
 71 |         <string>1.0</string>
 72 |        </property>
 73 |       </widget>
 74 |      </item>
 75 |      <item row="2" column="0" colspan="2">
 76 |       <widget class="QCheckBox" name="DynamicCheck">
 77 |        <property name="layoutDirection">
 78 |         <enum>Qt::RightToLeft</enum>
 79 |        </property>
 80 |        <property name="styleSheet">
 81 |         <string notr="true">QCheckBox {padding-right: 25px;}</string>
 82 |        </property>
 83 |        <property name="text">
 84 |         <string>Use Fixed Limits?     </string>
 85 |        </property>
 86 |        <property name="checked">
 87 |         <bool>true</bool>
 88 |        </property>
 89 |       </widget>
 90 |      </item>
 91 |      <item row="1" column="0">
 92 |       <widget class="QLabel" name="label_2">
 93 |        <property name="text">
 94 |         <string>Graph Maximum:</string>
 95 |        </property>
 96 |       </widget>
 97 |      </item>
 98 |      <item row="0" column="1">
 99 |       <widget class="QLineEdit" name="MinInput">
100 |        <property name="text">
101 |         <string>0.0</string>
102 |        </property>
103 |       </widget>
104 |      </item>
105 |     </layout>
106 |    </widget>
107 |   </widget>
108 |   <widget class="QGroupBox" name="groupBox_2">
109 |    <property name="geometry">
110 |     <rect>
111 |      <x>310</x>
112 |      <y>20</y>
113 |      <width>141</width>
114 |      <height>80</height>
115 |     </rect>
116 |    </property>
117 |    <property name="title">
118 |     <string>History Size</string>
119 |    </property>
120 |    <widget class="QLineEdit" name="HistoryInput">
121 |     <property name="geometry">
122 |      <rect>
123 |       <x>20</x>
124 |       <y>40</y>
125 |       <width>101</width>
126 |       <height>30</height>
127 |      </rect>
128 |     </property>
129 |     <property name="text">
130 |      <string>100</string>
131 |     </property>
132 |    </widget>
133 |   </widget>
134 |  </widget>
135 |  <resources>
136 |   <include location="resources.qrc"/>
137 |  </resources>
138 |  <connections>
139 |   <connection>
140 |    <sender>buttonBox</sender>
141 |    <signal>accepted()</signal>
142 |    <receiver>ConfigureTrend</receiver>
143 |    <slot>accept()</slot>
144 |    <hints>
145 |     <hint type="sourcelabel">
146 |      <x>248</x>
147 |      <y>254</y>
148 |     </hint>
149 |     <hint type="destinationlabel">
150 |      <x>157</x>
151 |      <y>274</y>
152 |     </hint>
153 |    </hints>
154 |   </connection>
155 |   <connection>
156 |    <sender>buttonBox</sender>
157 |    <signal>rejected()</signal>
158 |    <receiver>ConfigureTrend</receiver>
159 |    <slot>reject()</slot>
160 |    <hints>
161 |     <hint type="sourcelabel">
162 |      <x>316</x>
163 |      <y>260</y>
164 |     </hint>
165 |     <hint type="destinationlabel">
166 |      <x>286</x>
167 |      <y>274</y>
168 |     </hint>
169 |    </hints>
170 |   </connection>
171 |  </connections>
172 | </ui>
173 | 


--------------------------------------------------------------------------------
/trend_line.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file trend_line.cpp
  3 |  * \brief Individual trend line
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | 
 27 | //  c++ includes
 28 | #include <limits>  //  std::numeric_limits
 29 | #include <QStringBuilder>  //  operator%
 30 | #include <algorithm>  //  std::fill
 31 | 
 32 | // C includes
 33 | /* -none- */
 34 | 
 35 | // project includes
 36 | #include "trend_line.h"  //  local include
 37 | #include "exceptions.h"  //  AppException
 38 | #include "configure_trend_line.h"  //  ConfigureTrendLine
 39 | 
 40 | 
 41 | TrendLine::TrendLine(TrendWindow *parent,
 42 |                      const quint16 reg,
 43 |                      const quint8 node) :
 44 |         QPushButton(parent->m_scroll_container),
 45 |         m_reg_number{reg},
 46 |         m_device_id{node},
 47 |         m_num_points{parent->m_timestamps.size()},
 48 |         m_signed_value{true},
 49 |         m_mult{1.0},
 50 |         m_offset{0.0},
 51 |         m_pen_color(Qt::blue),
 52 |         m_history(m_num_points),
 53 |         m_last_value(),
 54 |         m_next_index{0},
 55 |         m_parent{parent}
 56 | {
 57 |     connect(this, &TrendLine::clicked, this, &TrendLine::on_clicked);
 58 |     setupUi();
 59 | }
 60 | 
 61 | 
 62 | void TrendLine::set_data(const quint16 value) noexcept
 63 | {
 64 |     if (m_signed_value) {
 65 |         const auto v = static_cast<qint16>(value);
 66 |         m_last_value = qint32(v);
 67 |     } else {
 68 |         m_last_value = qint32(value);
 69 |     }
 70 | }
 71 | 
 72 | 
 73 | void TrendLine::update()
 74 | {
 75 |     if (!bool(m_last_value)) {
 76 |         throw AppException(tr("Update called on invalid data"));
 77 |     }
 78 | 
 79 |     auto v = double(m_last_value.value()) * m_mult;
 80 |     v += m_offset;
 81 |     m_parent->update_min_max(v);
 82 |     m_history[m_next_index] = v;
 83 | 
 84 |     if (++m_next_index >= m_num_points) {
 85 |         m_next_index = 0;
 86 |     }
 87 | 
 88 |     m_last_value.reset();
 89 | }
 90 | 
 91 | 
 92 | TrendLine::operator bool() const noexcept
 93 | {
 94 |     return m_last_value.has_value();
 95 | }
 96 | 
 97 | 
 98 | const double& TrendLine::operator[] (int index) const
 99 | {
100 |     auto array_index = m_next_index + index;
101 |     if (array_index >= m_num_points) {
102 |         array_index -= m_num_points;
103 |     }
104 | 
105 |     return m_history.at(array_index);
106 | }
107 | 
108 | 
109 | void TrendLine::configure(const double m, const double b, const bool set_signed)
110 | {
111 |     m_mult = m;
112 |     m_offset = b;
113 |     m_signed_value = set_signed;
114 | }
115 | 
116 | 
117 | void TrendLine::set_color(const QColor &pen_color) noexcept
118 | {
119 |     m_pen_color = pen_color;
120 |     setupUi();
121 | }
122 | 
123 | 
124 | TrendLine::operator quint32() const noexcept
125 | {
126 |     return m_parent->get_key(m_reg_number, m_device_id);
127 | }
128 | 
129 | 
130 | TrendLine::operator QPen() const noexcept
131 | {
132 |     return QPen(m_pen_color);
133 | }
134 | 
135 | 
136 | void TrendLine::on_clicked()
137 | {
138 |     auto dlg = ConfigureTrendLine(this);
139 |     dlg.exec();
140 | }
141 | 
142 | 
143 | void TrendLine::setupUi()
144 | {
145 |     setFixedWidth(m_parent->m_add_button->size().width());
146 |     setAutoDefault(false);
147 |     const auto reg_number = QString::number(m_reg_number);
148 |     const auto reg_padding = QString(5 - reg_number.size(), QChar('0'));
149 |     setText("------\n" % reg_padding %
150 |             reg_number % QChar('@') % QString::number(m_device_id));
151 |     setStyleSheet("QPushButton {color: " % m_pen_color.name() % ";}");
152 | }
153 | 
154 | 
155 | void TrendLine::save_configuration(QDomElement &node) const
156 | {
157 |     node.setAttribute("register", QString::number(m_reg_number));
158 |     node.setAttribute("node", QString::number(m_device_id));
159 |     node.setAttribute("signed", QString::number(int(m_signed_value)));
160 |     node.setAttribute("m", QString::number(m_mult));
161 |     node.setAttribute("b", QString::number(m_offset));
162 |     node.setAttribute("color", m_pen_color.name());
163 | 
164 | }
165 | 
166 | 
167 | void TrendLine::resize(int new_size)
168 | {
169 |     m_next_index = 0;
170 |     m_num_points = new_size;
171 |     m_history.resize(new_size);
172 |     std::fill(m_history.begin(), m_history.end(), m_offset);
173 | }
174 | 


--------------------------------------------------------------------------------
/trend_line.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file trend_line.h
  3 |  * \brief Individual trend line
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * The trend data is encapsulated within the "Button" located in the "Legend"
 28 |  * section of the graph.  It overlads the actual button and provides a bunch of
 29 |  * syntactic sugar to interface to the underlying trend data.  This class shall
 30 |  * not be used outside of the TrendWindow class.
 31 |  */
 32 | 
 33 | #ifndef TREND_LINE_H
 34 | #define TREND_LINE_H
 35 | 
 36 | //  c++ includes
 37 | #include <QVector>  //  QVector
 38 | #include <QColor>  //  QColor
 39 | #include <QPushButton>  //  QPushButton
 40 | #include <QPen>  //  QPen
 41 | #include <QDomElement>  //  QDomElement
 42 | #include <optional>  //  std::optional
 43 | 
 44 | // C includes
 45 | /* -none- */
 46 | 
 47 | // project includes
 48 | #include "trend_window.h"
 49 | 
 50 | 
 51 | /**
 52 |  * @brief Graph indivdual line configuration and storage
 53 |  */
 54 | class TrendLine : public QPushButton
 55 | {
 56 |     friend class ConfigureTrendLine;
 57 | 
 58 |     Q_OBJECT
 59 | 
 60 | public:
 61 | 
 62 |     /**
 63 |      * @brief constructor
 64 |      * @param parent parent TrendWindo
 65 |      * @param reg modbus register to monitor
 66 |      * @param node node / device ID to monitor
 67 |      */
 68 |     TrendLine(TrendWindow *parent, const quint16 reg, const quint8 node=0);
 69 | 
 70 |     /**
 71 |      * @brief Set the current data
 72 |      * @param value current data value
 73 |      */
 74 |     void set_data(const quint16 value) noexcept;
 75 | 
 76 |     /**
 77 |      * @brief configure trend internals
 78 |      * @param m multiplier
 79 |      * @param b offset
 80 |      * @param set_signed interpret register as signed (``true``)
 81 |      *        or unsigned (``false``)
 82 |      */
 83 |     void configure(const double m, const double b, const bool set_signed=true);
 84 | 
 85 |     /**
 86 |      * @brief Set the trend line color
 87 |      * @param pen_color line color
 88 |      */
 89 |     void set_color(const QColor &pen_color) noexcept;
 90 | 
 91 |     /**
 92 |      * @brief Update history with current value
 93 |      * \note
 94 |      * This also updates the parent min/max values
 95 |      *
 96 |      * @throw AppException if no value has been stored.
 97 |      */
 98 |     void update();
 99 | 
100 |     /**
101 |      * @brief get current state : IE is there a value currently stored?
102 |      */
103 |     [[nodiscard]] operator bool() const noexcept;
104 | 
105 |     /**
106 |       * \brief Get the QPen for graph drawing
107 |       */
108 |     [[nodiscard]] operator QPen() const noexcept;
109 | 
110 |     /**
111 |       * \brief get hash key from TrendLine instance
112 |       */
113 |     [[nodiscard]] operator quint32() const noexcept;
114 | 
115 |     /**
116 |      * @brief Get the value at an index
117 |      * @param index index: 0 => oldest, g_num_points-1 => newest
118 |      * @return historical value
119 |      */
120 |     [[nodiscard]] const double& operator[] (int index) const;
121 | 
122 |     /**
123 |      * @brief Save trend line configuration
124 |      * @param node fill data in node
125 |      */
126 |     void save_configuration(QDomElement &node) const;
127 | 
128 |     /**
129 |      * @brief Resize the number of history items
130 |      * @param new_size new number of history items
131 |      */
132 |     void resize(int new_size);
133 | 
134 |     const quint16 m_reg_number; /**< Register number associated with line */
135 |     const quint8 m_device_id; /**< Device ID to monitor */
136 | 
137 | private slots:
138 | 
139 |     /**
140 |      * @brief On button clicked handler
141 |      */
142 |     void on_clicked();
143 | 
144 | private:
145 | 
146 |     /**
147 |      * @brief Update the UI (Button contents)
148 |      */
149 |     void setupUi();
150 | 
151 |     int m_num_points;
152 |     bool m_signed_value; /**< Treat incoming data as signed? */
153 |     double m_mult; /**< Multiply value by m */
154 |     double m_offset; /**< Add b to value after multiplication */
155 | 
156 |     QColor m_pen_color; /**< Desired pen color */
157 |     QVector<double> m_history;
158 |     std::optional<qint32> m_last_value;
159 |     qint32 m_next_index;
160 |     TrendWindow *const m_parent;
161 | };
162 | 
163 | 
164 | #endif // TREND_LINE_H
165 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## QModbusTool - A QT Based Modbus Client
 2 | QModbusTool is a multi-modal interface for interacting with Modbus registers on devices ranging from mid-range PLCs to smaller industrial end-devices that provide access through Modbus/TCP.  It aims to be simple and light weight while providing several key capabilities that are extremely helpful when commissioning and calibrating Modbus enabled devices including:
 3 | 
 4 | * **Live data trend**
 5 | * Save/Restore register sets
 6 | * Save/Restore session
 7 | * Support for loading register metadata using a simple plugin interface (see [PLUGIN.md][1]).
 8 | 
 9 | ### License
10 | Copyright (C) 2021 Andrew Buettner (ABi)
11 | 
12 | QModbusTool is released under the GPLv2 license.  See [LICENSE.md][2] for complete terms and conditions.
13 | 
14 | The metadata plugin header "[metadata.h][3]" is released under the 3-clause BSD license to allow equipment developers to create proprietary plugins specific to their equipment.
15 | 
16 | ### Basic usage
17 | Open the application and add 1 or more register sets to poll.  Each window represents a sequential block of registers that are polled with a single poll.  The number of registers presented can be polled is between 1 and the protocol maximum (125 for 16-bit analog values, 2000 for digital signals).  Polls can be directed to a specific "Slave ID", also known as an "Instance ID", "Device ID", or "Node".
18 | 
19 | The communication parameters may also be configured (remote device IP address and port).  The timeout is a local timeout to wait for a response.  Generally, Modbus/TCP does not implement a timeout in the way that it does on other transports such as UDP, RTU, or ASCII.  This is provided for recovery from Modbus/TCP devices and protocol gateways that don't handle Modbus timeouts correctly.  Alternatively, a previously saved session can be restored.
20 | 
21 | Optionally, a trend window can be created.  Using the available controls on the trend add one or more registers to be graphed.  These registers must be polled VIA another register window.  The trend will be updated once for each set of registers polled.
22 | 
23 | Once the communication parameters have been correctly configured and the desired windows have been created, select "Connect" from the "File" menu and the program will connect.  If the device connected to supports "Read Device ID" at address 0, the device name will briefly appear in the status bar section.  Once connected data may be polled either on request or automatically by selecting the appropriate option from the "Poll" menu.  If the meta data plug-in is available, the system may also poll register meta data from the the connected device.  The session may also be saved as can any window data and the trend.
24 | 
25 | ### Building
26 | QModbusTool was specifically designed for Linux, it should be reasonably easy to build under both Windows and macOS. However, the plugin interface has not been ported to these platforms. 
27 | QModbusTool is built with qmake and requires a compiler that supports C++17 or newer.  It has been successfully built using both GCC and CLang.
28 | 
29 | ### Prerequisites
30 | * Qt 5+
31 | 	- += core gui xml widgets printsupport
32 | * [LibModbus][4] (Modbus back-end)
33 | * [QtCSV][5] (saving / restoring register and trend data)
34 | * [QCustomPlot][6] (trending widget)
35 | 	- The build process expects this to be available as a library.  It does not ship with the amalgamation.
36 | 	- It is recommended to build with OpenGL support as it will utilize that functionality if available to improve redraw performance.
37 | 
38 | ### Expanding
39 | QModbusTool can easily have functionality expanded.  The base class for nearly all data-driven displays is defined in [base\_dialog.h][7]/.cpp.  This provides a bare-minimum interface needed to send and receive data from the scheduler.  The most important interfaces are:
40 | 
41 | * *`window_closed`* - Guaranteed to be emitted exactly once when the window is closed regardless of method.
42 | * *`setupUi`* - Guaranteed to be called exactly once the very first time that the *show* event is called.
43 | * *`window_first_display`* - Guaranteed to be emitted exactly once after the *startUi* function has been called.
44 | * *`write_requested`* - may be emitted if the window requests to write registers.
45 | * *`metadata_requested`* - may be emitted if the window requests to read metadata _(`set_metadata` must be implemented)_.
46 | * *`on_new_value`* - received whenever new data is received or a scheduler/system event occurs.
47 | * *`on_exception_status`* - received if a read, write, or metadata request results in a Modbus exception.
48 | 
49 | The appropriate signals and slots must be connected to the Scheduler in order for the window to receive Modbus events.
50 | 
51 | ### Missing Features
52 | While the application is mostly complete and should be usable for many applications, there are some notable items currently missing:
53 | 
54 | 1. Modbus/RTU - I had to do some "hackey" stuff in order to handle custom modbus requests see [this issue][8].  This may not translate well to other flavors of the protocol.
55 | 2. Translations - All strings should be annotated.
56 | 3. Help documentation / about box
57 | 
58 | [1]: PLUGIN.md
59 | [2]: LICENSE.md
60 | [3]: metadata.h
61 | [4]: https://libmodbus.org/
62 | [5]: https://github.com/iamantony/qtcsv
63 | [6]: https://www.qcustomplot.com/
64 | [7]: base_data.h
65 | [8]: https://github.com/stephane/libmodbus/issues/231
66 | 


--------------------------------------------------------------------------------
/metadata.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file metadata.h
  3 |  * \brief Modbus metadata plugin public interface
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  * All rights reserved.
  7 |  *
  8 |  * \section LICENSE
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions are met:
 12 |  * (1) Redistributions of source code must retain the above copyright notice, 
 13 |  *     this list of conditions and the following disclaimer.
 14 |  * (2) Redistributions in binary form must reproduce the above copyright notice,
 15 |  *     this list of conditions and the following disclaimer in the documentation
 16 |  *     and/or other materials provided with the distribution.
 17 |  * (3) Neither the name of the <copyright holder> nor the names of its 
 18 |  *     contributors may be used to endorse or promote products derived from this
 19 |  *     software without specific prior written permission.
 20 |  *
 21 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 22 |  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 23 |  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 24 |  * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY 
 25 |  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
 26 |  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
 27 |  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
 28 |  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 29 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 30 |  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 31 |  */
 32 | 
 33 | #ifndef METADATA_DLL_H
 34 | #define METADATA_DLL_H
 35 | 
 36 | 
 37 | #ifdef __cplusplus
 38 | extern "C" {
 39 | #endif
 40 | 
 41 | #include <stdint.h>  //  uint8_t and friends
 42 | 
 43 | #define DATA_BUFFER_REQUIRED_SIZE 252
 44 | 
 45 | 
 46 | /**
 47 |  * \fn create_request
 48 |  * \brief Create a request instance.
 49 |  * @param register_number Register number (IE 40001, or 10003)
 50 |  * @param function_code [optional, out] update with the function code
 51 |  * @return pointer to data, or ``NULL`` if invalid
 52 |  */
 53 | typedef void* (*create)(uint16_t /*register_number*/, uint8_t* /*function_code*/);
 54 | #define CREATE_SYMBOL "create_request"
 55 | 
 56 | /**
 57 |  * \fn encode_request
 58 |  * \brief Encode outgoing request to databuffer
 59 |  * @param request Request instance previously created
 60 |  * @param data Data buffer (must be at least 252 bytes long)
 61 |  * @return number of bytes written to output data, 0 on error
 62 |  */
 63 | typedef uint8_t (*encode)(void* /*request*/, uint8_t* /*data*/);
 64 | #define ENCODE_SYMBOL "encode_request"
 65 | 
 66 | /**
 67 |  * \fn decode_response
 68 |  * \brief Decode incoming request
 69 |  * @param request Request instance previously created
 70 |  * @param data response buffer
 71 |  * @param data_len response length
 72 |  * 
 73 |  * @return 0 on success, != 0 on error
 74 |  */
 75 | typedef int (*decode)(void* /*request*/, const uint8_t* /*data*/, uint8_t /*data_len*/);
 76 | #define DECODE_SYMBOL "decode_response"
 77 | 
 78 | /**
 79 |  * \fn decode_label
 80 |  * \brief Decode the label section of a response
 81 |  * @param request Request instance previously created
 82 |  * @param data (Optional) write null-terminated string to buffer
 83 |  * @return Number of bytes that have been (or would be) written to data, 
 84 |  *         <0 for error
 85 |  */
 86 | typedef int32_t (*label)(void* /*request*/, char* /*data*/);
 87 | #define LABEL_SYMBOL "decode_label"
 88 | 
 89 | /**
 90 |  * \fn read_min_max
 91 |  * \brief Decode the min/max fields of the response
 92 |  *
 93 |  * @param request Request instance previously created
 94 |  * @param min Update with min value
 95 |  * @param max Update with max value
 96 |  * 
 97 |  * @return 0 if response contains data, != 0 otherwise (min/max not updated)
 98 |  */
 99 | typedef int (*minmax)(void* /*request*/, int32_t* /*min*/, int32_t* /*max*/);
100 | #define MINMAX_SYMBOL "read_min_max"
101 | 
102 | /**
103 |  * \fn read_default
104 |  * \brief Decode the default value field of the response
105 |  * @param request Request instance previously created
106 |  * @param dflt Update with default value
107 |  * @param max Update with max value
108 |  * @return 0 if response contains data, != 0 otherwise (dflt not updated)
109 |  */
110 | typedef int (*get_default)(void* /*request*/, int32_t* /*dflt*/);
111 | #define DEFAULT_SYMBOL "read_default"
112 | 
113 | /**
114 |  * \fn get_encoding
115 |  * \brief Decode the register encoding field of the response
116 |  * @param request Request instance previously created
117 |  * @param data Data buffer from protocol
118 |  * @param data_len Total length of data
119 |  * @return Encoding enumeration as int8_t (<0 for no data)
120 |  */
121 | typedef int8_t (*encoding)(void* /*request*/);
122 | #define ENCODING_SYMBOL "get_encoding"
123 | 
124 | /**
125 |  * \fn release_request
126 |  * \brief Delete a previously created request and release all resources
127 |  * @param request Request instance previously created
128 |  */
129 | typedef void (*release)(void* /*request*/);
130 | #define RELEASE_SYMBOL "release_request"
131 | 
132 | #ifdef __cplusplus
133 | }
134 | #endif
135 | 
136 | #endif
137 | 


--------------------------------------------------------------------------------
/modbusthread.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file modbusthread.h
  3 |  * \brief Modbus thread container
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * Modbus protocol functionality is abstracted (somewhat) from the display and
 28 |  * takes place in a separate thread because all libmodbus transactions are
 29 |  * treated as blocking calls.
 30 |  */
 31 | 
 32 | #ifndef MODBUSTHREAD_H
 33 | #define MODBUSTHREAD_H
 34 | 
 35 | //  c++ includes
 36 | #include <QThread>  //  QThread
 37 | #include <QMutex>  //  QMutex
 38 | #include <QWaitCondition>  //  QWaitCondition
 39 | #include <QString>  //  QString
 40 | 
 41 | // C includes
 42 | #include <modbus/modbus.h>  //  modbus_t
 43 | 
 44 | // project includes
 45 | /* -none- */
 46 | 
 47 | 
 48 | /**
 49 |  * \brief Modbus communication thread
 50 |  */
 51 | class ModbusThread : public QThread
 52 | {
 53 |     Q_OBJECT
 54 | 
 55 | public:
 56 | 
 57 |     /**
 58 |      * \brief constructor
 59 |      * @param parent parent QObject owner
 60 |      * @param host host to be resolved and connected to
 61 |      * @param port destination port
 62 |      */
 63 |     ModbusThread(QObject *parent, const QString &host, const quint16 port);
 64 | 
 65 |     /**
 66 |      * \brief Close and exit thread.
 67 |      * \note
 68 |      * Blocking call
 69 |      */
 70 |     void close();
 71 | 
 72 |     /**
 73 |      * \brief Issue a modbus read request
 74 |      * @param first_reg first register number (0 = device id)
 75 |      * @param num_regs number of registers to read
 76 |      * @param uid Unit ID / Node to poll
 77 |      */
 78 |     void modbus_request(const quint16 first_reg, const quint16 num_regs, const quint8 uid);
 79 | 
 80 |     /**
 81 |      * \brief Issue a modbus write request
 82 |      * @param first_reg first register number
 83 |      * @param regs_to_write list of values to be written
 84 |      * @param uid Unit ID / Node to poll
 85 |      */
 86 |     void modbus_request(const quint16 first_reg, std::vector<quint16> &&regs_to_write, const quint8 uid);
 87 | 
 88 |     /**
 89 |      * \brief Issue a raw modbus PDU
 90 |      * @param pdu Modbus raw PDU to send
 91 |      * @param length length of PDU
 92 |      * @param fc function code
 93 |      * @param uid Unit ID / Node to poll
 94 |      */
 95 |     void modbus_request(const quint8 *pdu, const quint8 length, const qint8 fc, const quint8 uid);
 96 | 
 97 |     /**
 98 |      * \brief Obtain results from a previous modbus transaction.
 99 |      * \note
100 |      * vector will contain a character array (quint8) if the request was
101 |      * device ID or a custom response.  Values promoted from quint8 to
102 |      * quint16.  This call results in the value being std::move'd from
103 |      * internal storage and can be made only once for each complete
104 |      * signal.
105 |      *
106 |      * @return register list
107 |      */
108 |     [[nodiscard]] std::vector<quint16> modbus_result();
109 | 
110 |     /**
111 |      * \brief Get the starting register for the most recent request call.
112 |      * \note
113 |      * This call and the next can't be const because they invoke lock.
114 |      * \sa get_unit_id
115 |      * @return register number (0 = id, 0xffff = custom)
116 |      */
117 |     [[nodiscard]] quint16 get_start_reg();
118 | 
119 |     /**
120 |      * \brief Get the node (unit id) that the most recent request was sent to.
121 |      * @return device / node / unit ID
122 |      */
123 |     [[nodiscard]] quint8 get_unit_id();
124 | 
125 |     virtual void run() override;
126 | 
127 |     ~ModbusThread() override;
128 | 
129 | signals:
130 | 
131 |     /**
132 |      * \brief Emit poll exception.
133 |      * @param error_code Modbus error code reported
134 |      */
135 |     void modbus_error(const int error_code);
136 | 
137 |     /**
138 |      * \brief Emit poll complete.
139 |      */
140 |     void complete();
141 | 
142 | private:
143 | 
144 |     /**
145 |      * \brief Assemble a write multiple registers request
146 |      * @return result from modbus call
147 |      */
148 |     int do_write_request();
149 | 
150 |     /**
151 |      * \brief Consolidate the logic for custom requests (Modbus/TCP).
152 |      * @return result code
153 |      */
154 |     int do_custom_request_tcp();
155 | 
156 |     const QString m_host;
157 |     const quint16 m_port;
158 |     modbus_t *m_ctx=nullptr;
159 |     QMutex m_mx;
160 |     QWaitCondition m_cond;
161 |     bool m_quit=false;
162 |     bool m_write_request=false;
163 |     const quint8 *m_raw_request=nullptr;
164 | 
165 |     std::vector<quint16> m_regs;
166 |     quint16 m_reg_number=0;
167 |     quint16 m_count=0;
168 |     quint8 m_node=0;
169 | };
170 | 
171 | 
172 | #endif // MODBUSTHREAD_H
173 | 


--------------------------------------------------------------------------------
/configure_trend.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file configure_trend.cpp
  3 |  * \brief Trend graph configuration dialog box
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | 
 27 | //  c++ includes
 28 | #include <QPushButton>  //  QPushButton
 29 | #include <QMessageBox>  //  QMessageBox
 30 | #include <QStringList>  //  QStringList
 31 | 
 32 | // C includes
 33 | /* -none- */
 34 | 
 35 | // project includes
 36 | #include "configure_trend.h"  //  local include
 37 | 
 38 | 
 39 | namespace {
 40 |     const auto g_max_points = 1000000;  //  some arbitrary limit.
 41 | }
 42 | 
 43 | 
 44 | ConfigureTrend::ConfigureTrend(QWidget *const parent,
 45 |                                const double min,
 46 |                                const double max,
 47 |                                const int n_points) :
 48 |         BaseDialog(parent, false),
 49 |         m_ui{new Ui::ConfigureTrend()},
 50 |         m_initial_points{n_points},
 51 |         m_initial_min{min},
 52 |         m_initial_max{max},
 53 |         m_first_edit{true}
 54 | {
 55 |     m_ui->setupUi(this);
 56 |     m_ui->MinInput->setText(QString::number(min));
 57 |     m_ui->MaxInput->setText(QString::number(max));
 58 | }
 59 | 
 60 | 
 61 | void ConfigureTrend::setupUi()
 62 | {
 63 |     m_ui->HistoryInput->setText(QString::number(m_initial_points));
 64 |     QPushButton *btn1 = m_ui->buttonBox->button(QDialogButtonBox::Cancel);
 65 |     add_icon_to_button(btn1, QStyle::SP_DialogCloseButton);
 66 | 
 67 |     QPushButton *btn2 = m_ui->buttonBox->button(QDialogButtonBox::Ok);
 68 |     add_icon_to_button(btn2, QStyle::SP_DialogApplyButton);
 69 | }
 70 | 
 71 | 
 72 | void ConfigureTrend::on_HistoryInput_textEdited()
 73 | {
 74 |     if (m_first_edit) {
 75 |         m_first_edit = false;
 76 |         auto msg_box = QMessageBox(this);
 77 |         msg_box.setIcon(QMessageBox::Warning);
 78 |         msg_box.setStandardButtons(QMessageBox::Ok|QMessageBox::Cancel);
 79 |         msg_box.setText(tr("Change history size"));
 80 |         msg_box.setInformativeText(tr(
 81 |                "Notice:\n"
 82 |                "Changing the history size will clear currently captured data."));
 83 |         if (msg_box.exec() != QMessageBox::Ok) {
 84 |             m_ui->HistoryInput->setText(QString::number(m_initial_points));
 85 |         }
 86 |     }
 87 | }
 88 | 
 89 | 
 90 | std::pair<double, double> ConfigureTrend::get_min_max() const
 91 | {
 92 |     bool okmin, okmax;
 93 |     auto min = m_ui->MinInput->text().toDouble(&okmin);
 94 |     if (!okmin) {
 95 |         min = m_initial_min;
 96 |     }
 97 | 
 98 |     auto max = m_ui->MaxInput->text().toDouble(&okmax);
 99 |     if (!okmax) {
100 |         max = m_initial_max;
101 |     }
102 | 
103 |     if (min >= max) {
104 |         min = m_initial_min;
105 |         max = m_initial_max;
106 |     }
107 | 
108 |     return { min, max };
109 | }
110 | 
111 | 
112 | std::optional<int> ConfigureTrend::get_num_points() const
113 | {
114 |     bool ok;
115 |     const auto new_points = m_ui->HistoryInput->text().toInt(&ok);
116 |     if ((m_initial_points == new_points) || !ok || (new_points < 3)) {
117 |         return std::optional<int>();
118 |     }
119 | 
120 |     return new_points;
121 | }
122 | 
123 | 
124 | void ConfigureTrend::accept()
125 | {
126 |     QStringList error_text;
127 |     bool okmin, okmax;
128 |     const auto min = m_ui->MinInput->text().toDouble(&okmin);
129 |     if (!okmin) {
130 |         error_text << tr("Invalid minimum value specified.");
131 |     }
132 | 
133 |     const auto max = m_ui->MaxInput->text().toDouble(&okmax);
134 |     if (!okmax) {
135 |         error_text << tr("Invalid maximum value specified.");
136 |     }
137 | 
138 |     if (okmin && okmax && (min >= max)) {
139 |         error_text << tr("Max value must be greater than min value.");
140 |     }
141 | 
142 |     bool ok;
143 |     const auto points = m_ui->HistoryInput->text().toInt(&ok);
144 |     if (!ok) {
145 |         error_text << tr("Invalid number of points specified.");
146 |     } else if (points < 3 || points > g_max_points) {
147 |         error_text << tr("Points must be between 3 and %1").arg(g_max_points);
148 |     }
149 | 
150 |     if (error_text.size() > 0) {
151 |         auto error_box = QMessageBox(this);
152 |         error_box.setIcon(QMessageBox::Critical);
153 |         error_box.setStandardButtons(QMessageBox::Ok);
154 |         error_box.setText(tr("Invalid trend configuration specified"));
155 |         error_box.setInformativeText(tr("Errors were detected"));
156 |         error_box.setWindowTitle(tr("Invalid Configuration"));
157 |         error_box.setDetailedText(error_text.join('\n'));
158 |         error_box.exec();
159 |     } else {
160 |         BaseDialog::accept();
161 |     }
162 | }
163 | 
164 | 
165 | ConfigureTrend::operator bool() const
166 | {
167 |     return m_ui->DynamicCheck->isChecked();
168 | }
169 | 
170 | 
171 | ConfigureTrend::~ConfigureTrend()
172 | {
173 |     delete m_ui;
174 | }
175 | 


--------------------------------------------------------------------------------
/configure_trend_line.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file configure_trend_line.cpp
  3 |  * \brief Trend configuration dialog box
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | 
 27 | //  c++ includes
 28 | #include <QColorDialog>  //  QColorDialog
 29 | #include <QMessageBox>  //  QMessageBox
 30 | #include <QStringBuilder>  //  operator%
 31 | 
 32 | // C includes
 33 | /* -none- */
 34 | 
 35 | // project includes
 36 | #include "configure_trend_line.h"  //  local include
 37 | #include "exceptions.h"  //  AppException
 38 | 
 39 | 
 40 | ConfigureTrendLine::ConfigureTrendLine(TrendWindow *const parent) :
 41 |     BaseDialog(parent, false),
 42 |     m_ui{new Ui::ConfigureTrendDialog()},
 43 |     m_display_color{Qt::black},
 44 |     m_parent{parent},
 45 |     m_trend{nullptr}
 46 | {
 47 |     m_ui->setupUi(this);
 48 | }
 49 | 
 50 | 
 51 | ConfigureTrendLine::ConfigureTrendLine(TrendLine *const parent) :
 52 |     ConfigureTrendLine(parent->m_parent)
 53 | {
 54 |     m_trend = parent;
 55 |     m_display_color = parent->m_pen_color;
 56 | }
 57 | 
 58 | 
 59 | void ConfigureTrendLine::setupUi()
 60 | {
 61 |     update_color_labels();
 62 | 
 63 |     add_icon_to_button(m_ui->Accept, QStyle::SP_DialogApplyButton);
 64 |     add_icon_to_button(m_ui->Delete, QStyle::SP_BrowserStop);
 65 |     add_icon_to_button(m_ui->Cancel, QStyle::SP_DialogCloseButton);
 66 | 
 67 |     if (nullptr == m_trend) {
 68 |         m_ui->Accept->setText(tr("Create"));
 69 |         m_ui->Delete->setHidden(true);
 70 |     } else {
 71 |         m_ui->RegEdit->setText(QString::number(m_trend->m_reg_number));
 72 |         m_ui->RegEdit->setEnabled(false);
 73 |         m_ui->NodeEdit->setValue(int(m_trend->m_device_id));
 74 |         m_ui->NodeEdit->setEnabled(false);
 75 |         m_ui->SignedEdit->setChecked(m_trend->m_signed_value);
 76 |         m_ui->MultBox->setText(QString::number(m_trend->m_mult));
 77 |         m_ui->OffsetBox->setText(QString::number(m_trend->m_offset));
 78 |     }
 79 | }
 80 | 
 81 | 
 82 | void ConfigureTrendLine::on_Accept_pressed()
 83 | {
 84 |     bool ok;
 85 |     const auto reg = m_ui->RegEdit->text().toInt(&ok);
 86 |     QStringList error_text;
 87 |     if (!ok || (reg <= 0) || (reg >= 50000) || (reg >= 20000 && reg <= 30000)) {
 88 |         error_text << tr("Illegal register number");
 89 |     }
 90 | 
 91 |     const auto m = m_ui->MultBox->text().toDouble(&ok);
 92 |     if (!ok) {
 93 |         error_text << tr("Illegal multiply value");
 94 |     }
 95 | 
 96 |     const auto b = m_ui->OffsetBox->text().toDouble(&ok);
 97 |     if (!ok) {
 98 |         error_text << tr("Illegal offset value");
 99 |     }
100 | 
101 |     if (error_text.size() > 0) {
102 |         auto error_box = QMessageBox(this);
103 |         error_box.setIcon(QMessageBox::Critical);
104 |         error_box.setStandardButtons(QMessageBox::Ok);
105 |         error_box.setText(tr("Invalid trend configuration specified"));
106 |         error_box.setInformativeText(tr("Errors were detected"));
107 |         error_box.setWindowTitle(tr("Invalid Configuration"));
108 |         error_box.setDetailedText(error_text.join('\n'));
109 |         error_box.exec();
110 |         return;
111 |     }
112 | 
113 |     if (nullptr != m_trend) {
114 |         m_trend->configure(m, b, m_ui->SignedEdit->isChecked());
115 |         m_trend->set_color(m_display_color);
116 |     }
117 | 
118 |     accept();
119 | }
120 | 
121 | 
122 | void ConfigureTrendLine::on_Cancel_pressed()
123 | {
124 |     reject();
125 | }
126 | 
127 | 
128 | void ConfigureTrendLine::on_Delete_pressed()
129 | {
130 |     reject();
131 |     m_parent->remove_trend(quint32(*m_trend));
132 | }
133 | 
134 | 
135 | void ConfigureTrendLine::on_ColorButton_pressed()
136 | {
137 |     auto dlg = QColorDialog(m_display_color, this);
138 |     if (dlg.exec() != 0) {
139 |         m_display_color = dlg.selectedColor();
140 |         update_color_labels();
141 |     }
142 | }
143 | 
144 | 
145 | void ConfigureTrendLine::update_color_labels()
146 | {
147 |     m_ui->ColorText->setText(m_display_color.name());
148 |     m_ui->ColorSample->setStyleSheet("QLabel {"
149 |                                      "color: " % m_display_color.name() %
150 |                                      "; background-color: #FFFFFF;}");
151 | }
152 | 
153 | 
154 | TrendLine* ConfigureTrendLine::create_trend()
155 | {
156 |     if (nullptr != m_trend) {
157 |         throw AppException(tr("Error, creating duplicate TrendLine"));
158 |     }
159 | 
160 |     const auto m = m_ui->MultBox->text().toDouble();
161 |     const auto b = m_ui->OffsetBox->text().toDouble();
162 |     const auto node = m_ui->NodeEdit->value();
163 |     const auto reg = m_ui->RegEdit->text().toInt();
164 |     auto trend = new TrendLine(m_parent, quint16(reg), quint8(node));
165 |     trend->configure(m, b, m_ui->SignedEdit->isChecked());
166 |     trend->set_color(m_display_color);
167 |     m_trend = trend;
168 | 
169 |     return trend;
170 | }
171 | 
172 | 
173 | ConfigureTrendLine::operator quint32() const
174 | {
175 |     return m_parent->get_key(quint16(m_ui->RegEdit->text().toUInt()),
176 |                              quint8(m_ui->NodeEdit->value()));
177 | }
178 | 
179 | 
180 | ConfigureTrendLine::~ConfigureTrendLine()
181 | {
182 |     delete m_ui;
183 | }
184 | 


--------------------------------------------------------------------------------
/trend_window.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file trend_window.h
  3 |  * \brief Graphing / Trend support
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * The project may include 1 trend window with many trend lines updated from
 28 |  * polling data.
 29 |  */
 30 | 
 31 | #ifndef TREND_WINDOW_H
 32 | #define TREND_WINDOW_H
 33 | 
 34 | //  c++ includes
 35 | #include <QList>  //  QList
 36 | #include <QHBoxLayout>  //  QHBoxLayout
 37 | #include <QScrollArea>  //  QScrollArea
 38 | #include <QPushButton>  //  QPushButton
 39 | #include <QGroupBox>  //  QGroupBox
 40 | #include <QMenu>  //  QMenu
 41 | #include <QDomElement>  //  QDomElement
 42 | #include <QDomDocument>  //  QDomDocument
 43 | #include <qcustomplot.h>  //  QCustomPlot
 44 | #include <chrono>  //  std::chrono
 45 | #include <unordered_map>  //  std::unordered_map
 46 | 
 47 | // C includes
 48 | /* -none- */
 49 | 
 50 | // project includes
 51 | #include "base_dialog.h"
 52 | 
 53 | 
 54 | // /////////////////////////////////////////////////////////////////////////////
 55 | // Forward declarations
 56 | // /////////////////////////////////////////////////////////////////////////////
 57 | class TrendLine;
 58 | 
 59 | 
 60 | /**
 61 |  * \brief Graphing window
 62 |  */
 63 | class TrendWindow : public BaseDialog
 64 | {
 65 |     //  Allow individual trends to access internal widgets to self-configure.
 66 |     friend class TrendLine;
 67 | 
 68 |     Q_OBJECT
 69 | 
 70 | public:
 71 | 
 72 |     /**
 73 |      * \brief constructor
 74 |      * @param parent parent QObject owner
 75 |      */
 76 |     TrendWindow(QWidget *const parent);
 77 | 
 78 |     /**
 79 |       * \brief get hash key from reg, node
 80 |       * @param reg register number
 81 |       * @param node node/device ID
 82 |       */
 83 |     [[nodiscard]] quint32 get_key(const quint16 reg, const quint8 node) const noexcept;
 84 | 
 85 |     /**
 86 |      * @brief remove_trend
 87 |      * \note
 88 |      * This function shall only be called by the ConfigureTrendLine dialog box.
 89 |      *
 90 |      * @param trend_key
 91 |      */
 92 |     void remove_trend(const quint32 trend_key);
 93 | 
 94 |     /**
 95 |      * @brief Update Min/Max value
 96 |      * \note
 97 |      * This function is only called by connected trends
 98 |      *
 99 |      * @param value new value
100 |      */
101 |     void update_min_max(const double value) noexcept;
102 | 
103 |     /**
104 |      * @brief save_configuration
105 |      * @param root
106 |      * @return
107 |      */
108 |     QDomElement save_configuration(QDomDocument &root) const;
109 | 
110 |     /**
111 |      * @brief load_configuration
112 |      * @param node
113 |      * @return
114 |      */
115 |     bool load_configuration(const QDomElement &node);
116 | 
117 | public slots:
118 | 
119 |     virtual void on_new_value(const quint16 reg, const quint16 value, const quint8 unit_id) override;
120 | 
121 | protected:
122 | 
123 |     /**
124 |      * @brief Re-draw the graph from class data
125 |      */
126 |     void redraw_graph();
127 | 
128 |     /**
129 |      * @brief Scan current data set to see if it's complete.  If it is, update
130 |      *        and re-draw the graph.
131 |      */
132 |     void scan();
133 | 
134 |     /**
135 |      * @brief Add trend to the graph
136 |      * @param trend newly created trend
137 |      */
138 |     void add_trend(TrendLine *const trend);
139 | 
140 |     virtual void setupUi() override;
141 | 
142 |     QCustomPlot *const m_plot;
143 |     std::unordered_map<quint32, TrendLine*> m_data;
144 |     QList<double> m_timestamps;
145 |     const std::chrono::time_point<std::chrono::steady_clock> m_start_time;
146 | 
147 | private slots:
148 | 
149 |     /**
150 |      * @brief Action when the "Add new trend" button is clicked
151 |      */
152 |     void on_add_button_clicked();
153 | 
154 |     /**
155 |      * @brief Action taken when the "Configure Graph" menu item is selected
156 |      */
157 |     void on_configure_triggered();
158 | 
159 |     /**
160 |      * @brief Action taken when the "Save data" menu item is selected
161 |      */
162 |     void on_save_triggered();
163 | 
164 |     /**
165 |      * @brief Action taken when the "Save image" menu item is selected
166 |      */
167 |     void on_capture_triggered();
168 | 
169 | private:
170 | 
171 |     /**
172 |      * \brief Save register data to CSV file
173 |      * @param path absolute path and file name to save to
174 |      */
175 |     bool save_register_set(const QString &path);
176 | 
177 |     /**
178 |      * @brief Resize the history
179 |      * @param points new number of points to include in history
180 |      * @param redraw set ``false`` to skip graph redraw
181 |      */
182 |     void resize_history(const int points, bool redraw=true);
183 | 
184 |     QHBoxLayout *const m_layout;
185 |     QGroupBox *const m_legend;
186 |     QVBoxLayout *const m_legend_layout;
187 |     QScrollArea *const m_button_area;
188 |     QWidget *const m_scroll_container;
189 |     QVBoxLayout *const m_scroll_layout;
190 |     QPushButton *const m_add_button;
191 |     QPushButton *const m_configure_button;
192 |     QMenu *const m_main_menu;
193 |     bool m_fixed_limits = false;
194 | 
195 |     double m_miny;
196 |     double m_maxy;
197 | };
198 | 
199 | 
200 | #endif // TREND_WINDOW_H
201 | 


--------------------------------------------------------------------------------
/mainwindow.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>MainWindow</class>
  4 |  <widget class="QMainWindow" name="MainWindow">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>297</width>
 10 |     <height>174</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>QModbusTool</string>
 15 |   </property>
 16 |   <property name="windowIcon">
 17 |    <iconset resource="resources.qrc">
 18 |     <normaloff>:/QModbusTool.ico</normaloff>:/QModbusTool.ico</iconset>
 19 |   </property>
 20 |   <widget class="QWidget" name="centralwidget">
 21 |    <layout class="QGridLayout" name="gridLayout">
 22 |     <item row="1" column="1">
 23 |      <widget class="QLineEdit" name="portEdit">
 24 |       <property name="text">
 25 |        <string>502</string>
 26 |       </property>
 27 |      </widget>
 28 |     </item>
 29 |     <item row="0" column="1">
 30 |      <widget class="QLineEdit" name="ipEdit">
 31 |       <property name="text">
 32 |        <string>127.0.0.1</string>
 33 |       </property>
 34 |      </widget>
 35 |     </item>
 36 |     <item row="0" column="0">
 37 |      <widget class="QLabel" name="label">
 38 |       <property name="text">
 39 |        <string>Slave IP Address:</string>
 40 |       </property>
 41 |      </widget>
 42 |     </item>
 43 |     <item row="1" column="0">
 44 |      <widget class="QLabel" name="label_2">
 45 |       <property name="text">
 46 |        <string>Slave Port:</string>
 47 |       </property>
 48 |      </widget>
 49 |     </item>
 50 |     <item row="2" column="1">
 51 |      <widget class="QLineEdit" name="timeoutEdit">
 52 |       <property name="text">
 53 |        <string>3000</string>
 54 |       </property>
 55 |      </widget>
 56 |     </item>
 57 |     <item row="2" column="0">
 58 |      <widget class="QLabel" name="label_3">
 59 |       <property name="text">
 60 |        <string>Request Timeout (ms):</string>
 61 |       </property>
 62 |      </widget>
 63 |     </item>
 64 |    </layout>
 65 |   </widget>
 66 |   <widget class="QStatusBar" name="statusbar">
 67 |    <property name="sizeGripEnabled">
 68 |     <bool>true</bool>
 69 |    </property>
 70 |   </widget>
 71 |   <widget class="QMenuBar" name="menubar">
 72 |    <property name="geometry">
 73 |     <rect>
 74 |      <x>0</x>
 75 |      <y>0</y>
 76 |      <width>297</width>
 77 |      <height>27</height>
 78 |     </rect>
 79 |    </property>
 80 |    <widget class="QMenu" name="menuWindow">
 81 |     <property name="title">
 82 |      <string>Window</string>
 83 |     </property>
 84 |     <widget class="QMenu" name="menuNew">
 85 |      <property name="title">
 86 |       <string>New</string>
 87 |      </property>
 88 |      <addaction name="actionCoils"/>
 89 |      <addaction name="actionInputs"/>
 90 |      <addaction name="actionInput_Registers"/>
 91 |      <addaction name="actionHolding_Registers"/>
 92 |      <addaction name="separator"/>
 93 |      <addaction name="actionTrend"/>
 94 |     </widget>
 95 |     <addaction name="menuNew"/>
 96 |    </widget>
 97 |    <widget class="QMenu" name="menuFile">
 98 |     <property name="title">
 99 |      <string>File</string>
100 |     </property>
101 |     <addaction name="actionConnect"/>
102 |     <addaction name="separator"/>
103 |     <addaction name="actionSave_Session"/>
104 |     <addaction name="actionRestore_Session"/>
105 |     <addaction name="separator"/>
106 |     <addaction name="actionLoad_Register_Data"/>
107 |    </widget>
108 |    <widget class="QMenu" name="menuPoll">
109 |     <property name="enabled">
110 |      <bool>false</bool>
111 |     </property>
112 |     <property name="title">
113 |      <string>Poll</string>
114 |     </property>
115 |     <addaction name="actionContinuous"/>
116 |     <addaction name="separator"/>
117 |     <addaction name="actionOnce"/>
118 |     <addaction name="actionRead_Metadata"/>
119 |    </widget>
120 |    <addaction name="menuFile"/>
121 |    <addaction name="menuWindow"/>
122 |    <addaction name="menuPoll"/>
123 |   </widget>
124 |   <action name="actionConnect">
125 |    <property name="text">
126 |     <string>Connect</string>
127 |    </property>
128 |   </action>
129 |   <action name="actionCoils">
130 |    <property name="text">
131 |     <string>Coils</string>
132 |    </property>
133 |   </action>
134 |   <action name="actionInputs">
135 |    <property name="text">
136 |     <string>Inputs</string>
137 |    </property>
138 |   </action>
139 |   <action name="actionInput_Registers">
140 |    <property name="text">
141 |     <string>Input Registers</string>
142 |    </property>
143 |   </action>
144 |   <action name="actionHolding_Registers">
145 |    <property name="text">
146 |     <string>Holding Registers</string>
147 |    </property>
148 |   </action>
149 |   <action name="actionSave_Session">
150 |    <property name="text">
151 |     <string>Save Session</string>
152 |    </property>
153 |   </action>
154 |   <action name="actionRestore_Session">
155 |    <property name="text">
156 |     <string>Restore Session</string>
157 |    </property>
158 |   </action>
159 |   <action name="actionContinuous">
160 |    <property name="checkable">
161 |     <bool>true</bool>
162 |    </property>
163 |    <property name="enabled">
164 |     <bool>true</bool>
165 |    </property>
166 |    <property name="text">
167 |     <string>Continuous</string>
168 |    </property>
169 |   </action>
170 |   <action name="actionOnce">
171 |    <property name="text">
172 |     <string>Once</string>
173 |    </property>
174 |   </action>
175 |   <action name="actionRead_Metadata">
176 |    <property name="text">
177 |     <string>Read Metadata</string>
178 |    </property>
179 |   </action>
180 |   <action name="actionLoad_Register_Data">
181 |    <property name="enabled">
182 |     <bool>true</bool>
183 |    </property>
184 |    <property name="text">
185 |     <string>Load Register Data</string>
186 |    </property>
187 |   </action>
188 |   <action name="actionTrend">
189 |    <property name="text">
190 |     <string>Trend</string>
191 |    </property>
192 |   </action>
193 |  </widget>
194 |  <resources>
195 |   <include location="resources.qrc"/>
196 |  </resources>
197 |  <connections/>
198 | </ui>
199 | 


--------------------------------------------------------------------------------
/metadata_wrapper.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file metadata_wrapper.cpp
  3 |  * \brief Wrapper singleton around the Read Metadata plugin shared object.
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | //  c++ includes
 27 | #include <QStringBuilder>  //  operator %
 28 | #include <QCoreApplication>  //  QCoreApplication
 29 | 
 30 | 
 31 | // C includes
 32 | #include <metadata.h>  //  modbus_plugin: all symbols and definitions in plugin
 33 | 
 34 | // project includes
 35 | #include "metadata_wrapper.h"  //  local include
 36 | #include "exceptions.h"  //  AppException
 37 | 
 38 | 
 39 | using namespace std::string_view_literals;
 40 | 
 41 | 
 42 | namespace {
 43 |     const auto g_dll_name = "mod_plugin.so"sv;
 44 | }
 45 | 
 46 | 
 47 | MetadataWrapper::MetadataWrapper(const QString &lib_path) :
 48 |     QObject(nullptr),
 49 |     m_dll_reference{new QLibrary(lib_path, this)}
 50 | {
 51 |     m_dll_reference->load();
 52 | }
 53 | 
 54 | 
 55 | MetadataWrapper* MetadataWrapper::get_instance()
 56 | {
 57 |     static MetadataWrapper *inst = nullptr;
 58 |     if (nullptr == inst) {
 59 |         const QString dll_path = QCoreApplication::applicationDirPath() %
 60 |                                  QChar('/') %
 61 |                                  QString(g_dll_name.data());
 62 |         inst = new MetadataWrapper(dll_path);
 63 |     }
 64 | 
 65 |     return inst;
 66 | }
 67 | 
 68 | 
 69 | bool MetadataWrapper::loaded() const
 70 | {
 71 |     return m_dll_reference->isLoaded();
 72 | }
 73 | 
 74 | 
 75 | std::shared_ptr<Metadata> MetadataWrapper::create_request(const quint16 reg_number)
 76 | {
 77 |     if (!loaded()) {
 78 |         throw AppException(tr("Plugin unavailable"));
 79 |     }
 80 | 
 81 |     quint8 fc;
 82 | //    auto p_fn = reinterpret_cast<create>(dlsym(m_dll_reference, CREATE_SYMBOL));
 83 |     auto p_fn = reinterpret_cast<create>(m_dll_reference->resolve(CREATE_SYMBOL));
 84 |     auto inst = p_fn(reg_number, &fc);
 85 |     if (nullptr == inst) {
 86 |         throw AppException(tr("Illegal request: ") % QString::number(reg_number));
 87 |     }
 88 | 
 89 |     return std::make_shared<Metadata>(reg_number, inst, fc);
 90 | }
 91 | 
 92 | 
 93 | QPair<const quint8*, quint8> MetadataWrapper::encode_request(std::shared_ptr<Metadata> request)
 94 | {
 95 | //    auto p_fn = reinterpret_cast<encode>(dlsym(m_dll_reference, ENCODE_SYMBOL));
 96 |     auto p_fn = reinterpret_cast<encode>(m_dll_reference->resolve(ENCODE_SYMBOL));
 97 | 
 98 |     auto length = p_fn(request->m_request_instance, request->m_request.data());
 99 |     return {request->m_request.data(), quint8(length)};
100 | }
101 | 
102 | 
103 | void MetadataWrapper::decode_response(std::shared_ptr<Metadata> request, const std::vector<quint8> &data)
104 | {
105 | //    auto p_fn = reinterpret_cast<decode>(dlsym(m_dll_reference, DECODE_SYMBOL));
106 |     auto p_fn = reinterpret_cast<decode>(m_dll_reference->resolve(DECODE_SYMBOL));
107 | 
108 |     if (p_fn(request->m_request_instance, data.data(), uint8_t(data.size())) == 0) {
109 |         decode_labels(request.get());
110 |         decode_defaults(request.get());
111 |         decode_encoding(request.get());
112 |         decode_limits(request.get());
113 |     }
114 | }
115 | 
116 | 
117 | void MetadataWrapper::dispose_metadata(const Metadata *const m)
118 | {
119 | //    auto p_fn = reinterpret_cast<release>(dlsym(m_dll_reference, RELEASE_SYMBOL));
120 |     auto p_fn = reinterpret_cast<release>(m_dll_reference->resolve(RELEASE_SYMBOL));
121 |     p_fn(m->m_request_instance);
122 | }
123 | 
124 | 
125 | void MetadataWrapper::decode_labels(Metadata *const request)
126 | {
127 | //    auto p_fn = reinterpret_cast<label>(dlsym(m_dll_reference, LABEL_SYMBOL));
128 |     auto p_fn = reinterpret_cast<label>(m_dll_reference->resolve(LABEL_SYMBOL));
129 | 
130 |     const auto lbl_len = p_fn(request->m_request_instance, nullptr);
131 |     if (lbl_len > 0) {
132 |         auto raw_string = std::vector<char>(size_t(lbl_len));
133 |         p_fn(request->m_request_instance, raw_string.data());
134 |         request->label = QString(raw_string.data());
135 |     }
136 | }
137 | 
138 | 
139 | void MetadataWrapper::decode_defaults(Metadata *const request)
140 | {
141 | //    auto p_fn = reinterpret_cast<get_default>(dlsym(m_dll_reference, DEFAULT_SYMBOL));
142 |     auto p_fn = reinterpret_cast<get_default>(m_dll_reference->resolve(DEFAULT_SYMBOL));
143 | 
144 |     qint32 dflt;
145 |     if (p_fn(request->m_request_instance, &dflt) == 0) {
146 |         request->dflt = dflt;
147 |     }
148 | }
149 | 
150 | 
151 | void MetadataWrapper::decode_encoding(Metadata *const request)
152 | {
153 | //    auto p_fn = reinterpret_cast<encoding>(dlsym(m_dll_reference, ENCODING_SYMBOL));
154 |     auto p_fn = reinterpret_cast<encoding>(m_dll_reference->resolve(ENCODING_SYMBOL));
155 | 
156 |     const auto reported = p_fn(request->m_request_instance);
157 |     if (reported >= 0) {
158 |         request->encoding = RegisterEncoding(reported);
159 |     }
160 | }
161 | 
162 | 
163 | void MetadataWrapper::decode_limits(Metadata *const request)
164 | {
165 | //    auto p_fn = reinterpret_cast<minmax>(dlsym(m_dll_reference, MINMAX_SYMBOL));
166 |     auto p_fn = reinterpret_cast<minmax>(m_dll_reference->resolve(MINMAX_SYMBOL));
167 | 
168 |     qint32 min, max;
169 |     if (p_fn(request->m_request_instance, &min, &max) == 0) {
170 |         request->min = min;
171 |         request->max = max;
172 |     }
173 | }
174 | 
175 | 
176 | MetadataWrapper::~MetadataWrapper()
177 | {
178 |     m_dll_reference->unload();
179 | }
180 | 


--------------------------------------------------------------------------------
/scheduler.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file scheduler.h
  3 |  * \brief Poll request scheduler
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * Implement a multi-tier scheduling mechanism.  Although Modbus/TCP allows
 28 |  * for queued requests libmodbus doesn't support this feature.  Therefore this
 29 |  * works as a single request-response mechanism.  All requests are one-shot and
 30 |  * require requests to re-enqueue any periodic polls.  A complete set of thread-
 31 |  * safe signals are provided for key events including register data dispatch
 32 |  * which is intended for situations where there are multiple consumers of a
 33 |  * register data point.  Be aware that the interface is not thread safe, only
 34 |  * the signals and slots.  Interface APIs are only to be called from the main\
 35 |  * (window) thread.
 36 |  */
 37 | 
 38 | #ifndef SCHEDULER_H
 39 | #define SCHEDULER_H
 40 | 
 41 | //  c++ includes
 42 | #include <chrono>  //  std::chrono::milliseconds
 43 | #include <deque>  //  std::deque
 44 | #include <QObject>  //  QObject
 45 | #include <QPair>  //  QPair
 46 | 
 47 | // C includes
 48 | /* -none- */
 49 | 
 50 | // project includes
 51 | #include "write_event.h"  //  WriteRequest
 52 | #include "register_display.h"  //  RegisterDisplay
 53 | #include "modbusthread.h"  //  ModbusThread
 54 | #include "metadata_structs.h"  //  WindowMetadataRequest
 55 | 
 56 | 
 57 | /**
 58 |  * \brief Enumeration of the valid poll request sources
 59 |  */
 60 | enum PollAction : int {
 61 |     POLLING_INACTIVE,
 62 |     POLLING_WRITE,
 63 |     POLLING_METADATA,
 64 |     POLLING_READ,
 65 |     POLLING_DEVID
 66 | };
 67 | 
 68 | 
 69 | /**
 70 |  * @brief Meanings associated with the "system" register (0)
 71 |  */
 72 | enum SystemRegister : quint16 {
 73 |     DEVICE_ID_POLL_COMPLETE=0,
 74 |     CUSTOM_POLL_COMPLETE,
 75 |     POLL_METADATA_COMPLETE,
 76 |     WRITE_REQUEST_COMPLETE,
 77 |     SYSTEM_CONNECTED,
 78 |     SYSTEM_DISCONNECTED
 79 | };
 80 | 
 81 | 
 82 | /**
 83 |  * \brief Modbus poll scheduler
 84 |  */
 85 | class Scheduler : public QObject
 86 | {
 87 |     Q_OBJECT
 88 | 
 89 | public:
 90 | 
 91 |     /**
 92 |      * \brief constructor
 93 |      * @param parent parent QObject owner
 94 |      */
 95 |     Scheduler(QObject *parent);
 96 | 
 97 |     /**
 98 |      * \brief Initiate modbus with connection
 99 |      * @param engine Modbus connection
100 |      * @param timeout poll timeout
101 |      */
102 |     void start_modbus(ModbusThread *const engine, const std::chrono::milliseconds timeout);
103 | 
104 |     /**
105 |      * \brief Immediately release all modbus resources and stop polling.
106 |      */
107 |     void stop_modbus();
108 | 
109 |     /**
110 |      * \brief Enqueue a register screen to have registers polled.
111 |      * \note
112 |      * RegisterDisplay objects are treated as the primary source of poll requests.
113 |      *
114 |      * @param source window or object that has poll data requests
115 |      */
116 |     void enqueue_request(BaseDialog *const source);
117 | 
118 |     /**
119 |      * \brief Immediately release all references in all queues to a specified
120 |      *        data object (screen)
121 |      * @param screen reference to be removed
122 |      */
123 |     void remove_reference(BaseDialog *const screen);
124 | 
125 |     /**
126 |      * \brief Get the overall success and error poll counts.
127 |      * @return pair of success and error counts since this connection began
128 |      */
129 |     [[nodiscard]] QPair<quint64, quint64> get_counts() const;
130 | 
131 |     /**
132 |      * \brief Check to see if the scheduler has an active request.
133 |      * @param requester [out] update with the current request source
134 |      * @return ``true`` if active, ``false`` otherwise
135 |      */
136 |     [[nodiscard]] bool get_active(BaseDialog* &requester) const;
137 | 
138 | signals:
139 | 
140 |     /**
141 |      * \brief Emit new reqister data.
142 |      * \note
143 |      * regnumber 0 has special meaning, see enum above
144 |      *
145 |      * @param regnumber register number (eg: 40001, 2, 10003, 30042)
146 |      * @param value register value
147 |      * @param device_id device id / node polled
148 |      */
149 |     void new_register_data(const quint16 regnumber, const quint16 value, const quint8 device_id);
150 | 
151 |     /**
152 |      * \brief Emit when the primary (enqueue_request) queue becomes empty.
153 |      */
154 |     void polling_complete();
155 | 
156 |     /**
157 |      * \brief Emit when a poll returns an exception reqponse
158 |      * \note
159 |      * requesster may be null if the request did not originate from a
160 |      * data source (ie reference removed or another source).
161 |      *
162 |      * @param requester The source of the request (see note)
163 |      * @param exception Exception text
164 |      */
165 |     void poll_exception(BaseDialog *const requester, const QString exception);
166 | 
167 | public slots:
168 | 
169 |     /**
170 |      * \brief Signal to request a modbus write.
171 |      * @param request request structure
172 |      */
173 |     void modbus_on_write_request(WriteRequest request);
174 | 
175 |     /**
176 |      * \brief Signal to request a modbus non-standard poll sequence.
177 |      * @param request_sequence description of metadata to read
178 |      */
179 |     void modbus_on_poll_meta(WindowMetadataRequest request_sequence);
180 | 
181 | protected slots:
182 | 
183 |     /**
184 |      * \brief Signal from modbus thread on a poll exception.
185 |      * @param error_code modbus exception code
186 |      */
187 |     void modbus_on_error(const int error_code);
188 | 
189 |     /**
190 |      * \brief Signal from modbus thread on a poll complete.
191 |      */
192 |     void modbus_on_data();
193 | 
194 |     /**
195 |      * \brief Signal from timer when a poll request has timed out.
196 |      */
197 |     void modbus_on_timer_expired();
198 | 
199 | protected:
200 | 
201 |     /**
202 |      * \brief Main logic to determine and send next poll
203 |      */
204 |     void figure_next();
205 | 
206 |     std::deque<WriteRequest> m_write_requests; /**< list of pending write requests */
207 | 
208 |     /**
209 |      * \var m_meta_requests
210 |      *  list of pending read metadata requests
211 |      */
212 |     std::deque<WindowMetadataRequest> m_meta_requests;
213 | 
214 |     /**
215 |      * \var m_standard_requests
216 |      *  list of pending write requests
217 |      */
218 |     std::deque<BaseDialog*> m_standard_requests;
219 |     ModbusThread *m_polling_thread=nullptr; /**< Pointer to thread (when connected) */
220 | 
221 |     /**
222 |      * \var m_current_action
223 |      *  Current polling state
224 |      */
225 |     PollAction m_current_action=PollAction::POLLING_INACTIVE;
226 | 
227 | private:
228 | 
229 |     /* individaul poll generators */
230 |     void poll_write_request();
231 |     bool poll_meta_request();
232 |     bool poll_read_request();
233 |     void poll_devid_request();
234 |     void poll_response_metadata();
235 | 
236 |     quint64 m_poll_count=0;
237 |     quint64 m_error_count=0;
238 |     QTimer *const m_modbus_timer;
239 |     bool m_active=false;
240 |     BaseDialog *m_current_request=nullptr;
241 | };
242 | 
243 | #endif // SCHEDULER_H
244 | 


--------------------------------------------------------------------------------
/holding_register_display.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file holding_register_display.cpp
  3 |  * \brief Holding Registers window
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | 
 27 | //  c++ includes
 28 | #include <QMessageBox>  //  QMessageBox
 29 | #include <QLineEdit>  //  QLineEdit
 30 | #include <chrono>  //  std::chrono::seconds
 31 | 
 32 | // C includes
 33 | /* -none- */
 34 | 
 35 | // project includes
 36 | #include "holding_register_display.h"  //  local include
 37 | 
 38 | 
 39 | HoldingRegisterDisplay::HoldingRegisterDisplay(QWidget *parent, const quint16 base_reg, const quint16 count, const quint8 uid)
 40 |         :RegisterDisplay(parent, base_reg, count, uid),
 41 |           m_activity_timer{new QTimer(this)}
 42 | {
 43 |     m_activity_timer->setInterval(std::chrono::seconds(8));
 44 |     m_activity_timer->setSingleShot(true);
 45 |     connect(m_activity_timer, &QTimer::timeout, this, &HoldingRegisterDisplay::on_timer_expired);
 46 | }
 47 | 
 48 | 
 49 | void HoldingRegisterDisplay::updateRegisterValue(const size_t index, const QString &value)
 50 | {
 51 |     if (!m_activity_timer->isActive() || int(index) != m_active_index) {
 52 |         auto widget = dynamic_cast<QLineEdit*>(m_register_values[index]);
 53 |         widget->setText(value);
 54 |     }
 55 | }
 56 | 
 57 | 
 58 | QWidget* HoldingRegisterDisplay::create_value_widget(const quint16 index, const bool initial)
 59 | {
 60 |     static_cast<void>(initial);
 61 |     auto widget = new QLineEdit(m_scroll_area);
 62 |     connect(widget, &QLineEdit::textEdited, this, [=]() {
 63 |         on_register_textEdited(index);
 64 |     });
 65 |     connect(widget, &QLineEdit::returnPressed, this, [=]() {
 66 |        on_register_returnPressed(index);
 67 |     });
 68 |     connect(widget, &QLineEdit::editingFinished, this, [=]() {
 69 |         on_register_editingFinished(index);
 70 |     });
 71 |     connect(widget, &QLineEdit::destroyed, this, [=](QWidget *w=nullptr) {
 72 |         static_cast<void>(w);
 73 |         on_register_destroyed(widget, index);
 74 |     });
 75 |     return widget;
 76 | }
 77 | 
 78 | 
 79 | void HoldingRegisterDisplay::on_register_textEdited(const quint16 index)
 80 | {
 81 |     auto widget = dynamic_cast<QLineEdit*>(m_register_values[index]);
 82 |     m_active_index=int(index);
 83 |     widget->setStyleSheet("background-color: #FFF0F0;");
 84 |     m_activity_timer->start();
 85 | }
 86 | 
 87 | 
 88 | void HoldingRegisterDisplay::on_register_returnPressed(const quint16 index)
 89 | {
 90 |     on_register_editingFinished(index);
 91 |     const auto display_value = get_display_value(index);
 92 |     auto encoded_regs = encode_register(display_value, m_register_encoding[index]);
 93 | 
 94 |     if (encoded_regs.size() == 0) {
 95 |         auto error_box = QMessageBox(this);
 96 |         error_box.setIcon(QMessageBox::Critical);
 97 |         error_box.setStandardButtons(QMessageBox::Ok);
 98 |         error_box.setText(tr("Unable to parse input"));
 99 |         error_box.setInformativeText(
100 |                     tr("Error parsing '%1' : values not updated").arg(display_value));
101 |         error_box.exec();
102 |     } else {
103 |         WriteRequest req{};
104 |         req.first_register = m_starting_register + index;
105 |         req.node = m_node;
106 |         req.values = std::move(encoded_regs);
107 |         req.requester = this;
108 |         emit write_requested(req);
109 |     }
110 | }
111 | 
112 | 
113 | void HoldingRegisterDisplay::on_register_editingFinished(const quint16 index)
114 | {
115 |     auto widget = dynamic_cast<QLineEdit*>(m_register_values[index]);
116 |     widget->setStyleSheet("background-color: #FFF;");
117 |     m_active_index=-1;
118 |     m_activity_timer->stop();
119 | }
120 | 
121 | 
122 | void HoldingRegisterDisplay::on_register_destroyed(QWidget *register_widget, const quint16 index)
123 | {
124 |     static_cast<void>(register_widget);
125 |     static_cast<void>(index);
126 | }
127 | 
128 | 
129 | void HoldingRegisterDisplay::on_timer_expired()
130 | {
131 |     if (m_active_index >= 0) {
132 |         on_register_editingFinished(quint16(m_active_index));
133 |     }
134 | }
135 | 
136 | 
137 | QString HoldingRegisterDisplay::get_object_name() const
138 | {
139 |     return "HoldingRegisterDisplay";
140 | }
141 | 
142 | 
143 | bool HoldingRegisterDisplay::load_configuration_parameters(const QDomElement &node)
144 | {
145 |     auto reg = node.attribute("register").toUInt();
146 |     if (reg < 40001 || reg >= 50000) {
147 |         return false;
148 |     }
149 | 
150 |     return RegisterDisplay::load_configuration_parameters(node);
151 | }
152 | 
153 | 
154 | QString HoldingRegisterDisplay::get_display_value(const size_t index) const
155 | {
156 |     const auto widget = dynamic_cast<QLineEdit*>(m_register_values[index]);
157 |     return widget->text();
158 | }
159 | 
160 | 
161 | std::vector<quint16> HoldingRegisterDisplay::encode_register(
162 |         const QString &value, const RegisterEncoding encoding) const
163 | {
164 |     std::vector<quint16> raw_values;
165 |     bool ok = true;
166 |     switch (encoding) {
167 |     case RegisterEncoding::ENCODING_NONE:
168 |     case RegisterEncoding::ENCODING_UINT16:
169 |     case RegisterEncoding::ENCODING_UNKNOWN:
170 |     case RegisterEncoding::ENCODING_USER:
171 |         raw_values.push_back(quint16(value.toInt(&ok)));
172 |         break;
173 | 
174 |     case RegisterEncoding::ENCODING_BITS:
175 |         raw_values.push_back(quint16(value.mid(2).toInt(&ok, 16)));
176 |         break;
177 | 
178 |     case RegisterEncoding::ENCODING_SIGNED_BYTES: {
179 |             const auto s = value.split(',');
180 |             bool oka = false;
181 |             bool okb = false;
182 |             if (s.size() == 2) {
183 |                 const auto ia = qint8(s[0].toInt(&ok));
184 |                 const auto ib = qint8(s[1].toInt(&ok));
185 |                 auto v16 = quint16(static_cast<quint8>(ia) << 8);
186 |                 v16 |= static_cast<quint8>(ib);
187 |                 raw_values.push_back(v16);
188 |             }
189 |             ok = (oka && okb);
190 |         } break;
191 | 
192 |     case RegisterEncoding::ENCODING_BYTES: {
193 |             const auto s = value.split(',');
194 |             bool oka = false;
195 |             bool okb = false;
196 |             if (s.size() == 2) {
197 |                 const auto ua = quint8(s[0].toInt(&ok));
198 |                 const auto ub = quint8(s[1].toInt(&ok));
199 |                 auto v16 = quint16(ua << 8);
200 |                 v16 |= ub;
201 |                 raw_values.push_back(v16);
202 |             }
203 |             ok = (oka && okb);
204 |         } break;
205 | 
206 |     case RegisterEncoding::ENCODINT_INT16: {
207 |             const auto ival = qint16(value.toInt(&ok));
208 |             raw_values.push_back(static_cast<quint16>(ival));
209 |         } break;
210 |     }
211 | 
212 |     if (ok) {
213 |         return raw_values;
214 |     }
215 | 
216 |     return {};
217 | }
218 | 
219 | 
220 | void HoldingRegisterDisplay::setupUi()
221 | {
222 |     RegisterDisplay::setupUi();
223 |     m_apply_button->setDefault(false);
224 |     m_apply_button->setAutoDefault(false);
225 |     if (nullptr != m_refresh_button) {
226 |         m_refresh_button->setDefault(false);
227 |         m_refresh_button->setAutoDefault(false);
228 |     }
229 |     m_save_button->setDefault(false);
230 |     m_save_button->setAutoDefault(false);
231 | }
232 | 


--------------------------------------------------------------------------------
/register_display.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file register_display.h
  3 |  * \brief Register set display window
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  *
 25 |  * \section DESCRIPTION
 26 |  *
 27 |  * The "RegisterDisplay" class is the base for all Modbus data pools.  This
 28 |  * class may be derived to form custom register set displays (such as writable
 29 |  * registers, indicators, and coils).  This also encludes a custom encoding
 30 |  * mechanism (ie non-modbus standard) to retrieve register metadata including
 31 |  * limits, defaults, data types, and a brief human-readable description.
 32 |  */
 33 | 
 34 | #ifndef REGISTER_DISPLAY_H
 35 | #define REGISTER_DISPLAY_H
 36 | 
 37 | //  c++ includes
 38 | #include <QLabel>  //  QLabel
 39 | #include <QScrollArea>  //  QScrollArea
 40 | #include <QGridLayout>  //  QGridLayout
 41 | #include <QStatusBar>  //  QStatusBar
 42 | #include <QGroupBox>  //  QGroupBox
 43 | #include <QSpinBox>  //  QSpinBox
 44 | #include <QPushButton>  //  QPushButton
 45 | #include <QString>  //  QString
 46 | #include <QTimer>  //  QTimer
 47 | #include <QDomElement>  //  QDomElement
 48 | #include <memory>  //  std::shared_ptr
 49 | #include <vector>  //  std::vector
 50 | #include <optional>  //  std::optional
 51 | 
 52 | // C includes
 53 | /* -none- */
 54 | 
 55 | // project includes
 56 | #include "base_dialog.h"  //  BaseDialog
 57 | #include "metadata_structs.h"  //  RegisterEncoding
 58 | 
 59 | 
 60 | /**
 61 |  * \brief Individual register set display.
 62 |  */
 63 | class RegisterDisplay : public BaseDialog
 64 | {
 65 |     Q_OBJECT
 66 | 
 67 | public:
 68 | 
 69 |     /**
 70 |      * \brief constructor
 71 |      * @param parent parent QObject owner
 72 |      * @param base_reg first register number
 73 |      * @param count number of registers to poll
 74 |      * @param uid device ID, unit ID, node of server to poll
 75 |      */
 76 |     RegisterDisplay(QWidget *parent, const quint16 base_reg, const quint16 count=32, const quint8 uid=0);
 77 | 
 78 |     /**
 79 |      * \brief Get the unique object name for save/restore
 80 |      * \note
 81 |      * All deriving classes must implement this method.
 82 |      *
 83 |      * @return Name of this object
 84 |      */
 85 |     virtual QString get_object_name() const;
 86 | 
 87 |     /**
 88 |      * \brief Save configuration parameters to XML node
 89 |      * @param node Store in node
 90 |      */
 91 |     virtual void save_configuration_parameters(QDomElement &node) const;
 92 | 
 93 |     /**
 94 |      * \brief Load / verify configuration parameters
 95 |      * @param node Read data from node
 96 |      * @return ``true`` if data is valid, ``false`` otherwise
 97 |      */
 98 |     virtual bool load_configuration_parameters(const QDomElement &node);
 99 | 
100 |     virtual void set_metadata(std::shared_ptr<Metadata> metadata, const quint8 node) override;
101 |     virtual void poll_register_set(ModbusThread *const engine) override;
102 | 
103 | protected:
104 | 
105 |     virtual void setupUi() override;
106 | 
107 |     /**
108 |      * \brief Update register widget with new value.
109 |      * @param index index \f(register number = start_reg + index)\f
110 |      * @param value value to display
111 |      */
112 |     virtual void updateRegisterValue(const size_t index, const QString &value);
113 | 
114 |     /**
115 |      * \brief Create a window-specific widget to display register data
116 |      * @param index index within the window (0-count)
117 |      * @param initial Initial call from setupUi
118 |      * @return Widget to add to container
119 |      */
120 |     virtual QWidget* create_value_widget(const quint16 index, const bool initial);
121 | 
122 |     /**
123 |      * \brief Decode modbus data to a displayable string.
124 |      * @param value raw modbus value
125 |      * @param encoding encoding to treat value as
126 |      * @return String representation of register value
127 |      */
128 |     QString decode_register(const quint16 value, const RegisterEncoding encoding) const;
129 | 
130 |     /**
131 |      * \brief Get the displayed value at an index
132 |      * @param index register index in form
133 |      * @return String representation of register value
134 |      */
135 |     virtual QString get_display_value(const size_t index) const;
136 | 
137 |     /**
138 |       * \brief Get the label text for a register number
139 |       * @param reg_number register number
140 |       */
141 |     [[nodiscard]] virtual QString get_register_number_text(const quint16 reg_number);
142 | 
143 |     /**
144 |      * @brief Set the title text that should dectorate this window
145 |      */
146 |     virtual void set_title();
147 | 
148 |     quint16 m_starting_register; /**< First register polled by this window */
149 |     quint16 m_count; /**< Number of registers polled */
150 |     quint16 m_max_regs=0; /**< Maximum number of registers allowed */
151 |     quint8 m_node; /**< Polls directed at this node/device ID */
152 |     bool m_have_metadata = false; /**< Flag indicating that metadata has been polled */
153 | 
154 |     std::vector<QLabel*> m_register_labels; /**< List of register number labels */
155 |     std::vector<QWidget*> m_register_values; /**< List of display values */
156 |     std::vector<QLabel*> m_register_descriptions; /**< List of descriptions (from metadata) */
157 | 
158 |     /**
159 |      * \var m_register_encoding
160 |      * List of encoding attributes for each register
161 |      * \sa RegisterEncoding
162 |      */
163 |     std::vector<RegisterEncoding> m_register_encoding;
164 |     std::vector<quint16> m_raw_values; /**< List of raw values from protocol layer */
165 | 
166 |     QScrollArea *const m_scroll_area; /**< Main display scroll area */
167 |     QWidget *const m_scroll_container; /**< Scroll area contents */
168 |     QGridLayout *const m_scroll_layout; /**< Scroll area layout control */
169 |     QStatusBar *const m_status; /**< Status notification area */
170 | 
171 |     QGroupBox *const m_control_box; /**< Group of configuration controls at top of scroll area */
172 |     QGridLayout *const m_control_grid; /**< layout for control box \sa m_control_box */
173 |     QSpinBox *const m_reg_select; /**< First register selection */
174 |     QSpinBox *const m_node_select; /**< Node / device ID selection */
175 |     QSpinBox *const m_quantity; /**< Number of registers selection */
176 |     QPushButton *const m_apply_button; /**< Update window (also default) */
177 |     QPushButton *m_refresh_button; /**< Refresh metadata */
178 |     QPushButton *const m_save_button; /**< Save data to CSV table */
179 | 
180 | public slots:
181 | 
182 |     /**
183 |      * \brief Signal on the refresh (update metadata) button clicked.
184 |      * \note
185 |      * Made public so the main window can trigger this as well.
186 |      */
187 |     void on_refresh_clicked();
188 | 
189 |     virtual void on_new_value(const quint16 reg, const quint16 value, const quint8 unit_id) override;
190 |     virtual void on_exception_status(BaseDialog *requester, const QString exception) override;
191 | 
192 | protected slots:
193 | 
194 |     /**
195 |      * \brief Signal on the apply (update configuration) button clicked.
196 |      */
197 |     void on_apply_clicked();
198 | 
199 |     /**
200 |      * \brief Signal on the "save data" button click.
201 |      */
202 |     void on_save_clicked();
203 | 
204 | private slots:
205 | 
206 |     /**
207 |      * \brief Signal on the status bar update timer expired.
208 |      */
209 |     void on_status_timer_timeout();
210 | 
211 | private:
212 | 
213 |     /**
214 |      * \brief Save register data to CSV file
215 |      * @param path absolute path and file name to save to
216 |      */
217 |     bool save_register_set(const QString &path);
218 | 
219 |     QTimer *const m_status_timer;
220 |     bool m_meta_in_process = false;
221 | };
222 | 
223 | 
224 | #endif // REGISTER_DISPLAY_H
225 | 


--------------------------------------------------------------------------------
/mainwindow.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file mainwindow.h
  3 |  * \brief Main window for program
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | #ifndef MAINWINDOW_H
 27 | #define MAINWINDOW_H
 28 | 
 29 | //  c++ includes
 30 | #include <unordered_set>  //  std::unordered_set
 31 | #include <QList>  //  QList
 32 | #include <QMainWindow>  //  QMainWindow
 33 | #include <QTimer>  //  QTimer
 34 | #include <QDomDocument>  //  QDomDocument
 35 | #include <QDomElement>  //  QDomElement, QDomNode
 36 | #include <QStringList>  //  QStringList
 37 | 
 38 | // C includes
 39 | /* -none- */
 40 | 
 41 | // project includes
 42 | #include "register_display.h"  //  RegisterDisplay
 43 | #include "modbusthread.h"  //  ModbusThread
 44 | #include "write_event.h"  //  WriteRequest
 45 | #include "scheduler.h"  //  Scheduler
 46 | #include "ui_mainwindow.h"  //  Ui::MainWindow
 47 | #include "trend_window.h"  //  TrendWindow
 48 | #include "base_dialog.h"  //  BaseDialog
 49 | 
 50 | 
 51 | /**
 52 |  * \brief The main window for application
 53 |  */
 54 | class MainWindow : public QMainWindow
 55 | {
 56 |     Q_OBJECT
 57 | 
 58 | public:
 59 | 
 60 |     /**
 61 |      * \brief constructor
 62 |      * @param parent parent QObject owner
 63 |      */
 64 |     MainWindow(QWidget *parent = nullptr);
 65 | 
 66 |     ~MainWindow() override;
 67 | 
 68 |     virtual void closeEvent(QCloseEvent *evt) override;
 69 | 
 70 | private slots:
 71 | 
 72 |     /**
 73 |      * \brief Signal Connect menu item triggered.
 74 |      */
 75 |     void on_actionConnect_triggered();
 76 | 
 77 |     /**
 78 |      * \brief Signal New Coils menu item triggered.
 79 |      */
 80 |     void on_actionCoils_triggered();
 81 | 
 82 |     /**
 83 |      * \brief Signal New Inputs menu item triggered.
 84 |      */
 85 |     void on_actionInputs_triggered();
 86 | 
 87 |     /**
 88 |      * \brief Signal New Input Registers menu item triggered.
 89 |      */
 90 |     void on_actionInput_Registers_triggered();
 91 | 
 92 |     /**
 93 |      * \brief Signal New Holding Registers menu item triggered.
 94 |      */
 95 |     void on_actionHolding_Registers_triggered();
 96 | 
 97 |     /**
 98 |      * \brief Signal modbus exception occurred.
 99 |      * @param requester Originating reqest window
100 |      * @param exception exception text
101 |      */
102 |     void modbus_on_error(BaseDialog *const requester, const QString exception);
103 | 
104 |     /**
105 |      * \brief Signal modbus poll complete (from modbus thread).
106 |      */
107 |     void modbus_on_data();
108 | 
109 |     /**
110 |      * @brief Signal modbus error (from modbus thread).
111 |      * @param error_code modbus error code
112 |      */
113 |     void modbus_on_error_protocol(const int error_code);
114 | 
115 |     /**
116 |      * \brief Signal Poll Once menu item triggered.
117 |      */
118 |     void on_actionOnce_triggered();
119 | 
120 |     /**
121 |      * \brief Signal Poll Continuous menu item toggled.
122 |      */
123 |     void on_actionContinuous_triggered();
124 | 
125 |     /**
126 |      * \brief Signal that a child window was closed.
127 |      * @param window reference window
128 |      */
129 |     void register_window_destroyed(BaseDialog *window);
130 | 
131 |     /**
132 |      * \brief Signal to periodically refresh the status bar (timer).
133 |      */
134 |     void update_timer_on_expired();
135 | 
136 |     /**
137 |      * \brief Signal that standard polling is complete (scheduler).
138 |      */
139 |     void polling_on_complete();
140 | 
141 |     /**
142 |      * \brief Signal save current session menu item triggered.
143 |      */
144 |     void on_actionSave_Session_triggered();
145 | 
146 |     /**
147 |      * \brief Signal restore previously saved session menu item triggered.
148 |      */
149 |     void on_actionRestore_Session_triggered();
150 | 
151 |     /**
152 |      * \brief Signal read metadata menu item triggered.
153 |      */
154 |     void on_actionRead_Metadata_triggered();
155 | 
156 |     /**
157 |      * \brief Signal read metadata menu item triggered.
158 |      */
159 |     void on_actionLoad_Register_Data_triggered();
160 | 
161 |     /**
162 |      * \brief Signal new Trend menu item triggered.
163 |      */
164 |     void on_actionTrend_triggered();
165 | 
166 |     /**
167 |      * \brief Signal that the trend window has been closed.
168 |      */
169 |     void trend_on_closed(BaseDialog *w);
170 | 
171 | private:
172 | 
173 |     /**
174 |      * \brief After connection completed logic.
175 |      */
176 |     void post_connected();
177 | 
178 |     /**
179 |      * \brief After Modbus thread closed logic.
180 |      */
181 |     void post_disconnected();
182 | 
183 |     /**
184 |      * \brief Save configuration
185 |      *
186 |      * @return XML tree to write to file.
187 |      */
188 |     [[nodiscard]] QDomDocument save_config() const;
189 | 
190 |     /**
191 |      * \brief Load configuration
192 |      * @throws FileLoadException on error
193 |      * @param filename file to load
194 |      */
195 |     void load_config(const QString &filename);
196 | 
197 |     /**
198 |      * \brief Configure a new register display window.
199 |      *
200 |      * @param window window to be added
201 |      */
202 |     void add_window(RegisterDisplay *const window);
203 | 
204 |     /**
205 |      * \brief Load the "communications" section of the configuration.
206 |      * @throws AppException on error
207 |      * @param node Communications root node reference
208 |      */
209 |     void load_communications_config(const QDomElement &node);
210 | 
211 |     /**
212 |      * \brief Load the individual windows section of the configuration.
213 |      * @throws AppException on error
214 |      * @param node Windows root node reference
215 |      */
216 |     void load_windows(const QDomNode &node);
217 | 
218 |     /**
219 |      * \brief Load the individual windows section of the configuration.
220 |      * @throws AppException on error
221 |      * @param node Window XML element node.
222 |      * @return tuple {slave id, start register, register count}
223 |      */
224 |     [[nodiscard]] std::tuple<quint8, quint16, quint16>
225 |         load_base_data(const QDomElement &node) const;
226 | 
227 |     /**
228 |      * \brief Load data from CSV and disseminate to components (windows, protocol layer)
229 |      * @param all_data parsed array of CSV data
230 |      * @param value_index index of field to interpret as the "value"
231 |      * @param register_index index of field to interpret as the "register number"
232 |      * @param node_index when >= 0 index of the field to interpret as the "Device ID"
233 |      *                   when < 0 the absolute value is \f node + 1 \f
234 |      * @param skip_first_row set ``true`` to skip the first row
235 |      */
236 |     void load_csv_data(const QList<QStringList> &all_data,
237 |                        const size_t value_index,
238 |                        const size_t register_index,
239 |                        const ssize_t node_index,
240 |                        const bool skip_first_row);
241 | 
242 |     /**
243 |      * \brief Append data to an outgoind write request
244 |      * @param wr reference to the write request
245 |      * @param reg register number
246 |      * @param value value to write
247 |      * @param node Device ID receiving the write
248 |      */
249 |     void append_write(WriteRequest &wr, const quint16 reg, const quint16 value, const quint8 node);
250 | 
251 |     Ui::MainWindow *const m_ui;
252 |     bool m_connected;
253 |     bool m_connecting=false;
254 |     bool m_connecting2=false;
255 |     bool m_active=false;
256 |     std::unordered_set<RegisterDisplay*> m_register_windows;
257 |     ModbusThread *m_engine=nullptr;
258 |     Scheduler *const m_scheduler;
259 |     QTimer *const m_update_timer;
260 |     TrendWindow *m_trend;
261 | };
262 | 
263 | 
264 | #endif // MAINWINDOW_H
265 | 


--------------------------------------------------------------------------------
/modbusthread.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file modbusthread.cpp
  3 |  * \brief Modbus thread container
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | //  c++ includes
 27 | /* -none- */
 28 | 
 29 | // C includes
 30 | #include <sys/socket.h>  //  recv
 31 | 
 32 | // project includes
 33 | #include "modbusthread.h"  //  local include
 34 | 
 35 | 
 36 | ModbusThread::ModbusThread(QObject *parent, const QString &host, const quint16 port)
 37 |         :QThread(parent),
 38 |           m_host(host),
 39 |           m_port(port),
 40 |           m_mx(),
 41 |           m_cond(),
 42 |           m_regs()
 43 | {
 44 |     connect(this, &ModbusThread::finished, this, &ModbusThread::deleteLater);
 45 | }
 46 | 
 47 | 
 48 | ModbusThread::~ModbusThread()
 49 | {
 50 |     if (nullptr != m_ctx) {
 51 |         modbus_free(m_ctx);
 52 |         m_ctx=nullptr;
 53 |     }
 54 | }
 55 | 
 56 | 
 57 | void ModbusThread::run()
 58 | {
 59 |     bool exit_signal;
 60 |     m_ctx = modbus_new_tcp(m_host.toLocal8Bit().data(), int(m_port));
 61 |     if (nullptr == m_ctx) {
 62 |         m_mx.lock();
 63 |         m_quit = true;
 64 |         m_mx.unlock();
 65 |         emit modbus_error(errno);
 66 |         return;
 67 |     }
 68 | 
 69 |     if (modbus_connect(m_ctx) != 0) {
 70 |         m_mx.lock();
 71 |         m_quit = true;
 72 |         m_mx.unlock();
 73 |         emit modbus_error(errno);
 74 |         return;
 75 |     }
 76 | 
 77 |     emit complete();
 78 | 
 79 |     std::vector<uint8_t> bits;
 80 |     do {
 81 |         m_mx.lock();
 82 |         if (!m_quit) {
 83 |             m_cond.wait(&m_mx);
 84 |         }
 85 |         exit_signal = m_quit;
 86 |         int result;
 87 |         auto bit_process=false;
 88 |         m_regs.resize(size_t(m_count));
 89 | 
 90 |         //  This does not generate network traffic.
 91 |         if (nullptr == m_raw_request) {
 92 |             result=modbus_set_slave(m_ctx, int(m_node));
 93 |         } else {
 94 |             result=0;
 95 |         }
 96 | 
 97 |         if (exit_signal) {
 98 |             result=0;
 99 |         } else if (0 != result) {
100 |             //  Don't do anything
101 |         } else if (nullptr != m_raw_request) {
102 |             result = do_custom_request_tcp();
103 |         } else if (0 == m_count) {
104 |             bits.resize(256);
105 |             result = modbus_report_slave_id(m_ctx, 256, &bits[0]);
106 |             bit_process=true;
107 |             if (result > 0) {
108 |                 m_count=quint16(result);
109 |                 m_regs.resize(m_count);
110 |             }
111 |         } else if (m_write_request) {
112 |             result = do_write_request();
113 |         } else if (m_reg_number >= 1 && m_reg_number <= 9999) {
114 |             bits.resize(size_t(m_count));
115 |             result = modbus_read_bits(m_ctx, int(m_reg_number - 1), int(m_count), bits.data());
116 |             bit_process=true;
117 |         } else if (m_reg_number >= 10001 && m_reg_number <= 19999) {
118 |             bits.resize(size_t(m_count));
119 |             result = modbus_read_input_bits(m_ctx, int(m_reg_number - 10001), int(m_count), bits.data());
120 |             bit_process=true;
121 |         } else if (m_reg_number >= 30001 && m_reg_number <= 39999) {
122 |             result = modbus_read_input_registers(m_ctx, int(m_reg_number - 30001), int(m_count), m_regs.data());
123 |         } else if (m_reg_number >= 40001 && m_reg_number <= 49999) {
124 |             result = modbus_read_registers(m_ctx, int(m_reg_number - 40001), int(m_count), m_regs.data());
125 |         } else {
126 |             emit modbus_error(2);  //  Illegal address
127 |         }
128 | 
129 |         if (result < 0) {
130 |             emit modbus_error(errno);
131 |         } else {
132 |             if (bit_process) {
133 |                 for (auto i=0U; i<m_count; ++i) {
134 |                     m_regs[i]=quint16(bits[i]);
135 |                 }
136 |             }
137 |             if (!exit_signal) {
138 |                 emit complete();
139 |             }
140 |         }
141 | 
142 |         m_mx.unlock();
143 |     } while (!exit_signal);
144 |     modbus_close(m_ctx);
145 | }
146 | 
147 | 
148 | void ModbusThread::modbus_request(const quint16 first_reg, const quint16 num_regs, const quint8 uid)
149 | {
150 |     m_mx.lock();
151 |     m_reg_number = first_reg;
152 |     m_count = num_regs;
153 |     m_node = uid;
154 |     m_write_request=false;
155 |     m_raw_request=nullptr;
156 |     m_cond.notify_one();
157 |     m_mx.unlock();
158 | }
159 | 
160 | 
161 | std::vector<quint16> ModbusThread::modbus_result()
162 | {
163 |     m_mx.lock();
164 |     std::vector<quint16> result = std::move(m_regs);
165 |     m_regs=std::vector<quint16>();
166 |     m_mx.unlock();
167 | 
168 |     return result;
169 | }
170 | 
171 | 
172 | void ModbusThread::close()
173 | {
174 |     m_mx.lock();
175 |     m_quit=true;
176 |     m_cond.notify_one();
177 |     m_mx.unlock();
178 |     wait();
179 | }
180 | 
181 | 
182 | void ModbusThread::modbus_request(const quint16 first_reg, std::vector<quint16> &&regs_to_write, const quint8 uid)
183 | {
184 |     auto reg_count = regs_to_write.size();
185 |     m_mx.lock();
186 |     m_regs = std::move(regs_to_write);
187 |     m_reg_number = first_reg;
188 |     m_count = quint16(reg_count);
189 |     m_node = uid;
190 |     m_write_request=true;
191 |     m_raw_request=nullptr;
192 |     m_cond.notify_one();
193 |     m_mx.unlock();
194 | }
195 | 
196 | 
197 | void ModbusThread::modbus_request(const quint8 *pdu, const quint8 length, const qint8 fc, const quint8 uid)
198 | {
199 |     m_mx.lock();
200 |     m_regs = {};
201 |     m_node = uid;
202 |     m_count = quint16(length);
203 |     m_raw_request = pdu;
204 |     m_write_request=false;
205 |     m_reg_number = quint16(fc);
206 |     m_cond.notify_one();
207 |     m_mx.unlock();
208 | }
209 | 
210 | 
211 | int ModbusThread::do_write_request()
212 | {
213 |     int result;
214 |     auto write_count=m_regs.size();
215 |     if (1 == write_count && m_reg_number <= 19999) {
216 |         result = modbus_write_bit(m_ctx, int(m_reg_number - 1), (m_regs[0] > 0 ? TRUE : FALSE));
217 |     } else if (m_reg_number <= 19999) {
218 |         std::vector<quint8>write_bits(write_count);
219 |         for (decltype(write_count) i=0; i<write_count; i++) {
220 |             write_bits[i] = (m_regs[i] > 0 ? TRUE : FALSE);
221 |         }
222 |         result = modbus_write_bits(m_ctx, int(m_reg_number - 1), int(write_count), &write_bits[0]);
223 |     } else if (1 == write_count) {
224 |         result = modbus_write_register(m_ctx, int(m_reg_number - 40001), m_regs[0]);
225 |     } else {
226 |         result = modbus_write_registers(m_ctx, int(m_reg_number - 40001), int(write_count), &m_regs[0]);
227 |     }
228 | 
229 |     return result;
230 | }
231 | 
232 | 
233 | quint16 ModbusThread::get_start_reg()
234 | {
235 |     m_mx.lock();
236 |     auto retval = m_reg_number;
237 |     m_mx.unlock();
238 |     return retval;
239 | }
240 | 
241 | 
242 | quint8 ModbusThread::get_unit_id()
243 | {
244 |     m_mx.lock();
245 |     auto retval = m_node;
246 |     m_mx.unlock();
247 |     return retval;
248 | }
249 | 
250 | 
251 | int ModbusThread::do_custom_request_tcp()
252 | {
253 |     //  Actually looking through the code in libmodbus, their handling of
254 |     // custom functions is hopelessly broken.  Rather than alter the library I
255 |     // thought it best to just put this kludge in.
256 |     std::vector<uint8_t> req(m_count + 2);
257 |     auto fc = uint8_t(m_reg_number);  //  Function code stored in reg_number
258 |     m_reg_number = 0xFFFFU;  //  Always set the "custom function" state.
259 | 
260 |     req[0] = uint8_t(m_node);
261 |     req[1] = fc;
262 |     for (auto i=0; i<m_count; ++i) {
263 |         req[size_t(i+2)] = uint8_t(m_raw_request[i]);
264 |     }
265 |     auto result = modbus_send_raw_request(m_ctx, req.data(), int(req.size()));
266 |     if (result < 0) {
267 |         return result;
268 |     }
269 | 
270 |     uint8_t rsp_data[MODBUS_MAX_ADU_LENGTH];
271 |     result = modbus_receive_confirmation(m_ctx, rsp_data);
272 |     if (result < 0) {
273 |         return result;
274 |     }
275 | 
276 |     auto index=modbus_get_header_length(m_ctx);
277 |     auto fcode = qint16(rsp_data[size_t(index)]);
278 |     if (fcode != fc) {
279 |         errno = int(rsp_data[index + 1]) + MODBUS_ENOBASE;
280 |         return -1;
281 |     }
282 |     auto length = int(rsp_data[4]) * 256;
283 |     length += int(rsp_data[5]) + 6;  //  Add in the Modbus/TCP overhead
284 |     if (length > result) {
285 |         //  Reach in and grab the rest of the packet
286 |         auto sock = modbus_get_socket(m_ctx);
287 |         //auto p = static_cast<void*>(&rsp_data[result]);
288 |         recv(sock, &rsp_data[result], size_t(length - result), MSG_WAITALL);
289 |     }
290 |     index++;
291 |     m_count=0;
292 |     m_regs.resize(size_t(length - index));
293 |     for (; index<length; ++index) {
294 |         m_regs[m_count++] = quint16(rsp_data[size_t(index)]);
295 |     }
296 | 
297 |     return int(m_count);
298 | }
299 | 


--------------------------------------------------------------------------------
/configure_trend_line.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>ConfigureTrendDialog</class>
  4 |  <widget class="QDialog" name="ConfigureTrendDialog">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>491</width>
 10 |     <height>300</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>Configure Trend</string>
 15 |   </property>
 16 |   <property name="windowIcon">
 17 |    <iconset resource="resources.qrc">
 18 |     <normaloff>:/QModbusTool.ico</normaloff>:/QModbusTool.ico</iconset>
 19 |   </property>
 20 |   <widget class="QGroupBox" name="groupBox">
 21 |    <property name="enabled">
 22 |     <bool>true</bool>
 23 |    </property>
 24 |    <property name="geometry">
 25 |     <rect>
 26 |      <x>250</x>
 27 |      <y>10</y>
 28 |      <width>226</width>
 29 |      <height>171</height>
 30 |     </rect>
 31 |    </property>
 32 |    <property name="sizePolicy">
 33 |     <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
 34 |      <horstretch>0</horstretch>
 35 |      <verstretch>0</verstretch>
 36 |     </sizepolicy>
 37 |    </property>
 38 |    <property name="styleSheet">
 39 |     <string notr="true"/>
 40 |    </property>
 41 |    <property name="title">
 42 |     <string>Monitor Configuration</string>
 43 |    </property>
 44 |    <widget class="QWidget" name="gridLayoutWidget_2">
 45 |     <property name="geometry">
 46 |      <rect>
 47 |       <x>10</x>
 48 |       <y>30</y>
 49 |       <width>206</width>
 50 |       <height>124</height>
 51 |      </rect>
 52 |     </property>
 53 |     <layout class="QGridLayout" name="gridLayout_2">
 54 |      <item row="1" column="0">
 55 |       <widget class="QLabel" name="label_2">
 56 |        <property name="text">
 57 |         <string>Device ID (Node):</string>
 58 |        </property>
 59 |        <property name="alignment">
 60 |         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
 61 |        </property>
 62 |       </widget>
 63 |      </item>
 64 |      <item row="1" column="1">
 65 |       <widget class="QSpinBox" name="NodeEdit">
 66 |        <property name="sizePolicy">
 67 |         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
 68 |          <horstretch>0</horstretch>
 69 |          <verstretch>0</verstretch>
 70 |         </sizepolicy>
 71 |        </property>
 72 |        <property name="minimumSize">
 73 |         <size>
 74 |          <width>75</width>
 75 |          <height>0</height>
 76 |         </size>
 77 |        </property>
 78 |        <property name="maximum">
 79 |         <number>255</number>
 80 |        </property>
 81 |       </widget>
 82 |      </item>
 83 |      <item row="0" column="1">
 84 |       <widget class="QLineEdit" name="RegEdit">
 85 |        <property name="enabled">
 86 |         <bool>true</bool>
 87 |        </property>
 88 |        <property name="sizePolicy">
 89 |         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
 90 |          <horstretch>0</horstretch>
 91 |          <verstretch>0</verstretch>
 92 |         </sizepolicy>
 93 |        </property>
 94 |        <property name="maximumSize">
 95 |         <size>
 96 |          <width>75</width>
 97 |          <height>16777215</height>
 98 |         </size>
 99 |        </property>
100 |        <property name="text">
101 |         <string>30001</string>
102 |        </property>
103 |        <property name="maxLength">
104 |         <number>6</number>
105 |        </property>
106 |       </widget>
107 |      </item>
108 |      <item row="2" column="0" colspan="2">
109 |       <widget class="QCheckBox" name="SignedEdit">
110 |        <property name="minimumSize">
111 |         <size>
112 |          <width>192</width>
113 |          <height>28</height>
114 |         </size>
115 |        </property>
116 |        <property name="layoutDirection">
117 |         <enum>Qt::RightToLeft</enum>
118 |        </property>
119 |        <property name="text">
120 |         <string>Treat as signed number:  </string>
121 |        </property>
122 |        <property name="checked">
123 |         <bool>true</bool>
124 |        </property>
125 |       </widget>
126 |      </item>
127 |      <item row="0" column="0">
128 |       <widget class="QLabel" name="label">
129 |        <property name="text">
130 |         <string>Register Number:</string>
131 |        </property>
132 |        <property name="alignment">
133 |         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
134 |        </property>
135 |       </widget>
136 |      </item>
137 |     </layout>
138 |    </widget>
139 |   </widget>
140 |   <widget class="QGroupBox" name="groupBox_2">
141 |    <property name="geometry">
142 |     <rect>
143 |      <x>10</x>
144 |      <y>10</y>
145 |      <width>221</width>
146 |      <height>131</height>
147 |     </rect>
148 |    </property>
149 |    <property name="styleSheet">
150 |     <string notr="true"/>
151 |    </property>
152 |    <property name="title">
153 |     <string>Scaling Configuration</string>
154 |    </property>
155 |    <widget class="QWidget" name="gridLayoutWidget_3">
156 |     <property name="geometry">
157 |      <rect>
158 |       <x>10</x>
159 |       <y>30</y>
160 |       <width>201</width>
161 |       <height>91</height>
162 |      </rect>
163 |     </property>
164 |     <layout class="QGridLayout" name="gridLayout_3">
165 |      <item row="1" column="0">
166 |       <widget class="QLabel" name="label_4">
167 |        <property name="text">
168 |         <string>Offset (b):</string>
169 |        </property>
170 |        <property name="alignment">
171 |         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
172 |        </property>
173 |       </widget>
174 |      </item>
175 |      <item row="1" column="1">
176 |       <widget class="QLineEdit" name="OffsetBox">
177 |        <property name="text">
178 |         <string>0.0</string>
179 |        </property>
180 |       </widget>
181 |      </item>
182 |      <item row="0" column="1">
183 |       <widget class="QLineEdit" name="MultBox">
184 |        <property name="text">
185 |         <string>1.0</string>
186 |        </property>
187 |       </widget>
188 |      </item>
189 |      <item row="0" column="0">
190 |       <widget class="QLabel" name="label_3">
191 |        <property name="sizePolicy">
192 |         <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
193 |          <horstretch>0</horstretch>
194 |          <verstretch>0</verstretch>
195 |         </sizepolicy>
196 |        </property>
197 |        <property name="text">
198 |         <string>Multiplyer (m):</string>
199 |        </property>
200 |        <property name="alignment">
201 |         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
202 |        </property>
203 |       </widget>
204 |      </item>
205 |     </layout>
206 |    </widget>
207 |   </widget>
208 |   <widget class="QGroupBox" name="groupBox_3">
209 |    <property name="geometry">
210 |     <rect>
211 |      <x>30</x>
212 |      <y>140</y>
213 |      <width>201</width>
214 |      <height>161</height>
215 |     </rect>
216 |    </property>
217 |    <property name="sizePolicy">
218 |     <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
219 |      <horstretch>0</horstretch>
220 |      <verstretch>0</verstretch>
221 |     </sizepolicy>
222 |    </property>
223 |    <property name="styleSheet">
224 |     <string notr="true">QGroupBox{
225 |                       border: 0px;
226 | } 
227 | </string>
228 |    </property>
229 |    <property name="title">
230 |     <string/>
231 |    </property>
232 |    <widget class="QWidget" name="gridLayoutWidget">
233 |     <property name="geometry">
234 |      <rect>
235 |       <x>10</x>
236 |       <y>30</y>
237 |       <width>181</width>
238 |       <height>121</height>
239 |      </rect>
240 |     </property>
241 |     <layout class="QGridLayout" name="gridLayout">
242 |      <property name="verticalSpacing">
243 |       <number>16</number>
244 |      </property>
245 |      <item row="1" column="1">
246 |       <widget class="QLabel" name="ColorSample">
247 |        <property name="text">
248 |         <string>----------</string>
249 |        </property>
250 |        <property name="alignment">
251 |         <set>Qt::AlignCenter</set>
252 |        </property>
253 |       </widget>
254 |      </item>
255 |      <item row="0" column="1">
256 |       <widget class="QLabel" name="ColorText">
257 |        <property name="text">
258 |         <string>#0000FF</string>
259 |        </property>
260 |       </widget>
261 |      </item>
262 |      <item row="0" column="0">
263 |       <widget class="QLabel" name="label_5">
264 |        <property name="text">
265 |         <string>Current Color:</string>
266 |        </property>
267 |       </widget>
268 |      </item>
269 |      <item row="1" column="0">
270 |       <widget class="QPushButton" name="ColorButton">
271 |        <property name="text">
272 |         <string>Change
273 | Color</string>
274 |        </property>
275 |       </widget>
276 |      </item>
277 |     </layout>
278 |    </widget>
279 |   </widget>
280 |   <widget class="QPushButton" name="Accept">
281 |    <property name="geometry">
282 |     <rect>
283 |      <x>390</x>
284 |      <y>260</y>
285 |      <width>91</width>
286 |      <height>30</height>
287 |     </rect>
288 |    </property>
289 |    <property name="text">
290 |     <string>Update</string>
291 |    </property>
292 |    <property name="default">
293 |     <bool>true</bool>
294 |    </property>
295 |   </widget>
296 |   <widget class="QPushButton" name="Delete">
297 |    <property name="geometry">
298 |     <rect>
299 |      <x>250</x>
300 |      <y>200</y>
301 |      <width>91</width>
302 |      <height>30</height>
303 |     </rect>
304 |    </property>
305 |    <property name="text">
306 |     <string>Delete</string>
307 |    </property>
308 |    <property name="autoDefault">
309 |     <bool>false</bool>
310 |    </property>
311 |   </widget>
312 |   <widget class="QPushButton" name="Cancel">
313 |    <property name="geometry">
314 |     <rect>
315 |      <x>250</x>
316 |      <y>260</y>
317 |      <width>91</width>
318 |      <height>30</height>
319 |     </rect>
320 |    </property>
321 |    <property name="text">
322 |     <string>Cancel</string>
323 |    </property>
324 |    <property name="autoDefault">
325 |     <bool>false</bool>
326 |    </property>
327 |   </widget>
328 |  </widget>
329 |  <resources>
330 |   <include location="resources.qrc"/>
331 |  </resources>
332 |  <connections/>
333 | </ui>
334 | 


--------------------------------------------------------------------------------
/scheduler.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file scheduler.cpp
  3 |  * \brief Poll request scheduler
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | //  c++ includes
 27 | #include <cassert>  //  assert
 28 | 
 29 | // C includes
 30 | #include <modbus/modbus.h>  //  modbus_strerror
 31 | 
 32 | // project includes
 33 | #include "scheduler.h"  //  Local include
 34 | #include "metadata_wrapper.h"  //  MetadataWrapper
 35 | 
 36 | 
 37 | Scheduler::Scheduler(QObject *parent)
 38 |     :QObject(parent),
 39 |     m_write_requests(),
 40 |     m_meta_requests(),
 41 |     m_standard_requests(),
 42 |     m_modbus_timer{new QTimer(this)}
 43 | {
 44 |     connect(m_modbus_timer, &QTimer::timeout, this, &Scheduler::modbus_on_timer_expired);
 45 |     m_modbus_timer->setSingleShot(true);
 46 | }
 47 | 
 48 | 
 49 | void Scheduler::start_modbus(ModbusThread *const engine, const std::chrono::milliseconds timeout)
 50 | {
 51 |     assert(nullptr == m_polling_thread);
 52 |     m_polling_thread=engine;
 53 |     m_modbus_timer->setInterval(timeout);
 54 |     m_write_requests.clear();
 55 |     m_meta_requests.clear();
 56 |     m_standard_requests.clear();
 57 |     m_current_request=nullptr;
 58 |     m_active=false;
 59 |     connect(engine, &ModbusThread::modbus_error, this, &Scheduler::modbus_on_error);
 60 |     connect(engine, &ModbusThread::complete, this, &Scheduler::modbus_on_data);
 61 |     m_poll_count = 0;
 62 |     m_error_count = 0;
 63 |     emit new_register_data(0, SystemRegister::SYSTEM_CONNECTED, 255);
 64 | }
 65 | 
 66 | 
 67 | void Scheduler::stop_modbus()
 68 | {
 69 |     if (nullptr != m_polling_thread) {
 70 |         disconnect(m_polling_thread, &ModbusThread::modbus_error, this, &Scheduler::modbus_on_error);
 71 |         disconnect(m_polling_thread, &ModbusThread::complete, this, &Scheduler::modbus_on_data);
 72 |         m_current_request=nullptr;
 73 |         m_active=false;
 74 |         m_write_requests.clear();
 75 |         m_meta_requests.clear();
 76 |         m_polling_thread=nullptr;
 77 |         if (m_standard_requests.size() > 0) {
 78 |             m_standard_requests.clear();
 79 |             emit polling_complete();  //  TODO: Really?
 80 |         }
 81 |         emit new_register_data(0, SystemRegister::SYSTEM_DISCONNECTED, 255);
 82 |     }
 83 | }
 84 | 
 85 | 
 86 | void Scheduler::enqueue_request(BaseDialog *const source)
 87 | {
 88 |     if (nullptr != m_polling_thread) {
 89 |         m_standard_requests.push_back(source);
 90 |         figure_next();
 91 |     }
 92 | }
 93 | 
 94 | 
 95 | void Scheduler::modbus_on_write_request(WriteRequest request)
 96 | {
 97 |     if (nullptr != m_polling_thread) {
 98 |         m_write_requests.push_back(request);
 99 |         figure_next();
100 |     }
101 | }
102 | 
103 | 
104 | void Scheduler::remove_reference(BaseDialog *const screen)
105 | {
106 |     for (auto &i: m_write_requests) {
107 |         if (screen == i.requester) {
108 |             i.requester = nullptr;
109 |         }
110 |     }
111 | 
112 |     for (auto &i: m_meta_requests) {
113 |         if (screen == i.requester) {
114 |             i.requester = nullptr;
115 |         }
116 |     }
117 | 
118 |     decltype(m_standard_requests) request_list = {};
119 |     auto start_count = m_standard_requests.size();
120 |     for (const auto i: m_standard_requests) {
121 |         if (i != screen) {
122 |             request_list.push_back(i);
123 |         }
124 |     }
125 |     m_standard_requests = std::move(request_list);
126 | 
127 |     if (m_current_request == screen) {
128 |         m_current_request = nullptr;
129 |     }
130 | 
131 |     if (m_standard_requests.size() == 0 && 0 != start_count) {
132 |         emit polling_complete();
133 |     }
134 | }
135 | 
136 | 
137 | void Scheduler::modbus_on_error(const int error_code)
138 | {
139 |     m_modbus_timer->stop();
140 |     m_error_count++;
141 |     const QString modbus_error{tr(modbus_strerror(error_code))};
142 |     m_active=false;
143 |     emit poll_exception(m_current_request, modbus_error);
144 | 
145 |     if (PollAction::POLLING_METADATA == m_current_action) {
146 |         m_meta_requests.pop_front();
147 |     }
148 | 
149 |     figure_next();
150 | }
151 | 
152 | 
153 | void Scheduler::modbus_on_data()
154 | {
155 |     m_modbus_timer->stop();
156 |     m_poll_count++;
157 |     m_active=false;
158 |     if (nullptr == m_polling_thread) {
159 |         //  Escape if no longer connected (IE Queued callback)
160 |     } else if (PollAction::POLLING_METADATA == m_current_action) {
161 |         const auto node = m_polling_thread->get_unit_id();
162 |         emit new_register_data(0, SystemRegister::POLL_METADATA_COMPLETE, node);
163 |         poll_response_metadata();
164 |     } else if (PollAction::POLLING_READ == m_current_action) {
165 |         const auto register_set = m_polling_thread->modbus_result();
166 |         const auto node = m_polling_thread->get_unit_id();
167 |         auto register_number = m_polling_thread->get_start_reg();
168 | 
169 |         for (const auto i: register_set) {
170 |             emit new_register_data(register_number, i, node);
171 |             ++register_number;
172 |         }
173 |     } else {
174 |         //  Write request
175 |         emit new_register_data(0,
176 |                                SystemRegister::WRITE_REQUEST_COMPLETE,
177 |                                m_polling_thread->get_unit_id());
178 |     }
179 | 
180 |     figure_next();
181 | }
182 | 
183 | 
184 | void Scheduler::modbus_on_timer_expired()
185 | {
186 |     if (m_active) {
187 |         modbus_on_error(11);  //  Device timeout
188 |     }
189 | }
190 | 
191 | 
192 | void Scheduler::figure_next()
193 | {
194 |     if (m_active || (nullptr == m_polling_thread)) {
195 |         return;
196 |     }
197 | 
198 |     m_active = true;
199 |     PollAction next_action = PollAction::POLLING_READ;
200 |     m_current_request = nullptr;
201 |     bool emit_poll_complete = false;
202 |     bool loop;
203 |     do {
204 |         loop = false;
205 |         //  Default: read unless there's nothing to read
206 |         if (m_standard_requests.size() == 0) {
207 |             next_action = PollAction::POLLING_INACTIVE;
208 |         }
209 | 
210 |         //  Low priority: read metadata
211 |         if (m_meta_requests.size() > 0) {
212 |             next_action = PollAction::POLLING_METADATA;
213 |         }
214 | 
215 |         //  High priority: write
216 |         if (m_write_requests.size() > 0) {
217 |             next_action = PollAction::POLLING_WRITE;
218 |         }
219 | 
220 |         switch (next_action) {
221 |         case PollAction::POLLING_WRITE:
222 |             poll_write_request();
223 |             break;
224 | 
225 |         case PollAction::POLLING_METADATA:
226 |             if (!poll_meta_request()) {
227 |                 //  A window is done with polling metadata attempt a read.
228 |                 if (m_standard_requests.size() > 0) {
229 |                     next_action = PollAction::POLLING_READ;
230 |                     emit_poll_complete = poll_read_request();
231 |                 } else {
232 |                     //  Read queue is empty, scan for something else to do.
233 |                     loop = true;
234 |                 }
235 |             }
236 |             break;
237 | 
238 |         case PollAction::POLLING_READ:
239 |             emit_poll_complete = poll_read_request();
240 |             break;
241 | 
242 |         case PollAction::POLLING_DEVID:
243 |             poll_devid_request();
244 |             break;
245 | 
246 |         case PollAction::POLLING_INACTIVE:
247 | //            emit_poll_complete = true;
248 |             m_active = false;
249 |             break;
250 |         }
251 | 
252 |     } while (loop);
253 | 
254 |     m_current_action = next_action;
255 | 
256 |     if (emit_poll_complete) {
257 |         //  This function can't be reentrant.
258 |         emit polling_complete();
259 |     }
260 | }
261 | 
262 | 
263 | void Scheduler::poll_write_request()
264 | {
265 |     auto write = m_write_requests.front();
266 |     m_write_requests.pop_front();
267 |     m_current_request = write.requester;
268 |     m_polling_thread->modbus_request(write.first_register, std::move(write.values), write.node);
269 | }
270 | 
271 | 
272 | bool Scheduler::poll_meta_request()
273 | {
274 |     auto &cur = m_meta_requests.front();
275 |     auto wrapper = MetadataWrapper::get_instance();
276 |     if (wrapper->loaded() &&
277 |             (cur.current_register <= cur.last_register) &&
278 |             (nullptr != cur.requester)) {
279 |         cur.request = wrapper->create_request(cur.current_register);
280 |         const auto pdu = wrapper->encode_request(cur.request);
281 |         m_polling_thread->modbus_request(pdu.first,
282 |                                          pdu.second,
283 |                                          cur.request->function_code,
284 |                                          cur.node);
285 | 
286 |         m_current_request = cur.requester;
287 |         return true;
288 |     }
289 | 
290 |     m_meta_requests.pop_front();
291 |     return false;
292 | }
293 | 
294 | 
295 | bool Scheduler::poll_read_request()
296 | {
297 |     m_current_request = m_standard_requests.front();
298 |     m_standard_requests.pop_front();
299 |     m_current_request->poll_register_set(m_polling_thread);
300 |     return (m_standard_requests.size() == 0);
301 | }
302 | 
303 | 
304 | void Scheduler::poll_devid_request()
305 | {
306 |     m_current_request = nullptr;
307 |     m_polling_thread->modbus_request(0, 0, 0);
308 | }
309 | 
310 | 
311 | void Scheduler::poll_response_metadata()
312 | {
313 |     auto &cur = m_meta_requests.front();
314 |     cur.current_register++;
315 | 
316 |     const auto register_set = m_polling_thread->modbus_result();
317 |     const auto node = m_polling_thread->get_unit_id();
318 |     std::vector<quint8> rsp(register_set.size());
319 | 
320 |     for (auto i=register_set.begin(); register_set.end() != i; ++i) {
321 |         rsp[size_t(std::distance(register_set.begin(), i))] = quint8(*i);
322 |     }
323 | 
324 |     auto wrapper = MetadataWrapper::get_instance();
325 |     wrapper->decode_response(cur.request, rsp);
326 |     if (nullptr != cur.requester) {
327 |         cur.requester->set_metadata(cur.request, node);
328 |     }
329 | }
330 | 
331 | 
332 | QPair<quint64, quint64> Scheduler::get_counts() const
333 | {
334 |     return {m_poll_count, m_error_count};
335 | }
336 | 
337 | 
338 | bool Scheduler::get_active(BaseDialog* &requester) const
339 | {
340 |     requester = m_current_request;
341 |     return m_active;
342 | }
343 | 
344 | 
345 | void Scheduler::modbus_on_poll_meta(WindowMetadataRequest request_sequence)
346 | {
347 |     if (nullptr != m_polling_thread) {
348 |         m_meta_requests.push_back(request_sequence);
349 |         figure_next();
350 |     }
351 | }
352 | 


--------------------------------------------------------------------------------
/csv_importer.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file csv_importer.cpp
  3 |  * \brief Import CSV data interactive modal dialog.
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | 
 27 | //  c++ includes
 28 | #include <QMessageBox>  //  QMessageBox
 29 | #include <QRegExp>  //  QRegExp
 30 | #include <QTimer> //  QTimer
 31 | #include <optional>  //  std::optional
 32 | #include <algorithm>  //  std::fill
 33 | #include <unordered_set>  //  std::unordered_set
 34 | 
 35 | // C includes
 36 | /* -none- */
 37 | 
 38 | // project includes
 39 | #include "csv_importer.h"  //  local include
 40 | #include "exceptions.h"  //  AppException
 41 | 
 42 | 
 43 | namespace {
 44 |     const auto g_enabled_tint = 0xFF;
 45 |     const auto g_disabled_tint = 0xE0;
 46 |     const auto g_disabled_color = QColor(g_disabled_tint, g_disabled_tint, g_disabled_tint);
 47 |     const auto g_enabled_color = QColor(g_enabled_tint, g_enabled_tint, g_enabled_tint);
 48 |     const auto g_header_color = QColor(g_disabled_tint, g_disabled_tint, g_enabled_tint);
 49 | 
 50 | }  //  Anonymous namespace
 51 | 
 52 | 
 53 | CsvImporter::CsvImporter(QWidget *parent, const QList<QStringList> &all_data)
 54 |     : BaseDialog(parent),
 55 |       m_preview_table{new QTableWidget(7, all_data[0].size(), this)},
 56 |       m_grid_container{new QWidget(this)},
 57 |       m_control_grid{new QGridLayout(m_grid_container)},
 58 |       m_ok{new QPushButton(tr("Ok"), m_grid_container)},
 59 |       m_cancel{new QPushButton(tr("Cancel"), m_grid_container)},
 60 |       m_first_row_headers{new QCheckBox(tr("First row contains headers?"), m_grid_container)},
 61 |       m_fixed_node{new QCheckBox(tr("Use fixed node?"), m_grid_container)},
 62 |       m_node_select{new QSpinBox(m_grid_container)},
 63 |       m_test_text(size_t(all_data[0].size())),
 64 |       m_role_selection(size_t(all_data[0].size())),
 65 |       m_options{tr("Register Number"), tr("Value"), tr("Device ID/Node")},
 66 |       m_config{}
 67 | {
 68 |     for (auto i=all_data.begin(); all_data.end() != i; ++i) {
 69 |         const auto row = size_t(std::distance(all_data.begin(), i));
 70 |         if (row >= m_test_text[0].size()) {
 71 |             break;
 72 |         }
 73 | 
 74 |         for (auto j=i->begin(); i->end() != j; ++j) {
 75 |             const auto col = size_t(std::distance(i->begin(), j));
 76 |             if (col < m_test_text.size()) {
 77 |                 m_test_text[col][row] = *j;
 78 |             }
 79 |         }
 80 |     }
 81 | 
 82 |     connect(m_ok, &QPushButton::clicked, this, &CsvImporter::on_ok_clicked);
 83 |     connect(m_cancel, &QPushButton::clicked, this, &CsvImporter::close);
 84 | 
 85 |     m_node_select->setRange(0, 255);
 86 |     m_node_select->setEnabled(false);
 87 |     connect(m_first_row_headers, &QCheckBox::stateChanged, this, &CsvImporter::on_header_row_checked);
 88 |     connect(m_fixed_node, &QCheckBox::stateChanged, this, &CsvImporter::on_single_node_checked);
 89 | }
 90 | 
 91 | 
 92 | void CsvImporter::setupUi()
 93 | {
 94 |     m_top_layout->addWidget(m_preview_table);
 95 |     m_top_layout->addWidget(m_grid_container);
 96 |     m_top_layout->setSizeConstraint(QLayout::SetMinimumSize);
 97 |     m_top_layout->setContentsMargins(0, 0, 0, 0);
 98 |     setContentsMargins(0, 0, 0, 0);
 99 | 
100 |     m_preview_table->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
101 |     m_preview_table->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
102 | 
103 |     for (size_t col=0; col<m_test_text.size(); ++col) {
104 |         auto check = new QCheckBox(tr("Use Column"));
105 |         m_preview_table->setCellWidget(0, int(col), check);
106 |         connect(check, &QCheckBox::stateChanged, this, [=](int status) {
107 |             static_cast<void>(status);
108 |             on_column_checked(check, col);
109 |         });
110 | 
111 |         auto selection = new QComboBox(m_preview_table);
112 |         selection->addItems(m_options);
113 |         selection->setEnabled(false);
114 |         m_preview_table->setCellWidget(1, int(col), selection);
115 |         m_role_selection[col] = {selection, check};
116 | 
117 |         for (size_t row=0; row<m_test_text[col].size(); ++row) {
118 |             auto item = new QTableWidgetItem(m_test_text[col][row]);
119 |             item->setFlags(Qt::NoItemFlags);
120 |             item->setBackgroundColor(g_disabled_color);
121 |             item->setTextColor(QColor(0, 0, 0));
122 |             m_preview_table->setItem(int(row + 2U), int(col), item);
123 |         }
124 |     }
125 | 
126 |     m_grid_container->setLayout(m_control_grid);
127 |     m_control_grid->addWidget(m_first_row_headers, 0, 0);
128 |     m_control_grid->addWidget(m_fixed_node, 0, 1);
129 |     m_control_grid->addWidget(m_node_select, 0, 2);
130 |     m_control_grid->addWidget(m_ok, 1, 0);
131 |     add_icon_to_button(m_ok, QStyle::SP_DialogApplyButton);
132 |     m_control_grid->addWidget(m_cancel, 1, 2);
133 |     add_icon_to_button(m_cancel, QStyle::SP_DialogCloseButton);
134 |     m_preview_table->show();
135 |     m_grid_container->show();
136 |     m_preview_table->resizeColumnsToContents();
137 |     resize(477, 323);
138 |     setWindowTitle(tr("Import CSV Data"));
139 |     QTimer::singleShot(160, this, &CsvImporter::attempt_autoconfig);
140 | }
141 | 
142 | 
143 | void CsvImporter::on_column_checked(const QCheckBox *const checkbox, const size_t column)
144 | {
145 |     m_role_selection[column].first->setEnabled(checkbox->isChecked());
146 |     for (size_t i=0U; i<m_test_text[column].size(); ++i) {
147 |         auto color = g_disabled_color;
148 |         if ((0U == i) && m_first_row_headers->isChecked()) {
149 |             color = g_header_color;
150 |         } else if (checkbox->isChecked())  {
151 |             color = g_enabled_color;
152 |         } else {
153 | 
154 |         }
155 |         auto w = m_preview_table->item(int(i+2U), int(column));
156 |         w->setBackgroundColor(color);
157 |     }
158 | }
159 | 
160 | 
161 | void CsvImporter::on_ok_clicked()
162 | {
163 |     std::optional<ssize_t> node{};
164 |     std::optional<size_t> register_index{};
165 |     std::optional<size_t> value_index{};
166 |     if (m_fixed_node->isChecked()) {
167 |         auto node_val = m_node_select->value() * -1;
168 |         node = node_val - 1;
169 |     }
170 | 
171 |     QStringList error_text;
172 |     for (size_t i=0U; i<m_test_text.size(); ++i) {
173 |         if (m_role_selection[i].second->isChecked()) {
174 |             switch (m_role_selection[i].first->currentIndex()) {
175 |             case 0:
176 |                 if (register_index.has_value()) {
177 |                     error_text << tr("Duplicate register column %i").arg(i);
178 |                 } else {
179 |                     register_index = i;
180 |                 }
181 |                 break;
182 | 
183 |             case 1:
184 |                 if (value_index.has_value()) {
185 |                     error_text << tr("Duplicate value column %i").arg(i);
186 |                 } else {
187 |                     value_index = i;
188 |                 }
189 |                 break;
190 | 
191 |             case 2:
192 |                 if (node.has_value()) {
193 |                     error_text << tr("Duplicate node column %i").arg(i);
194 |                 } else {
195 |                     node = ssize_t(i);
196 |                 }
197 |                 break;
198 | 
199 |             default:
200 |                 error_text << tr("Illegal selection on row %i").arg(i);
201 |             }
202 |         }
203 |     }
204 | 
205 |     if (!register_index.has_value()) {
206 |         error_text << tr("No register column");
207 |     }
208 | 
209 |     if (!value_index.has_value()) {
210 |         error_text << tr("No value column");
211 |     }
212 | 
213 |     if (!node.has_value()) {
214 |         error_text << tr("No node");
215 |     }
216 | 
217 |     if (error_text.size() == 0) {
218 |         m_config = {register_index.value(),
219 |                     value_index.value(),
220 |                     node.value(),
221 |                     m_first_row_headers->isChecked()};
222 |         m_is_valid = true;
223 |         emit accept();
224 |     } else {
225 |         auto error_box = QMessageBox(this);
226 |         error_box.setIcon(QMessageBox::Critical);
227 |         error_box.setStandardButtons(QMessageBox::Ok);
228 |         error_box.setText(tr("Invalid import configuration specified"));
229 |         error_box.setInformativeText(tr("Import errors were reported"));
230 |         error_box.setWindowTitle(tr("Import error"));
231 |         error_box.setDetailedText(error_text.join('\n'));
232 |         error_box.exec();
233 |     }
234 | }
235 | 
236 | 
237 | void CsvImporter::on_single_node_checked(int status)
238 | {
239 |     static_cast<void>(status);
240 |     m_node_select->setEnabled(m_fixed_node->isChecked());
241 | }
242 | 
243 | 
244 | void CsvImporter::on_header_row_checked(int status)
245 | {
246 |     static_cast<void>(status);
247 |     for (size_t i=0U; i<m_test_text.size(); ++i) {
248 |         auto color = g_disabled_color;
249 |         if (m_first_row_headers->isChecked()) {
250 |             color = g_header_color;
251 |         } else if (m_role_selection[i].second->isChecked()) {
252 |             color = g_enabled_color;
253 |         } else {
254 | 
255 |         }
256 | 
257 |         auto w = m_preview_table->item(2, int(i));
258 |         w->setBackgroundColor(color);
259 |     }
260 | }
261 | 
262 | 
263 | const std::tuple<size_t, size_t, ssize_t, bool> CsvImporter::get_config() const
264 | {
265 |     if (!m_is_valid) {
266 |         throw AppException("Requested invalid configuration");
267 |     }
268 | 
269 |     return m_config;
270 | }
271 | 
272 | 
273 | void CsvImporter::attempt_autoconfig()
274 | {
275 |     auto headers_in_row = false;
276 | 
277 |     std::array<int, TestFields::HEADER_ROW> fields;
278 |     std::fill(fields.begin(), fields.end(), -1);
279 | 
280 |     size_t row = 0U;
281 |     auto re = QRegExp("\\d{1,5}");
282 | 
283 |     bool strings_in_row;
284 |     int int8_in_row;
285 |     std::vector<int> candidate_columns;
286 | 
287 |     do {
288 |         strings_in_row = false;
289 |         int8_in_row = -1;
290 |         candidate_columns.clear();
291 | 
292 |         for (size_t i=0U; i<m_test_text.size(); ++i) {
293 |             const auto &test = m_test_text[i][row];
294 |             if (re.exactMatch(test)) {
295 |                 /* Test if contents are purely numerical */
296 |                 const auto test_int = test.toInt();
297 |                 if (test_int >= 0 && test_int <= 0xFFFF) {
298 |                     candidate_columns.push_back(int(i));
299 |                     if (test_int <= 0xFF) {
300 |                         int8_in_row = int(i);
301 |                     }
302 |                 }
303 |             } else if (0 == row) {
304 |                 strings_in_row = true;
305 | 
306 |                 /* Test for known column header titles */
307 |                 const auto test_lower = test.toLower();
308 |                 if (tr("Raw Value").toLower() == test_lower) {
309 |                     //  Special case...
310 |                     fields[TestFields::REG_VALUE] = int(i);
311 |                     headers_in_row = true;
312 |                 }
313 | 
314 |                 for (auto j=0; j<m_options.size(); ++j) {
315 |                     if (m_options[j].toLower() == test_lower && fields[size_t(j)] < 0) {
316 |                         headers_in_row = true;
317 |                         fields[size_t(j)] = int(i);
318 |                         break;
319 |                     }
320 |                 }
321 |             } else {
322 |                 strings_in_row = true;
323 |             }
324 |         }
325 | 
326 |         if (!strings_in_row) {
327 |             break;
328 |         }
329 | 
330 |         if (!headers_in_row && (candidate_columns.size() >= 2U)) {
331 |             break;
332 |         }
333 |     } while (++row < 2);
334 | 
335 |     /* See if there's a good argument for assigning the node column */
336 |     if (fields[TestFields::NODE_ID] < 0 && candidate_columns.size() > 2U && int8_in_row >= 0) {
337 |         //  No known column already assigned as the node and we have at least 3
338 |         // columns with only numbers, use the last one that has a value < 256
339 |         fields[TestFields::NODE_ID] = int8_in_row;
340 |     }
341 | 
342 |     /* Now, try to assign any remaining unassigned fields */
343 |     std::unordered_set<int> used_fields;
344 |     for (auto i: fields) {
345 |         if (i >= 0) {
346 |             used_fields.insert(i);
347 |         }
348 |     }
349 |     for (auto i: candidate_columns) {
350 |         if (used_fields.find(i) == used_fields.end()) {
351 |             if (fields[TestFields::REG_NUMBER] < 0) {
352 |                 fields[TestFields::REG_NUMBER] = i;
353 |             } else if (fields[TestFields::REG_VALUE] < 0) {
354 |                 fields[TestFields::REG_VALUE] = i;
355 |             } else {
356 |                 break;
357 |             }
358 |         }
359 |     }
360 | 
361 |     /* Update controls according to what has been discovered */
362 |     if (headers_in_row || row > 0) {
363 |         m_first_row_headers->setChecked(true);
364 |     }
365 | 
366 |     if (fields[TestFields::NODE_ID] < 0) {
367 |         m_fixed_node->setChecked(true);
368 |     }
369 | 
370 |     for (auto i=0; i<m_options.size(); ++i) {
371 |         const auto column = fields[size_t(i)];
372 |         if (column >= 0) {
373 |             m_role_selection[size_t(column)].second->setChecked(true);
374 |             m_role_selection[size_t(column)].first->setCurrentIndex(i);
375 |         }
376 |     }
377 | }
378 | 


--------------------------------------------------------------------------------
/trend_window.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * \file trend_window.cpp
  3 |  * \brief Graphing / Trend support
  4 |  * \copyright
  5 |  * 2021 Andrew Buettner (ABi)
  6 |  *
  7 |  * \section LICENSE
  8 |  *
  9 |  * QModbusTool - A QT Based Modbus Client
 10 |  *
 11 |  * This program is free software; you can redistribute it and/or
 12 |  * modify it under the terms of the GNU General Public License
 13 |  * as published by the Free Software Foundation; either version 2
 14 |  * of the License, or (at your option) any later version.
 15 |  *
 16 |  * This program is distributed in the hope that it will be useful,
 17 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19 |  *  GNU General Public License for more details.
 20 |  *
 21 |  * You should have received a copy of the GNU General Public License
 22 |  * along with this program; if not, write to the Free Software
 23 |  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 24 |  */
 25 | 
 26 | 
 27 | //  c++ includes
 28 | #include <QTimer>  //  QTimer
 29 | #include <QMessageBox>  //  QMessageBox
 30 | #include <QAction>  //  QAction
 31 | #include <QFileDialog>  //  QFileDialog
 32 | #include <qtcsv/stringdata.h>  //  QtCSV::StringData
 33 | #include <qtcsv/writer.h>  //  QtCSV::Writer::write
 34 | 
 35 | // C includes
 36 | /* -none- */
 37 | 
 38 | // project includes
 39 | #include "trend_window.h"  //  local include
 40 | #include "trend_line.h"  //  TrendLine
 41 | #include "configure_trend_line.h"  //  ConfigureTrendLine
 42 | #include "configure_trend.h"  //  ConfigureTrend
 43 | 
 44 | 
 45 | using TimeDiff = std::chrono::duration<double>;
 46 | using std::chrono::steady_clock;
 47 | 
 48 | 
 49 | namespace {
 50 |     const auto g_num_points = 100;
 51 | }
 52 | 
 53 | 
 54 | TrendWindow::TrendWindow(QWidget *const parent) :
 55 |     BaseDialog(parent, false),
 56 |     m_plot{new QCustomPlot(this)},
 57 |     m_data(),
 58 |     m_timestamps(),
 59 |     m_start_time{steady_clock::now()},
 60 |     m_layout{new QHBoxLayout(this)},
 61 |     m_legend{new QGroupBox(tr("Legend:"), this)},
 62 |     m_legend_layout{new QVBoxLayout(m_legend)},
 63 |     m_button_area{new QScrollArea(m_legend)},
 64 |     m_scroll_container{new QWidget(m_button_area)},
 65 |     m_scroll_layout{new QVBoxLayout(m_scroll_container)},
 66 |     m_add_button{new QPushButton(tr("Add new\nregister"), m_scroll_container)},
 67 |     m_configure_button{new QPushButton(tr("Graph\nMenu"), m_legend)},
 68 |     m_main_menu{new QMenu(m_configure_button->text(), m_configure_button)},
 69 |     m_miny{0.0},
 70 |     m_maxy{1.0}
 71 | {
 72 |     auto timepoint = 0.0;
 73 |     for (auto i=g_num_points; i>0; --i) {
 74 |         --timepoint;
 75 |         m_timestamps.prepend(timepoint);
 76 |     }
 77 | 
 78 |     setLayout(m_layout);
 79 |     connect(m_add_button, &QPushButton::clicked, this, &TrendWindow::on_add_button_clicked);
 80 | }
 81 | 
 82 | 
 83 | void TrendWindow::setupUi()
 84 | {
 85 |     /* Configure basic window layout and top-level widgets */
 86 |     m_layout->addWidget(m_legend);
 87 |     m_legend->setLayout(m_legend_layout);
 88 |     m_legend->setFixedWidth(160);
 89 |     m_legend_layout->addSpacing(15);
 90 |     m_legend_layout->addWidget(m_configure_button);
 91 | 
 92 |     /* Menu Button and menu */
 93 |     m_configure_button->setAutoDefault(false);
 94 |     m_configure_button->setMenu(m_main_menu);
 95 |     auto configure = m_main_menu->addAction(tr("Configure Graph"));
 96 |     connect(configure, &QAction::triggered, this, &TrendWindow::on_configure_triggered);
 97 |     auto save = m_main_menu->addAction(tr("Save Data"));
 98 |     connect(save, &QAction::triggered, this, &TrendWindow::on_save_triggered);
 99 |     auto capture = m_main_menu->addAction(tr("Save Screenshot"));
100 |     connect(capture, &QAction::triggered, this, &TrendWindow::on_capture_triggered);
101 | 
102 |     /* Scrollable "Legend" containing a list of graphs */
103 |     m_legend_layout->addWidget(m_button_area);
104 |     m_button_area->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
105 |     m_button_area->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
106 |     m_button_area->setWidget(m_scroll_container);
107 |     m_scroll_container->setLayout(m_scroll_layout);
108 |     m_button_area->setFrameShape(QFrame::NoFrame);
109 |     m_button_area->setFrameRect(QRect(0, 0, 0, 0));
110 |     m_button_area->setWidgetResizable(true);
111 |     m_scroll_layout->setAlignment(Qt::AlignTop);
112 |     m_scroll_layout->addWidget(m_add_button);
113 |     m_add_button->setFixedWidth(125);
114 |     m_add_button->setDefault(true);
115 | 
116 |     /* Build the actual plot.  It must have at least 1 graph. */
117 |     m_layout->addWidget(m_plot);
118 |     m_plot->addGraph();
119 |     m_plot->xAxis->setLabel(tr("time"));
120 |     m_plot->yAxis->setLabel(tr("value"));
121 |     m_plot->setOpenGl(true);
122 | 
123 |     resize(850, 340);
124 | 
125 |     setWindowTitle(tr("Trend"));
126 | }
127 | 
128 | 
129 | void TrendWindow::on_new_value(const quint16 reg,
130 |                                const quint16 value,
131 |                                const quint8 unit_id)
132 | {
133 |     auto graph_inst = m_data.find(get_key(reg, unit_id));
134 |     if (m_data.end() != graph_inst) {
135 |         graph_inst->second->set_data(value);
136 |         scan();
137 |     }
138 | }
139 | 
140 | 
141 | void TrendWindow::redraw_graph()
142 | {
143 |     auto time = m_timestamps.begin();
144 |     const auto start_time = *time;
145 |     const auto graph_size = m_timestamps.size();
146 |     auto end_time = std::numeric_limits<double>::max();
147 | 
148 |     QVector<double> x(graph_size);
149 |     for (auto i=0; i < graph_size; ++i) {
150 |         end_time = *time;
151 |         x[i] = end_time;
152 |         ++time;
153 |     }
154 | 
155 |     QVector<double> y(graph_size, 0.0);
156 |     auto graph = 0;
157 | 
158 |     for (const auto &line: m_data) {
159 |         for (auto i=0; i<graph_size; ++i) {
160 |             y[i] = (*line.second)[i];
161 |         }
162 |         m_plot->graph(graph)->setData(x, y, true);
163 |         m_plot->graph(graph)->setPen(QPen(*line.second));
164 |         ++graph;
165 |     }
166 | 
167 |     if (0 == graph) {
168 |         m_plot->graph(0)->setData(x, y, true);
169 |     }
170 | 
171 |     m_plot->xAxis->setRange(start_time, end_time);
172 |     m_plot->yAxis->setRange(m_miny, m_maxy);
173 |     m_plot->replot();
174 | }
175 | 
176 | 
177 | void TrendWindow::scan()
178 | {
179 |     for (const auto &i: m_data) {
180 |         if (!bool(*(i.second))) {
181 |             return;
182 |         }
183 |     }
184 | 
185 |     const TimeDiff diff = steady_clock::now() - m_start_time;
186 |     m_timestamps.removeFirst();
187 |     m_timestamps.append(diff.count());
188 | 
189 |     for (auto &i: m_data) {
190 |         i.second->update();
191 |     }
192 | 
193 |     redraw_graph();
194 | }
195 | 
196 | 
197 | quint32 TrendWindow::get_key(const quint16 reg, const quint8 node) const noexcept
198 | {
199 |     return (quint32(node) << 16U) | quint32(reg);
200 | }
201 | 
202 | 
203 | void TrendWindow::add_trend(TrendLine *const trend)
204 | {
205 |     m_data[quint32(*trend)] = trend;
206 |     if (size_t(m_plot->graphCount()) < m_data.size()) {
207 |         m_plot->addGraph();
208 |     }
209 | 
210 |     auto w = m_scroll_layout->count();
211 |     m_scroll_layout->insertWidget(w - 1, trend);
212 | 
213 |     redraw_graph();
214 | }
215 | 
216 | 
217 | void TrendWindow::on_add_button_clicked()
218 | {
219 |     auto dlg = ConfigureTrendLine(this);
220 |     if (dlg.exec() != 0) {
221 |         auto key = quint32(dlg);
222 |         const auto trend = m_data.find(key);
223 |         if (m_data.end() != trend) {
224 |             auto error_box = QMessageBox(this);
225 |             error_box.setIcon(QMessageBox::Critical);
226 |             error_box.setStandardButtons(QMessageBox::Ok);
227 |             error_box.setText(tr("Error"));
228 |             error_box.setWindowTitle(tr("Invalid Configuration"));
229 |             error_box.setInformativeText(tr("Duplicate trend requested.\n"
230 |                                             "Edit trend instead"));
231 |             error_box.setDetailedText(tr("Register: %1\nRemote Node: %2")
232 |                                       .arg(trend->second->m_reg_number)
233 |                                       .arg(trend->second->m_device_id));
234 |             error_box.exec();
235 |         } else {
236 |             add_trend(dlg.create_trend());
237 |         }
238 |     }
239 | }
240 | 
241 | 
242 | void TrendWindow::remove_trend(const quint32 trend_key)
243 | {
244 |     auto trend_index = m_data.find(trend_key);
245 |     auto trend = trend_index->second;
246 |     m_data.erase(trend_index);
247 |     m_scroll_layout->removeWidget(trend);
248 |     const auto graph_count = m_plot->graphCount();
249 |     if (graph_count > 1) {
250 |         m_plot->removeGraph(graph_count - 1);
251 |     }
252 | 
253 |     redraw_graph();
254 | 
255 |     //  Don't let it happen until the next entry into the scheduler as the
256 |     // instance is probably in our call path.
257 |     emit trend->deleteLater();
258 | }
259 | 
260 | 
261 | void TrendWindow::on_configure_triggered()
262 | {
263 |     auto dlg = ConfigureTrend(this, m_miny, m_maxy, m_timestamps.size());
264 |     if (dlg.exec() != 0) {
265 |         m_fixed_limits = bool(dlg);
266 | 
267 |         const auto limits = dlg.get_min_max();
268 |         m_miny = limits.first;
269 |         m_maxy = limits.second;
270 | 
271 |         const auto points = dlg.get_num_points();
272 |         if (points.has_value()) {
273 |             resize_history(points.value());
274 |         }
275 |     }
276 | }
277 | 
278 | 
279 | void TrendWindow::on_save_triggered()
280 | {
281 |     auto dialog = QFileDialog(this, tr("Save data as..."));
282 |     dialog.setNameFilters({tr("Spreadsheet (*.csv)"),
283 |                            tr("All files (*)")});
284 |     dialog.setAcceptMode(QFileDialog::AcceptSave);
285 |     dialog.setViewMode(QFileDialog::Detail);
286 |     dialog.setFileMode(QFileDialog::AnyFile);
287 |     dialog.setDefaultSuffix("csv");
288 |     if (dialog.exec() != 0) {
289 |         auto file_name = dialog.selectedFiles().first();
290 |         if (!save_register_set(file_name)) {
291 |             QMessageBox::warning(this, tr("Save history"),
292 |                                  tr("Cannot write file %1:\n.")
293 |                                  .arg(QDir::toNativeSeparators(file_name)));
294 |         }
295 |     }
296 | }
297 | 
298 | 
299 | void TrendWindow::on_capture_triggered()
300 | {
301 |     auto dialog = QFileDialog(this, tr("Save image as..."));
302 |     dialog.setNameFilters({tr("PNG (*.png)"),
303 |                            tr("JPG (*.jpg)"),
304 |                            tr("BMP (*.bmp)")});
305 |     dialog.setAcceptMode(QFileDialog::AcceptSave);
306 |     dialog.setViewMode(QFileDialog::Detail);
307 |     dialog.setFileMode(QFileDialog::AnyFile);
308 |     dialog.setDefaultSuffix("png");
309 |     if (dialog.exec() != 0) {
310 |         auto file_name = dialog.selectedFiles().first();
311 |         const auto ext = file_name.split(".").back().toLower();
312 |         auto status = true;
313 |         if (ext == "png") {
314 |             status = m_plot->savePng(file_name);
315 |         } else if (ext == "jpg") {
316 |             status = m_plot->saveJpg(file_name);
317 |         } else if (ext == "bmp") {
318 |             status = m_plot->saveBmp(file_name);
319 |         } else {
320 |             QMessageBox::warning(this, tr("Save Image"),
321 |                                  tr("Unknown extension: %1")
322 |                                  .arg(ext));
323 |         }
324 | 
325 |         if (!status) {
326 |             QMessageBox::warning(this, tr("Save Image"),
327 |                                  tr("Error saving image: %1")
328 |                                  .arg(QDir::toNativeSeparators(file_name)));
329 |         }
330 |     }
331 | }
332 | 
333 | 
334 | void TrendWindow::update_min_max(const double value) noexcept
335 | {
336 |     if (!m_fixed_limits) {
337 |         if (value > m_maxy) {
338 |             m_maxy = value;
339 |         } else if (value < m_miny) {
340 |             m_miny = value;
341 |         } else {
342 | 
343 |         }
344 |     }
345 | }
346 | 
347 | 
348 | bool TrendWindow::save_register_set(const QString &path)
349 | {
350 |     QStringList header;
351 |     header << tr("Register number") << tr("Device ID/Node") << tr("Line Color");
352 | 
353 |     for (const auto i: m_timestamps) {
354 |         header << QString::number(i);
355 |     }
356 |     QtCSV::StringData csv_data;
357 |     csv_data.addRow(header);
358 | 
359 |     for (const auto &i: m_data) {
360 |         QStringList row;
361 |         row << QString::number(i.second->m_reg_number)
362 |             << QString::number(i.second->m_device_id)
363 |             << QPen(*(i.second)).color().name();
364 | 
365 | 
366 |         for (auto index=0; index<m_timestamps.size(); ++index) {
367 |             row << QString::number((*(i.second))[index]);
368 |         }
369 |         csv_data.addRow(row);
370 |     }
371 | 
372 |     return QtCSV::Writer::write(path, csv_data);
373 | }
374 | 
375 | 
376 | QDomElement TrendWindow::save_configuration(QDomDocument &root) const
377 | {
378 |     auto trend = root.createElement("trend");
379 |     const auto position = pos();
380 |     const auto w_size = size();
381 |     trend.setAttribute("w", QString::number(w_size.width()));
382 |     trend.setAttribute("h", QString::number(w_size.height()));
383 |     trend.setAttribute("x", QString::number(position.x()));
384 |     trend.setAttribute("y", QString::number(position.y()));
385 |     trend.setAttribute("min", QString::number(m_miny));
386 |     trend.setAttribute("max", QString::number(m_maxy));
387 |     trend.setAttribute("fixed", QString::number(int(m_fixed_limits)));
388 |     trend.setAttribute("points", QString::number(m_timestamps.size()));
389 | 
390 |     for (const auto &i: m_data) {
391 |         auto line = root.createElement("trend_line");
392 |         i.second->save_configuration(line);
393 |         trend.appendChild(line);
394 |     }
395 | 
396 |     return trend;
397 | }
398 | 
399 | 
400 | bool TrendWindow::load_configuration(const QDomElement &node)
401 | {
402 |     if (m_data.size() > 0) {
403 |         return false;
404 |     }
405 | 
406 |     bool okmin, okmax;
407 |     const auto w = node.attribute("w", "-1").toInt();
408 |     const auto h = node.attribute("h", "-1").toInt();
409 |     const auto points = node.attribute("points", "-1").toInt();
410 |     const auto fixed = node.attribute("fixed", "-1").toInt();
411 |     const auto x = node.attribute("x", "");
412 |     const auto y = node.attribute("y", "");
413 |     const auto min = node.attribute("min", "[bad]").toDouble(&okmin);
414 |     const auto max = node.attribute("max", "[bad]").toDouble(&okmax);
415 | 
416 |     if ((w <= 0) || (h <= 0) || (points <= 0) || (fixed < 0) ||
417 |             (x.size() == 0) || (y.size() == 0) || !okmin || !okmax) {
418 |         return false;
419 |     }
420 | 
421 |     resize_history(points, false);
422 |     m_fixed_limits = bool(fixed);
423 |     m_miny = min;
424 |     m_maxy = max;
425 | 
426 |     QVector<TrendLine*> new_lines;
427 |     const auto &children = node.childNodes();
428 |     new_lines.reserve(children.count());
429 |     for (auto i=0; i<children.count(); ++i) {
430 |         const auto &node = children.at(i);
431 |         if (node.isElement() && node.nodeName() == "trend_line") {
432 |             const auto &element = node.toElement();
433 | 
434 |             const auto reg = element.attribute("register", "-1").toInt();
435 |             const auto node = element.attribute("node", "-1").toInt();
436 |             const auto is_signed = element.attribute("signed", "-1").toInt();
437 |             bool okm, okb;
438 |             const auto m = element.attribute("m", "[bad]").toDouble(&okm);
439 |             const auto b = element.attribute("b", "[bad]").toDouble(&okb);
440 |             const auto color = QColor(element.attribute("color", "[bad]"));
441 | 
442 |             if ((reg < 1) || (node < 0) || (is_signed < 0) || !okm || !okb) {
443 |                 return false;
444 |             }
445 | 
446 |             auto line = new TrendLine(this, quint16(reg), quint8(node));
447 |             new_lines.append(line);
448 | 
449 |             line->configure(m, b, bool(is_signed));
450 |             line->set_color(color);
451 |         }
452 |     }
453 | 
454 |     QTimer::singleShot(160, this, [=]() {
455 |         resize(w, h);
456 |         move(x.toInt(), y.toInt());
457 |         for (auto i: new_lines) {
458 |             add_trend(i);
459 |         }
460 |     });
461 | 
462 |     return true;
463 | }
464 | 
465 | 
466 | void TrendWindow::resize_history(const int points, bool redraw)
467 | {
468 |     while (m_timestamps.size() > points) {
469 |         m_timestamps.removeFirst();
470 |     }
471 | 
472 |     auto earliest = m_timestamps.first();
473 |     while (m_timestamps.size() < points) {
474 |         --earliest;
475 |         m_timestamps.prepend(earliest);
476 |     }
477 | 
478 |     for (auto &i: m_data) {
479 |         i.second->resize(points);
480 |     }
481 | 
482 |     if (redraw) {
483 |         redraw_graph();
484 |     }
485 | }
486 | 


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