GuiHealthClientWidgetController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * \package    RobotAPI::gui-plugins::GuiHealthClientWidgetController
 * \author     Simon Ottenhaus ( simon dot ottenhaus at kit dot edu )
 * \date       2018
 * \copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "GuiHealthClientWidgetController.h"
 
#include <RobotAPI/gui-plugins/GuiHealthClient/ui_GuiHealthClientWidget.h>
 
#include <iomanip>
#include <string>
 
#include <QLabel>
#include <QPushButton>
#include <qcolor.h>
#include <qnamespace.h>
#include <qrgb.h>
#include <qtablewidget.h>
 
#include <SimoxUtility/algorithm/get_map_keys_values.h>
 
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/Duration.h>
#include <ArmarXCore/core/time/ice_conversions.h>
 
namespace armarx
{
    std::string
    serializeList(const std::vector<std::string>& l)
    {
        std::string s;
        for (std::size_t i = 0; i < l.size(); i++)
        {
            const auto& tag = l.at(i);
            s += tag;
 
            if (i != l.size() - 1)
            {
                s += ", ";
            }
        }
 
        return s;
    }
 
    GuiHealthClientWidgetController::GuiHealthClientWidgetController()
    {
        widget = std::make_unique<Ui::GuiHealthClientWidget>();
        widget->setupUi(getWidget());
 
        connect(this,
                SIGNAL(invokeConnectComponentQt()),
                this,
                SLOT(onConnectComponentQt()),
                Qt::QueuedConnection);
        connect(this,
                SIGNAL(invokeDisconnectComponentQt()),
                this,
                SLOT(onDisconnectComponentQt()),
                Qt::QueuedConnection);
 
        connect(widget->pushButtonUnrequireAll, SIGNAL(clicked()), this, SLOT(unrequireAll()));
 
        updateSummaryTimer = new QTimer(this);
        updateSummaryTimer->setInterval(100);
        connect(updateSummaryTimer, SIGNAL(timeout()), this, SLOT(updateSummaryTimerClb()));
    }
 
    GuiHealthClientWidgetController::~GuiHealthClientWidgetController()
    {
    }
 
    void
    GuiHealthClientWidgetController::loadSettings(QSettings* settings)
    {
    }
 
    void
    GuiHealthClientWidgetController::saveSettings(QSettings* settings)
    {
    }
 
    void
    GuiHealthClientWidgetController::onInitComponent()
    {
        //ARMARX_IMPORTANT << "onInitComponent";
        usingProxy("RobotHealth");
        offeringTopic("RobotHealthTopic");
    }
 
    void
    GuiHealthClientWidgetController::healthTimerClb()
    {
        armarx::core::time::dto::DateTime now;
        armarx::core::time::toIce(now, armarx::core::time::DateTime::Now());
        robotHealthTopicPrx->heartbeat(getName(), now);
    }
 
    std::string
    to_string_rounded(float value, int decimals = 100)
    {
        std::stringstream ss;
        ss << std::fixed << std::setprecision(3) << value;
        return ss.str();
    }
 
    QTableWidgetItem*
    make_item(const std::string& text, Qt::AlignmentFlag horAlignment = Qt::AlignLeft)
    {
        auto* item = new QTableWidgetItem(QString::fromStdString(text));
        item->setTextAlignment(horAlignment | Qt::AlignVCenter);
        return item;
    }
 
