Node<> and NodeStatusProvider updated

libuavcan/include/uavcan/node/node.hpp

@@ -156,19 +156,25 @@ public:
     void setName(const char* name) { proto_nsp_.setName(name); }
 
     /**
-     * Status code helpers.
+     * Node health code helpers.
      */
-    void setStatusOk()           { proto_nsp_.setStatusOk(); }
+    void setHealthOk()           { proto_nsp_.setHealthOk(); }
-    void setStatusInitializing() { proto_nsp_.setStatusInitializing(); }
+    void setHealthWarning()      { proto_nsp_.setHealthWarning(); }
-    void setStatusWarning()      { proto_nsp_.setStatusWarning(); }
+    void setHealthError()        { proto_nsp_.setHealthError(); }
-    void setStatusCritical()     { proto_nsp_.setStatusCritical(); }
+    void setHealthCritical()     { proto_nsp_.setHealthCritical(); }
 
     /**
-     * Sets the status OFFLINE and publishes it immediately.
+     * Node mode code helpers.
+     * Note that INITIALIZATION is the default mode; the application has to manually set it to OPERATIONAL.
      */
-    void setStatusOffline()
+    void setModeOperational()    { proto_nsp_.setModeOperational(); }
+    void setModeInitialization() { proto_nsp_.setModeInitialization(); }
+    void setModeMaintenance()    { proto_nsp_.setModeMaintenance(); }
+    void setModeSoftwareUpdate() { proto_nsp_.setModeSoftwareUpdate(); }
+
+    void setModeOfflineAndPublish()
     {
-        proto_nsp_.setStatusOffline();
+        proto_nsp_.setModeOffline();
         (void)proto_nsp_.forcePublish();
     }
 

libuavcan/include/uavcan/protocol/node_status_provider.hpp

