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

FinalCode

AddStatus
nasicurious 4 years ago
parent
edbf2fa791
commit
5aa976b17a
8 changed files with 126 additions and 71 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. 3
      Servo/include/ModbusMaster.h
  2. 3
      Servo/include/ModbusWrapper.h
  3. 16
      Servo/include/ServoController.h
  4. 31
      Servo/src/ModbusMaster.cpp
  5. 60
      Servo/src/ModbusWrapper.cpp
  6. 9
      Servo/src/ServoController.cpp
  7. 53
      Test/MainWindow.cpp
  8. 22
      Test/main.cpp

3
Servo/include/ModbusMaster.h
View File

@ -20,6 +20,7 @@ class ModbusMaster : public QObject
private: private:
bool _initialized = false; bool _initialized = false;
bool _connected = false;
QModbusClient* _modbusDevice = nullptr; QModbusClient* _modbusDevice = nullptr;
int _clientAddress; int _clientAddress;
QModbusDataUnit _modbusReplyUnit; QModbusDataUnit _modbusReplyUnit;
@ -38,12 +39,14 @@ public:
quint16 writeSize); quint16 writeSize);
//uncrustify off //uncrustify off
public slots: public slots:
//uncrustify on //uncrustify on
void init(ExpConfig& expConfig); void init(ExpConfig& expConfig);
void connectToDevice(ModbusConfig modbusConfig, ExpConfig& expConfig); void connectToDevice(ModbusConfig modbusConfig, ExpConfig& expConfig);
void connectionStateChanged(QModbusDevice::State state); void connectionStateChanged(QModbusDevice::State state);
bool getConnectionState();
QBitArray getCoil(int startAddress, quint16 readSize, ExpConfig& expConfig); QBitArray getCoil(int startAddress, quint16 readSize, ExpConfig& expConfig);
QBitArray getInputCoil(int startAddress, quint16 readSize, ExpConfig& expConfig); QBitArray getInputCoil(int startAddress, quint16 readSize, ExpConfig& expConfig);

3
Servo/include/ModbusWrapper.h
View File

@ -31,11 +31,12 @@ public:
void setMultipleCoil(int startAddress, quint16 writeSize, QBitArray coilFlags); void setMultipleCoil(int startAddress, quint16 writeSize, QBitArray coilFlags);
void setSingleRegister(int startAddress, quint16 registerValue); void setSingleRegister(int startAddress, quint16 registerValue);
void setMultipleRegister(int startAddress, quint16 writeSize, QVector<quint16> registerValues); void setMultipleRegister(int startAddress, quint16 writeSize, QVector<quint16> registerValues);
bool getStatus();
signals: signals:
void connectOrder(ModbusConfig modbusConfig, ExpConfig& expConfig); void connectOrder(ModbusConfig modbusConfig, ExpConfig& expConfig);
void initOrder(ExpConfig& expConfig); void initOrder(ExpConfig& expConfig);
void closeOrder(); void closeOrder();
bool getConnectionStateOrder();
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);

16
Servo/include/ServoController.h
View File

@ -11,14 +11,14 @@ private:
const int SRV_START_ANGLE_INT_PART_REG = 2000; const int SRV_START_ANGLE_INT_PART_REG = 2000;
const int SRV_STOP_ANGLE_INT_PART_REG = 2001; const int SRV_STOP_ANGLE_INT_PART_REG = 2001;
const int SRV_AZIMUTH_SPEED_REG = 2002; const int SRV_AZIMUTH_SPEED_REG = 2002;
const int SRV_APPLY_SETTING_REG = 2003; //2004; const int SRV_APPLY_SETTING_REG = 2004;
const int SRV_START_STOP_REG = 2004; //2005; const int SRV_START_STOP_REG = 2005;
const int SRV_ZERO_OFFSET_ANGLE = 2005; //2007; const int SRV_ZERO_OFFSET_ANGLE = 2007;
const int SRV_START_ANGLE_FRAC_PART_REG = 2006; //2010; const int SRV_START_ANGLE_FRAC_PART_REG = 2010;
const int SRV_STOP_ANGLE_FRAC_PART_REG = 2007; //2011; const int SRV_STOP_ANGLE_FRAC_PART_REG = 2011;
const int SRV_CALIBRATE_REG = 2008; //2013; const int SRV_CALIBRATE_REG = 2013;
const int SRV_ENABLE_DRIVE_REG = 2009; //2017; const int SRV_ENABLE_DRIVE_REG = 2017;
const int SRV_AZIMUTH_REG = 2010; //2030; const int SRV_AZIMUTH_REG = 2030;
const double SRV_ANGLE_FACTOR = 100.0; const double SRV_ANGLE_FACTOR = 100.0;
const double SRV_SPEED_FACTOR = 1000.0; const double SRV_SPEED_FACTOR = 1000.0;

