Exception Whose occur stop socat is solved

Servo/Servo.pro

@@ -25,7 +25,6 @@ SOURCES += \
 
 HEADERS += \
     $$files(*.h, true) \
-    include/ExpConfig.h
 
 
 INCLUDEPATH += $$PWD/include

Servo/include/ModbusMaster.h

@@ -20,6 +20,7 @@ class ModbusMaster : public QObject
 
 private:
 	bool _initialized = false;
+    bool _connected = false;
 	QModbusClient* _modbusDevice = nullptr;
 	int _clientAddress;
 	QModbusDataUnit _modbusReplyUnit;
@@ -36,7 +37,8 @@ public:
 	void writeRequest(QModbusDataUnit::RegisterType registerType,
 					  int startAddress,
 					  quint16 writeSize);
-	void close();
+
+
 
 //uncrustify off
 public	slots:
@@ -44,6 +46,7 @@ public	slots:
 	void init(ExpConfig& expConfig);
 	void connectToDevice(ModbusConfig modbusConfig, ExpConfig& expConfig);
 	void connectionStateChanged(QModbusDevice::State state);
+    bool getConnectionState();
 
 	QBitArray getCoil(int startAddress, quint16 readSize, ExpConfig& expConfig);
 	QBitArray getInputCoil(int startAddress, quint16 readSize, ExpConfig& expConfig);
@@ -60,6 +63,8 @@ public	slots:
 							 quint16 writeSize,
 							 QVector<quint16> registerValues,
 							 ExpConfig& expConfig);
+
+    void close();
 };
 
 #endif //MODBUSMASTER_H

Servo/include/ModbusWrapper.h

@@ -21,7 +21,7 @@ public:
 	~ModbusWrapper();
 	void connectToDevice(ModbusConfig modbusConfig);
 	void init();
-
+    void close();
 	QBitArray getCoil(int startAddress, quint16 readSize);
 	QBitArray getInputCoil(int startAddress, quint16 readSize);
 	QVector<quint16> getHoldingRegister(int startAddress, quint16 readSize);
@@ -31,10 +31,12 @@ public:
 	void setMultipleCoil(int startAddress, quint16 writeSize, QBitArray coilFlags);
 	void setSingleRegister(int startAddress, quint16 registerValue);
 	void setMultipleRegister(int startAddress, quint16 writeSize, QVector<quint16> registerValues);
-
+    bool getStatus();
 signals:
 	void connectOrder(ModbusConfig modbusConfig, ExpConfig& expConfig);
 	void initOrder(ExpConfig& expConfig);
+    void closeOrder();
+    bool getConnectionStateOrder();
 
 	QBitArray getCoilOrder(int startAddress, quint16 readSize, ExpConfig& expConfig);
 	QBitArray getInputCoilOrder(int startAddress, quint16 readSize, ExpConfig& expConfig);

Servo/include/ServoController.h

@@ -48,6 +48,8 @@ public:
 	double getAngleOffset();
 	void setAngleOffset(double offset);
 	double getAzimuth();
+
+    bool getStatus();
 };
 
 #endif //SERVOCONTROLLER_H

Servo/src/ModbusMaster.cpp

@@ -2,9 +2,10 @@
 
 #include <QModbusRtuSerialMaster>
 #include <QEventLoop>
-
+#include <QThread>
 ModbusMaster::ModbusMaster(QObject* parent) : QObject(parent)
 {
+
 }
 
 /*************************************************************************************************/
