BatteryWidget.cpp

Go to the documentation of this file.

#include "BatteryWidget.h"
 
#include <QToolTip>
 
namespace armarx
{
 
    constexpr std::string_view battery_master_default_name = "DiagnosticsUnit";
 
    BatteryIcon::BatteryIcon(QWidget* parent) : QWidget(parent)
    {
        QSizePolicy policy{QSizePolicy::Policy::Fixed, QSizePolicy::Policy::Fixed};
        setSizePolicy(policy);
    }
 
    void
    BatteryIcon::paintEvent(QPaintEvent* event)
    {
        QWidget::paintEvent(event);
 
        int filled = std::clamp(percentage, 0, 100); // between 0 and 100
        QColor fg(0, 200, 0);
 
        if (filled < 15)
        {
            fg = QColor(200, 0, 0);
        }
        else if (filled < 45)
        {
            fg = QColor(200, 100, 0);
        }
 
        if (state != dto::BatteryState::discharging)
        {
            fg = QColor(255, 255, 255);
        }
 
        // Draw inner and cap.
        QColor bg(fg.red() * .6, fg.green() * .6, fg.blue() * .6);
        int ht = event->rect().height();
        int wd = ht / 2 - 1;
        QPainter painter;
        // painter.setRenderHint(QPainter::Antialiasing, true);
        painter.begin(this);
        int m = 1 * ht / 10 + 1;
        QRect cap(QPoint(m, m), QPoint(wd - m, 2 * m));
        painter.fillRect(cap, filled == 100 ? fg : bg);
        QRect body(QPoint(0, 2 * m), QPoint(wd, ht - m));
        painter.fillRect(body, bg);
        float dist = (1.0 - filled * .01);
        QRect bodyFull(QPoint(0, 2 * m + dist * (ht - 3 * m)), QPoint(wd, ht - m));
        painter.fillRect(bodyFull, fg);
 
        // Draw a border.
        int lWd = ht / 40;
        QRect a;
        a = QRect(QPoint(m, m), QPoint(wd - m, m + lWd));
        painter.fillRect(a, bg);
        a = QRect(QPoint(wd - m - lWd, m), QPoint(wd - m, 2 * m + lWd));
        painter.fillRect(a, bg);
        a = QRect(QPoint(wd - m - lWd, 2 * m), QPoint(wd, 2 * m + lWd));
        painter.fillRect(a, bg);
        a = QRect(QPoint(wd - lWd, 2 * m), QPoint(wd, ht - m));
        painter.fillRect(a, bg);
        a = QRect(QPoint(0, ht - m - lWd), QPoint(wd, ht - m));
        painter.fillRect(a, bg);
        a = QRect(QPoint(0, 2 * m), QPoint(lWd, ht - m));
        painter.fillRect(a, bg);
        a = QRect(QPoint(0, 2 * m), QPoint(m + lWd, 2 * m + lWd));
        painter.fillRect(a, bg);
        a = QRect(QPoint(m, m), QPoint(m + lWd, 2 * m + lWd));
        painter.fillRect(a, bg);
 
        // Draw lightning if charging.
        if (state == dto::BatteryState::charging)
        {
            QPolygon poly;
            float lHeight = .6 * ht;
            int xOff = .1 * ht + 1;
            int yOff = .2 * ht + 1;
            poly << QPoint(xOff + 7 * lHeight / 20, yOff)
                 << QPoint(xOff + 5 * lHeight / 20, yOff + 4.5 * lHeight / 10)
                 << QPoint(xOff + 10 * lHeight / 20, yOff + 4.5 * lHeight / 10)
                 << QPoint(xOff + 3 * lHeight / 20, yOff + lHeight)
                 << QPoint(xOff + 5 * lHeight / 20, yOff + 5.5 * lHeight / 10)
                 << QPoint(xOff + 0 * lHeight / 20, yOff + 5.5 * lHeight / 10)
                 << QPoint(xOff + 7 * lHeight / 20, yOff);
            QPainterPath path;
            path.addPolygon(poly);
            painter.fillPath(path, QColor(40, 40, 40));
        }
 
        // Draw cross if unavailable.
        if (state == dto::BatteryState::unavailable)
        {
            int u = .1 * wd;
            QPolygon poly;
            poly << QPoint(u, .1 * ht) << QPoint(wd - 2 * u, .9 * ht) << QPoint(wd - u, .9 * ht)
                 << QPoint(2 * u, .1 * ht) << QPoint(u, .1 * ht);
            QPainterPath path;
            path.addPolygon(poly);
            painter.fillPath(path, QColor(200, 0, 0));
            QPolygon poly2;
            poly2 << QPoint(wd - 2 * u, .1 * ht) << QPoint(wd - u, .1 * ht)
                  << QPoint(2 * u, .9 * ht) << QPoint(u, .9 * ht) << QPoint(wd - 2 * u, .1 * ht);
            QPainterPath path2;
            path2.addPolygon(poly2);
            painter.fillPath(path2, QColor(200, 0, 0));
        }
 
        painter.end();
    }
 
