aswi2021virtual-surreality-gitlab/deltarobot/mainwindow.cpp @ 74adfd5f

#include "mainwindow.h"
#include "curvedialog.h"
#include "infodialog.h"
#include "curvedataserver.h"
#include "selectpatientdlg.h"
#include "ui_mainwindow.h"
#include <QModbusTcpClient>
#include <QList>
#include <QVector3D>
#include <QVector>
#include <QTimer>
#include <QTime>
#include <QSettings>
#include <QFileDialog>
#include <QMessageBox>
#include <QSqlQueryModel>
#include <QScreen>

//prehravani naucene krivky
#define BIT_BPLAY           32772
//cviceni naucene kriky
#define BIT_BPLAY_ASSIST    32773

//povoleni tenzometru
#define BIT_BXYZ            32779
//uceni krivky
#define BIT_BTEACH          32780
//poloha klicku - je to discrete input
#define BIT_BKEY            32789
//bezpecnostni tlacitko
#define BIT_SAFETY_BTN      32785

//polohovaci motor
#define BIT_MOTOR_UP        32788
#define BIT_MOTOR_DOWN      32789

//reset pozice
#define BIT_RESET_POS       32769

#define BIT_WRITE_ENABLE    32868
#define BIT_DATA_TO_PLC     32869
#define BIT_DATA_TO_PC      32870
#define BIT_RDY             32871
#define BIT_PART_FINISHED   32873
#define BIT_MEASUREMENT_TO_PC 32874

//aktualni pozice
#define REG_X       32768
#define REG_Y       32769
#define REG_Z       32770
#define REG_A       32771

//pozice vektoru, kam se tlaci
#define REG_ACT_X   32772
#define REG_ACT_Y   32773
#define REG_ACT_Z   32774

//pozice vektoru, kam se ma tlacit
#define REG_DIR_X   32776
#define REG_DIR_Y   32777
#define REG_DIR_Z   32778

#define REG_LEN     32866
#define REG_INDEX   32867
#define REG_DATA    32868

#define REG_Q_1     32780
#define REG_Q_TOT   32781
#define REG_Q_PART  32782

//rychlost cviceni
#define REG_SPEED   32799

#define NO_STATE        0
#define SEND_CURVE      1
#define SEND_PREP_CURVE 2
#define SEND_WAIT_CURVE 3
#define SEND_LAST_CURVE 4
#define GET_CURVE       5
#define GET_WAIT_CURVE  6
#define GET_PART_CURVE  7
#define GET_NEXT_PART   8
#define GET_LAST_CURVE  9
#define GET_MEAS_START  10
#define GET_MEAS_WAIT   11
#define GET_MEAS_LEN    12
#define GET_MEAS_NEXT   13
#define GET_MEAS_LAST   14

//poloha aplikatoru v zakladnim stavu (tj. v reset pozici)
#define RES_X_POS       1000
#define RES_Y_POS       1000
#define RES_Z_POS       3000

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    cdServer(new CurveDataServer)
{
    ui->setupUi(this);

    mbClient = new QModbusTcpClient(this);

    pendingRead = pendingWrite = lastPacket = initStep = bSpeedUpdated = false;
    calcCurvePoints[0] = calcCurvePoints[1] = staticSpherePos = spherePos = QVector3D(0,0,0);
    dirArrow = QVector3D(0,0,0);
    actualArrow = QVector3D(0,0,0);
    testSpherePos = QVector3D(0,0,0);
    overallQ = oneCycleQ = tempQ = 0;
    pId = indId = 0;
    pronSupVal = PRON_SUP_NOT;
    actSeries = 0;

    itemCount = cntr = 0;

    safetyBtnState = safetyBtnBlinkOn = keyAutoBtnBlinkOn = 0;

    receivedDataSize = 0;

    mbServerId = 1;

    pd = waitDlg = nullptr;

    checkTimer = new QTimer(this);
    procedureTimer = new QTimer(this);
    procedureTimeRemaining = 600;
    ui->procTimeDial->setValue(10);

    connect(mbClient, &QModbusClient::errorOccurred, this, &MainWindow::handleDeviceError);
    connect(mbClient, &QModbusClient::stateChanged, this, &MainWindow::onStateChanged);

    connect(ui->curveGenerateBtn, SIGNAL(clicked()), this, SLOT(curveGenerateClicked()));
    connect(ui->curvePlayBtn, SIGNAL(toggled(bool)), this, SLOT(curvePlayChanged(bool)));
    connect(ui->curveAssistPlayBtn, SIGNAL(toggled(bool)), this, SLOT(curveAssistChanged(bool)));
    connect(ui->curveTeachBtn, SIGNAL(toggled(bool)), this, SLOT(curveTeachChanged(bool)));
    connect(ui->curveStoreBtn, SIGNAL(clicked()), this, SLOT(curveStoreClicked()));
    connect(ui->curveLoadBtn, SIGNAL(clicked()), this, SLOT(curveLoadClicked()));
    connect(ui->measurementLoadBtn, SIGNAL(clicked()), this, SLOT(measurementLoadClicked()));
    connect(ui->resetPosBtn, SIGNAL(clicked()), this, SLOT(deviceResetClicked()));
    connect(ui->patientSelectBtn, SIGNAL(clicked()), this, SLOT(patientSelectClicked()));

    connect(ui->procTimeDial, SIGNAL(sliderMoved(int)), this, SLOT(timeDialMoved(int)));
    connect(ui->procTimeDial, SIGNAL(sliderReleased()), this, SLOT(timeDialReleased()));

    connect(ui->upDownSlider, SIGNAL(sliderMoved(int)), this, SLOT(upDownSliderMoved(int)));
    connect(ui->upDownSlider, SIGNAL(sliderReleased()), this, SLOT(movementSliderReleased()));

    connect(checkTimer, SIGNAL(timeout()), this, SLOT(mainCycle()));
    connect(procedureTimer, SIGNAL(timeout()), this, SLOT(updateAppTime()));


    currState = numPoints = 0;

    ui->connectionLabel->setStyleSheet("background-color: rgb(255,0,0)");
    ui->dbConnectionStatusLabel->setStyleSheet("background-color: rgb(255,0,0)");

    mbConnected = false;
    bTeachStatus = bWriteEnable = bProcedureRunning = bPartState = bKeyState = bPlay = 0;

    qualitySet = new QBarSet("Kvalita");
    qualityData = new QBarSeries();
    qualityData->append(qualitySet);

    QFont font;
    font.setPixelSize(18);

    chart = new QChart();
    chart->addSeries(qualityData);

    axisy = new QValueAxis();
    axisy->setRange(0.0, 100.0);
    axisy->setLabelsFont(font);

    //chart->createDefaultAxes(); // Preparing the axis
    chart->setAxisY(axisy, qualityData);
    //chart->axisX()->setRange(0,1);
    //chart->axisX()->setLabelsFont(font);
    //chart->axisY()->setLabelsFont(font);
    //chart->axisY()->setRange(0,100);
    chart->setTitle(tr("Graf kvality cvičení"));

    // Same formatting
    chart->setTitleFont(font);
    chart->setBackgroundVisible(false);
    chart->setMargins(QMargins(0,0,0,0));
    //chart->layout()->setContentsMargins(0,0,0,0);
    chart->legend()->hide();
    chart->setPlotAreaBackgroundBrush(QBrush(Qt::black));
    chart->setPlotAreaBackgroundVisible(true);
    graphView = new QChartView(chart);
    graphView->setMinimumSize(250,120);

    ui->verticalLayout->addWidget(graphView);
    ui->splitter->setStretchFactor(0,0);
    ui->splitter->setStretchFactor(1,1);

    QString stFname = qApp->applicationDirPath() + "/settings.ini";
    QSettings st(stFname, QSettings::IniFormat);
    serverIp = st.value("serverIP","127.0.0.1:1502").toString();
    actCurveType = st.value("curveType", CURVE_NONE).toInt();
    actCurveFileName = st.value("curveFileName","").toString();
    minDistanceFromTarget = st.value("minDistance", 400).toInt();
    ui->splitter->restoreState(st.value("splitterSizes").toByteArray());
    int cStep = st.value("curveStep", 1).toInt();
    //ui->glwidget->setConfig(cStep);
    calculatedCurve.clear();

    //inicializace databaze
    useDb = st.value("useDb", 0).toInt();
    auto dbAddr = st.value("dbAddress", "localhost").toString();
    auto dbUser = st.value("dbUser", "postgres").toString();
    auto dbPassword = st.value("dbPassword", "").toString();
    auto dbPort = st.value("dbPort", 5432).toInt();
    auto dbName = st.value("dbName","Cviceni").toString();

    db = new dbAccess();
    model = new QSqlQueryModel;

    if (useDb) {
        dbConnected = db->connect(dbAddr, dbUser, dbPassword, dbPort, dbName);
        if (dbConnected) {
            QLOG_INFO() << tr("OK< db connection established");
            ui->dbConnectionStatusLabel->setStyleSheet("background-color: rgb(0,255,0)");
            ui->dbConnectionStatusLabel->setText(tr("DB připojena"));
        }
    }

    //knofliky pro cviceni jsou pro zacatek disablovany
    ui->resetPosBtn->setEnabled(false);
    ui->curvePlayBtn->setEnabled(false);
    ui->curveAssistPlayBtn->setEnabled(false);
    ui->curveGenerateBtn->setEnabled(false);
    //ui->curveGenerateBtn->setEnabled(true);
    ui->curveTeachBtn->setEnabled(false);
    ui->curveLoadBtn->setEnabled(false);
    ui->curveStoreBtn->setEnabled(false);

    QScreen *screen = QGuiApplication::primaryScreen();
    QRect  screenGeometry = screen->geometry();
    this->setFixedSize(screenGeometry.width(),screenGeometry.height());
    //this->setFixedSize(1366,768);

    QTimer::singleShot(100, this, SLOT(display3DScene())); //kvuli nakresleni zakladni sceny

    connectionGuard = new QTime;
    connectionGuard->start();
    connectionEstablished = false;
    connectClicked();
        QLOG_DEBUG() << "Get part";
#ifdef PROCEDURE_TEST
    sphere.append(readPoints("kruh.txt"));
    act.append(readPoints("act.txt"));
    dir.append(readPoints("dir.txt"));
    cur.clear();
#endif
}

