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

@@ -11,14 +11,14 @@ private:
 	const int SRV_START_ANGLE_INT_PART_REG = 2000;
 	const int SRV_STOP_ANGLE_INT_PART_REG = 2001;
 	const int SRV_AZIMUTH_SPEED_REG = 2002;
-	const int SRV_APPLY_SETTING_REG = 2004;
-	const int SRV_START_STOP_REG = 2005;
-	const int SRV_ZERO_OFFSET_ANGLE = 2007;
-	const int SRV_START_ANGLE_FRAC_PART_REG = 2010;
-	const int SRV_STOP_ANGLE_FRAC_PART_REG = 2011;
-	const int SRV_CALIBRATE_REG = 2013;
-	const int SRV_ENABLE_DRIVE_REG = 2017;
-	const int SRV_AZIMUTH_REG = 2030;
+    const int SRV_APPLY_SETTING_REG = 2004;
+    const int SRV_START_STOP_REG = 2005;
+    const int SRV_ZERO_OFFSET_ANGLE = 2007;
+    const int SRV_START_ANGLE_FRAC_PART_REG = 2010;
+    const int SRV_STOP_ANGLE_FRAC_PART_REG = 2011;
+    const int SRV_CALIBRATE_REG = 2013;
+    const int SRV_ENABLE_DRIVE_REG = 2017;
+    const int SRV_AZIMUTH_REG = 2030;
 
 	const double SRV_ANGLE_FACTOR = 100.0;
 	const double SRV_SPEED_FACTOR = 1000.0;
@@ -48,6 +48,8 @@ public:
 	double getAngleOffset();
 	void setAngleOffset(double offset);
 	double getAzimuth();
+
+    bool getStatus();
 };
 
 #endif //SERVOCONTROLLER_H

Servo/src/ModbusMaster.cpp

@@ -2,368 +2,397 @@
 
 #include <QModbusRtuSerialMaster>
 #include <QEventLoop>