    void
    BatteryIcon::setPercentage(int percentage)
    {
        this->percentage = std::clamp(percentage, 0, 100);
    }
 
    void
    BatteryIcon::setState(dto::BatteryState state)
    {
        this->state = state;
    }
 
    QSize
    BatteryIcon::sizeHint() const
    {
        return QSize{16, 32};
    }
 
    BatteryWidget::BatteryWidget(QWidget* parent, ArmarXMainWindow* mainWindow) :
        mainWindow(mainWindow), timer(new QTimer(this))
    {
        qRegisterMetaType<dto::BatteryStatus>("dto::BatteryStatus");
        QGridLayout* layout = new QGridLayout(this->getWidget());
        this->getWidget()->setContentsMargins(4, 0, 0, 0);
        icon = new BatteryIcon();
        layout->addWidget(icon, 0, 0);
        layout->setContentsMargins(0, 0, 0, 0);
        this->getWidget()->setLayout(layout);
        icon->setVisible(true);
        lbl = new QLabel();
        txtPercentage = QString("%1%").arg(lastStatus.energyFromFullCharge_pct);
        lbl->setText(txtPercentage);
        lbl->setVisible(false);
        layout->addWidget(lbl, 0, 1);
 
        qRegisterMetaType<dto::BatteryState>("BatteryState");
 
        timer->setInterval(std::chrono::milliseconds(1'000));
        connect(timer, &QTimer::timeout, this, &BatteryWidget::updateBatteryStatus);
        connect(this, &BatteryWidget::startPeriodicStateUpdate, timer, qOverload<>(&QTimer::start));
        connect(this, &BatteryWidget::stopPeriodicStateUpdate, timer, &QTimer::stop);
 
        QString style = QString("QToolTip {"
                                // StyleSheet for tool tip
                                "    background: white;"
                                "    padding: 3px;"
                                "}");
        getWidget()->setStyleSheet(style);
 
        updateTooltip();
    }
 
    QWidget*
    BatteryWidget::getBatteryWidget()
    {
        return this->getWidget();
    }
 
    void
    BatteryWidget::updateTooltip()
    {
        dto::BatteryState state = lastStatus.state;
 
        QString text;
 
        if (state == dto::BatteryState::unavailable)
        {
            text = "No battery detected.";
        }
        else if (state == dto::BatteryState::full)
        {
            text = "Battery fully charged.";
        }
        else
        {
            QString status;
            switch (state)
            {
                case dto::BatteryState::charging:
                    status = "charging";
                    break;
                case dto::BatteryState::discharging:
                    status = "discharging";
                    break;
                case dto::BatteryState::full:
                    status = "full";
                    break;
                case dto::BatteryState::notCharging:
                    status = "not charging";
                    break;
                case dto::BatteryState::unavailable:
                    status = "unavailable";
                    break;
            }
 
            QString detailedReport;
            {
                QString charge = QString("&nbsp;- Charge: %1<br>").arg(txtPercentage);
 
                QString energy = QString("&nbsp;- Energy: %2 Wh / %3 Wh<br>")
                                     .arg(lastStatus.energy_Wh, 0, 'f', 1)
                                     .arg(lastStatus.fullChargeEnergy_Wh, 0, 'f', 1);
 
                QString power = QString("&nbsp;- %1: %2 W (%3 A, %4 V)<br>")
                                    .arg(state == dto::BatteryState::charging ? "Charging power"
                                                                              : "Provided power")
                                    .arg(std::abs(lastStatus.power_W), 0, 'f', 1)
                                    .arg(std::abs(lastStatus.current_A), 0, 'f', 1)
                                    .arg(lastStatus.voltage_V, 0, 'f', 1);
 
                bool showPrognosis =
                    state == dto::BatteryState::charging or state == dto::BatteryState::discharging;
                QString prognosis = "";
                if (showPrognosis)
                {
                    QString fullOrEmpty = state == dto::BatteryState::charging ? "Full" : "Empty";
                    prognosis = QString("&nbsp;- %1 in: &asymp; %2 h <br>")
                                    .arg(fullOrEmpty)
                                    .arg(lastStatus.remainingTime_h, 0, 'f', 1);
                }
 
                QString temperature = QString("&nbsp;- Temperature: %6 °C<br>")
                                          .arg(lastStatus.temperature_degC, 0, 'f', 1);
 
                QString health = QString("&nbsp;- Health: %7%")
                                     .arg(lastStatus.fullEnergyFromDesignEnergy_pct, 0, 'f', 1);
 
                detailedReport = QString("%1%2%3%4%5%6")
                                     .arg(charge, energy, power, prognosis, temperature, health);
            }
 
            QString errorsText =
                lastStatus.hasError
                    ? "<br><b><font color='red'>Battery error occured! Check the logs.</font></b>"
                    : "";
 
            text = QString("Battery %1.<br>%2%3").arg(status).arg(detailedReport).arg(errorsText);
        }
 
        getWidget()->setToolTip(text);
 
        if (not QToolTip::isVisible())
        {
            return;
        }
 
        QPoint p = getWidget()->mapFromGlobal(QCursor::pos());
 
        if (p.x() >= 0 and p.y() >= 0 and p.x() < getWidget()->width() and
            p.y() < getWidget()->height())
        {
            QToolTip::showText(QCursor::pos(), text);
        }
    }
 
    void
    BatteryWidget::onInitComponent()
    {
        usingProxy(std::string{battery_master_default_name});
    }
 
    void
    BatteryWidget::onConnectComponent()
    {
        QMetaObject::invokeMethod(icon, "setVisible", Qt::QueuedConnection, Q_ARG(bool, true));
 
        ARMARX_INFO << "Battery widget connected.";
        batteryManagement = getProxy<armarx::BatteryManagementInterfacePrx>(
            std::string{battery_master_default_name});
 
        emit startPeriodicStateUpdate();
    }
 
    void
    BatteryWidget::onDisconnectComponent()
    {
        ARMARX_IMPORTANT
            << "Battery widget disconnected.  This is expected if the earlier connected "
               "robot unit shut down.";
 
        QMetaObject::invokeMethod(this,
                                  "setBatteryStatus",
                                  Qt::QueuedConnection,
                                  Q_ARG(dto::BatteryStatus, invalidStatus));
 
        emit stopPeriodicStateUpdate();
    }
 
    void
    BatteryWidget::loadSettings(QSettings* settings)
    {
        ;
    }
 
    void
    BatteryWidget::saveSettings(QSettings* settings)
    {
        ;
    }
 
    void
    BatteryWidget::updateBatteryStatus()
    {
        dto::BatteryStatus newStatus;
 
        try
        {
            newStatus = batteryManagement->getBatteryStatus();
        }
        catch (...)
        {
            ARMARX_DEBUG << deactivateSpam(60) << "Failed to get current battery percentage";
            newStatus.state = dto::BatteryState::unavailable;
        }
 
        QMetaObject::invokeMethod(
            this, "setBatteryStatus", Qt::QueuedConnection, Q_ARG(dto::BatteryStatus, newStatus));
    }
 
    void
    BatteryWidget::setBatteryStatus(dto::BatteryStatus batteryStatus)
    {
        lastStatus = batteryStatus;
 
        icon->setPercentage(lastStatus.energyFromFullCharge_pct);
        txtPercentage = QString("%1%").arg(lastStatus.energyFromFullCharge_pct, 0, 'f', 1);
        lbl->setText(txtPercentage);
 
        dto::BatteryState state = lastStatus.state;
 
        icon->setState(state);
        if (state == dto::BatteryState::unavailable)
        {
            lbl->setVisible(false);
        }
        else
        {
            lbl->setVisible(true);
        }
 
        updateTooltip();
        icon->update();
    }
 
    std::string
    BatteryWidget::getDefaultName() const
    {
        return "BatteryWidget" + iceNameUUID;
    }
 
} // namespace armarx