h-4nd-h
/
Servo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Add Close and Status

AddStatus
nasicurious 3 years ago
parent
11ab0aaca0
commit
edbf2fa791
7 changed files with 662 additions and 619 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      Servo/Servo.pro
  2. 4
      Servo/include/ModbusMaster.h
  3. 1
      Servo/include/ModbusWrapper.h
  4. 585
      Servo/src/ModbusMaster.cpp
  5. 276
      Servo/src/ModbusWrapper.cpp
  6. 410
      Test/MainWindow.cpp
  7. 2
      Test/MainWindow.ui

1
Servo/Servo.pro
View File

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

4
Servo/include/ModbusMaster.h
View File

@ -36,7 +36,7 @@ public:
void writeRequest(QModbusDataUnit::RegisterType registerType, void writeRequest(QModbusDataUnit::RegisterType registerType,
int startAddress, int startAddress,
quint16 writeSize); quint16 writeSize);
void close();
//uncrustify off //uncrustify off
public slots: public slots:
@ -60,6 +60,8 @@ public slots:
quint16 writeSize, quint16 writeSize,
QVector<quint16> registerValues, QVector<quint16> registerValues,
ExpConfig& expConfig); ExpConfig& expConfig);
void close();
}; };
#endif //MODBUSMASTER_H #endif //MODBUSMASTER_H

1
Servo/include/ModbusWrapper.h
View File

@ -35,6 +35,7 @@ public:
signals: signals:
void connectOrder(ModbusConfig modbusConfig, ExpConfig& expConfig); void connectOrder(ModbusConfig modbusConfig, ExpConfig& expConfig);
void initOrder(ExpConfig& expConfig); void initOrder(ExpConfig& expConfig);
void closeOrder();
QBitArray getCoilOrder(int startAddress, quint16 readSize, ExpConfig& expConfig); QBitArray getCoilOrder(int startAddress, quint16 readSize, ExpConfig& expConfig);
QBitArray getInputCoilOrder(int startAddress, quint16 readSize, ExpConfig& expConfig); QBitArray getInputCoilOrder(int startAddress, quint16 readSize, ExpConfig& expConfig);

585
Servo/src/ModbusMaster.cpp
View File

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

276
Servo/src/ModbusWrapper.cpp
View File

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

410
Test/MainWindow.cpp
View File

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

2
Test/MainWindow.ui
View File

@ -957,7 +957,7 @@ color: rgb(238, 238, 236);
background-color: rgb(186, 178, 158);</string> background-color: rgb(186, 178, 158);</string>
</property> </property>
<property name="text"> <property name="text">
<string>Error Monitoring</string> <string/>
</property> </property>
<property name="wordWrap"> <property name="wordWrap">
<bool>true</bool> <bool>true</bool>

Write Preview
Loading…
Cancel
Save