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

FinalCode

AddStatus
nasicurious 3 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
Split 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. 27
      Servo/src/ModbusMaster.cpp
  5. 60
      Servo/src/ModbusWrapper.cpp
  6. 9
      Servo/src/ServoController.cpp
  7. 49
      Test/MainWindow.cpp
  8. 22
      Test/main.cpp

3
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;
@ -38,12 +39,14 @@ public:
quint16 writeSize);
//uncrustify off
public slots:
//uncrustify on
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);

3
Servo/include/ModbusWrapper.h
View File

@ -31,11 +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);

16
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 = 2003; //2004;
const int SRV_START_STOP_REG = 2004; //2005;
const int SRV_ZERO_OFFSET_ANGLE = 2005; //2007;
const int SRV_START_ANGLE_FRAC_PART_REG = 2006; //2010;
const int SRV_STOP_ANGLE_FRAC_PART_REG = 2007; //2011;
const int SRV_CALIBRATE_REG = 2008; //2013;
const int SRV_ENABLE_DRIVE_REG = 2009; //2017;
const int SRV_AZIMUTH_REG = 2010; //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;

27
Servo/src/ModbusMaster.cpp
View File

@ -48,7 +48,11 @@ void ModbusMaster::connectionStateChanged(QModbusDevice::State state)
{
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.message = ex.getMessage();
return QBitArray();
}
}
@ -138,6 +143,7 @@ QBitArray ModbusMaster::getInputCoil(int startAddress, quint16 readSize, ExpConf
{
expConfig.valid = true;
expConfig.message = ex.getMessage();
return QBitArray();
}
}
@ -166,6 +172,7 @@ QVector<quint16> ModbusMaster::getHoldingRegister(int startAddress,
{
expConfig.valid = true;
expConfig.message = ex.getMessage();
return QVector<quint16>();
}
}
@ -194,6 +201,7 @@ QVector<quint16> ModbusMaster::getInputRegister(int startAddress,
{
expConfig.valid = true;
expConfig.message = ex.getMessage();
return QVector<quint16>();
}
}
@ -308,16 +316,20 @@ void ModbusMaster::readRequest(QModbusDataUnit::RegisterType registerType,
void ModbusMaster::checkForError(QModbusReply* _reply)
{
if(_reply->error() == QModbusDevice::NoError)
{
_connected = true;
return;
}
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->rawResult().exceptionCode()));
}
else
{
_connected = false;
throw ServoException(QString("Read response error: %1 (code: %2)")
.arg(_reply->errorString())
.arg(_reply->error()));
@ -363,9 +375,16 @@ void ModbusMaster::writeRequest(QModbusDataUnit::RegisterType registerType,
}
}
/*************************************************************************************************/
bool ModbusMaster::getConnectionState()
{
return _connected;
}
/*************************************************************************************************/
void ModbusMaster::close()
{
qDebug() << " ModbusMaster::close " <<QThread::currentThreadId() ;
_initialized = false;
if(_modbusDevice)
{
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);
loop.exec();
connect(this,
&ModbusWrapper::getConnectionStateOrder,
&_modbusMaster,
&ModbusMaster::getConnectionState,
Qt::BlockingQueuedConnection);
connect(this,
&ModbusWrapper::initOrder,
&_modbusMaster,
@ -97,6 +102,55 @@ void ModbusWrapper::close()
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);
}
}
@ -200,6 +254,12 @@ void ModbusWrapper::setMultipleRegister(int startAddress,
}
}
/*************************************************************************************************/
bool ModbusWrapper::getStatus()
{
return emit getConnectionStateOrder();
}
/*************************************************************************************************/
void ModbusWrapper::connectToDevice(ModbusConfig modbusConfig)
{

9
Servo/src/ServoController.cpp
View File

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

49
Test/MainWindow.cpp
View File

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