MainWindow::~MainWindow()
{
    QString stFname = qApp->applicationDirPath() + "/settings.ini";
    QSettings st(stFname, QSettings::IniFormat);
    st.setValue("splitterSizes",ui->splitter->saveState());
    st.setValue("curveType", actCurveType);
    st.setValue("curveFileName",actCurveFileName);

    if (mbConnected) {
        mbClient->disconnectDevice();
    }
    delete db;
    delete ui;
    delete cdServer;
}

//! Připojit/Odpojit modbus server
/*!
 * Funkce připojí, nebo odpojí modbus zařízení
 */
void MainWindow::connectClicked()
{
    const QUrl url = QUrl::fromUserInput(serverIp);

#ifdef PROCEDURE_TEST
        checkTimer->start(100);
        //ui->glwidget->procedureState(true);
        ui->curvePlayBtn->setEnabled(true);
        ui->curveAssistPlayBtn->setEnabled(true);
        ui->curveGenerateBtn->setEnabled(true);
        ui->curveTeachBtn->setEnabled(true);
        ui->curveLoadBtn->setEnabled(true);
        ui->curveStoreBtn->setEnabled(true);
        ui->safetyBtnLabel->setStyleSheet("background-color: rgb(0,255,0)");
        ui->connectionLabel->setStyleSheet("background-color: rgb(0,255,0)");
        ui->connectionLabel->setText(tr("Připojeno"));

        return;
#endif

    if (!mbConnected) {
        mbClient->setConnectionParameter(QModbusDevice::NetworkPortParameter, url.port());
        mbClient->setConnectionParameter(QModbusDevice::NetworkAddressParameter, url.host());
        mbClient->setTimeout(500);
        mbClient->setNumberOfRetries(3);
        if (!mbClient->connectDevice()) {
            QLOG_ERROR() << "Err connecting";
        }
        connectionGuard->start();
        checkTimer->start(500);
    } else {
        mbClient->disconnectDevice();
    }
}

//! Funkce volána po ukončení učení křivky
/*!
 * Funkce je volána poté, co je dokončeno učení nové křivky. Začne se stahování
 *  křivky do PC
 */
void MainWindow::changeClicked()
{
#ifndef FILE_TEST
    file.setFileName("data.txt");
    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
         store.setDevice(&file);

         //QLOG_WARN() << "e";
         store << "x;y;z;r" << endl;
    }

    currState = GET_CURVE;
    calculatedCurve.clear();
#else
    QString line;
    QStringList list;
    int i = 0;
    qint16 x,y,z,a;
    file.setFileName("data.txt");
    calculatedCurve.clear();
    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         store.setDevice(&file);

         //QLOG_WARN() << "e";

         while(!store.atEnd()) {
             line = store.readLine();
             list = line.split(';');
             x = list.at(0).toShort();
             y = list.at(1).toShort();
             z = list.at(2).toShort();
             a = list.at(3).toShort();
             calculatedCurve.append(QVector3D(x,y,z,a));
         }
         file.close();
    }
    ui->glwidget->setCurve(calculatedCurve);
#endif
}

//! Výběr předpočítané křivky
/*!
 * Po stisknutí tlačítka na výběr křivky. Zavolá se odpovídající dialog a po
 *  úspěšném výběru parametrů křivky se tato předpočte a pošle do stroje
 */
void MainWindow::curveGenerateClicked()
{
    curveDialog dlg;

    if (dlg.exec() == QDialog::Accepted) {
        dlg.getCurve(&actCurveType, &actCurveAngle, &actCurveRot, &pronSupVal);
        ui->glwidget->setTubusColor(QVector4D(1, 0.737f, 0.231f, 0.7f));
        setCurveData();
#ifdef PROCEDURE_TEST
        itemCount = cntr = 0;
#endif
    }
 }

//! Připravení dat křivky
/*!
 * Připraví křivku, která pak bude poslána do stroje. Křika bude buďto předpočítaná na
 *  základě vybraných parametrů, anebo bude načtena ze souboru na disku.
 */
void MainWindow::setCurveData()
{
    int stepcount = 250,i, tmpI;
    double x, x1, y, y1, z, a, tmpdeg;

#ifdef FILE_TEST
    file.setFileName("data.txt");
    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
         store.setDevice(&file);
    }
#endif

    if (actCurveType == CURVE_EXTERN) {
        if (!getCurveDataFromFile(actCurveFileName)) {
            QMessageBox::critical(this, tr("Cvičební stroj"),
                             tr("<font size=15>Nepodařilo se importovat křivku ze souboru.\nVyberte jiný soubor, nebo vygenerujte jinou křivku.</font>"),
                             QMessageBox::Ok);

            return;
        }
    } else {
        calculatedCurve.clear();

        //kdyz nebude pouzita zadna krivka - vymazat starou krivku
        if (actCurveType == CURVE_NONE)
            display3DScene();

        for (i=0; i < stepcount+1; i++) {
            if (actCurveRot == ROTATE_CLKWISE)
                tmpI = stepcount - i;
            else
                tmpI = i;
            tmpdeg = tmpI * (360.0/stepcount) * M_PI / 180.0;

            switch(actCurveType) {
            case CURVE_CIRCLE:
                x = 1600 * cos(tmpdeg);
                y = 1600 * sin(tmpdeg);
                break;
            case CURVE_ELLIPSE:
                x = 1200 * cos(tmpdeg);
                y = 1600 * sin(tmpdeg);
                break;
            case CURVE_LEMN:
                x = sqrt(2)*(1400)*cos(tmpdeg)/(1+sin(tmpdeg)*sin(tmpdeg));
                y = sqrt(2)*(3650)*sin(tmpdeg)*cos(tmpdeg)/(1+sin(tmpdeg)*sin(tmpdeg));
                break;
            case CURVE_KARD:
                x = (750)*2*cos(tmpdeg)-(750)*cos(2*tmpdeg);
                y = (750)*2*sin(tmpdeg)-(750)*sin(2*tmpdeg);
                break;
            case CURVE_LINE:
                if (i < stepcount/2)
                    tmpI = i * 2;
                else
                    tmpI = (stepcount - i) * 2;

                if (actCurveRot != ROTATE_CLKWISE)
                    tmpI = (stepcount - tmpI);

                //x = -2200 + tmpI * 4400.0 / stepcount;
                x = -2200 + tmpI * 4400.0 / stepcount;
                y = 0;// -2200 + tmpI * 4400.0 / stepcount;
                break;
            default:
                x = RES_X_POS;
                y = RES_Y_POS;
                z = RES_Z_POS;
            }

            x1 = x*cos(actCurveAngle*M_PI/4)-y*sin(actCurveAngle*M_PI/4);
            y1 = x*sin(actCurveAngle*M_PI/4)+y*cos(actCurveAngle*M_PI/4);

            if (actCurveType != CURVE_NONE)
                z = 6500.0 - y1*0.9;

            tmpdeg = 2 * M_PI * i / (double)stepcount;   //to same jako horni tmpdeg, jen s i
            switch(pronSupVal) {
            case PRON_SUP_1:
                a = sin(tmpdeg) * 15 + 45;
                break;
            case PRON_SUP_2:
                a = sin(tmpdeg) * 45 + 45;
                break;
            default:
                a = 0.0;
            }

            if (i == stepcount/2)
                calcCurvePoints[0] = QVector3D(x1,y1,z);
            else if (i == stepcount)
                calcCurvePoints[1] = QVector3D(x1,y1,z);

            calculatedCurve.append(QVector4D(x1,y1,z,a*10));
#ifdef FILE_TEST
            if (file.isOpen()) {
                store << (qint16)x1 << ";" << (qint16)y1 << ";" << (qint16)(7500.0+y/2.5) << ";" << (qint16)a << endl;
            }
#endif
        }
#ifdef FILE_TEST
        if (file.isOpen())
            file.close();
#endif
        ui->glwidget->setTubusColor(QVector4D(1, 0.737f, 0.231f, 0.7f));
        if (actCurveType != CURVE_NONE)
            ui->glwidget->setCurve(calculatedCurve, cdServer);
        currState = SEND_CURVE;
    }
}