@@ -18,7 +19,8 @@ void ModbusMaster::init(ExpConfig& expConfig)
 
             connect(_modbusDevice, &QModbusClient::errorOccurred, [this](QModbusDevice::Error)
             {
-				throw ServoException(_modbusDevice->errorString());
+                _initialized = false;
+                connectionStateChanged(QModbusDevice::UnconnectedState);
             });
 
             connect(_modbusDevice,
@@ -44,9 +46,14 @@ void ModbusMaster::init(ExpConfig& expConfig)
 /*************************************************************************************************/
 void ModbusMaster::connectionStateChanged(QModbusDevice::State state)
 {
+
     if(state == QModbusDevice::UnconnectedState)
     {
-		throw ServoException("Connection wasnt prepared");
+        _connected = false;
+    }
+    else if (state == QModbusDevice::ConnectedState)
+    {
+        _connected = true;
     }
 }
 
@@ -108,6 +115,7 @@ QBitArray ModbusMaster::getCoil(int startAddress, quint16 readSize, ExpConfig& e
     {
         expConfig.valid = true;
         expConfig.message = ex.getMessage();
+        return QBitArray();
     }
 }
 
@@ -136,6 +144,7 @@ QBitArray ModbusMaster::getInputCoil(int startAddress, quint16 readSize, ExpConf
     {
         expConfig.valid = true;
         expConfig.message = ex.getMessage();
+        return QBitArray();
     }
 }
 
@@ -164,6 +173,7 @@ QVector<quint16> ModbusMaster::getHoldingRegister(int startAddress,
     {
         expConfig.valid = true;
         expConfig.message = ex.getMessage();
+        return QVector<quint16>();
     }
 }
 
@@ -192,6 +202,7 @@ QVector<quint16> ModbusMaster::getInputRegister(int startAddress,
     {
         expConfig.valid = true;
         expConfig.message = ex.getMessage();
+        return QVector<quint16>();
     }
 }
 
@@ -306,16 +317,20 @@ void ModbusMaster::readRequest(QModbusDataUnit::RegisterType registerType,
 void ModbusMaster::checkForError(QModbusReply* _reply)
 {
     if(_reply->error() == QModbusDevice::NoError)
+    {
+        _connected = true;
         return;
-
+    }
     if(_reply->error() == QModbusDevice::ProtocolError)
     {
-		throw ServoException(QString("Read response error: %1 (Mobus exception: %2)")
+        _connected = false;
+        throw ServoException(QString("Read response error: %1 (Modbus exception: %2)")
                              .arg(_reply->errorString())
                              .arg(_reply->rawResult().exceptionCode()));
     }
     else
     {
+        _connected = false;
         throw ServoException(QString("Read response error: %1 (code: %2)")
                              .arg(_reply->errorString())
                              .arg(_reply->error()));
@@ -361,9 +376,23 @@ void ModbusMaster::writeRequest(QModbusDataUnit::RegisterType registerType,
     }
 }
 
+/*************************************************************************************************/
+bool ModbusMaster::getConnectionState()
+{
+    return _connected;
+}
+
+/*************************************************************************************************/
 void ModbusMaster::close()
 {
+    _initialized = false;
     if(_modbusDevice)
+    {
+        if (_modbusDevice->state() == QModbusDevice::ConnectedState || _modbusDevice->state() == QModbusDevice::ConnectingState)
+        {
             _modbusDevice->disconnectDevice();
+        }
         delete _modbusDevice;
+        _modbusDevice = nullptr;
+    }
 }

Servo/src/ModbusWrapper.cpp

@@ -23,6 +23,11 @@ void ModbusWrapper::init()
     connect(&_workerThread, &QThread::started, &loop, &QEventLoop::quit);
     loop.exec();
 
+    connect(this,
+            &ModbusWrapper::getConnectionStateOrder,
+            &_modbusMaster,
+            &ModbusMaster::getConnectionState,
+            Qt::BlockingQueuedConnection);
     connect(this,
             &ModbusWrapper::initOrder,
             &_modbusMaster,
@@ -74,6 +79,11 @@ void ModbusWrapper::init()
             &_modbusMaster,
             &ModbusMaster::setMultipleRegister,
             Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::closeOrder,
+            &_modbusMaster,
+            &ModbusMaster::close,
+            Qt::BlockingQueuedConnection);
 
     ExpConfig exp;
     emit initOrder(exp);
@@ -83,6 +93,68 @@ void ModbusWrapper::init()
     }
 }
 
+/*************************************************************************************************/
+void ModbusWrapper::close()
+{ 
+
+    if (_workerThread.isRunning())
+    {
+        emit closeOrder();
+        _workerThread.quit();
+        _workerThread.wait();
+        disconnect(this,
+                &ModbusWrapper::getConnectionStateOrder,
+                &_modbusMaster,
+                &ModbusMaster::getConnectionState);
+        disconnect(this,
+                &ModbusWrapper::initOrder,
+                &_modbusMaster,
+                &ModbusMaster::init);
+        disconnect(this,
+                &ModbusWrapper::connectOrder,
+                &_modbusMaster,
+                &ModbusMaster::connectToDevice);
+        disconnect(this,
+                &ModbusWrapper::getCoilOrder,
+                &_modbusMaster,
+                &ModbusMaster::getCoil);
+        disconnect(this,
+                &ModbusWrapper::getInputCoilOrder,
+                &_modbusMaster,
+                &ModbusMaster::getInputCoil);
+        disconnect(this,
+                &ModbusWrapper::getHoldingRegisterOrder,
+                &_modbusMaster,
+                &ModbusMaster::getHoldingRegister);
+        disconnect(this,
+                &ModbusWrapper::getInputRegisterOrder,
+                &_modbusMaster,
+                &ModbusMaster::getInputRegister);
+
+        disconnect(this,
+                &ModbusWrapper::setSingleCoilOrder,
+                &_modbusMaster,
+                &ModbusMaster::setSingleCoil);
+        disconnect(this,
+                &ModbusWrapper::setMultipleCoilOrder,
+                &_modbusMaster,
+                &ModbusMaster::setMultipleCoil);
+        disconnect(this,
+                &ModbusWrapper::setSingleRegisterOrder,
+                &_modbusMaster,
+                &ModbusMaster::setSingleRegister);
+        disconnect(this,
+                &ModbusWrapper::setMultipleRegisterOrder,
+                &_modbusMaster,
+                &ModbusMaster::setMultipleRegister);
+        disconnect(this,
+                &ModbusWrapper::closeOrder,
+                &_modbusMaster,
+                &ModbusMaster::close);
+    }
+
+}
+
 /*************************************************************************************************/
 QBitArray ModbusWrapper::getCoil(int startAddress, quint16 readSize)
 {
@@ -182,6 +254,12 @@ void ModbusWrapper::setMultipleRegister(int startAddress,
     }
 }
 
+/*************************************************************************************************/
+bool ModbusWrapper::getStatus()
+{
+    return  emit getConnectionStateOrder();
+}
+
 /*************************************************************************************************/
 void ModbusWrapper::connectToDevice(ModbusConfig modbusConfig)
 {

Servo/src/ServoController.cpp

@@ -73,6 +73,7 @@ void ServoController::changeMode(double startAngle, double stopAngle, double spe
 /*************************************************************************************************/
 void ServoController::init(QString serialPort)
 {
+    _modbusWrapper.close();
     _modbusWrapper.init();
     _modbusWrapper.connectToDevice(initiateConfig(serialPort));
 }
@@ -155,3 +156,9 @@ double ServoController::getAzimuth()
 
     return (azimuthVector[0] / SRV_ANGLE_FACTOR);
 }
+
+/*************************************************************************************************/
+bool ServoController::getStatus()
+{
+   return _modbusWrapper.getStatus();
+}

Test/MainWindow.cpp

@@ -1,5 +1,6 @@
 #include "MainWindow.h"
 #include "ui_MainWindow.h"
+#include "QtConcurrent/QtConcurrent"
 
 MainWindow::MainWindow(QWidget* parent)
     : QMainWindow(parent)
@@ -17,7 +18,6 @@ MainWindow::MainWindow(QWidget* parent)
 MainWindow::~MainWindow()
 {
     delete ui;
-	timer->stop();
 }
 
 /*************************************************************************************************/
@@ -196,11 +196,9 @@ void MainWindow::on_writeMultiRegister_clicked()
 void MainWindow::on_init_clicked()
 {
     try {
+        ui->showServoError->setText("");
         _servoControler.init(ui->serialPortServo->text());
-		timer = new QTimer();
-		timer->setInterval(1000);
-		timer->start();
-		connect(timer, &QTimer::timeout, this, &MainWindow::handleGetRequestFromServo);
+        QtConcurrent::run(this,&MainWindow::handleGetRequestFromServo);
     }
     catch(ServoException exp)
     {
@@ -210,6 +208,8 @@ void MainWindow::on_init_clicked()
 
 /*************************************************************************************************/
 void MainWindow::handleGetRequestFromServo()
+{
+    while(1)
     {
         try {
             ui->showSpeed->setText(QString::number(_servoControler.getSpeed()));
@@ -217,11 +217,16 @@ void MainWindow::handleGetRequestFromServo()
             ui->showStopAngle->setText(QString::number(_servoControler.getStopAngle()));
             ui->showAngleOffset->setText(QString::number(_servoControler.getAngleOffset()));
             ui->showAzimuth->setText(QString::number(_servoControler.getAzimuth()));
+            ui->showServoError->setText("");
+            QThread::sleep(2);
         }
         catch(ServoException exp)
         {
             ui->showServoError->setText(exp.getMessage());
         }
+        auto currentstatus=_servoControler.getStatus();
+        ui->connectionState->setText(QVariant(currentstatus).toString());
+    }
 }
 
 /*************************************************************************************************/

Test/MainWindow.ui

@@ -621,6 +621,40 @@ background-color: rgb(186, 178, 158);</string>
         </rect>
        </property>
       </widget>
+      <widget class="QLabel" name="label_18">
+       <property name="geometry">
+        <rect>
+         <x>180</x>
+         <y>0</y>
+         <width>181</width>
+         <height>17</height>
+        </rect>
+       </property>
+       <property name="text">
+        <string>Connection State to Client:</string>
+       </property>
+      </widget>
+      <widget class="QLabel" name="connectionState">
+       <property name="geometry">
+        <rect>
+         <x>370</x>
+         <y>0</y>
+         <width>121</width>
+         <height>20</height>
+        </rect>
+       </property>
+       <property name="styleSheet">
+        <string notr="true">background-color: rgb(52, 101, 164);
+color: rgb(238, 238, 236);
+</string>
+       </property>
+       <property name="text">
+        <string/>
+       </property>
+       <property name="margin">
+        <number>0</number>
+       </property>
+      </widget>
      </widget>
      <widget class="QGroupBox" name="groupBox_12">
       <property name="geometry">
@@ -923,7 +957,7 @@ color: rgb(238, 238, 236);
 background-color: rgb(186, 178, 158);</string>
        </property>
        <property name="text">
-        <string>Error Monitoring</string>
+        <string/>
        </property>
        <property name="wordWrap">
         <bool>true</bool>

Test/main.cpp

@@ -15,18 +15,18 @@ public:
 	}
 
 	//reimplemented from QApplication so we can throw exceptions in slots
-	virtual bool notify(QObject* receiver, QEvent* event) {
-		try {
-			return QApplication::notify(receiver, event);
-		}
-		catch(std::exception& e)
-		{
-			qDebug() << "e exception " << e.what();
-			;
-		}
+//	virtual bool notify(QObject* receiver, QEvent* event) {
+//		try {
+//			return QApplication::notify(receiver, event);
+//		}
+//		catch(std::exception& e)
+//		{
+//			qDebug() << "e exception " << e.what();
+//			;
+//		}
 
-		return false;
-	}
+//		return false;
+//	}
 };
 
 int main(int argc, char* argv[]) {