HeartbeatComponentPlugin.cpp

Go to the documentation of this file.

#include "HeartbeatComponentPlugin.h"
 
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/ice_conversions.h>
 
#include <RobotAPI/interface/components/RobotHealthInterface.h>
 
namespace armarx::plugins
{
 
    void
    HeartbeatComponentPlugin::signUp(const std::string& identifier,
                                     const std::vector<std::string>& tags,
                                     const std::string& description)
    {
        RobotHealthHeartbeatArgs argsCopy = defaultHeartbeatArgs;
        argsCopy.description = description;
        argsCopy.identifier = identifier;
        argsCopy.tags = tags;
        signUp(argsCopy);
    }
 
    void
    HeartbeatComponentPlugin::signUp(const std::string& identifier,
                                     const armarx::core::time::Duration& warning,
                                     const armarx::core::time::Duration& error,
                                     const std::vector<std::string>& tags,
                                     const std::string& description)
    {
        RobotHealthHeartbeatArgs argsCopy = defaultHeartbeatArgs;
        argsCopy.description = description;
        argsCopy.tags = tags;
        argsCopy.identifier = identifier;
        toIce(argsCopy.maximumCycleTimeWarning, warning);
        toIce(argsCopy.maximumCycleTimeError, error);
 
        ARMARX_TRACE;
        signUp(argsCopy);
    }
 
    void
    HeartbeatComponentPlugin::signUp(const armarx::core::time::Duration& warning,
                                     const armarx::core::time::Duration& error,
                                     const std::vector<std::string>& tags,
                                     const std::string& description)
    {
        RobotHealthHeartbeatArgs argsCopy = defaultHeartbeatArgs;
        argsCopy.description = description;
        argsCopy.tags = tags;
        toIce(argsCopy.maximumCycleTimeWarning, warning);
        toIce(argsCopy.maximumCycleTimeError, error);
        // argsCopy.requiredByDefault = required;
        signUp(argsCopy);
    }
 
    void
    HeartbeatComponentPlugin::signUp(const RobotHealthHeartbeatArgs& args)
    {
        ARMARX_TRACE;
        ARMARX_CHECK_NOT_NULL(robotHealthComponentPrx);
 
        if (args.identifier.empty())
        {
            RobotHealthHeartbeatArgs argsCopy = args;
            argsCopy.identifier = parent().getName();
            robotHealthComponentPrx->signUp(argsCopy);
        }
        else
        {
            // add component name prefix to identifier
            RobotHealthHeartbeatArgs argsCopy = args;
            argsCopy.identifier = parent().getName() + "_" + argsCopy.identifier;
            robotHealthComponentPrx->signUp(argsCopy);
        }
    }
 
    void
    HeartbeatComponentPlugin::heartbeat()
    {
        if (robotHealthComponentPrx)
        {
            armarx::core::time::dto::DateTime now;
            armarx::core::time::toIce(now, armarx::core::time::DateTime::Now());
            robotHealthComponentPrx->heartbeat(parent().getName(), now);
        }
        else
        {
            ARMARX_WARNING << "No robot health proxy available!";
        }
    }
 
    void
    HeartbeatComponentPlugin::heartbeatOnChannel(const std::string& channelName)
    {
        if (robotHealthComponentPrx)
        {
            armarx::core::time::dto::DateTime now;
            armarx::core::time::toIce(now, armarx::core::time::DateTime::Now());
            robotHealthComponentPrx->heartbeat(parent().getName() + "_" + channelName, now);
        }
        else
        {
            ARMARX_WARNING << "No robot health proxy available!";
        }
    }
 
    void
    HeartbeatComponentPlugin::preOnInitComponent()
    {
        // defaultHeartbeatArgs.requiredByDefault = true;
 
        //        if (topicName.empty())
        //        {
        //            parent<Component>().getProperty(topicName, makePropertyName(topicPropertyName));
        //        }
        //        parent<Component>().offeringTopic(topicName);
    }
 
    void
    HeartbeatComponentPlugin::postOnInitComponent()
    {
        // set default args
        auto warn = armarx::core::time::Duration::MilliSeconds(p.maximumCycleTimeWarningMS);
        auto err = armarx::core::time::Duration::MilliSeconds(p.maximumCycleTimeErrorMS);
        armarx::core::time::toIce(defaultHeartbeatArgs.maximumCycleTimeWarning, warn);
        armarx::core::time::toIce(defaultHeartbeatArgs.maximumCycleTimeError, err);
    }
 
    void
    HeartbeatComponentPlugin::postOnConnectComponent()
    {
        ARMARX_CHECK_NOT_NULL(robotHealthComponentPrx);
    }
 
    void
    HeartbeatComponentPlugin::postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties)
    {
        if (!properties->hasDefinition(makePropertyName(healthPropertyName)))
        {
            properties->component(robotHealthComponentPrx,
                                  "RobotHealth",
                                  healthPropertyName,
                                  "Name of the robot health component.");
        }
 
        if (not properties->hasDefinition(makePropertyName(maximumCycleTimeWarningMSPropertyName)))
        {
            properties->optional(p.maximumCycleTimeWarningMS,
                                 maximumCycleTimeWarningMSPropertyName,
                                 "maximum cycle time before warning is emitted");
        }
 
        if (not properties->hasDefinition(makePropertyName(maximumCycleTimeErrorMSPropertyName)))
        {
            properties->optional(p.maximumCycleTimeErrorMS,
                                 maximumCycleTimeErrorMSPropertyName,
                                 "maximum cycle time before error is emitted");
        }
    }
 
} // namespace armarx::plugins