@@ -18,7 +18,12 @@ namespace uavcan
 {
 /**
  * Provides the status and basic information about this node to other network participants.
+ *
  * Usually the application does not need to deal with this class directly - it's instantiated by the node class.
+ *
+ * Default values:
+ *  - health - OK
+ *  - mode   - INITIALIZATION
  */
 class UAVCAN_EXPORT NodeStatusProvider : private TimerBase
 {
@@ -54,7 +59,9 @@ public:
     {
         UAVCAN_ASSERT(!creation_timestamp_.isZero());
 
-        node_info_.status.status_code = protocol::NodeStatus::STATUS_INITIALIZING;
+        node_info_.status.mode = protocol::NodeStatus::MODE_INITIALIZATION;
+
+        node_info_.status.health = protocol::NodeStatus::HEALTH_OK;
     }
 
     /**
@@ -78,15 +85,25 @@ public:
     uavcan::MonotonicDuration getStatusPublicationPeriod() const;
 
     /**
-     * Local node status code control.
+     * Local node health code control.
      */
-    uint8_t getStatusCode() const { return node_info_.status.status_code; }
+    uint8_t getHealth() const { return node_info_.status.health; }
-    void setStatusCode(uint8_t code);
+    void setHealth(uint8_t code);
-    void setStatusOk()           { setStatusCode(protocol::NodeStatus::STATUS_OK); }
+    void setHealthOk()           { setHealth(protocol::NodeStatus::HEALTH_OK); }
-    void setStatusInitializing() { setStatusCode(protocol::NodeStatus::STATUS_INITIALIZING); }
+    void setHealthWarning()      { setHealth(protocol::NodeStatus::HEALTH_WARNING); }
-    void setStatusWarning()      { setStatusCode(protocol::NodeStatus::STATUS_WARNING); }
+    void setHealthError()        { setHealth(protocol::NodeStatus::HEALTH_ERROR); }
-    void setStatusCritical()     { setStatusCode(protocol::NodeStatus::STATUS_CRITICAL); }
+    void setHealthCritical()     { setHealth(protocol::NodeStatus::HEALTH_CRITICAL); }
-    void setStatusOffline()      { setStatusCode(protocol::NodeStatus::STATUS_OFFLINE); }
+
+    /**
+     * Local node mode code control.
+     */
+    uint8_t getMode() const { return node_info_.status.mode; }
+    void setMode(uint8_t code);
+    void setModeOperational()    { setMode(protocol::NodeStatus::MODE_OPERATIONAL); }
+    void setModeInitialization() { setMode(protocol::NodeStatus::MODE_INITIALIZATION); }
+    void setModeMaintenance()    { setMode(protocol::NodeStatus::MODE_MAINTENANCE); }
+    void setModeSoftwareUpdate() { setMode(protocol::NodeStatus::MODE_SOFTWARE_UPDATE); }
+    void setModeOffline()        { setMode(protocol::NodeStatus::MODE_OFFLINE); }
 
     /**
      * Local node vendor-specific status code control.

libuavcan/src/protocol/uc_node_status_provider.cpp

@@ -21,7 +21,7 @@ int NodeStatusProvider::publish()
     UAVCAN_ASSERT(uptime.isPositive());
     node_info_.status.uptime_sec = uint32_t(uptime.toMSec() / 1000);
 
-    UAVCAN_ASSERT(node_info_.status.status_code <= protocol::NodeStatus::FieldTypes::status_code::max());
+    UAVCAN_ASSERT(node_info_.status.health <= protocol::NodeStatus::FieldTypes::health::max());
 
     return node_status_pub_.broadcast(node_info_.status);
 }
@@ -109,9 +109,14 @@ uavcan::MonotonicDuration NodeStatusProvider::getStatusPublicationPeriod() const
     return TimerBase::getPeriod();
 }
 
-void NodeStatusProvider::setStatusCode(uint8_t code)
+void NodeStatusProvider::setHealth(uint8_t code)
 {
-    node_info_.status.status_code = code;
+    node_info_.status.health = code;
+}
+
+void NodeStatusProvider::setMode(uint8_t code)
+{
+    node_info_.status.mode = code;
 }
 
 void NodeStatusProvider::setVendorSpecificStatusCode(VendorSpecificStatusCode code)

libuavcan/test/protocol/node_status_provider.cpp

@@ -32,9 +32,12 @@ TEST(NodeStatusProvider, Basic)
     nsp.setName("superluminal_communication_unit");
     ASSERT_STREQ("superluminal_communication_unit", nsp.getName().c_str());
 
-    ASSERT_EQ(uavcan::protocol::NodeStatus::STATUS_INITIALIZING, nsp.getStatusCode());
+    ASSERT_EQ(uavcan::protocol::NodeStatus::HEALTH_OK, nsp.getHealth());
-    nsp.setStatusOk();
+    ASSERT_EQ(uavcan::protocol::NodeStatus::MODE_INITIALIZATION, nsp.getMode());
-    ASSERT_EQ(uavcan::protocol::NodeStatus::STATUS_OK, nsp.getStatusCode());
+    nsp.setHealthError();
+    nsp.setModeOperational();
+    ASSERT_EQ(uavcan::protocol::NodeStatus::HEALTH_ERROR, nsp.getHealth());
+    ASSERT_EQ(uavcan::protocol::NodeStatus::MODE_OPERATIONAL, nsp.getMode());
 
     // Will fail - types are not registered
     uavcan::GlobalDataTypeRegistry::instance().reset();
@@ -68,7 +71,7 @@ TEST(NodeStatusProvider, Basic)
     nodes.spinBoth(uavcan::MonotonicDuration::fromMSec(10));
 
     ASSERT_TRUE(status_sub.collector.msg.get());  // Was published at startup
-    ASSERT_EQ(uavcan::protocol::NodeStatus::STATUS_OK, status_sub.collector.msg->status_code);
+    ASSERT_EQ(uavcan::protocol::NodeStatus::HEALTH_OK, status_sub.collector.msg->health);
     ASSERT_EQ(0, status_sub.collector.msg->vendor_specific_status_code);
     ASSERT_GE(1, status_sub.collector.msg->uptime_sec);
 
@@ -83,7 +86,7 @@ TEST(NodeStatusProvider, Basic)
 
     nodes.spinBoth(uavcan::MonotonicDuration::fromMSec(10));
 
-    ASSERT_EQ(uavcan::protocol::NodeStatus::STATUS_OK, status_sub.collector.msg->status_code);
+    ASSERT_EQ(uavcan::protocol::NodeStatus::HEALTH_OK, status_sub.collector.msg->health);
     ASSERT_EQ(1234, status_sub.collector.msg->vendor_specific_status_code);
     ASSERT_GE(1, status_sub.collector.msg->uptime_sec);
 
@@ -92,7 +95,7 @@ TEST(NodeStatusProvider, Basic)
      */
     ServiceClientWithCollector<uavcan::protocol::GetNodeInfo> gni_cln(nodes.b);
 
-    nsp.setStatusCritical();
+    nsp.setHealthCritical();
 
     ASSERT_FALSE(gni_cln.collector.result.get());  // No data yet
     ASSERT_LE(0, gni_cln.call(1, uavcan::protocol::GetNodeInfo::Request()));
@@ -103,8 +106,8 @@ TEST(NodeStatusProvider, Basic)
     ASSERT_TRUE(gni_cln.collector.result->isSuccessful());
     ASSERT_EQ(1, gni_cln.collector.result->getCallID().server_node_id.get());
 
-    ASSERT_EQ(uavcan::protocol::NodeStatus::STATUS_CRITICAL,
+    ASSERT_EQ(uavcan::protocol::NodeStatus::HEALTH_CRITICAL,
-              gni_cln.collector.result->getResponse().status.status_code);
+              gni_cln.collector.result->getResponse().status.health);
 
     ASSERT_TRUE(hwver == gni_cln.collector.result->getResponse().hardware_version);
     ASSERT_TRUE(swver == gni_cln.collector.result->getResponse().software_version);