-
+#include <QThread>
 ModbusMaster::ModbusMaster(QObject* parent) : QObject(parent)
 {
+
 }
 
 /*************************************************************************************************/
 void ModbusMaster::init(ExpConfig& expConfig)
 {
-	try {
-		if(!_initialized)
-		{
-			_modbusDevice = nullptr;
-			_modbusDevice = new QModbusRtuSerialMaster(this);
-
-			connect(_modbusDevice, &QModbusClient::errorOccurred, [this](QModbusDevice::Error)
-			{
-				throw ServoException(_modbusDevice->errorString());
-			});
-
-			connect(_modbusDevice,
-					&QModbusClient::stateChanged,
-					this,
-					&ModbusMaster::connectionStateChanged);
-
-			_initialized = true;
-		}
-		else
-		{
-			throw ServoException(
-					  "Modbus Device Object Created Before First Delete it Then Make New One");
-		}
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try {
+        if(!_initialized)
+        {
+            _modbusDevice = nullptr;
+            _modbusDevice = new QModbusRtuSerialMaster(this);
+
+            connect(_modbusDevice, &QModbusClient::errorOccurred, [this](QModbusDevice::Error)
+            {
+                _initialized = false;
+                connectionStateChanged(QModbusDevice::UnconnectedState);
+            });
+
+            connect(_modbusDevice,
+                    &QModbusClient::stateChanged,
+                    this,
+                    &ModbusMaster::connectionStateChanged);
+
+            _initialized = true;
+        }
+        else
+        {
+            throw ServoException(
+                        "Modbus Device Object Created Before First Delete it Then Make New One");
+        }
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::connectionStateChanged(QModbusDevice::State state)
 {
-	if(state == QModbusDevice::UnconnectedState)
-	{
-		throw ServoException("Connection wasnt prepared");
-	}
+
+    if(state == QModbusDevice::UnconnectedState)
+    {
+        _connected = false;
+    }
+    else if (state == QModbusDevice::ConnectedState)
+    {
+        _connected = true;
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::connectToDevice(ModbusConfig modbusConfig, ExpConfig& expConfig)
 {
-	try {
-		if(_modbusDevice->state() != QModbusDevice::ConnectedState)
-		{
-			_clientAddress = modbusConfig.clientAddress;
-			_modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter,
-												  modbusConfig.serialPort);
-			_modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter,
-												  modbusConfig.parity);
-			_modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter,
-												  modbusConfig.baud);
-			_modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter,
-												  modbusConfig.dataBits);
-			_modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter,
-												  modbusConfig.stopBits);
-			_modbusDevice->setTimeout(modbusConfig.responseTime);
-
-
-			if(!_modbusDevice->connectDevice())
-			{
-				throw ServoException(_modbusDevice->errorString());
-			}
-		}
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try {
+        if(_modbusDevice->state() != QModbusDevice::ConnectedState)
+        {
+            _clientAddress = modbusConfig.clientAddress;
+            _modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter,
+                                                  modbusConfig.serialPort);
+            _modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter,
+                                                  modbusConfig.parity);
+            _modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter,
+                                                  modbusConfig.baud);
+            _modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter,
+                                                  modbusConfig.dataBits);
+            _modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter,
+                                                  modbusConfig.stopBits);
+            _modbusDevice->setTimeout(modbusConfig.responseTime);
+
+
+            if(!_modbusDevice->connectDevice())
+            {
+                throw ServoException(_modbusDevice->errorString());
+            }
+        }
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+    }
 }
 
 /*************************************************************************************************/
 QBitArray ModbusMaster::getCoil(int startAddress, quint16 readSize, ExpConfig& expConfig)
 {
-	try
-	{
-		readRequest(QModbusDataUnit::RegisterType::Coils, startAddress, readSize);
-		auto unit = _modbusReplyUnit;
-
-		QBitArray coils;
-		auto num = unit.valueCount();
-		coils.resize(static_cast<int>(num));
-		for(uint i = 0; i < num; i++)
-		{
-			if(unit.value(static_cast<int>(i)) == 1)
-				coils.setBit(static_cast<int>(i));
-			else
-				coils.clearBit(static_cast<int>(i));
-		}
-
-		return coils;
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        readRequest(QModbusDataUnit::RegisterType::Coils, startAddress, readSize);
+        auto unit = _modbusReplyUnit;
+
+        QBitArray coils;
+        auto num = unit.valueCount();
+        coils.resize(static_cast<int>(num));
+        for(uint i = 0; i < num; i++)
+        {
+            if(unit.value(static_cast<int>(i)) == 1)
+                coils.setBit(static_cast<int>(i));
+            else
+                coils.clearBit(static_cast<int>(i));
+        }
+
+        return coils;
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+        return QBitArray();
+    }
 }
 
 /*************************************************************************************************/
 QBitArray ModbusMaster::getInputCoil(int startAddress, quint16 readSize, ExpConfig& expConfig)
 {
-	try
-	{
-		readRequest(QModbusDataUnit::RegisterType::DiscreteInputs, startAddress, readSize);
-		auto unit = _modbusReplyUnit;
-
-		QBitArray coils;
-		auto num = unit.valueCount();
-		coils.resize(static_cast<int>(num));
-		for(uint i = 0; i < num; i++)
-		{
-			if(unit.value(static_cast<int>(i)) == 1)
-				coils.setBit(static_cast<int>(i));
-			else
-				coils.clearBit(static_cast<int>(i));
-		}
-
-		return coils;
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        readRequest(QModbusDataUnit::RegisterType::DiscreteInputs, startAddress, readSize);
+        auto unit = _modbusReplyUnit;
+
+        QBitArray coils;
+        auto num = unit.valueCount();
+        coils.resize(static_cast<int>(num));
+        for(uint i = 0; i < num; i++)
+        {
+            if(unit.value(static_cast<int>(i)) == 1)
+                coils.setBit(static_cast<int>(i));
+            else
+                coils.clearBit(static_cast<int>(i));
+        }
+
+        return coils;
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+        return QBitArray();
+    }
 }
 
 /*************************************************************************************************/
 QVector<quint16> ModbusMaster::getHoldingRegister(int startAddress,
-												  quint16 readSize,
-												  ExpConfig& expConfig)
+                                                  quint16 readSize,
+                                                  ExpConfig& expConfig)
 {
-	try
-	{
-		readRequest(QModbusDataUnit::RegisterType::HoldingRegisters, startAddress, readSize);
-		auto unit = _modbusReplyUnit;
-
-		QVector<quint16> registerValues;
-		auto num = unit.valueCount();
-		registerValues.resize(static_cast<int>(num));
-
-		for(uint i = 0; i < unit.valueCount(); i++)
-		{
-			registerValues[static_cast<int>(i)] = unit.value(static_cast<int>(i));
-		}
-
-		return registerValues;
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        readRequest(QModbusDataUnit::RegisterType::HoldingRegisters, startAddress, readSize);
+        auto unit = _modbusReplyUnit;
+
+        QVector<quint16> registerValues;
+        auto num = unit.valueCount();
+        registerValues.resize(static_cast<int>(num));
+
+        for(uint i = 0; i < unit.valueCount(); i++)
+        {
+            registerValues[static_cast<int>(i)] = unit.value(static_cast<int>(i));
+        }
+
+        return registerValues;
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+        return QVector<quint16>();
+    }
 }
 
 /*************************************************************************************************/
 QVector<quint16> ModbusMaster::getInputRegister(int startAddress,
-												quint16 readSize,
-												ExpConfig& expConfig)
+                                                quint16 readSize,
+                                                ExpConfig& expConfig)
 {
-	try
-	{
-		readRequest(QModbusDataUnit::RegisterType::InputRegisters, startAddress, readSize);
-		auto unit = _modbusReplyUnit;
-
-		QVector<quint16> registerValues;
-		auto num = unit.valueCount();
-		registerValues.resize(static_cast<int>(num));
-
-		for(uint i = 0; i < unit.valueCount(); i++)
-		{
-			registerValues[static_cast<int>(i)] = unit.value(static_cast<int>(i));
-		}
-
-		return registerValues;
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        readRequest(QModbusDataUnit::RegisterType::InputRegisters, startAddress, readSize);
+        auto unit = _modbusReplyUnit;
+
+        QVector<quint16> registerValues;
+        auto num = unit.valueCount();
+        registerValues.resize(static_cast<int>(num));
+
+        for(uint i = 0; i < unit.valueCount(); i++)
+        {
+            registerValues[static_cast<int>(i)] = unit.value(static_cast<int>(i));
+        }
+
+        return registerValues;
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+        return QVector<quint16>();
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::setSingleCoil(int startAddress, bool coilFlag, ExpConfig& expConfig)
 {
-	try
-	{
-		_coilsToWrite.resize(1);
-
-		if(coilFlag)
-			_coilsToWrite.setBit(0);
-		else
-			_coilsToWrite.clearBit(0);
-
-		writeRequest(QModbusDataUnit::RegisterType::Coils, startAddress, 1);
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        _coilsToWrite.resize(1);
+
+        if(coilFlag)
+            _coilsToWrite.setBit(0);
+        else
+            _coilsToWrite.clearBit(0);
+
+        writeRequest(QModbusDataUnit::RegisterType::Coils, startAddress, 1);
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::setMultipleCoil(int startAddress,
-								   quint16 writeSize,
-								   QBitArray coilFlags,
-								   ExpConfig& expConfig)
+                                   quint16 writeSize,
+                                   QBitArray coilFlags,
+                                   ExpConfig& expConfig)
 {
-	try
-	{
-		_coilsToWrite = coilFlags;
-		writeRequest(QModbusDataUnit::RegisterType::Coils, startAddress, writeSize);
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        _coilsToWrite = coilFlags;
+        writeRequest(QModbusDataUnit::RegisterType::Coils, startAddress, writeSize);
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::setSingleRegister(int startAddress, quint16 registerValue, ExpConfig& expConfig)
 {
-	try
-	{
-		_RegistersToWrite.resize(1);
-		_RegistersToWrite[0] = registerValue;
-		writeRequest(QModbusDataUnit::RegisterType::HoldingRegisters, startAddress, 1);
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        _RegistersToWrite.resize(1);
+        _RegistersToWrite[0] = registerValue;
+        writeRequest(QModbusDataUnit::RegisterType::HoldingRegisters, startAddress, 1);
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::setMultipleRegister(int startAddress,
-									   quint16 writeSize,
-									   QVector<quint16> registerValues, ExpConfig& expConfig)
+                                       quint16 writeSize,
+                                       QVector<quint16> registerValues, ExpConfig& expConfig)
 {
-	try
-	{
-		_RegistersToWrite = registerValues;
-		writeRequest(QModbusDataUnit::RegisterType::HoldingRegisters, startAddress, writeSize);
-	}
-	catch(const ServoException& ex)
-	{
-		expConfig.valid = true;
-		expConfig.message = ex.getMessage();
-	}
+    try
+    {
+        _RegistersToWrite = registerValues;
+        writeRequest(QModbusDataUnit::RegisterType::HoldingRegisters, startAddress, writeSize);
+    }
+    catch(const ServoException& ex)
+    {
+        expConfig.valid = true;
+        expConfig.message = ex.getMessage();
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::readRequest(QModbusDataUnit::RegisterType registerType,
-							   int startAddress,
-							   quint16 readSize)
+                               int startAddress,
+                               quint16 readSize)
 {
-	auto table = registerType;
-
-	auto reply = _modbusDevice->sendReadRequest(QModbusDataUnit(table, startAddress, readSize),
-												_clientAddress);
-	if(reply)
-	{
-		if(!reply->isFinished())
-		{
-			QEventLoop loop;
-			connect(reply,
-					&QModbusReply::finished,
-					&loop,
-					&QEventLoop::quit
-					);
-			loop.exec();
-
-			checkForError(reply);
-			_modbusReplyUnit = reply->result();
-
-			reply->deleteLater();
-		}
-		else
-			delete reply; //broadcast replies return immediately
-	}
-	else
-	{
-		throw ServoException(_modbusDevice->errorString());
-	}
+    auto table = registerType;
+
+    auto reply = _modbusDevice->sendReadRequest(QModbusDataUnit(table, startAddress, readSize),
+                                                _clientAddress);
+    if(reply)
+    {
+        if(!reply->isFinished())
+        {
+            QEventLoop loop;
+            connect(reply,
+                    &QModbusReply::finished,
+                    &loop,
+                    &QEventLoop::quit
+                    );
+            loop.exec();
+
+            checkForError(reply);
+            _modbusReplyUnit = reply->result();
+
+            reply->deleteLater();
+        }
+        else
+            delete reply; //broadcast replies return immediately
+    }
+    else
+    {
+        throw ServoException(_modbusDevice->errorString());
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::checkForError(QModbusReply* _reply)
 {
-	if(_reply->error() == QModbusDevice::NoError)
-		return;
-
-	if(_reply->error() == QModbusDevice::ProtocolError)
-	{
-		throw ServoException(QString("Read response error: %1 (Mobus exception: %2)")
-							 .arg(_reply->errorString())
-							 .arg(_reply->rawResult().exceptionCode()));
-	}
-	else
-	{
-		throw ServoException(QString("Read response error: %1 (code: %2)")
-							 .arg(_reply->errorString())
-							 .arg(_reply->error()));
-	}
+    if(_reply->error() == QModbusDevice::NoError)
+    {
+        _connected = true;
+        return;
+    }
+    if(_reply->error() == QModbusDevice::ProtocolError)
+    {
+        _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()));
+    }
 }
 
 /*************************************************************************************************/
 void ModbusMaster::writeRequest(QModbusDataUnit::RegisterType registerType,
-								int startAddress,
-								quint16 writeSize)
+                                int startAddress,
+                                quint16 writeSize)
+{
+    auto table = registerType;
+    QModbusDataUnit writeUnit = QModbusDataUnit(table, startAddress, writeSize);
+    for(int i = 0; i < writeUnit.valueCount(); i++)
+    {
+        if(table == QModbusDataUnit::Coils)
+            writeUnit.setValue(i, _coilsToWrite[i]);
+        else
+            writeUnit.setValue(i, _RegistersToWrite[i]);
+    }
+
+    if(auto* reply = _modbusDevice->sendWriteRequest(writeUnit, _clientAddress))
+    {
+        if(!reply->isFinished())
+        {
+            QEventLoop loop;
+            connect(reply, &QModbusReply::finished, &loop,
+                    &QEventLoop::quit
+                    );
+            loop.exec();
+
+            checkForError(reply);
+            _modbusReplyUnit = reply->result();
+
+            reply->deleteLater();
+        }
+        else
+            delete reply; //broadcast replies return immediately
+    }
+    else
+    {
+        throw ServoException(_modbusDevice->errorString());
+    }
+}
+
+/*************************************************************************************************/
+bool ModbusMaster::getConnectionState()
 {
-	auto table = registerType;
-	QModbusDataUnit writeUnit = QModbusDataUnit(table, startAddress, writeSize);
-	for(int i = 0; i < writeUnit.valueCount(); i++)
-	{
-		if(table == QModbusDataUnit::Coils)
-			writeUnit.setValue(i, _coilsToWrite[i]);
-		else
-			writeUnit.setValue(i, _RegistersToWrite[i]);
-	}
-
-	if(auto* reply = _modbusDevice->sendWriteRequest(writeUnit, _clientAddress))
-	{
-		if(!reply->isFinished())
-		{
-			QEventLoop loop;
-			connect(reply, &QModbusReply::finished, &loop,
-					&QEventLoop::quit
-					);
-			loop.exec();
-
-			checkForError(reply);
-			_modbusReplyUnit = reply->result();
-
-			reply->deleteLater();
-		}
-		else
-			delete reply; //broadcast replies return immediately
-	}
-	else
-	{
-		throw ServoException(_modbusDevice->errorString());
-	}
+    return _connected;
 }
 
+/*************************************************************************************************/
 void ModbusMaster::close()
 {
-	if(_modbusDevice)
-		_modbusDevice->disconnectDevice();
-	delete _modbusDevice;
+    _initialized = false;
+    if(_modbusDevice)
+    {
+        if (_modbusDevice->state() == QModbusDevice::ConnectedState || _modbusDevice->state() == QModbusDevice::ConnectingState)
+        {
+            _modbusDevice->disconnectDevice();
+        }
+        delete _modbusDevice;
+        _modbusDevice = nullptr;
+    }
 }

Servo/src/ModbusWrapper.cpp

@@ -8,187 +8,265 @@ ModbusWrapper::ModbusWrapper(QObject* parent) : QObject(parent)
 /*************************************************************************************************/
 ModbusWrapper::~ModbusWrapper()
 {
-	_workerThread.quit();
-	_workerThread.wait();
+    _workerThread.quit();
+    _workerThread.wait();
 }
 
 /*************************************************************************************************/
 void ModbusWrapper::init()
 {
-	_modbusMaster.moveToThread(&_workerThread);
-	_workerThread.setObjectName("workerThread");
-	_workerThread.start();
-
-	QEventLoop loop;
-	connect(&_workerThread, &QThread::started, &loop, &QEventLoop::quit);
-	loop.exec();
-
-	connect(this,
-			&ModbusWrapper::initOrder,
-			&_modbusMaster,
-			&ModbusMaster::init,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::connectOrder,
-			&_modbusMaster,
-			&ModbusMaster::connectToDevice,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::getCoilOrder,
-			&_modbusMaster,
-			&ModbusMaster::getCoil,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::getInputCoilOrder,
-			&_modbusMaster,
-			&ModbusMaster::getInputCoil,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::getHoldingRegisterOrder,
-			&_modbusMaster,
-			&ModbusMaster::getHoldingRegister,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::getInputRegisterOrder,
-			&_modbusMaster,
-			&ModbusMaster::getInputRegister,
-			Qt::BlockingQueuedConnection);
-
-	connect(this,
-			&ModbusWrapper::setSingleCoilOrder,
-			&_modbusMaster,
-			&ModbusMaster::setSingleCoil,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::setMultipleCoilOrder,
-			&_modbusMaster,
-			&ModbusMaster::setMultipleCoil,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::setSingleRegisterOrder,
-			&_modbusMaster,
-			&ModbusMaster::setSingleRegister,
-			Qt::BlockingQueuedConnection);
-	connect(this,
-			&ModbusWrapper::setMultipleRegisterOrder,
-			&_modbusMaster,
-			&ModbusMaster::setMultipleRegister,
-			Qt::BlockingQueuedConnection);
-
-	ExpConfig exp;
-	emit initOrder(exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
+    _modbusMaster.moveToThread(&_workerThread);
+    _workerThread.setObjectName("workerThread");
+    _workerThread.start();
+
+    QEventLoop loop;
+    connect(&_workerThread, &QThread::started, &loop, &QEventLoop::quit);
+    loop.exec();
+
+    connect(this,
+            &ModbusWrapper::getConnectionStateOrder,
+            &_modbusMaster,
+            &ModbusMaster::getConnectionState,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::initOrder,
+            &_modbusMaster,
+            &ModbusMaster::init,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::connectOrder,
+            &_modbusMaster,
+            &ModbusMaster::connectToDevice,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::getCoilOrder,
+            &_modbusMaster,
+            &ModbusMaster::getCoil,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::getInputCoilOrder,
+            &_modbusMaster,
+            &ModbusMaster::getInputCoil,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::getHoldingRegisterOrder,
+            &_modbusMaster,
+            &ModbusMaster::getHoldingRegister,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::getInputRegisterOrder,
+            &_modbusMaster,
+            &ModbusMaster::getInputRegister,
+            Qt::BlockingQueuedConnection);
+
+    connect(this,
+            &ModbusWrapper::setSingleCoilOrder,
+            &_modbusMaster,
+            &ModbusMaster::setSingleCoil,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::setMultipleCoilOrder,
+            &_modbusMaster,
+            &ModbusMaster::setMultipleCoil,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::setSingleRegisterOrder,
+            &_modbusMaster,
+            &ModbusMaster::setSingleRegister,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::setMultipleRegisterOrder,
+            &_modbusMaster,
+            &ModbusMaster::setMultipleRegister,
+            Qt::BlockingQueuedConnection);
+    connect(this,
+            &ModbusWrapper::closeOrder,
+            &_modbusMaster,
+            &ModbusMaster::close,
+            Qt::BlockingQueuedConnection);
+
+    ExpConfig exp;
+    emit initOrder(exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
+}
+
+/*************************************************************************************************/
+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)
 {
-	ExpConfig exp;
-	auto ret = emit getCoilOrder(startAddress, readSize, exp);
+    ExpConfig exp;
+    auto ret = emit getCoilOrder(startAddress, readSize, exp);
 
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
 
-	return ret;
+    return ret;
 }
 
 /*************************************************************************************************/
 QBitArray ModbusWrapper::getInputCoil(int startAddress, quint16 readSize)
 {
-	ExpConfig exp;
-	auto ret = emit getInputCoilOrder(startAddress, readSize, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
-
-	return ret;
+    ExpConfig exp;
+    auto ret = emit getInputCoilOrder(startAddress, readSize, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
+
+    return ret;
 }
 
 /*************************************************************************************************/
 QVector<quint16> ModbusWrapper::getHoldingRegister(int startAddress, quint16 readSize)
 {
-	ExpConfig exp;
-	auto ret = emit getHoldingRegisterOrder(startAddress, readSize, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
-
-	return ret;
+    ExpConfig exp;
+    auto ret = emit getHoldingRegisterOrder(startAddress, readSize, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
+
+    return ret;
 }
 
 /*************************************************************************************************/
 QVector<quint16> ModbusWrapper::getInputRegister(int startAddress, quint16 readSize)
 {
-	ExpConfig exp;
-	auto ret = emit getInputRegisterOrder(startAddress, readSize, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
-
-	return ret;
+    ExpConfig exp;
+    auto ret = emit getInputRegisterOrder(startAddress, readSize, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
+
+    return ret;
 }
 
 /*************************************************************************************************/
 void ModbusWrapper::setSingleCoil(int startAddress, bool coilFlag)
 {
-	ExpConfig exp;
-	emit setSingleCoilOrder(startAddress, coilFlag, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
+    ExpConfig exp;
+    emit setSingleCoilOrder(startAddress, coilFlag, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
 }
 
 /*************************************************************************************************/
 void ModbusWrapper::setMultipleCoil(int startAddress, quint16 writeSize, QBitArray coilFlags)
 {
-	ExpConfig exp;
-	emit setMultipleCoilOrder(startAddress, writeSize, coilFlags, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
+    ExpConfig exp;
+    emit setMultipleCoilOrder(startAddress, writeSize, coilFlags, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
 }
 
 /*************************************************************************************************/
 void ModbusWrapper::setSingleRegister(int startAddress, quint16 registerValue)
 {
-	ExpConfig exp;
-	emit setSingleRegisterOrder(startAddress, registerValue, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
+    ExpConfig exp;
+    emit setSingleRegisterOrder(startAddress, registerValue, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
 }
 
 /*************************************************************************************************/
 void ModbusWrapper::setMultipleRegister(int startAddress,
-										quint16 writeSize,
-										QVector<quint16> registerValues)
+                                        quint16 writeSize,
+                                        QVector<quint16> registerValues)
+{
+    ExpConfig exp;
+    emit setMultipleRegisterOrder(startAddress, writeSize, registerValues, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
+}
+
+/*************************************************************************************************/
+bool ModbusWrapper::getStatus()
 {
-	ExpConfig exp;
-	emit setMultipleRegisterOrder(startAddress, writeSize, registerValues, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
+    return  emit getConnectionStateOrder();
 }
 
 /*************************************************************************************************/
 void ModbusWrapper::connectToDevice(ModbusConfig modbusConfig)
 {
-	ExpConfig exp;
-	emit connectOrder(modbusConfig, exp);
-	if(exp.valid)
-	{
-		throw ServoException(exp.message);
-	}
+    ExpConfig exp;
+    emit connectOrder(modbusConfig, exp);
+    if(exp.valid)
+    {
+        throw ServoException(exp.message);
+    }
 }

Servo/src/ServoController.cpp

@@ -2,156 +2,163 @@
 
 ModbusConfig ServoController::initiateConfig(QString serialPort)
 {
-	ModbusConfig _config;
-	_config.baud = QSerialPort::Baud19200;
-	_config.parity = QSerialPort::EvenParity;
-	_config.dataBits = QSerialPort::Data8;
-	_config.stopBits = QSerialPort::OneStop;
-	_config.responseTime = 2000;
-	_config.serialPort = serialPort;
-	_config.clientAddress = 1;
+    ModbusConfig _config;
+    _config.baud = QSerialPort::Baud19200;
+    _config.parity = QSerialPort::EvenParity;
+    _config.dataBits = QSerialPort::Data8;
+    _config.stopBits = QSerialPort::OneStop;
+    _config.responseTime = 2000;
+    _config.serialPort = serialPort;
+    _config.clientAddress = 1;
 
-	return _config;
+    return _config;
 }
 
 /*************************************************************************************************/
 void ServoController::apply()
 {
-	_modbusWrapper.setSingleRegister(SRV_APPLY_SETTING_REG, SRV_APPLY_SETTING_VAL);
+    _modbusWrapper.setSingleRegister(SRV_APPLY_SETTING_REG, SRV_APPLY_SETTING_VAL);
 }
 
 /*************************************************************************************************/
 void ServoController::enableDrive()
 {
-	_modbusWrapper.setSingleRegister(SRV_ENABLE_DRIVE_REG, 3);
-	apply();
+    _modbusWrapper.setSingleRegister(SRV_ENABLE_DRIVE_REG, 3);
+    apply();
 }
 
 /*************************************************************************************************/
 void ServoController::setStartStop(bool start)
 {
-	_modbusWrapper.setSingleRegister(SRV_START_STOP_REG, start ? 3 : 0);
-	apply();
+    _modbusWrapper.setSingleRegister(SRV_START_STOP_REG, start ? 3 : 0);
+    apply();
 }
 
 /*************************************************************************************************/
 void ServoController::setStartAngle(double angle)
 {
-	_modbusWrapper.setSingleRegister(SRV_START_ANGLE_INT_PART_REG, static_cast<quint16>(angle));
-	_modbusWrapper.setSingleRegister(SRV_START_ANGLE_FRAC_PART_REG,
-									 static_cast<quint16>((angle - (static_cast<int>(angle))) *
-														  100));
+    _modbusWrapper.setSingleRegister(SRV_START_ANGLE_INT_PART_REG, static_cast<quint16>(angle));
+    _modbusWrapper.setSingleRegister(SRV_START_ANGLE_FRAC_PART_REG,
+                                     static_cast<quint16>((angle - (static_cast<int>(angle))) *
+                                                          100));
 }
 
 /*************************************************************************************************/
 void ServoController::setStopAngle(double angle)
 {
-	_modbusWrapper.setSingleRegister(SRV_STOP_ANGLE_INT_PART_REG, static_cast<quint16>(angle));
-	_modbusWrapper.setSingleRegister(SRV_STOP_ANGLE_FRAC_PART_REG,
-									 static_cast<quint16>((angle - (static_cast<int>(angle))) *
-														  100));
+    _modbusWrapper.setSingleRegister(SRV_STOP_ANGLE_INT_PART_REG, static_cast<quint16>(angle));
+    _modbusWrapper.setSingleRegister(SRV_STOP_ANGLE_FRAC_PART_REG,
+                                     static_cast<quint16>((angle - (static_cast<int>(angle))) *
+                                                          100));
 }
 
 /*************************************************************************************************/
 void ServoController::setSpeed(double speed)
 {
-	_modbusWrapper.setSingleRegister(SRV_AZIMUTH_SPEED_REG,
-									 static_cast<quint16>(speed * SRV_SPEED_FACTOR));
+    _modbusWrapper.setSingleRegister(SRV_AZIMUTH_SPEED_REG,
+                                     static_cast<quint16>(speed * SRV_SPEED_FACTOR));
 }
 
 /*************************************************************************************************/
 void ServoController::changeMode(double startAngle, double stopAngle, double speed)
 {
-	setStartAngle(startAngle);
-	setStopAngle(stopAngle);
-	setSpeed(speed);
-	setStartStop(true);
-	enableDrive();
-	apply();
+    setStartAngle(startAngle);
+    setStopAngle(stopAngle);
+    setSpeed(speed);
+    setStartStop(true);
+    enableDrive();
+    apply();
 }
 
 /*************************************************************************************************/
 void ServoController::init(QString serialPort)
 {
-	_modbusWrapper.init();
-	_modbusWrapper.connectToDevice(initiateConfig(serialPort));
+    _modbusWrapper.close();
+    _modbusWrapper.init();
+    _modbusWrapper.connectToDevice(initiateConfig(serialPort));
 }
 
 /*************************************************************************************************/
 void ServoController::startMoving()
 {
-	setStartStop(true);
+    setStartStop(true);
 }
 
 /*************************************************************************************************/
 void ServoController::stopMoving()
 {
-	setStartStop(false);
+    setStartStop(false);
 }
 
 /*************************************************************************************************/
 void ServoController::resetAzimuth()
 {
-	_modbusWrapper.setSingleRegister(SRV_CALIBRATE_REG, SRV_CALIBRATION_VAL);
+    _modbusWrapper.setSingleRegister(SRV_CALIBRATE_REG, SRV_CALIBRATION_VAL);
 }
 
 /*************************************************************************************************/
 void ServoController::fix(double angle)
 {
-	changeMode(angle, angle, 5 / 6.0);
+    changeMode(angle, angle, 5 / 6.0);
 }
 
 /*************************************************************************************************/
 void ServoController::sector(double startAngle, double stopAngle, double speed)
 {
-	changeMode(startAngle, stopAngle, speed);
+    changeMode(startAngle, stopAngle, speed);
 }
 
 /*************************************************************************************************/
 double ServoController::getSpeed()
 {
-	auto speedVector = _modbusWrapper.getHoldingRegister(SRV_AZIMUTH_SPEED_REG, 1);
+    auto speedVector = _modbusWrapper.getHoldingRegister(SRV_AZIMUTH_SPEED_REG, 1);
 
-	return (speedVector[0] / SRV_SPEED_FACTOR);
+    return (speedVector[0] / SRV_SPEED_FACTOR);
 }
 
 /*************************************************************************************************/
 double ServoController::getStopAngle()
 {
-	auto speedVector1 = _modbusWrapper.getHoldingRegister(SRV_STOP_ANGLE_INT_PART_REG, 1);
-	auto speedVector2 = _modbusWrapper.getHoldingRegister(SRV_STOP_ANGLE_FRAC_PART_REG, 1);
+    auto speedVector1 = _modbusWrapper.getHoldingRegister(SRV_STOP_ANGLE_INT_PART_REG, 1);
+    auto speedVector2 = _modbusWrapper.getHoldingRegister(SRV_STOP_ANGLE_FRAC_PART_REG, 1);
 
-	return (speedVector1[0] + speedVector2[0] / SRV_ANGLE_FACTOR);
+    return (speedVector1[0] + speedVector2[0] / SRV_ANGLE_FACTOR);
 }
 
 /*************************************************************************************************/
 double ServoController::getStartAngle()
 {
-	auto speedVector1 = _modbusWrapper.getHoldingRegister(SRV_START_ANGLE_INT_PART_REG, 1);
-	auto speedVector2 = _modbusWrapper.getHoldingRegister(SRV_START_ANGLE_FRAC_PART_REG, 1);
+    auto speedVector1 = _modbusWrapper.getHoldingRegister(SRV_START_ANGLE_INT_PART_REG, 1);
+    auto speedVector2 = _modbusWrapper.getHoldingRegister(SRV_START_ANGLE_FRAC_PART_REG, 1);
 
-	return (speedVector1[0] + speedVector2[0] / SRV_ANGLE_FACTOR);
+    return (speedVector1[0] + speedVector2[0] / SRV_ANGLE_FACTOR);
 }
 
 /*************************************************************************************************/
 double ServoController::getAngleOffset()
 {
-	auto angleOffsetVector = _modbusWrapper.getHoldingRegister(SRV_ZERO_OFFSET_ANGLE, 1);
+    auto angleOffsetVector = _modbusWrapper.getHoldingRegister(SRV_ZERO_OFFSET_ANGLE, 1);
 
-	return (angleOffsetVector[0] / SRV_ANGLE_FACTOR);
+    return (angleOffsetVector[0] / SRV_ANGLE_FACTOR);
 }
 
 /*************************************************************************************************/
 void ServoController::setAngleOffset(double offset)
 {
-	_modbusWrapper.setSingleRegister(SRV_ZERO_OFFSET_ANGLE,
-									 static_cast<quint16>(offset * SRV_ANGLE_FACTOR));
+    _modbusWrapper.setSingleRegister(SRV_ZERO_OFFSET_ANGLE,
+                                     static_cast<quint16>(offset * SRV_ANGLE_FACTOR));
 }
 
 /*************************************************************************************************/
 double ServoController::getAzimuth()
 {
-	auto azimuthVector = _modbusWrapper.getHoldingRegister(SRV_AZIMUTH_REG, 1);
+    auto azimuthVector = _modbusWrapper.getHoldingRegister(SRV_AZIMUTH_REG, 1);
 
-	return (azimuthVector[0] / SRV_ANGLE_FACTOR);
+    return (azimuthVector[0] / SRV_ANGLE_FACTOR);
+}
+
+/*************************************************************************************************/
+bool ServoController::getStatus()
+{
+   return _modbusWrapper.getStatus();
 }

Test/MainWindow.cpp

@@ -1,287 +1,292 @@
 #include "MainWindow.h"
 #include "ui_MainWindow.h"
+#include "QtConcurrent/QtConcurrent"
 
 MainWindow::MainWindow(QWidget* parent)
-	: QMainWindow(parent)
-	, ui(new Ui::MainWindow)
+    : QMainWindow(parent)
+    , ui(new Ui::MainWindow)
 {
-	ui->setupUi(this);
+    ui->setupUi(this);
 
-	ui->writeTable->addItem(tr("Coils"), 0);
-	ui->writeTable->addItem(tr("Discrete Inputs"), 1);
-	ui->writeTable->addItem(tr("Input Registers"), 2);
-	ui->writeTable->addItem(tr("Holding Registers"), 3);
+    ui->writeTable->addItem(tr("Coils"), 0);
+    ui->writeTable->addItem(tr("Discrete Inputs"), 1);
+    ui->writeTable->addItem(tr("Input Registers"), 2);
+    ui->writeTable->addItem(tr("Holding Registers"), 3);
 }
 
 /*************************************************************************************************/
 MainWindow::~MainWindow()
 {
-	delete ui;
-	timer->stop();
+    delete ui;
 }
 
 /*************************************************************************************************/
 void MainWindow::on_connect_clicked()
 {
-	try
-	{
-		configDevice.serialPort = "/dev/pts/2";
-		configDevice.clientAddress = 1;
-		configDevice.responseTime = 1000;
-		qDebug() << "before init";
-		modbusWrapper.init();
-		qDebug() << "after init";
-		qDebug() << "before connect";
-		modbusWrapper.connectToDevice(configDevice);
-		qDebug() << "after connect";
-		ui->errorMonitoring->setText("No Error");
-	}
-	catch(ServoException ex)
-	{
-		ui->errorMonitoring->setText(ex.getMessage());
-	}
+    try
+    {
+        configDevice.serialPort = "/dev/pts/2";
+        configDevice.clientAddress = 1;
+        configDevice.responseTime = 1000;
+        qDebug() << "before init";
+        modbusWrapper.init();
+        qDebug() << "after init";
+        qDebug() << "before connect";
+        modbusWrapper.connectToDevice(configDevice);
+        qDebug() << "after connect";
+        ui->errorMonitoring->setText("No Error");
+    }
+    catch(ServoException ex)
+    {
+        ui->errorMonitoring->setText(ex.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_readButton_clicked()
 {
-	int startAddress = ui->startAddress->text().toInt();
-	int numberOfEntries = ui->readSize->text().toInt();
-	try
-	{
-		switch(ui->writeTable->currentData().toInt())
-		{
-			case 0:
-				printCoilsDataFromClient(modbusWrapper.getCoil(startAddress,
-															   static_cast<quint16>(numberOfEntries)));
-				break;
+    int startAddress = ui->startAddress->text().toInt();
+    int numberOfEntries = ui->readSize->text().toInt();
+    try
+    {
+        switch(ui->writeTable->currentData().toInt())
+        {
+        case 0:
+            printCoilsDataFromClient(modbusWrapper.getCoil(startAddress,
+                                                           static_cast<quint16>(numberOfEntries)));
+            break;
 
-			case 1:
-				printCoilsDataFromClient(modbusWrapper.getInputCoil(startAddress,
-																	static_cast<quint16>(
-																		numberOfEntries)));
-				break;
+        case 1:
+            printCoilsDataFromClient(modbusWrapper.getInputCoil(startAddress,
+                                                                static_cast<quint16>(
+                                                                    numberOfEntries)));
+            break;
 
-			case 2:
-				printRegisterDataFromClient(modbusWrapper.getInputRegister(startAddress,
-																		   static_cast<quint16>(
-																			   numberOfEntries)));
-				break;
+        case 2:
+            printRegisterDataFromClient(modbusWrapper.getInputRegister(startAddress,
+                                                                       static_cast<quint16>(
+                                                                           numberOfEntries)));
+            break;
 
-			case 3:
-				printRegisterDataFromClient(modbusWrapper.getHoldingRegister(startAddress,
-																			 static_cast<quint16>(
-																				 numberOfEntries)));
-				break;
-		}
-		ui->errorMonitoring->setText("No Error");
-	}
-	catch(const ServoException& exp)
-	{
-		ui->errorMonitoring->setText(exp.getMessage());
-	}
+        case 3:
+            printRegisterDataFromClient(modbusWrapper.getHoldingRegister(startAddress,
+                                                                         static_cast<quint16>(
+                                                                             numberOfEntries)));
+            break;
+        }
+        ui->errorMonitoring->setText("No Error");
+    }
+    catch(const ServoException& exp)
+    {
+        ui->errorMonitoring->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::printCoilsDataFromClient(QBitArray uiCoils)
 {
-	QString readedData;
-	for(int i = 0; i < uiCoils.count(); i++)
-	{
-		const QString entry = tr("Number: %1, Value: %2").arg(i)
-							  .arg(QString::number(uiCoils[i]));
-		readedData += (entry + "\n");
-	}
-	ui->textEditRead->setText(readedData);
+    QString readedData;
+    for(int i = 0; i < uiCoils.count(); i++)
+    {
+        const QString entry = tr("Number: %1, Value: %2").arg(i)
+                .arg(QString::number(uiCoils[i]));
+        readedData += (entry + "\n");
+    }
+    ui->textEditRead->setText(readedData);
 }
 
 /*************************************************************************************************/
 void MainWindow::printRegisterDataFromClient(QVector<quint16> uiHoldingRegisters)
 {
-	QString readedData;
-	for(int i = 0; i < uiHoldingRegisters.count(); i++)
-	{
-		const QString entry = tr("Number: %1, Value: %2").arg(i)
-							  .arg(QString::number(uiHoldingRegisters[i]));
-		readedData += (entry + "\n");
-	}
-	ui->textEditRead->setText(readedData);
+    QString readedData;
+    for(int i = 0; i < uiHoldingRegisters.count(); i++)
+    {
+        const QString entry = tr("Number: %1, Value: %2").arg(i)
+                .arg(QString::number(uiHoldingRegisters[i]));
+        readedData += (entry + "\n");
+    }
+    ui->textEditRead->setText(readedData);
 }
 
 /*************************************************************************************************/
 void MainWindow::on_writeSingleCoil_clicked()
 {
-	try {
-		int startAddress = ui->writeSingleCoilAddress->text().toInt();
-		modbusWrapper.setSingleCoil(startAddress, ui->coilData->isChecked());
-		ui->errorMonitoring->setText("No Error");
-	}
-	catch(const ServoException& exp)
-	{
-		ui->errorMonitoring->setText(exp.getMessage());
-	}
+    try {
+        int startAddress = ui->writeSingleCoilAddress->text().toInt();
+        modbusWrapper.setSingleCoil(startAddress, ui->coilData->isChecked());
+        ui->errorMonitoring->setText("No Error");
+    }
+    catch(const ServoException& exp)
+    {
+        ui->errorMonitoring->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_writeMultiCoil_clicked()
 {
-	try {
-		int startAddress = ui->writeMultiCoilStartAddress->text().toInt();
-		int writeQty = ui->writeMultiCoilQty->text().toInt();
-		QString valueToWrite = ui->writeMultiCoilValue->text();
+    try {
+        int startAddress = ui->writeMultiCoilStartAddress->text().toInt();
+        int writeQty = ui->writeMultiCoilQty->text().toInt();
+        QString valueToWrite = ui->writeMultiCoilValue->text();
 
-		QBitArray uiCoils;
-		uiCoils.resize(writeQty);
+        QBitArray uiCoils;
+        uiCoils.resize(writeQty);
 
-		for(int i = 0; i < valueToWrite.size(); i++)
-		{
-			if(valueToWrite.at(i) == '0')
-				uiCoils[i] = false;
-			else
-				uiCoils[i] = true;
-		}
-		modbusWrapper.setMultipleCoil(startAddress, static_cast<quint16>(writeQty), uiCoils);
-		ui->errorMonitoring->setText("No Error");
-	}
-	catch(const ServoException& exp)
-	{
-		ui->errorMonitoring->setText(exp.getMessage());
-	}
+        for(int i = 0; i < valueToWrite.size(); i++)
+        {
+            if(valueToWrite.at(i) == '0')
+                uiCoils[i] = false;
+            else
+                uiCoils[i] = true;
+        }
+        modbusWrapper.setMultipleCoil(startAddress, static_cast<quint16>(writeQty), uiCoils);
+        ui->errorMonitoring->setText("No Error");
+    }
+    catch(const ServoException& exp)
+    {
+        ui->errorMonitoring->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_writeSingleRegister_clicked()
 {
-	try {
-		int startAddress = ui->writeSingleRegisterAddress->text().toInt();
-		quint16 value = static_cast<quint16>(ui->writeSingleRegisterValue->text().toInt());
-		modbusWrapper.setSingleRegister(startAddress, value);
-		ui->errorMonitoring->setText("No Error");
-	}
-	catch(const ServoException& exp)
-	{
-		ui->errorMonitoring->setText(exp.getMessage());
-	}
+    try {
+        int startAddress = ui->writeSingleRegisterAddress->text().toInt();
+        quint16 value = static_cast<quint16>(ui->writeSingleRegisterValue->text().toInt());
+        modbusWrapper.setSingleRegister(startAddress, value);
+        ui->errorMonitoring->setText("No Error");
+    }
+    catch(const ServoException& exp)
+    {
+        ui->errorMonitoring->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_writeMultiRegister_clicked()
 {
-	try {
-		int startAddress = ui->writeMultiRegisterStartAddress->text().toInt();
-		int writeQty = ui->writeMultiRegisterQty->text().toInt();
-		QString valueToWrite = ui->writeMultiRegisterValue->text();
-		QVector<quint16> uiHoldingRegisters;
-		uiHoldingRegisters.resize(writeQty);
+    try {
+        int startAddress = ui->writeMultiRegisterStartAddress->text().toInt();
+        int writeQty = ui->writeMultiRegisterQty->text().toInt();
+        QString valueToWrite = ui->writeMultiRegisterValue->text();
+        QVector<quint16> uiHoldingRegisters;
+        uiHoldingRegisters.resize(writeQty);
 
-		QRegExp rx("(\\ |\\,|\\.|\\:|\\t)"); //RegEx for ' ' or ',' or '.' or ':' or '\t'
-		QStringList stringListValue = valueToWrite.split(rx);
+        QRegExp rx("(\\ |\\,|\\.|\\:|\\t)"); //RegEx for ' ' or ',' or '.' or ':' or '\t'
+        QStringList stringListValue = valueToWrite.split(rx);
 
-		for(int i = 0; i < stringListValue.size(); i++)
-		{
-			uiHoldingRegisters[i] = static_cast<quint16>(stringListValue[i].toInt());
-		}
-		modbusWrapper.setMultipleRegister(startAddress,
-										  static_cast<quint16>(writeQty),
-										  uiHoldingRegisters);
-		ui->errorMonitoring->setText("No Error");
-	}
-	catch(const ServoException& exp)
-	{
-		ui->errorMonitoring->setText(exp.getMessage());
-	}
+        for(int i = 0; i < stringListValue.size(); i++)
+        {
+            uiHoldingRegisters[i] = static_cast<quint16>(stringListValue[i].toInt());
+        }
+        modbusWrapper.setMultipleRegister(startAddress,
+                                          static_cast<quint16>(writeQty),
+                                          uiHoldingRegisters);
+        ui->errorMonitoring->setText("No Error");
+    }
+    catch(const ServoException& exp)
+    {
+        ui->errorMonitoring->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_init_clicked()
 {
-	try {
-		_servoControler.init(ui->serialPortServo->text());
-		timer = new QTimer();
-		timer->setInterval(1000);
-		timer->start();
-		connect(timer, &QTimer::timeout, this, &MainWindow::handleGetRequestFromServo);
-	}
-	catch(ServoException exp)
-	{
-		ui->showServoError->setText(exp.getMessage());
-	}
+    try {
+        ui->showServoError->setText("");
+        _servoControler.init(ui->serialPortServo->text());
+        QtConcurrent::run(this,&MainWindow::handleGetRequestFromServo);
+    }
+    catch(ServoException exp)
+    {
+        ui->showServoError->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::handleGetRequestFromServo()
 {
-	try {
-		ui->showSpeed->setText(QString::number(_servoControler.getSpeed()));
-		ui->showStartAngle->setText(QString::number(_servoControler.getStartAngle()));
-		ui->showStopAngle->setText(QString::number(_servoControler.getStopAngle()));
-		ui->showAngleOffset->setText(QString::number(_servoControler.getAngleOffset()));
-		ui->showAzimuth->setText(QString::number(_servoControler.getAzimuth()));
-	}
-	catch(ServoException exp)
-	{
-		ui->showServoError->setText(exp.getMessage());
-	}
+    while(1)
+    {
+        try {
+            ui->showSpeed->setText(QString::number(_servoControler.getSpeed()));
+            ui->showStartAngle->setText(QString::number(_servoControler.getStartAngle()));
+            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());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_startMoving_clicked()
 {
-	try {
-		_servoControler.startMoving();
-	}
-	catch(ServoException exp)
-	{
-		ui->showServoError->setText(exp.getMessage());
-	}
+    try {
+        _servoControler.startMoving();
+    }
+    catch(ServoException exp)
+    {
+        ui->showServoError->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_stopMoving_clicked()
 {
-	try {
-		_servoControler.stopMoving();
-	}
-	catch(ServoException exp)
-	{
-		ui->showServoError->setText(exp.getMessage());
-	}
+    try {
+        _servoControler.stopMoving();
+    }
+    catch(ServoException exp)
+    {
+        ui->showServoError->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_ResetAzimuth_clicked()
 {
-	try {
-		_servoControler.resetAzimuth();
-	}
-	catch(ServoException exp)
-	{
-		ui->showServoError->setText(exp.getMessage());
-	}
+    try {
+        _servoControler.resetAzimuth();
+    }
+    catch(ServoException exp)
+    {
+        ui->showServoError->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_sectorSpeed_clicked()
 {
-	try {
-		_servoControler.sector(ui->startAngle->text().toDouble(),
-							   ui->stopAngle->text().toDouble(),
-							   ui->speed->text().toDouble());
-	}
-	catch(ServoException exp)
-	{
-		ui->showServoError->setText(exp.getMessage());
-	}
+    try {
+        _servoControler.sector(ui->startAngle->text().toDouble(),
+                               ui->stopAngle->text().toDouble(),
+                               ui->speed->text().toDouble());
+    }
+    catch(ServoException exp)
+    {
+        ui->showServoError->setText(exp.getMessage());
+    }
 }
 
 /*************************************************************************************************/
 void MainWindow::on_fix_clicked()
 {
-	try {
-		_servoControler.fix(ui->startAngle->text().toDouble());
-	}
-	catch(ServoException exp)
-	{
-		ui->showServoError->setText(exp.getMessage());
-	}
+    try {
+        _servoControler.fix(ui->startAngle->text().toDouble());
+    }
+    catch(ServoException exp)
+    {
+        ui->showServoError->setText(exp.getMessage());
+    }
 }

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[]) {