//! Učení křivky
/*!
 * V závislosti na vstupním parametru je zahájeno, nebo ukončeno učení křivky. Pokud je učení zahájeno, je nejprve zobrazen
 *  dialog s informací o tom, že je třeba počkat, než bude aplikátor v základní pozici. Pak je možno začít manuálně
 * projíždět křivku, která bude zaznamenána strojem.
 * Pokud je učení ukončeno, je do stroje poslán příkaz o ukončení učení
 * \param pressed Parametr, který obsahuje informaci o tom, jestli má být učení zahájeno, nebo ukončeno
 */
void MainWindow::curveTeachChanged(bool pressed)
{
    if (pressed) {
        deviceResetClicked();
        display3DScene();

        waitDlg = new QProgressDialog("<font size=15>Počkejte, než bude stroj v základní pozici</font>", "Zrušit", 0, 50);
        waitDlg->setModal(true);
        waitDlg->setValue(0);
        waitDlg->show();
        ui->curveTeachBtn->setStyleSheet("background-color: rgb(0, 85, 255)");
    } else {
        if (waitDlg != nullptr) {
            delete waitDlg;
            waitDlg = nullptr;
        }

        writeValue(BIT_BTEACH, QModbusDataUnit::Coils,0);
        writeValue(BIT_BXYZ, QModbusDataUnit::Coils,0);
        ui->curveTeachBtn->setStyleSheet("background-color: rgb(0, 222, 222)");
    }
}

//! Výběr uložené křivky
/*!
 * Po stisknutí tlačítka na načtení křivky z disku se objeví dialog pro výběr souboru. Pak
 * je křivka vyčtena z daného souboru.
 */
void MainWindow::curveLoadClicked()
{
    QString fileName = QFileDialog::getOpenFileName(this,
         tr("Načíst křivku"), "", tr("Souboru s křivkou (*.txt);;Vše (*.*)"));

    getCurveDataFromFile(fileName);
}

void MainWindow::measurementLoadClicked()
{
    openMeasurementFile();
    writeValue(BIT_MEASUREMENT_TO_PC, QModbusDataUnit::Coils, 1);
    currState = GET_MEAS_START;
}

QVector4D MainWindow::getDeltaMovingAverage(QVector4D point)
{
    tmpCurveMA.push_back(point);
    if (tmpCurveMA.size() > 10)
        tmpCurveMA.pop_front();
    qint32 sumx = 0, sumy = 0, sumz = 0;
    for (auto val: tmpCurveMA) {   //std::list<float>::iterator p = listDeltaMA.begin(); p != listDeltaMA.end(); ++p)
        sumx += val.x();
        sumy += val.y();
        sumz += val.z();
    }
    return QVector4D(sumx/tmpCurveMA.size(), sumy/tmpCurveMA.size(), sumz/tmpCurveMA.size(), point.w());
}

void MainWindow::openMeasurementFile()
{
    file.setFileName(QString("%1.csv").arg(QDateTime::currentDateTime().toString("yyyyMMdd-hhmmss")));
    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
         store.setDevice(&file);

         store << "cas;x1;y1;z1;x2;y2;z2;x3;y3;z3" << endl;
    }
}

//!  Načtení uložené křivky ze souboru
int MainWindow::getCurveDataFromFile(QString fileName)
{
    int nRet = 0;
    QFile file(fileName);

    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        calculatedCurve.clear();

        QTextStream storeFile(&file);
        QVector4D point;
        QVector3D pointPrev;
        QStringList list;
        QString line;

        tmpCurveMA.clear();

        while(!storeFile.atEnd()) {
            line = storeFile.readLine();
            list = line.split(';');
            if (list.size() < 4)
                continue;
            point.setX(list.at(0).toShort());
            point.setY(list.at(1).toShort());
            point.setZ(list.at(2).toShort());
            point.setW(list.at(3).toShort());
            if (calculatedCurve.size() > 1) {
                pointPrev = calculatedCurve.last().toVector3D();
                if (pointPrev.distanceToPoint(point.toVector3D()) > 500.0)
                    calculatedCurve.append(getDeltaMovingAverage(point));
            } else
                calculatedCurve.append(getDeltaMovingAverage(point));
            /*pos++;
            if ((pos % 4) == 0)
                calculatedCurve.append(getDeltaMovingAverage(point));*/
        }
        if (calculatedCurve.size() > 2) {
            for (int i = 0; i<10; i++)
                calculatedCurve.append(getDeltaMovingAverage(calculatedCurve.first()));
        }

        file.close();
        if (calculatedCurve.size() > 0) {
            ui->glwidget->setTubusColor(QVector4D(1, 0.737f, 0.231f, 0.7f));
            ui->glwidget->setCurve(calculatedCurve, cdServer);
        }
        actCurveFileName = fileName;
        actCurveType = CURVE_EXTERN;
        currState = SEND_CURVE;
        nRet = 1;
    }
    return nRet;
}

//! Uložení aktuální křivky
/*!
 * Po stisknutí tlačítka "Uložení křivky" se objeví dialog pro výběr souboru. Pak
 * je aktuální křivka uložena do daného souboru.
 */
void MainWindow::curveStoreClicked()
{
    if (calculatedCurve.size() > 0) {
        QString fileName = QFileDialog::getSaveFileName(this,
            tr("Uložit křivku"), "", tr("Souboru s křivkou (*.txt)"));

        QFile file(fileName);
        if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
            QTextStream storeFile(&file);

            for(auto &point: calculatedCurve) { //C++ 11 use
                storeFile << static_cast<qint16>(point.x()) << ";" << static_cast<qint16>(point.y())
                          << ";" << static_cast<qint16>(point.z()) << ";" << static_cast<qint16>(point.w()) << endl;
            }
            file.close();
        }

    } else {
        QMessageBox::warning(this, tr("Cvičební stroj"),
                             tr("<font size=15>V aplikaci není stažená žádná křivka\n</font>"),
                             QMessageBox::Ok);
    }
}

//! Přesun aktuatoru do defaultní pozice
void MainWindow::deviceResetClicked()
{
    writeValue(BIT_RESET_POS, QModbusDataUnit::Coils, 1);
}

//! Výběr pacienta
/*!
 * Po stisknutí tlačítka "Výběr pacienta" se objeví dialog pro výběr pacienta, který bude provádět procedury.
 * Konkrétní křivka a její provedení odpovídající proceduře je získána z databáze.
 */
void MainWindow::patientSelectClicked()
{
    if (!useDb) {
        infoDialog dlg;
        dlg.setInfoText(tr("Výběr pacienta/indikace"),tr("DB není použita, data nemohou být vybrána"));
        dlg.exec();
    } else {
        if (dbConnected) {
            selectPatientDlg dlg(db);
            QString cName;
            QStringList curveDataStr;
            dlg.exec();
            if (dlg.result() == QDialog::Accepted) {
                QString name, surname;
                dlg.getPatientInfo(&pId, &indId, &name, &surname, &actSeries, &procedureTimeRemaining, &cName);

                if (!cName.isEmpty()) {
                    curveDataStr = cName.split("_");
                    if (curveDataStr.size() == 4) {
                        actCurveType = curveDataStr.at(0).toInt();
                        actCurveAngle = curveDataStr.at(1).toInt();
                        actCurveRot = curveDataStr.at(2).toInt();
                        pronSupVal = curveDataStr.at(3).toInt();
                        ui->glwidget->setTubusColor(QVector4D(1, 0.737f, 0.231f, 0.7f));
                        setCurveData();
                    }
                }

                ui->patientNameLabel->setText(tr("Jméno: ") + name + " " + surname);
                ui->indicationLabel->setText(tr("Série: ") + QString::number(actSeries));
                ui->curveAssistPlayBtn->setText(tr("Spustit cvičení\n") + QString::number(procedureTimeRemaining/60)
                                                + ":" + QString("%1").arg(procedureTimeRemaining%60,2,10,QChar('0')) + "min");
                ui->procTimeDial->setValue(procedureTimeRemaining/60);
            }
        } else {
            infoDialog dlg;
            dlg.setInfoText(tr("Výběr pacienta/indikace"),tr("DB není připojena, data nemohou být vybrána"));
            dlg.exec();
        }
    }
}