31
Servo/src/ModbusMaster.cpp
View File

@ -19,8 +19,8 @@ void ModbusMaster::init(ExpConfig& expConfig)
connect(_modbusDevice, &QModbusClient::errorOccurred, [this](QModbusDevice::Error) connect(_modbusDevice, &QModbusClient::errorOccurred, [this](QModbusDevice::Error)
{ {
_initialized = false; _initialized = false;
throw ServoException(_modbusDevice->errorString()); throw ServoException(_modbusDevice->errorString());
}); });
connect(_modbusDevice, connect(_modbusDevice,
@ -48,7 +48,11 @@ void ModbusMaster::connectionStateChanged(QModbusDevice::State state)
{ {
if(state == QModbusDevice::UnconnectedState) if(state == QModbusDevice::UnconnectedState)
{ {
throw ServoException("Connection wasnt prepared"); _connected = false;
}
else if (state == QModbusDevice::ConnectedState)
{
_connected = true;
} }
} }
@ -110,6 +114,7 @@ QBitArray ModbusMaster::getCoil(int startAddress, quint16 readSize, ExpConfig& e
{ {
expConfig.valid = true; expConfig.valid = true;
expConfig.message = ex.getMessage(); expConfig.message = ex.getMessage();
return QBitArray();
} }
} }
@ -138,6 +143,7 @@ QBitArray ModbusMaster::getInputCoil(int startAddress, quint16 readSize, ExpConf
{ {
expConfig.valid = true; expConfig.valid = true;
expConfig.message = ex.getMessage(); expConfig.message = ex.getMessage();
return QBitArray();
} }
} }
@ -166,6 +172,7 @@ QVector<quint16> ModbusMaster::getHoldingRegister(int startAddress,
{ {
expConfig.valid = true; expConfig.valid = true;
expConfig.message = ex.getMessage(); expConfig.message = ex.getMessage();
return QVector<quint16>();
} }
} }
@ -194,6 +201,7 @@ QVector<quint16> ModbusMaster::getInputRegister(int startAddress,
{ {
expConfig.valid = true; expConfig.valid = true;
expConfig.message = ex.getMessage(); expConfig.message = ex.getMessage();
return QVector<quint16>();
} }
} }
@ -308,16 +316,20 @@ void ModbusMaster::readRequest(QModbusDataUnit::RegisterType registerType,
void ModbusMaster::checkForError(QModbusReply* _reply) void ModbusMaster::checkForError(QModbusReply* _reply)
{ {
if(_reply->error() == QModbusDevice::NoError) if(_reply->error() == QModbusDevice::NoError)
{
_connected = true;
return; return;
}
if(_reply->error() == QModbusDevice::ProtocolError) if(_reply->error() == QModbusDevice::ProtocolError)
{ {
throw ServoException(QString("Read response error: %1 (Mobus exception: %2)") _connected = false;
throw ServoException(QString("Read response error: %1 (Modbus exception: %2)")
.arg(_reply->errorString()) .arg(_reply->errorString())
.arg(_reply->rawResult().exceptionCode())); .arg(_reply->rawResult().exceptionCode()));
} }
else else
{ {
_connected = false;
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()));
@ -363,9 +375,16 @@ void ModbusMaster::writeRequest(QModbusDataUnit::RegisterType registerType,
} }
} }
/*************************************************************************************************/
bool ModbusMaster::getConnectionState()
{
return _connected;
}
/*************************************************************************************************/
void ModbusMaster::close() void ModbusMaster::close()
{ {
qDebug() << " ModbusMaster::close " <<QThread::currentThreadId() ; _initialized = false;
if(_modbusDevice) if(_modbusDevice)
{ {
if (_modbusDevice->state() == QModbusDevice::ConnectedState || _modbusDevice->state() == QModbusDevice::ConnectingState) if (_modbusDevice->state() == QModbusDevice::ConnectedState || _modbusDevice->state() == QModbusDevice::ConnectingState)

60
Servo/src/ModbusWrapper.cpp
View File

@ -23,6 +23,11 @@ void ModbusWrapper::init()
connect(&_workerThread, &QThread::started, &loop, &QEventLoop::quit); connect(&_workerThread, &QThread::started, &loop, &QEventLoop::quit);
loop.exec(); loop.exec();
connect(this,
&ModbusWrapper::getConnectionStateOrder,
&_modbusMaster,
&ModbusMaster::getConnectionState,
Qt::BlockingQueuedConnection);
connect(this, connect(this,
&ModbusWrapper::initOrder, &ModbusWrapper::initOrder,
&_modbusMaster, &_modbusMaster,
@ -97,6 +102,55 @@ void ModbusWrapper::close()
emit closeOrder(); emit closeOrder();
_workerThread.quit(); _workerThread.quit();
_workerThread.wait(); _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);
} }
} }
@ -200,6 +254,12 @@ void ModbusWrapper::setMultipleRegister(int startAddress,
} }
} }
/*************************************************************************************************/
bool ModbusWrapper::getStatus()
{
return emit getConnectionStateOrder();
}
/*************************************************************************************************/ /*************************************************************************************************/
void ModbusWrapper::connectToDevice(ModbusConfig modbusConfig) void ModbusWrapper::connectToDevice(ModbusConfig modbusConfig)
{ {

9
Servo/src/ServoController.cpp
View File

@ -160,12 +160,5 @@ double ServoController::getAzimuth()
/*************************************************************************************************/ /*************************************************************************************************/
bool ServoController::getStatus() bool ServoController::getStatus()
{ {
try { return _modbusWrapper.getStatus();
getSpeed();
return true;
} catch (ServoException ex) {
_modbusWrapper.close();
return false;
}
} }

53
Test/MainWindow.cpp
View File

@ -1,5 +1,6 @@
#include "MainWindow.h" #include "MainWindow.h"
#include "ui_MainWindow.h" #include "ui_MainWindow.h"
#include "QtConcurrent/QtConcurrent"
MainWindow::MainWindow(QWidget* parent) MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent) : QMainWindow(parent)
@ -16,11 +17,6 @@ MainWindow::MainWindow(QWidget* parent)
/*************************************************************************************************/ /*************************************************************************************************/
MainWindow::~MainWindow() MainWindow::~MainWindow()
{ {
if (timer->isActive())
{
timer->stop();
delete timer;
}
delete ui; delete ui;
} }
@ -200,19 +196,12 @@ void MainWindow::on_writeMultiRegister_clicked()
void MainWindow::on_init_clicked() void MainWindow::on_init_clicked()
{ {
try { try {
ui->showServoError->setText("");
_servoControler.init(ui->serialPortServo->text()); _servoControler.init(ui->serialPortServo->text());
timer = new QTimer(); QtConcurrent::run(this,&MainWindow::handleGetRequestFromServo);
timer->setInterval(2000);
timer->start();
connect(timer, &QTimer::timeout, this, &MainWindow::handleGetRequestFromServo);
} }
catch(ServoException exp) catch(ServoException exp)
{ {
if (timer->isActive())
{
timer->stop();
delete timer;
}
ui->showServoError->setText(exp.getMessage()); ui->showServoError->setText(exp.getMessage());
} }
} }
@ -220,32 +209,22 @@ void MainWindow::on_init_clicked()
/*************************************************************************************************/ /*************************************************************************************************/
void MainWindow::handleGetRequestFromServo() void MainWindow::handleGetRequestFromServo()
{ {
try { while(1)
//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()));
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()) 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()));
QThread::sleep(2);
}
catch(ServoException exp)
{ {
timer->stop(); ui->showServoError->setText(exp.getMessage());
delete timer;
} }
ui->showServoError->setText(exp.getMessage()); auto currentstatus=_servoControler.getStatus();
ui->connectionState->setText(QVariant(currentstatus).toString());
} }
} }

22
Test/main.cpp
View File

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

Write Preview
Loading…
Cancel
Save