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

Compare commits

merge into: h-4nd-h:master
...
pull from: h-4nd-h:AddStatus

5 Commits
master ... AddStatus

Author SHA1 Message Date
nasicurious a9c2eb3a62 Exception Whose occur stop socat is solved
3 years ago
nasicurious 4a58ffe9a8 Exception Whose occur stop socat is solved
3 years ago
nasicurious 5aa976b17a FinalCode
3 years ago
nasicurious edbf2fa791 Add Close and Status
3 years ago
nasi 11ab0aaca0 Add Get Status
3 years ago
10 changed files with 848 additions and 687 deletions
Split View
  1. 1
      Servo/Servo.pro
  2. 7
      Servo/include/ModbusMaster.h
  3. 6
      Servo/include/ModbusWrapper.h
  4. 18
      Servo/include/ServoController.h
  5. 605
      Servo/src/ModbusMaster.cpp
  6. 340
      Servo/src/ModbusWrapper.cpp
  7. 109
      Servo/src/ServoController.cpp
  8. 391
      Test/MainWindow.cpp
  9. 36
      Test/MainWindow.ui
  10. 22
      Test/main.cpp

1
Servo/Servo.pro
View File

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

7
Servo/include/ModbusMaster.h
View File

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

6
Servo/include/ModbusWrapper.h
View File

@ -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);

18
Servo/include/ServoController.h
View File

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

605
Servo/src/ModbusMaster.cpp
View File

@ -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;
}
}

340
Servo/src/ModbusWrapper.cpp
View File

@ -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);
}
}

109
Servo/src/ServoController.cpp
View File

@ -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();
}

391
Test/MainWindow.cpp
View File

@ -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());
}
}

36
Test/MainWindow.ui
View File

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

22
Test/main.cpp
View File

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

Write Preview
Loading…
Cancel
Save