//! Předvedení křivky strojem
/*!
 * Po stisknutí tlačítka "Provedení křivky" stroj začne opisovat křivku (bez asistence pacienta), která byla naposledy
 * do stroje poslána. Tento příkaz slouží k otestování, jak bude cvičení vypadat. Po dalším stisknutí tlačítka se
 * provádění křivky ukončí.
 * \param pressed Parametr, který obsahuje informaci o tom, jestli má být předvádění zahájeno, nebo ukončeno
 */
void MainWindow::curvePlayChanged(bool pressed)
{
    if (pressed)
        writeValue(BIT_BPLAY, QModbusDataUnit::Coils,1);
    else
        writeValue(BIT_BPLAY, QModbusDataUnit::Coils,0);
}

//! Start/stop procedury
/*!
 * Po stisknutí tlačítka "Spustit cvičení" stroj začne provádět cvičení (s asistencí pacienta) procedury. Provádí se
 * po křivce, která byla naposledy do stroje poslána. Procedura se zastaví buď po uplynutí nastaveného času a nebo po
 * dalším stisknutí téhož tlačítka, které bude po startu cvičení přejmenováno na "Ukončit cvičení"
 * \param pressed Parametr, který obsahuje informaci o tom, jestli má být procedura zahájena, nebo ukončena
 */
void MainWindow::curveAssistChanged(bool pressed)
{
#ifdef PROCEDURE_TEST
    if (pressed) {
        procedureTimer->start(1000);
        ui->curveAssistPlayBtn->setStyleSheet("background-color: rgb(255, 170, 0);");
    }
    else {
        procedureTimer->stop();

        procedureTimeRemaining = ui->procTimeDial->value()*60;
        ui->curveAssistPlayBtn->setText(tr("Spustit cvičení\n") + QString::number(procedureTimeRemaining/60)
                                        + ":" + QString("%1").arg(procedureTimeRemaining%60,2,10,QChar('0')) + "min");

        ui->curveAssistPlayBtn->setStyleSheet("background-color: rgb(0, 255, 0);");

        infoDialog dlg;
        dlg.setInfoText(tr("Cvičení"),tr("Cvičení je dokončeno"));
        dlg.exec();
    }
#else
    if (!bKeyState)
        return;

    if (pressed) {
        writeValue(BIT_BPLAY_ASSIST, QModbusDataUnit::Coils,1);
        ui->curveAssistPlayBtn->setStyleSheet("background-color: rgb(255, 170, 0);");
    } else {
        writeValue(BIT_BPLAY_ASSIST, QModbusDataUnit::Coils,0);
        ui->curveAssistPlayBtn->setStyleSheet("background-color: rgb(0, 255, 0);");
    }
#endif
}

//! Posun aktuátoru nahoru/dolu
/*!
 * Když je posuvník potažen směrem nahoru, stroj jede s aktuátorem nahoru. Dtto pro směr dolu
 * \param val Parametr, podle kterého se pozná, zda má stroj jet nahoru, nebo dolu
 */
void MainWindow::upDownSliderMoved(int val)
{
    QVector<quint16> vals;

    if (val > 50) { //motor nahoru
        vals.append(1);  //up
        vals.append(0);  //down
    } else if (val == 50) {  // motor zastavit
        vals.append(0);  //up
        vals.append(0);  //down
    } else { //motor dolu
        vals.append(0);  //up
        vals.append(1);  //down
    }
    writeValues(BIT_MOTOR_UP, QModbusDataUnit::Coils, vals);
}

//! Posun aktuátoru zastavit
/*!
 * Když je posuvník uvolněn, stroj zastaví pohyb nahoru/dolu.
 */
void MainWindow::movementSliderReleased()
{  //motor zastavit
    ui->upDownSlider->setValue(50);
    writeValue(BIT_MOTOR_UP, QModbusDataUnit::Coils,0);
    writeValue(BIT_MOTOR_DOWN, QModbusDataUnit::Coils,0);
}

//! Hlavní cyklus
/*!
 * Funkce je volána periodicky každých 100ms, když je modbus/tcp aktivní. Je zde řešena periodická kontrola spojení se strojem.
 * Pokud je modbus/tcp spojení ukončeno, zkusí se znovu připojit. V každém volání funkce se vytváří pořadavky na čtení dat ze stroje.
 * Dále se mění parametry stavového stroje na základě přijatých dat
 */
