add serialpackage

BrainATUMtome/BrainATUMtome.pro

@@ -4,7 +4,7 @@
 #
 #-------------------------------------------------
 
-QT       += core gui
+QT       += core gui serialport
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
@@ -30,14 +30,18 @@ SOURCES += \
     eventlog.cpp \
     epos.cpp \
     microtome.cpp \
-    syringe.cpp
+    syringe.cpp \
+    serialport.cpp \
+    serialpackage.cpp
 
 HEADERS += \
         mainwindow.h \
     eventlog.h \
     epos.h \
     microtome.h \
-    syringe.h
+    syringe.h \
+    serialport.h \
+    serialpackage.h
 
 FORMS += \
         mainwindow.ui

BrainATUMtome/mainwindow.cpp

@@ -41,7 +41,7 @@ MainWindow::~MainWindow()
 void MainWindow::configure_epos()
 {
     if (m_settings->value("epos/deviceName").isNull()) {
-        ui->widget_board->on_log(EventLogType::Warn, "Settings :: failed to parse INI file " + m_settings->fileName());
+        ui->widget_board->on_log(EventLogType::Warn, "Settings :: failed to parse Epos settings in configuration file " + m_settings->fileName());
         return;
     }
     QString portLower = m_settings->value("epos/portLower", "USB0").toString();
@@ -51,10 +51,10 @@ void MainWindow::configure_epos()
     QString interfaceName = m_settings->value("epos/interfaceName", "USB").toString();
 
     m_driverEpos = new Epos(this);
+    connect(m_driverEpos, &Epos::log, ui->widget_board, &EventLog::on_log);
     m_driverEpos->open(EPOS_MOTORID_LOWER, deviceName, protocolStackName, interfaceName, portLower);
     m_driverEpos->open(EPOS_MOTORID_UPPER, deviceName, protocolStackName, interfaceName, portUpper);
 
-    connect(m_driverEpos, &Epos::log, ui->widget_board, &EventLog::on_log);
     connect(this, &MainWindow::uirequest_epos_velocity, m_driverEpos, &Epos::on_uirequest_velocity);
     connect(this, &MainWindow::uirequest_epos_tension, m_driverEpos, &Epos::on_uirequest_tension);
 
@@ -91,8 +91,18 @@ void MainWindow::configure_epos()
 
 void MainWindow::configure_microtome()
 {
+    if (m_settings->value("microtome/deviceName").isNull()) {
+        ui->widget_board->on_log(EventLogType::Warn, "Settings :: failed to parse microtome settings in configuration file " + m_settings->fileName());
+        return;
+    }
+
+    QString portName = m_settings->value("microtome/port", "COM2").toString();
+    int baudRate = m_settings->value("microtome/baudRate", 19200).toInt();
+
     m_driverMicrotome = new Microtome(this);
     connect(m_driverMicrotome, &Microtome::log, ui->widget_board, &EventLog::on_log);
+    m_driverMicrotome->open(portName, baudRate);
+
     connect(this, &MainWindow::uirequest_microtome_cuttingMotor, m_driverMicrotome, &Microtome::on_uirequest_cuttingMotor);
     connect(this, &MainWindow::uirequest_microtome_cuttingSpeed, m_driverMicrotome, &Microtome::on_uirequest_cuttingSpeed);
     connect(this, &MainWindow::uirequest_microtome_returnSpeed, m_driverMicrotome, &Microtome::on_uirequest_returnSpeed);
@@ -104,8 +114,18 @@ void MainWindow::configure_microtome()
 
 void MainWindow::configure_syringe()
 {
+    if (m_settings->value("syringe/deviceName").isNull()) {
+        ui->widget_board->on_log(EventLogType::Warn, "Settings :: failed to parse syringe settings in configuration file " + m_settings->fileName());
+        return;
+    }
+
+    QString portName = m_settings->value("syringe/port", "COM6").toString();
+    int baudRate = m_settings->value("syringe/baudRate", 9600).toInt();
+
     m_driverSyringe = new Syringe(this);
     connect(m_driverSyringe, &Syringe::log, ui->widget_board, &EventLog::on_log);
+    m_driverSyringe->open(portName, baudRate);
+
     connect(this, &MainWindow::uirequest_syringe_pump, m_driverSyringe, &Syringe::on_uirequest_pump);
     connect(this, &MainWindow::uirequest_syringe_auto, m_driverSyringe, &Syringe::on_uirequest_auto);
 }

BrainATUMtome/mainwindow.ui

@@ -448,7 +448,10 @@
          <item row="0" column="0">
           <widget class="QLabel" name="label_viewer_frame">
            <property name="text">
-            <string>FRAME</string>
+            <string>CAMERA</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignCenter</set>
            </property>
           </widget>
          </item>

BrainATUMtome/microtome.cpp

@@ -1,11 +1,30 @@
 #include "microtome.h"
 
-Microtome::Microtome(QObject *parent) : QObject(parent)
+Microtome::Microtome(QObject *parent) : QObject(parent),
+    m_serialPort(nullptr)
+{
+    m_serialPackage = new SerialPackage(this);
+    m_serialPackage->test();
+}
+
+
+Microtome::~Microtome()
 {
 
 }
 
 
+void Microtome::open(const QString &portName, int baudRate)
+{
+    m_serialPort = new SerialPort(this);
+    connect(m_serialPort, &SerialPort::log,
+            [this](EventLogType type, const QString &message) {
+                emit log(type, "Microtome :: " + message);
+            }
+    );
+    m_serialPort->open(portName, baudRate);
+}
+
 void Microtome::on_uirequest_cuttingMotor(bool state)
 {
     QString textState = (state) ? "on" : "off";

BrainATUMtome/microtome.h

@@ -4,13 +4,22 @@
 #include <QObject>
 
 #include "eventlog.h"
+#include "serialport.h"
+#include "serialpackage.h"
 
 class Microtome : public QObject
 {
     Q_OBJECT
 
 public:
     explicit Microtome(QObject *parent = nullptr);
+    ~Microtome();
+
+    void open(const QString &portName, int baudRate);
+
+private:
+    SerialPort *m_serialPort;
+    SerialPackage *m_serialPackage;
 
 public slots:
     void on_uirequest_cuttingMotor(bool state);

BrainATUMtome/serialpackage.cpp

@@ -0,0 +1,133 @@
+#include "serialpackage.h"
+
+SerialPackage::SerialPackage(QObject *parent) : QObject(parent)
+{
+
+}
+
+SerialPackage::~SerialPackage()
+{
+
+}
+
+
+void SerialPackage::test()
+{
+    setAddress(0xCA);
+    setCommand(0xFC);
+
+    qDebug() << m_buffer;
+    qDebug() << address();
+    qDebug() << command();
+    qDebug() << checksum();
+}
+
+
+quint8 SerialPackage::address()
+{
+   return unpack(0);
+}
+
+quint8 SerialPackage::command()
+{
+    return unpack(2);
+}
+
+quint8 SerialPackage::checksum()
+{
+    return unpack(m_buffer.size() - 2);
+}
+
+
+
+void SerialPackage::setAddress(quint8 value)
+{
+    pack(value, 0);
+}
+
+
+void SerialPackage::setCommand(quint8 value)
+{
+    pack(value, 2);
+}
+
+
+
+void SerialPackage::unpack(quint8 &value, int index)
+{
+    value = static_cast<quint8>(QString("%1%2").arg(m_buffer.mid(index, 1), m_buffer.mid(index + 1, 1)).toUInt(nullptr, 16));
+}
+
+
+
+
+void SerialPackage::pack(quint8 value, int index)
+{
+    QString textValue = QString("%1").arg(value, 2, 16, QChar('0')).toUpper();
+    m_buffer.replace(index, 2, textValue);
+}
+
+
+void SerialPackage::pack(quint16 value, int index)
+{
+    QString textValue = QString("%1").arg(value, 4, 16, QChar('0')).toUpper();
+    m_buffer.replace(index, 4, textValue);
+}
+
+
+void SerialPackage::pack(quint32 value, int index)
+{
+    QString textValue = QString("%1").arg(value, 8, 16, QChar('0')).toUpper();
+    m_buffer.replace(index, 8, textValue);
+}
+
+
+
+
+bool SerialPackage::parse(const QByteArray &package)
+{
+    // clean message
+    QString message(package);
+
+    message = message.simplified();
+
+    if (message.at(0) == '!')
+        message.remove(0, 1);
+
+
+
+    // check package size
+    if ((message.size() < SIZE_PACKAGE_MINIMUM) || (message.size() >= SIZE_PACKAGE_BUFFER))
+    {
+        emit log(EventLogType::Warn,
+                 "SerialPackage:: package size " +
+                  QString::number(message.size()) +
+                  " is outside package range [ " +
+                  QString::number(SIZE_PACKAGE_MINIMUM) +
+                  ", " +
+                  QString::number(SIZE_PACKAGE_BUFFER) +
+                  ") bytes.");
+        return false;
+    }
+
+    // check for even size
+    if ((message.size() % 2) != 0)
+    {
+        emit log(EventLogType::Warn,
+                 "SerialPackage:: package size " +
+                  QString::number(message.size()) +
+                  " is not even. Package is truncated.");
+        return false;
+    }
+
+    // get received checksum
+    quint8 checksumReceived = static_cast<quint8>(QString("%1%2").arg(message.mid(message.size() - 2, 1), m_buffer.mid(message.size() - 1, 1)).toUInt(nullptr, 16));
+    message.remove(message.size() - 2, 2);
+    m_buffer = message;
+
+    return (checksumReceived == checksum());
+}
+
+
+
+

BrainATUMtome/serialpackage.h

@@ -0,0 +1,53 @@
+#ifndef SERIALPACKAGE_H
+#define SERIALPACKAGE_H
+
+#include <QObject>
+#include <QDebug>
+
+#include "eventlog.h"
+
+class SerialPackage : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit SerialPackage(QObject *parent = nullptr);
+    ~SerialPackage();
+
+    bool parse(const QByteArray &package);
+
+    void test();
+    quint8 address();
+    quint8 command();
+    quint8 checksum();
+
+    void setAddress(quint8 value);
+    void setCommand(quint8 value);
+
+    void push(quint8 value);
+    void push(quint16 value);
+    void push(quint32 value);
+
+    void pop(quint8 &value);
+    void pop(quint16 &value);
+    void pop(quint32 &value);
+
+private:
+    QString m_buffer;
+
+    void unpack(quint8 &value, int index);
+    void unpack(quint16 &value, int index);
+    void unpack(quint32 &value, int index);
+    void pack(quint8 value, int index);
+    void pack(quint16 value, int index);
+    void pack(quint32 value, int index);
+
+    static const qint8 SIZE_PACKAGE_MINIMUM = 6;
+    static const qint8 SIZE_PACKAGE_BUFFER = 64;
+
+signals:
+    void log(EventLogType type, const QString &message);
+
+};
+
+#endif // SERIALPACKAGE_H