added setMaximumCycleTime

source/RobotAPI/components/RobotHealth/RobotHealth.cpp

@@ -65,42 +65,42 @@ void RobotHealth::monitorHealthTaskClb()
 
     RobotHealthState healthState = RobotHealthState::HealthOK;
 
-    for(size_t i = 0; i < validEntries; i++)
+    for (size_t i = 0; i < validEntries; i++)
     {
         Entry& e = entries.at(i);
         long delta = std::max(now - e.lastUpdate, e.lastDelta);
-        if(e.required && delta > e.maximumCycleTimeErr)
+        if (e.required && delta > e.maximumCycleTimeErr)
         {
             healthState = RobotHealthState::HealthError;
         }
 
-        if(!e.enabled)
+        if (!e.enabled)
         {
             continue;
         }
 
 
-        if(delta > e.maximumCycleTimeErr)
+        if (delta > e.maximumCycleTimeErr)
         {
             healthState = RobotHealthState::HealthError;
-            if(e.isRunning)
+            if (e.isRunning)
             {
                 ARMARX_ERROR << deactivateSpam(0.1, e.name) << "Component " << e.name << " has died.";
                 hasNewErr = true;
                 e.isRunning = false;
             }
         }
-        else if(e.isRunning && delta > e.maximumCycleTimeWarn)
+        else if (e.isRunning && delta > e.maximumCycleTimeWarn)
         {
             ARMARX_WARNING << deactivateSpam(0.1, e.name) << "Component " << e.name << " is running too slow.";
-            if(healthState == RobotHealthState::HealthOK)
+            if (healthState == RobotHealthState::HealthOK)
             {
                 healthState = RobotHealthState::HealthWarning;
             }
         }
 
     }
-    if(hasNewErr)
+    if (hasNewErr)
     {
         emergencyStopTopicPrx->reportEmergencyStopState(EmergencyStopState::eEmergencyStopActive);
     }
@@ -130,14 +130,14 @@ void RobotHealth::onExitComponent()
 armarx::PropertyDefinitionsPtr RobotHealth::createPropertyDefinitions()
 {
     return armarx::PropertyDefinitionsPtr(new RobotHealthPropertyDefinitions(
-                                              getConfigIdentifier()));
+            getConfigIdentifier()));
 }
 
 RobotHealth::Entry& RobotHealth::findOrCreateEntry(const std::string& name)
 {
-    for(size_t i = 0; i < entries.size(); i++)
+    for (size_t i = 0; i < entries.size(); i++)
     {
-        if(entries.at(i).name == name)
+        if (entries.at(i).name == name)
         {
             return entries.at(i);
         }
@@ -155,7 +155,7 @@ void armarx::RobotHealth::heartbeat(const std::string& componentName, const Ice:
 {
     Entry& e = findOrCreateEntry(componentName);
     long now = TimeUtil::GetTime().toMicroSeconds();
-    if(!e.isRunning)
+    if (!e.isRunning)
     {
         ARMARX_INFO << "'" << componentName << "' is now alive and running";
         e.lastDelta = 0;
@@ -166,9 +166,10 @@ void armarx::RobotHealth::heartbeat(const std::string& componentName, const Ice:
     }
     e.lastUpdate = now;
     e.isRunning = true;
+    e.enabled = true;
 }
 
-void armarx::RobotHealth::reportState(const std::string& componentName, RobotHealthState state, const std::string&message, const Ice::Current&)
+void armarx::RobotHealth::reportState(const std::string& componentName, RobotHealthState state, const std::string& message, const Ice::Current&)
 {
     Entry& e = findOrCreateEntry(componentName);
     e.state = state;
@@ -184,36 +185,43 @@ void armarx::RobotHealth::unregister(const std::string& componentName, const Ice
     ARMARX_INFO << "unregistering " << componentName;
 }
 
+void RobotHealth::setMaximumCycleTime(const std::string& componentName, int warningMS, int errorMS, const Ice::Current&)
+{
+    Entry& e = findOrCreateEntry(componentName);
+    e.maximumCycleTimeWarn = warningMS * 1000;
+    e.maximumCycleTimeErr = errorMS * 1000;
+}
+
 std::string RobotHealth::getSummary(const Ice::Current&)
 {
     long now = TimeUtil::GetTime().toMicroSeconds();
     std::stringstream ss;
-    for(size_t i = 0; i < validEntries; i++)
+    for (size_t i = 0; i < validEntries; i++)
     {
         Entry& e = entries.at(i);
         long delta = std::max(now - e.lastUpdate, e.lastDelta);
 
         ss << e.name;
-        if(e.required)
+        if (e.required)
         {
             ss << ", required";
         }
 
-        if(!e.required && !e.enabled)
+        if (!e.required && !e.enabled)
         {
             ss << ": disabled\n";
         }
-        else if(delta > e.maximumCycleTimeErr)
+        else if (delta > e.maximumCycleTimeErr)
         {
-            ss << ": ERROR (" << (delta/1000) << "ms)\n";
+            ss << ": ERROR (" << (delta / 1000) << "ms)\n";
         }
-        else if(delta > e.maximumCycleTimeWarn)
+        else if (delta > e.maximumCycleTimeWarn)
         {
-            ss << ": warning (" << (delta/1000) << "ms)\n";
+            ss << ": warning (" << (delta / 1000) << "ms)\n";
         }
         else
         {
-            ss << ": ok (" << (delta/1000) << "ms)\n";
+            ss << ": ok (" << (delta / 1000) << "ms)\n";
         }
 
     }

source/RobotAPI/components/RobotHealth/RobotHealth.h

@@ -90,7 +90,7 @@ namespace armarx
                 : name(name), maximumCycleTimeWarn(maximumCycleTimeWarn), maximumCycleTimeErr(maximumCycleTimeErr)
             {  }
             Entry(Entry&&) = default;
-            Entry& operator=(Entry&&) = default;
+            Entry& operator=(Entry &&) = default;
 
             std::string name;
             long maximumCycleTimeWarn;
@@ -101,7 +101,7 @@ namespace armarx
             std::string message = "";
             bool isRunning = false;
             bool required = false;
-            bool enabled = true;
+            bool enabled = false;
         };
 
     protected:
@@ -135,7 +135,7 @@ namespace armarx
 
         Mutex mutex;
         std::deque<Entry> entries;
-        std::atomic_size_t validEntries{0};
+        std::atomic_size_t validEntries {0};
         PeriodicTask<RobotHealth>::pointer_type monitorHealthTask;
         int defaultMaximumCycleTimeWarn;
         int defaultMaximumCycleTimeErr;
@@ -150,6 +150,7 @@ namespace armarx
         void heartbeat(const std::string& componentName, const Ice::Current&) override;
         void reportState(const std::string& componentName, RobotHealthState state, const std::string& message, const Ice::Current&) override;
         void unregister(const std::string& componentName, const Ice::Current&) override;
+        void setMaximumCycleTime(const std::string& componentName, int warningMS, int errorMS, const Ice::Current&) override;
         std::string getSummary(const Ice::Current&) override;
 
     };

source/RobotAPI/interface/components/RobotHealthInterface.ice

@@ -34,6 +34,7 @@ module armarx
         void heartbeat(string componentName);
         void reportState(string componentName, RobotHealthState state, string message);
         void unregister(string componentName);
+        void setMaximumCycleTime(string componentName, int warningMS, int errorMS);
     };
 
     interface AggregatedRobotHealthInterface