void MainWindow::mainCycle()
{
    if (connectionEstablished) {
        if (connectionGuard->elapsed() > 1000) {
            QLOG_ERROR() << tr("Od stroje nepřišla odpověď více, než 1 sekundu");
            connectionGuard->restart();
        }
    } else {
        if (connectionGuard->elapsed() > 20000) {
            QLOG_ERROR() << tr("Pokouším se znovu připojit");
            if (mbConnected) {
                mbClient->disconnectDevice();
                mbConnected = false;
            }
            connectClicked();
            connectionGuard->restart();
        }
    }

    if (waitDlg != nullptr) {
        int val = waitDlg->value();
        waitDlg->setValue(val+1);
#ifdef PROCEDURE_TEST
        itemCount = 0;
#endif
        if ((val > 48)|| (waitDlg->wasCanceled())) {
            delete waitDlg;
            waitDlg = nullptr;
            //stroj by mel byt v zakladni pozici

            infoDialog dlg;
            dlg.setInfoText("Učení", "Stroj je v základní pozici, stisknutím OK můžete začít učit pohyb\nPřipojte prosím pacienta ke stroji.");
            dlg.exec();

            writeValue(BIT_BTEACH, QModbusDataUnit::Coils,1);
            writeValue(BIT_BXYZ, QModbusDataUnit::Coils,1);
        }
    }

#if !defined(FILE_TEST) && !defined(PROCEDURE_TEST)
    if (!mbConnected)
        return;

    switch(currState) {
    case NO_STATE:
        if (!pendingRead) {
            //precteme vsechny vektory najednou - REG, REG_ACT,REG_DIR i REG_Q
            readValues(REG_X, QModbusDataUnit::HoldingRegisters, 15);
            //readValue(REG_SPEED, QModbusDataUnit::HoldingRegisters);
            readValue(BIT_WRITE_ENABLE, QModbusDataUnit::Coils);
            readValue(BIT_BTEACH, QModbusDataUnit::Coils);
            readValue(BIT_BPLAY_ASSIST, QModbusDataUnit::Coils);
            readValue(BIT_BPLAY, QModbusDataUnit::Coils);
            readValue(BIT_BKEY, QModbusDataUnit::DiscreteInputs);
            readValue(BIT_PART_FINISHED, QModbusDataUnit::Coils);
            readValue(BIT_SAFETY_BTN, QModbusDataUnit::DiscreteInputs);
            readValue(BIT_MEASUREMENT_TO_PC, QModbusDataUnit::Coils);
            pendingRead = true;
            if (!bProcedureRunning) {
                ui->glwidget->setSphereData(spherePos, QVector3D(0,0,0), QVector3D(0,0,0));
                ui->glwidget->setTestSphereData(spherePos);
            } else {
                ui->glwidget->setSphereData(spherePos,dirArrow*2,actualArrow*2); //pokusne prodlouzeni sipek - aby byly lepe videt
                if ((actCurveType == CURVE_CIRCLE) || (actCurveType == CURVE_ELLIPSE)
                        || (actCurveType == CURVE_KARD) || (actCurveType == CURVE_LEMN)
                        || (actCurveType == CURVE_LINE)) {
                    ui->glwidget->setTestSphereData(staticSpherePos);
                    if (staticSpherePos.distanceToPoint(spherePos) < minDistanceFromTarget) {
                        if (staticSpherePos == calcCurvePoints[0])
                            staticSpherePos = calcCurvePoints[1];
                        else
                            staticSpherePos = calcCurvePoints[0];
                    }
                } else {
                    ui->glwidget->setTestSphereData(spherePos);
                }
            }
            if (bTeachStatus) {
                ui->glwidget->addSphereData(spherePos, false, false);
                ui->glwidget->setTestSphereData(spherePos);
            }
        }
        break;
    case SEND_CURVE:
        curvePacket = 0;
        lastPacket = false;
        currState = SEND_PREP_CURVE;
        writeValue(BIT_DATA_TO_PLC, QModbusDataUnit::Coils,1);
        pd = new QProgressDialog("<font size=15>Křivka se odesílá do stroje</font>", "Zrušit", 0, calculatedCurve.size()/25+1);
        pd->setModal(true);
        pd->setValue(0);
        pd->show();
        break;
    case SEND_PREP_CURVE:
        int len;
        len = prepareCurveData(curvePacket);
        if (len < 25)
            lastPacket = true;

        currState = SEND_WAIT_CURVE;
        writeValue(BIT_RDY, QModbusDataUnit::Coils, 1);  //rdy
        QLOG_DEBUG() << "send packet";
        curvePacket++;
        break;
    case SEND_WAIT_CURVE:
        readValue(BIT_RDY, QModbusDataUnit::Coils);
        break;
    case SEND_LAST_CURVE:
        writeValue(BIT_DATA_TO_PLC, QModbusDataUnit::Coils,0);
        currState = NO_STATE;
        if (pd != nullptr) {
            delete pd;
            pd = nullptr;
        }
        break;
    case GET_CURVE:
        writeValue(BIT_DATA_TO_PC, QModbusDataUnit::Coils, 1); //ziskat krivku z PC
        curvePacket = 0;
        currState = GET_WAIT_CURVE;
        pd = new QProgressDialog("<font size=15>Křivka se čte ze stroje</font>", "Zrušit", 0, 100);
        pd->setModal(true);
        pd->setValue(0);
        pd->show();
        QLOG_DEBUG() << "Get new curve";
        receivedDataSize = 0;
        break;
    case GET_WAIT_CURVE:
        readValue(BIT_RDY, QModbusDataUnit::Coils);
        break;
    case GET_PART_CURVE:
        if (initStep) {
            readValues(REG_LEN, QModbusDataUnit::HoldingRegisters, 2);  //INDEX and LEN
            initStep = false;
        }
        break;
    case GET_NEXT_PART:
        QLOG_DEBUG() << "Get next part";
        currState = NO_STATE;
        break;
    case GET_MEAS_START:
        curvePacket = 0;
        receivedDataSize = 0;
        currState = GET_MEAS_WAIT;
        pd = new QProgressDialog("<font size=15>Měření se čte ze stroje</font>", "Zrušit", 0, 100);
        pd->setModal(true);
        pd->setValue(0);
        pd->show();
        QLOG_DEBUG() << "Get new measurement";
        break;
    case GET_MEAS_WAIT:
        readValue(BIT_RDY, QModbusDataUnit::Coils);
        break;
    case GET_MEAS_LEN:
        if (initStep) {
            readValues(REG_LEN, QModbusDataUnit::HoldingRegisters, 2);  //INDEX and LEN
            initStep = false;
        }
        break;
    case GET_MEAS_NEXT:
        QLOG_DEBUG() << "Get next part";
        currState = NO_STATE;
        break;
    default:
        ;
    }
#endif

    if (pd != nullptr) {
        if (pd->wasCanceled()) {
            QLOG_DEBUG() << "cancel dlg pressed";
            if (currState == SEND_WAIT_CURVE)
                currState = SEND_LAST_CURVE;
            else {
                if (file.isOpen()) {
                    file.close();
                }
                if (pd != nullptr) {
                    delete pd;
                    pd = nullptr;
                }
                writeValue(BIT_DATA_TO_PLC, QModbusDataUnit::Coils,0); //ukoncit krivku z PLC
                writeValue(BIT_DATA_TO_PC, QModbusDataUnit::Coils, 0); //ukoncit krivku z PC
                writeValue(BIT_MEASUREMENT_TO_PC, QModbusDataUnit::Coils, 0);
                currState = NO_STATE;
            }

        }
    }

    if ((safetyBtnState == 0)||(bKeyState == 0)) {  //neni stisknuto bezp. tlacitko, nebo nein nahozen klicek auto
        blinkCntr++;
        if (blinkCntr > 10) {
            if (safetyBtnState == 0) {
                if (safetyBtnBlinkOn)
                    ui->safetyBtnLabel->setStyleSheet("background-color: rgb(255,0,0)");
                else
                    ui->safetyBtnLabel->setStyleSheet("");
                safetyBtnBlinkOn = !safetyBtnBlinkOn;
            }
            if (bKeyState == 0) {
                if (keyAutoBtnBlinkOn)
                    ui->autoKeyStatusLabel->setStyleSheet("background-color: #ffa500");  //oranzova
                else
                    ui->autoKeyStatusLabel->setStyleSheet("");
                keyAutoBtnBlinkOn = !keyAutoBtnBlinkOn;
            }
            blinkCntr = 0;
        }
    }
#ifdef GRAPH_TEST
    cntr++;
    if (cntr > 100) {
        double r = ((double) rand() / (RAND_MAX))*100;
        cntr = 0;
        qualitySet->append(r);
        chart->removeSeries(qualityData);
        chart->addSeries(qualityData);
        chart->setAxisY(axisy, qualityData);

        QLOG_DEBUG() << QString("Data %1, %2").arg(itemCount).arg(r);
        itemCount++;
    }
#endif

#ifdef PROCEDURE_TEST
    cntr++;
    if (cntr > 1) {
        QVector4D vec, vec1, vec2;
        bool start = false, finish = false;
        cntr = 0;
        if (!calculatedCurve.isEmpty())
            vec = calculatedCurve.at(itemCount);
        else
            vec = QVector4D(0,0,0,0);


        //vec = sphere.at(itemCount);
        cur.append(vec);
        vec1 = dir.at(itemCount);
        vec2 = act.at(itemCount);
        vec1 = vec2 = QVector4D(0,0,0,0);

        if (itemCount == 0) {
            start = true;
        }
        //itemCount += 10;
        itemCount ++;
        //if (itemCount > sphere.size()-1) {
        if (itemCount > calculatedCurve.size()-1) {
            itemCount = 0;
            cur.clear();
            finish = true;
        }

        //ui->glwidget->setTubusColor(QVector4D(0, 0.87f, 0.87f, 1));
        //ui->glwidget->addSphereData(vec, start, finish);

        /*if (itemCount > calculatedCurve.size()-1)
            itemCount = 0;*/
        /*if (!cur.isEmpty() && (cur.size() > 5)) {
            const QList<QVector3D> *data;
            data = &cur;
            ui->glwidget->setCurve(*data);
        }*/
        //ui->glwidget->setSphereData(vec.toVector3D(), vec1.toVector3D(), vec2.toVector3D());
        vec1 = QVector4D((float)rand()/(RAND_MAX)*2-1.0,(float)rand()/(RAND_MAX)*2-1.0,(float)rand()/(RAND_MAX)*2-1.0,0);
        ui->glwidget->setSphereData(vec.toVector3D(),
                                    QVector3D::crossProduct(vec.toVector3D()/5, vec1.toVector3D()),
                                    QVector3D::crossProduct(vec.toVector3D()/5, QVector3D(0,1,0)));
                                    /*QVector3D::crossProduct(vec.toVector3D()/5, QVector3D(-1,0,0)),
                                    QVector3D::crossProduct(vec.toVector3D()/5, QVector3D(0,1,0)));*/
        //ui->glwidget->setSphereData(vec, QVector3D(1000,-1000,0), QVector3D(-1200,1200,500));
        connectionGuard->restart();
    }
#endif
    cdServer->sendActuatorPosition(spherePos.x(), spherePos.y(), spherePos.z());
    cdServer->sendActualDirection(actualArrow.x(), actualArrow.y(), actualArrow.z());
    cdServer->sendTargetDirection(dirArrow.x(), dirArrow.y(), dirArrow.z());
    cdServer->processPings();
}

//! Příjem dat ze stroje
/*!
 * Funkce je volána, jakmile přijdou jakákoliv data ze stroje po modbus/tcp. Data se zpracují a jsou připravena
 * pro provádění akce v hlavním cyklu
 */
