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
Split 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 += \
$$files(*.h, true) \
include/ExpConfig.h
INCLUDEPATH += $$PWD/include

4
Servo/include/ModbusMaster.h
View File

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

1
Servo/include/ModbusWrapper.h
View File

@ -35,6 +35,7 @@ public:
signals:
void connectOrder(ModbusConfig modbusConfig, ExpConfig& expConfig);
void initOrder(ExpConfig& expConfig);
void closeOrder();
QBitArray getCoilOrder(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 <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;
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();
}
}
/*************************************************************************************************/
void ModbusMaster::connectionStateChanged(QModbusDevice::State state)
{
if(state == QModbusDevice::UnconnectedState)
{
throw ServoException("Connection wasnt prepared");
}
if(state == QModbusDevice::UnconnectedState)
{
throw ServoException("Connection wasnt prepared");
}
}
/*************************************************************************************************/
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();
}
}
/*************************************************************************************************/
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();
}
}
/*************************************************************************************************/
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();
}
}
/*************************************************************************************************/
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();
}
}
/*************************************************************************************************/
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)
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()));
}
}
/*************************************************************************************************/
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());
}
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());
}
}
void ModbusMaster::close()
{
if(_modbusDevice)
_modbusDevice->disconnectDevice();
delete _modbusDevice;
qDebug() << " ModbusMaster::close " <<QThread::currentThreadId() ;
if(_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()
{
_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::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()
{
_modbusMaster.close();
_workerThread.quit();
_workerThread.wait();
if (_workerThread.isRunning())
{
emit closeOrder();
_workerThread.quit();
_workerThread.wait();
}
}
/*************************************************************************************************/
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);
}
ExpConfig exp;
emit setMultipleRegisterOrder(startAddress, writeSize, registerValues, exp);
if(exp.valid)
{
throw ServoException(exp.message);
}
}
/*************************************************************************************************/
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);
}
}

410
Test/MainWindow.cpp
View File

@ -2,289 +2,311 @@
#include "ui_MainWindow.h"
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();
if (timer->isActive())
{
timer->stop();
delete timer;
}
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 {
_servoControler.init(ui->serialPortServo->text());
timer = new QTimer();
timer->setInterval(2000);
timer->start();
connect(timer, &QTimer::timeout, this, &MainWindow::handleGetRequestFromServo);
}
catch(ServoException exp)
{
if (timer->isActive())
{
timer->stop();
delete timer;
}
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()));
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->connectionState->setText(QVariant(_servoControler.getStatus()).toString());
}
catch(ServoException exp)
{
timer->stop();
ui->showServoError->setText(exp.getMessage());
// ui->showAzimuth->setText(QString::number(_servoControler.getAzimuth()));
auto currentstatus=_servoControler.getStatus();
if (!currentstatus)
{
if (timer->isActive())
{
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()
{
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());
}
}

2
Test/MainWindow.ui
View File

@ -957,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>

Write Preview
Loading…
Cancel
Save