    void
    GuiHealthClientWidgetController::updateSummaryTimerClb()
    {
        //ARMARX_IMPORTANT << "updateSummaryTimerClb";
        if (robotHealthComponentPrx)
        {
            //ARMARX_IMPORTANT << "has robotHealthComponentPrx";
            try
            {
                auto summary = robotHealthComponentPrx->getSummary();
 
                const std::size_t nCols = 10;
 
                auto& tableWidget = widget->tableHealthState;
                tableWidget->setRowCount(summary.entries.size());
                tableWidget->setColumnCount(nCols);
 
                const auto summaryVals = simox::alg::get_values(summary.entries);
 
                tableWidget->setHorizontalHeaderLabels({"identifier",
                                                        "required",
                                                        "keeps frequency",
                                                        "tags",
                                                        "time since\nlast arrival [ms]",
                                                        "time to\nreference [ms]",
                                                        "time sync \n+ Ice [ms]",
                                                        "warning\nthreshold [ms]",
                                                        "error\nthreshold [ms]",
                                                        "hostname"});
 
                tableWidget->setColumnWidth(0, 250);
                tableWidget->setColumnWidth(1, 80);
                tableWidget->setColumnWidth(2, 120);
                tableWidget->setColumnWidth(3, 180);
                tableWidget->setColumnWidth(4, 120);
                tableWidget->setColumnWidth(5, 120);
                tableWidget->setColumnWidth(6, 120);
                tableWidget->setColumnWidth(7, 120);
 
                for (std::size_t i = 0; i < summary.entries.size(); i++)
                {
                    const auto& entry = summaryVals.at(i);
 
                    std::string stateRepr;
                    QColor stateColor;
                    switch (entry.state)
                    {
                        case HealthOK:
                            stateRepr = "yes";
                            stateColor.setRgb(0, 255, 0); // green
                            break;
                        case HealthWarning:
                            stateRepr = "yes";
                            stateColor.setRgb(255, 165, 0); // orange
                            break;
                        case HealthError:
                            stateRepr = "no";
                            stateColor.setRgb(255, 0, 0); // red
                            break;
                    }
 
                    const std::string hostname = entry.lastReferenceTimestamp.hostname;
 
                    const std::string timeSinceLastArrivalRepr =
                        to_string_rounded(entry.timeSinceLastArrival.microSeconds / 1000.0);
                    const std::string timeToLastReferenceRepr =
                        to_string_rounded(entry.timeSinceLastUpdateReference.microSeconds / 1000.0);
                    const std::string tagsRepr = serializeList(entry.tags);
 
                    const float syncErrorMilliSeconds =
                        std::abs(entry.timeSinceLastArrival.microSeconds -
                                 entry.timeSinceLastUpdateReference.microSeconds) /
                        1000.0;
 
                    tableWidget->setItem(
                        i, 0, new QTableWidgetItem(QString::fromStdString(entry.identifier)));
                    tableWidget->setItem(
                        i, 1, make_item(entry.required ? "yes" : "no", Qt::AlignHCenter));
 
                    {
                        auto* item = make_item(stateRepr, Qt::AlignHCenter);
                        item->setBackgroundColor(stateColor);
                        tableWidget->setItem(i, 2, item);
                    }
 
                    tableWidget->setItem(
                        i, 3, new QTableWidgetItem(QString::fromStdString(tagsRepr)));
                    tableWidget->setItem(i, 4, make_item(timeSinceLastArrivalRepr, Qt::AlignRight));
                    tableWidget->setItem(i, 5, make_item(timeToLastReferenceRepr, Qt::AlignRight));
 
                    {
                        auto* item =
                            make_item(to_string_rounded(syncErrorMilliSeconds), Qt::AlignRight);
 
                        QColor timeSyncColor;
                        if (syncErrorMilliSeconds > 20.)
                        {
                            timeSyncColor.setRgb(255, 0, 0);
                        }
                        else
                        {
                            timeSyncColor.setRgb(0, 255, 0);
                        }
                        item->setBackgroundColor(timeSyncColor);
 
                        tableWidget->setItem(i, 6, item);
                    }
 
                    tableWidget->setItem(
                        i,
                        7,
                        make_item(
                            to_string_rounded(entry.maximumCycleTimeWarning.microSeconds / 1000.),
                            Qt::AlignRight));
                    tableWidget->setItem(
                        i,
                        8,
                        make_item(
                            to_string_rounded(entry.maximumCycleTimeError.microSeconds / 1000.),
                            Qt::AlignRight));
                    tableWidget->setItem(
                        i, 9, new QTableWidgetItem(QString::fromStdString(hostname)));
                }
 
                std::string tagsText = "Active tags: [";
                {
                    std::sort(summary.activeTags.begin(), summary.activeTags.end());
 
                    tagsText += serializeList(summary.activeTags);
 
                    tagsText += "]";
                }
 
                widget->labelTags->setText(QString::fromStdString(tagsText));
            }
            catch (...)
            {
            }
        }
    }
 
    void
    GuiHealthClientWidgetController::unrequireAll()
    {
        ARMARX_INFO << "UnrequireAll.";
        if (robotHealthComponentPrx)
        {
            try
            {
                robotHealthComponentPrx->resetRequiredTags();
            }
            catch (...)
            {
            }
        }
    }
 
    void
    GuiHealthClientWidgetController::onConnectComponent()
    {
        //ARMARX_IMPORTANT << "onConnectComponent";
        robotHealthTopicPrx = getTopic<RobotHealthInterfacePrx>("RobotHealthTopic");
        robotHealthComponentPrx = getProxy<RobotHealthComponentInterfacePrx>("RobotHealth");
        invokeConnectComponentQt();
    }
 
    void
    GuiHealthClientWidgetController::onConnectComponentQt()
    {
        //healthTimer->start();
        //ARMARX_IMPORTANT <<ame "updateSummaryTimer->start";
        updateSummaryTimer->start();
    }
 
    void
    GuiHealthClientWidgetController::onDisconnectComponent()
    {
        invokeDisconnectComponentQt();
    }
 
    void
    GuiHealthClientWidgetController::onDisconnectComponentQt()
    {
        updateSummaryTimer->stop();
    }
} // namespace armarx