void MainWindow::readyRead()
{
    QModbusReply *readRequest = qobject_cast<QModbusReply *>(sender());
    if (!readRequest)
        return;

    if (readRequest->error() == QModbusDevice::NoError) {
        const QModbusDataUnit unit = readRequest->result();
        int value, address = unit.startAddress();
        connectionGuard->restart();

        switch(unit.registerType()) {
        case QModbusDataUnit::Coils:
            for (uint i = 0; i < unit.valueCount(); i++) {
                value = unit.value(i);
                int addr = address+i;
                /*if ((address+i) == BIT_DATA_TO_PLC) {
                    if (value != 0) {
                        if (currState != SEND_LAST_CURVE)
                            currState = SEND_CURVE;
                    } else {
                        currState = NO_STATE;
                        lastPacket = false;
                    }
                } else*/
                switch(addr) {
                case BIT_RDY:
                {
                    if ((currState == SEND_WAIT_CURVE) && (value == 0)) {
                        if (lastPacket) {
                            QLOG_DEBUG() << "Last packet sent";
                            currState = SEND_LAST_CURVE;
                        } else {
                            QLOG_DEBUG() << "Send new data";
                            currState = SEND_PREP_CURVE;
                        }
                        if (pd != nullptr) {
                            pd->setValue(curvePacket);
                        }
                    } else if ((currState == GET_WAIT_CURVE) && (value == 1)) {
                        initStep = true;
                        currState = GET_PART_CURVE;
                    } else if ((currState == GET_MEAS_WAIT) && (value == 1)) {
                        initStep = true;
                        currState = GET_MEAS_LEN;
                    }
                    break;
                }
                case BIT_WRITE_ENABLE:
                {
                    if (bWriteEnable != value) {
                        /*if (value == 0)
                            ui->curveBtn->setEnabled(false);
                        else
                            ui->curveBtn->setEnabled(true);*/
                        bWriteEnable = value;
                        QLOG_DEBUG() << "bWriteEnableChanged";
                    }
                    break;
                }
                case BIT_BTEACH:
                {
                    if (bTeachStatus != value) {
                        if (value == 0) {
                            changeClicked();//stahnout krivku
                            actCurveType = CURVE_NONE; //neni vybrana zadna predpocitana krivka
                            if (ui->curveTeachBtn->isChecked())
                                ui->curveTeachBtn->toggle();
                            ui->glwidget->addSphereData(spherePos, false, true);
                        } else {
                            if (!ui->curveTeachBtn->isChecked())
                                ui->curveTeachBtn->toggle();
                            ui->glwidget->setTubusColor(QVector4D(0, 0.87f, 0.87f, 0.7f));
                            ui->glwidget->addSphereData(spherePos, true, false);
                        }
                        QLOG_DEBUG() << "bTeach changed";
                        bTeachStatus = value;
                    }
                    break;
                }
                case BIT_BPLAY:
                {
                    if (bPlay != value) {
                        if (value == 0) {
                            if (ui->curvePlayBtn->isChecked())
                                ui->curvePlayBtn->toggle();
                        } else {
                            if (!ui->curvePlayBtn->isChecked())
                                ui->curvePlayBtn->toggle();
                        }
                        QLOG_DEBUG() << "bPlay changed";
                        bPlay = value;
                    }
                    break;
                }
                case BIT_BPLAY_ASSIST:
                {
                    if (bProcedureRunning != value) {
                        QLOG_DEBUG() << QString("bPlayAssist changed, val %1").arg(value);
                        bProcedureRunning = value;
                        //ui->glwidget->procedureState(value);
                        if (value != 0) {
                            overallQ = oneCycleQ = tempQ = 0;
                            itemCount = 0;
                            qualitySet->remove(0,qualitySet->count());
                            ui->overallQualityEdit->setText("0");
                            ui->oneCycleQualityEdit->setText("0");
                            ui->actQualityEdit->setText("0");
                            if (!ui->curveAssistPlayBtn->isChecked())
                                ui->curveAssistPlayBtn->toggle();
                            procedureQuality.clear();
                            procedureTimer->start(1000);
                            if (actCurveType != CURVE_NONE) {
                                staticSpherePos = calcCurvePoints[0];
                            }
                        } else {
                            ui->overallQualityEdit->setText(QString("%1").arg(overallQ));  //konec cviceni, zobrazit celkovy vysledek
                            if (ui->curveAssistPlayBtn->isChecked())
                                ui->curveAssistPlayBtn->toggle();
                            procedureTimer->stop();
                            if (dbConnected)
                                db->addResult(pId, indId, actSeries, procedureQuality);

                            procedureTimeRemaining = ui->procTimeDial->value()*60;
                            ui->curveAssistPlayBtn->setText(tr("Spustit cvičení\n") + QString::number(procedureTimeRemaining/60)
                                                + ":" + QString("%1").arg(procedureTimeRemaining%60,2,10,QChar('0')) + "min");
                        }
                    }
                    break;
                }
                case BIT_PART_FINISHED:
                {
                    if (bPartState != value) {
                        if (value != 0) {
                            QLOG_DEBUG() << "part finished";
                            ui->oneCycleQualityEdit->setText(QString("%1").arg(oneCycleQ));
                            writeValue(BIT_PART_FINISHED, QModbusDataUnit::Coils, 0); //vynulovat priznak konce jednoho cyklu
                            if (oneCycleQ > 0)
                                procedureQuality.append(oneCycleQ);
                            qualitySet->append(oneCycleQ);
                            chart->removeSeries(qualityData);
                            chart->addSeries(qualityData);
                            chart->setAxisY(axisy, qualityData);
                            itemCount++;
                        }
                        bPartState = value;
                    }
                    break;
                }
                case BIT_MEASUREMENT_TO_PC:
                {
                    if (value && (currState < GET_MEAS_START)) {
                        currState = GET_MEAS_START;
                        openMeasurementFile();
                    }
                    if (!value && (currState > GET_MEAS_START )) {
                        if (file.isOpen()) {
                            file.close();
                        }
                        if (pd != nullptr) {
                            delete pd;
                            pd = nullptr;
                        }
                    }
                    break;
                }
                default:
                    ;
                }
            }
            break;
        case QModbusDataUnit::HoldingRegisters:
            if ((unit.startAddress() == REG_X)&&(unit.valueCount() == 15)) {
                spherePos = QVector3D((qint16)unit.value(0)/1.0,(qint16)unit.value(1)/1.0,(qint16)unit.value(2)/1.0);
                //QLOG_DEBUG() << QString("sphere %1,%2,%3").arg((qint16)unit.value(0)/1.0).arg((qint16)unit.value(1)/1.0).arg((qint16)unit.value(2)/1.0);
                //a = unit.value(3);
                //REG_ACT_X
                dirArrow = QVector3D((qint16)unit.value(4)/1.0,(qint16)unit.value(5)/1.0,(qint16)unit.value(6)/1.0);
                //QLOG_DEBUG() << QString("dir %1,%2,%3").arg((qint16)unit.value(4)/1.0).arg((qint16)unit.value(5)/1.0).arg((qint16)unit.value(6)/1.0);
                //REG_DIR_X
                actualArrow = QVector3D((qint16)unit.value(8)*4.0,(qint16)unit.value(9)*4.0,(qint16)unit.value(10)*4.0);
                //QLOG_DEBUG() << QString("act %1,%2,%3").arg((qint16)unit.value(8)/1.0).arg((qint16)unit.value(9)/1.0).arg((qint16)unit.value(10)/1.0);
                //REG_Q
                overallQ = unit.value(13);
                value = unit.value(12);
                /*if ((value != 0)&&(oneCycleQ != 0)) {
                    QLOG_DEBUG() << "cycle finished - quality " << value;
                    ui->oneCycleQualityEdit->setText(QString("%1").arg(value));
                    procedureQuality.append(value);
                    //end of cycle
                }*/
                oneCycleQ = value;
                tempQ = unit.value(14);
                ui->overallQualityEdit->setText(QString("%1").arg(overallQ));
                ui->actQualityEdit->setText(QString("%1").arg(tempQ));
            }

            if (unit.startAddress() == REG_DATA) {
                QLOG_DEBUG() << QString("Mam %1 dat a %2 uz jich je stazeno").arg(unit.valueCount()/4).arg(calculatedCurve.size());
                getCurveData(currState, nIndex, unit.values());
                writeValue(BIT_RDY, QModbusDataUnit::Coils, 0); //ziskat krivku z PC
                if (pd != nullptr)
                    pd->setValue(receivedDataSize);

                /*if ((numPoints - nIndex) > 0) {
                    if (currState == GET_PART_CURVE) {
                        currState = GET_WAIT_CURVE;
                        pd->setValue(calculatedCurve.size());
                    }
                    else {
                        currState = GET_MEAS_WAIT;
                        pd->setValue(numPoints - nIndex);
                    }
                    QLOG_DEBUG() << "Dalsi cast";
                }*/

                if (receivedDataSize < numPoints) {
                    if (currState == GET_PART_CURVE)
                        currState = GET_WAIT_CURVE;
                    else
                        currState = GET_MEAS_WAIT;
                    QLOG_DEBUG() << "Dalsi cast";
                }
                else {
                    QLOG_DEBUG() << "OK mam krivku";
                    currState = NO_STATE;
                    if (currState == GET_PART_CURVE) {
                        writeValue(BIT_DATA_TO_PC, QModbusDataUnit::Coils, 0); //ziskat krivku z PC
                        ui->glwidget->setTubusColor(QVector4D(1, 0.737f, 0.231f, 0.7f));
                        if (calculatedCurve.size() > MAX_CURVE_SIZE) {
                            infoDialog dlg;
                            dlg.setInfoText(tr("Velikost křivky"), tr("Předcvičená křivka je příliš dlouhá.\nBude zkrácena."));
                            dlg.exec();
                        }
                        if (calculatedCurve.size() > 0) {
                            ui->glwidget->setCurve(calculatedCurve, cdServer);
                        } else {
                            infoDialog dlg;
                            dlg.setInfoText(tr("Velikost křivky"), tr("Naučená křivka nelze použít. Neplatná data."));
                            dlg.exec();
                            display3DScene();
                        }
                    } else {
                        writeValue(BIT_MEASUREMENT_TO_PC, QModbusDataUnit::Coils, 0);
                    }
                    if (file.isOpen()) {
                        file.close();
                    }
                    if (pd != nullptr) {
                        delete pd;
                        pd = nullptr;
                    }
                    //ui->changeDataBtn->setEnabled(false);   //ok mam vsechny data, cekam na dalsi nauceni stroje
                }
                initStep = true;
            } else if (unit.startAddress() == REG_LEN) {
                numPoints = unit.value(0);  //pocet bodu
                nIndex  = unit.value(1);    //index
                QLOG_DEBUG() << QString("Mam len  %1, index %2").arg(numPoints).arg(nIndex);
                readValues(REG_DATA, QModbusDataUnit::HoldingRegisters, 100); //precti data
                if (pd != nullptr)
                    pd->setMaximum(numPoints);
            } else if (unit.startAddress() == REG_SPEED) {
            }

            /*for (uint i = 0; i < unit.valueCount(); i++) {
                const QString entry = tr("Address: %1, Value: %2").arg(unit.startAddress() + i)
                        .arg(QString::number(unit.value(i)));
                ui->textEdit->append(entry);
            }*/
            break;
        case QModbusDataUnit::DiscreteInputs:
            value = unit.value(0);
            if  (address == BIT_BKEY) {
                if (bKeyState != value) {
                    QLOG_DEBUG() << "BKEY DI changed val = " << value;
                    if (value == 0) {
                        ui->curveAssistPlayBtn->setEnabled(false);
                    }
                    else {
                        ui->curveAssistPlayBtn->setEnabled(true);
                        ui->autoKeyStatusLabel->setStyleSheet("background-color: #00ff00");
                    }
                    bKeyState = value;
                }
            } else if  (address  == BIT_SAFETY_BTN) {
                safetyBtnState = value;
                if (value == 1)
                    ui->safetyBtnLabel->setStyleSheet("background-color: rgb(0,255,0)");
            }
            break;
        default:
            break;

        }
    } else if (readRequest->error() == QModbusDevice::ProtocolError) {
        QLOG_ERROR() << QString(tr("Read response error: %1 (Modbus exception: 0x%2)").
                                 arg(readRequest->errorString()).
                                 arg(readRequest->rawResult().exceptionCode(), -1, 16));
    } else {
        QLOG_ERROR() << QString(tr("Read response error: %1 (code: 0x%2)").
                                 arg(readRequest->errorString()).
                                 arg(readRequest->error(), -1, 16));
    }

    readRequest->deleteLater();

    pendingRead = false;
}

//! Potvrzení zápisu dat na Modbus/TCP
void MainWindow::writeFinished()
{
    QModbusReply *writeRequest = qobject_cast<QModbusReply *>(sender());
    if (!writeRequest)
        return;

    if (writeRequest->error() == QModbusDevice::ProtocolError) {
        QLOG_ERROR() << QString(tr("Write response error: %1 (Modbus exception: 0x%2)")
                                 .arg(writeRequest->errorString()).arg(writeRequest->rawResult().exceptionCode(), -1, 16));
    } else if (writeRequest->error() != QModbusDevice::NoError) {
        QLOG_ERROR() << QString(tr("Write response error: %1 (code: 0x%2)").
                                 arg(writeRequest->errorString()).arg(writeRequest->error(), -1, 16));
    }
    writeRequest->deleteLater();
}

//! Změna stavu spojení s modbus/tcp serverem
/*!
 * Funkce se volá, pokud se změní stav spojení modbus/tcp. Vzhled aplikace se upraví na základě stavu spojení.
 * \param state Stav spojení - Connected, nebo Unconnected
 */
void MainWindow::onStateChanged(int state)
{
    bool connected = (state != QModbusDevice::UnconnectedState);

    if (state == QModbusDevice::UnconnectedState) {
        ui->connectionLabel->setText(tr("Odpojeno"));
        ui->connectionLabel->setStyleSheet("background-color: rgb(255,0,0)");
        ui->safetyBtnLabel->setStyleSheet("");
        ui->autoKeyStatusLabel->setStyleSheet("");
        mbConnected = false;
        //checkTimer->stop();
        checkTimer->setInterval(500);

        ui->resetPosBtn->setEnabled(false);
        ui->curvePlayBtn->setEnabled(false);
        ui->curveAssistPlayBtn->setEnabled(false);
        ui->curveGenerateBtn->setEnabled(false);
        ui->curveTeachBtn->setEnabled(false);
        ui->curveLoadBtn->setEnabled(false);
        ui->curveStoreBtn->setEnabled(false);

        connectClicked();
    } else if (state == QModbusDevice::ConnectedState) {
        mbConnected = true;
        ui->connectionLabel->setText(tr("Připojeno"));
        ui->connectionLabel->setStyleSheet("background-color: rgb(0,255,0)");
        //checkTimer->start(100);
        checkTimer->setInterval(100);

        bTeachStatus = bWriteEnable = bProcedureRunning = bPartState = bKeyState = bPlay = safetyBtnState = 0;

        ui->resetPosBtn->setEnabled(true);
        ui->curvePlayBtn->setEnabled(true);
        ui->curveGenerateBtn->setEnabled(true);
        ui->curveTeachBtn->setEnabled(true);
        ui->curveLoadBtn->setEnabled(true);
        ui->curveStoreBtn->setEnabled(true);

        connectionGuard->restart();
        connectionEstablished = true;

        //ziskat rovnou status tlacitek
        readValue(BIT_BKEY, QModbusDataUnit::DiscreteInputs);
        readValue(BIT_SAFETY_BTN, QModbusDataUnit::DiscreteInputs);

        setCurveData();  //nahrat do stroje rovnou krivku
    }
}

//! Ošetření chyby při komunikaci
void MainWindow::handleDeviceError(QModbusDevice::Error newError)
{
    if (newError == QModbusDevice::NoError || !mbClient)
        return;

    QLOG_ERROR() <<  mbClient->errorString();
}

//! Vytvoření úvodní 3D "křivky", pokud není ještě křivka ze stroje k dispozici
void MainWindow::display3DScene()
{
    calculatedCurve.clear();
    calculatedCurve.append(QVector4D(0,0,-4900,0.0));
    calculatedCurve.append(QVector4D(0,0,-4900,0.0));
    calculatedCurve.append(QVector4D(0,0,-4900,0.0));
    calculatedCurve.append(QVector4D(0,0,-4000,0.0));
    ui->glwidget->setCurve(calculatedCurve, cdServer);
}

//! Aktualizace času při asistovaném cvičení pacienta
void MainWindow::updateAppTime()
{
    if (procedureTimeRemaining > 0) {
        procedureTimeRemaining--;
        ui->curveAssistPlayBtn->setText(tr("Ukončit cvičení\n") + QString::number(procedureTimeRemaining/60)
                                                + ":" + QString("%1").arg(procedureTimeRemaining%60,2,10,QChar('0')) + "min");
        if (procedureTimeRemaining == 0) {
            procedureTimer->stop();
            ui->curveAssistPlayBtn->toggle();
        }
    }
}

//! Úprava doby asistovaného cvičení
void MainWindow::timeDialMoved(int time)
{
    QString txt = tr("Ukončit cvičení\n");
    if (!bProcedureRunning) {
        txt = tr("Spustit cvičení\n");
    }
    ui->curveAssistPlayBtn->setText(txt + QString::number(time) + ":00 min");
}

//! Úprava doby asistovaného cvičení
void MainWindow::timeDialReleased()
{
    QString txt = tr("Ukončit cvičení\n");

    if (!bProcedureRunning) {
        txt = tr("Spustit cvičení\n");
    }
    procedureTimeRemaining = ui->procTimeDial->value()*60;
    ui->curveAssistPlayBtn->setText(txt + QString::number(procedureTimeRemaining/60) + ":00 min");
}

#ifdef PROCEDURE_TEST
QList<QVector4D> MainWindow::readPoints(QString fName)
{
    QList<QVector4D> results;
    double a = 0.0;

    QFile file(fName);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return results;
    }

    while (!file.atEnd())
    {
        QByteArray line = file.readLine();
        QList<QByteArray> splitted = line.split(';');
        if (splitted.size() < 3)
            continue;
        if (splitted.size() == 4)
            a = splitted.at(3).trimmed().toFloat();
        QVector4D point(QString(splitted.at(0)).trimmed().toFloat(), QString(splitted.at(1)).trimmed().toFloat(), QString(splitted.at(2)).trimmed().toFloat(),a);
        results.append(point);
    }
    return results;
}
#endif

//! Vytvoření modbus/tcp požadavku na čtení jedné hodnoty
/*!
 * \param addr Modbus adresa
 * \param table Typ registru
 */
void MainWindow::readValue(int addr, QModbusDataUnit::RegisterType table)
{
    QModbusDataUnit unit(table, addr, 1);
    if (QModbusReply *readRequest = mbClient->sendReadRequest(unit, mbServerId)) {
        if (!readRequest->isFinished())
            connect(readRequest, SIGNAL(finished()), this, SLOT(readyRead()));
        else
            delete readRequest; // broadcast replies return immediately
    } else {
        QLOG_ERROR() << QString("Read error: %1").arg(mbClient->errorString());
    }
}

//! Vytvoření modbus/tcp požadavku na čtení více hodnot
/*!
 * \param addr Modbus adresa
 * \param table Typ registrů
 * \param regCount Počet čtených registrů
 */
void MainWindow::readValues(int addr, QModbusDataUnit::RegisterType table, qint16 regCount)
{
    QModbusDataUnit unit(table, addr, regCount);
    if (QModbusReply *readRequest = mbClient->sendReadRequest(unit, mbServerId)) {
        if (!readRequest->isFinished())
            connect(readRequest, SIGNAL(finished()), this, SLOT(readyRead()));
        else
            delete readRequest; // broadcast replies return immediately
    } else {
        QLOG_ERROR() << QString("Read error: %1").arg(mbClient->errorString());
    }
}

//! Vytvoření modbus/tcp požadavku na zápis jedné hodnoty
/*!
 * \param addr Modbus adresa
 * \param table Typ registru
 * \param value Zapisovaná hodnota
 */
void MainWindow::writeValue(int addr, QModbusDataUnit::RegisterType table, qint16 value)
{
    QModbusDataUnit unit(table, addr, 1);
    unit.setValue(0, value);

    if (QModbusReply *reply = mbClient->sendWriteRequest(unit, mbServerId)) {
        if (!reply->isFinished()) {
            connect(reply, SIGNAL(finished()), this, SLOT(writeFinished()));
        } else {
            // broadcast replies return immediately
            reply->deleteLater();
        }
    } else {
        QLOG_ERROR() << QString("Write error: %1").arg(mbClient->errorString());
    }
}

//! Vytvoření modbus/tcp požadavku na zápis více hodnot
/*!
 * \param addr Modbus adresa
 * \param table Typ registru
 * \param vals Zapisované hodnoty
 */
void MainWindow::writeValues(int addr, QModbusDataUnit::RegisterType table, QVector<quint16> vals)
{
    QModbusDataUnit unit(table, addr, vals);
    if (QModbusReply *reply = mbClient->sendWriteRequest(unit, mbServerId)) {
        if (!reply->isFinished()) {
            connect(reply, SIGNAL(finished()), this, SLOT(writeFinished()));
        } else {
            // broadcast replies return immediately
            reply->deleteLater();
        }
    } else {
        QLOG_ERROR() << QString("Write error: %1").arg(mbClient->errorString());
    }
}

//! Příprava bloku dat pro stroj
/*!
 * Připraví požadovaný blok dat s křivkou pro poslání do stroje
 * \param packetNo Pořadové číslo bloku
 * \return Počet poslaných dat
 */
int MainWindow::prepareCurveData(int packetNo)
{
    int nLen = 0;
    QVector<quint16> vals;

    QLOG_DEBUG() << "prepare data";
    QLOG_DEBUG() << QString("data count %1, packetNo %2").arg(calculatedCurve.size()).arg(packetNo);

    if (calculatedCurve.size() < packetNo*25)
        return 0;

    if (calculatedCurve.size() > 0) {
        nLen = (calculatedCurve.size() - packetNo*25);
        if (nLen > 25)
            nLen = 25;
        QLOG_DEBUG() << QString("Send data size %1, packetNo %2").arg(nLen).arg(packetNo);
        for(int i = 0; i < nLen; i++) {
            vals.append((qint16)(calculatedCurve.at(i+25*packetNo).x())); //x
            vals.append((qint16)(calculatedCurve.at(i+25*packetNo).y())); //y
            vals.append((qint16)(calculatedCurve.at(i+25*packetNo).z())); //z
            vals.append((qint16)(calculatedCurve.at(i+25*packetNo).w())); //a
        }
        writeValues(REG_DATA, QModbusDataUnit::HoldingRegisters, vals);
        writeValue(REG_INDEX, QModbusDataUnit::HoldingRegisters, packetNo*25); //index
        writeValue(REG_LEN, QModbusDataUnit::HoldingRegisters, calculatedCurve.size()); //len
    }

    return nLen;
}

//! Získání bloku dat ze stroje
/*!
 * Přijme další blok dat s křivkou od stroje, přidá dané bodu do aktuální křivky, která se na konci vykreslí
 * ve 3D okně
 * \param packetNo Pořadové číslo bloku
 * \param data Přijatá data
 * \return Počet přijatých dat
 */
int MainWindow::getCurveData(int dataType, int packetNo, QVector<quint16> data)
{
    int nLen = 0, packetRemaining = numPoints - packetNo;

    if (dataType == GET_PART_CURVE)
    {
        nLen = (packetRemaining < 25) ? packetRemaining : 25;

        QLOG_DEBUG() <<  QString("nLen = %1, data size %2").arg(nLen).arg(data.size());
        if ((nLen*4) > data.size()) {
            QLOG_ERROR() << "Not enough data came - use only prersent data";
            nLen = data.size()/4;
        }

        for(int i = 0; i < nLen; i++) {
            calculatedCurve.append(QVector4D((qint16)data.at(i*4), (qint16)data.at(i*4 + 1),
                                         (qint16)data.at(i*4 + 2), (qint16)data.at(i*4 + 3)));
            if (file.isOpen()) {
                store << (qint16)data.at(i*4) << ";" << (qint16)data.at(i*4 + 1)
                      << ";" << (qint16)data.at(i*4 + 2) << ";" << (qint16)data.at(i*4 + 3) << endl;
            }
        }
    } else {
        nLen = (packetRemaining < 10) ? packetRemaining : 10;

        QLOG_DEBUG() <<  QString("nLen = %1, data size %2").arg(nLen).arg(data.size());
        if ((nLen*10) > data.size()) {
            QLOG_ERROR() << "Not enough data came - use only present data";
            nLen = data.size()/10;
        }

        for(int i = 0; i < nLen; i++) {
            if (file.isOpen()) {
                store << (qint16)data.at(i*10) << ";" << (qint16)data.at(i*10 + 1)
                      << ";" << (qint16)data.at(i*10 + 2) << ";" << (qint16)data.at(i*10 + 3)
                      << ";" << (qint16)data.at(i*10 + 4) << ";" << (qint16)data.at(i*10 + 5)
                      << ";" << (qint16)data.at(i*10 + 6) << ";" << (qint16)data.at(i*10 + 7)
                      << ";" << (qint16)data.at(i*10 + 8) << ";" << (qint16)data.at(i*10 + 9)
                      << endl;
            }
        }
    }
    receivedDataSize += nLen;
    QLOG_DEBUG() << QString("get data packet No %1, received data count %2, packetRem %3").arg(packetNo).arg(receivedDataSize).arg(packetRemaining);

    return nLen;
}