4 ➡️ 5

Changelog.md

@@ -573,6 +573,41 @@
 
 ## Ignition Gazebo 4.x
 
+### Ignition Gazebo 4.13.0 (2021-11-15)
+
+1. Prevent creation of spurious `<plugin>` elements when saving worlds
+    * [Pull request #1192](https://github.com/ignitionrobotics/ign-gazebo/pull/1192)
+
+1. Add support for tracked vehicles
+    * [Pull request #869](https://github.com/ignitionrobotics/ign-gazebo/pull/869)
+
+1. Add components to dynamically set joint limits
+    * [Pull request #847](https://github.com/ignitionrobotics/ign-gazebo/pull/847)
+
+1. Fix updating component from state
+    * [Pull request #1181](https://github.com/ignitionrobotics/ign-gazebo/pull/1181)
+
+1. Fix updating a component's data via SerializedState msg
+    * [Pull request #1149](https://github.com/ignitionrobotics/ign-gazebo/pull/1149)
+
+1. Sensor systems work if loaded after sensors
+    * [Pull request #1104](https://github.com/ignitionrobotics/ign-gazebo/pull/1104)
+
+1. Fix generation of systems library symlinks in build directory
+    * [Pull request #1160](https://github.com/ignitionrobotics/ign-gazebo/pull/1160)
+
+1. Edit material colors in component inspector
+    * [Pull request #1123](https://github.com/ignitionrobotics/ign-gazebo/pull/1123)
+
+1. Support setting the background color for sensors
+    * [Pull request #1147](https://github.com/ignitionrobotics/ign-gazebo/pull/1147)
+
+1. Use uint64_t for ComponentInspector Entity IDs
+    * [Pull request #1144](https://github.com/ignitionrobotics/ign-gazebo/pull/1144)
+
+1. Fix integers and floats on component inspector
+    * [Pull request #1143](https://github.com/ignitionrobotics/ign-gazebo/pull/1143)
+
 ### Ignition Gazebo 4.12.0 (2021-10-22)
 
 1. Fix performance issue with contact data and AABB updates.

src/SdfEntityCreator_TEST.cc

@@ -127,7 +127,7 @@ TEST_F(SdfEntityCreatorTest, CreateEntities)
 
       EXPECT_EQ("default", _name->Data());
       EXPECT_DOUBLE_EQ(0.001, _physics->Data().MaxStepSize());
-      EXPECT_DOUBLE_EQ(1.0, _physics->Data().RealTimeFactor());
+      EXPECT_DOUBLE_EQ(0.0, _physics->Data().RealTimeFactor());
 
       worldCount++;
 

src/SimulationRunner.cc

@@ -103,8 +103,15 @@ SimulationRunner::SimulationRunner(const sdf::World *_world,
   // So to get a given RTF, our desired period is:
   //
   // period = step_size / RTF
-  this->updatePeriod = std::chrono::nanoseconds(
-      static_cast<int>(this->stepSize.count() / this->desiredRtf));
+  if (this->desiredRtf < 1e-9)
+  {
+    this->updatePeriod = 0ms;
+  }
+  else
+  {
+    this->updatePeriod = std::chrono::nanoseconds(
+        static_cast<int>(this->stepSize.count() / this->desiredRtf));
+  }
 
   this->pauseConn = this->eventMgr.Connect<events::Pause>(
       std::bind(&SimulationRunner::SetPaused, this, std::placeholders::_1));

src/SimulationRunner_TEST.cc

@@ -1073,7 +1073,7 @@ TEST_P(SimulationRunnerTest, Time)
   EXPECT_EQ(0u, runner.CurrentInfo().iterations);
   EXPECT_EQ(0ms, runner.CurrentInfo().simTime);
   EXPECT_EQ(0ms, runner.CurrentInfo().dt);
-  EXPECT_EQ(1ms, runner.UpdatePeriod());
+  EXPECT_EQ(0ms, runner.UpdatePeriod());
   EXPECT_EQ(1ms, runner.StepSize());
 
   runner.SetPaused(false);
@@ -1086,7 +1086,7 @@ TEST_P(SimulationRunnerTest, Time)
   EXPECT_EQ(100u, runner.CurrentInfo().iterations);
   EXPECT_EQ(100ms, runner.CurrentInfo().simTime);
   EXPECT_EQ(1ms, runner.CurrentInfo().dt);
-  EXPECT_EQ(1ms, runner.UpdatePeriod());
+  EXPECT_EQ(0ms, runner.UpdatePeriod());
   EXPECT_EQ(1ms, runner.StepSize());
 
   int sleep = 0;
@@ -1107,7 +1107,7 @@ TEST_P(SimulationRunnerTest, Time)
   EXPECT_EQ(200u, runner.CurrentInfo().iterations);
   EXPECT_EQ(300ms, runner.CurrentInfo().simTime);
   EXPECT_EQ(2ms, runner.CurrentInfo().dt);
-  EXPECT_EQ(1ms, runner.UpdatePeriod());
+  EXPECT_EQ(0ms, runner.UpdatePeriod());
   EXPECT_EQ(2ms, runner.StepSize());
 
   sleep = 0;
@@ -1127,7 +1127,7 @@ TEST_P(SimulationRunnerTest, Time)
   EXPECT_EQ(200u, runner.CurrentInfo().iterations);
   EXPECT_EQ(300ms, runner.CurrentInfo().simTime);
   EXPECT_EQ(2ms, runner.CurrentInfo().dt);
-  EXPECT_EQ(1ms, runner.UpdatePeriod());
+  EXPECT_EQ(0ms, runner.UpdatePeriod());
   EXPECT_EQ(2ms, runner.StepSize());
 
   // Verify info published to /clock topic
@@ -1145,7 +1145,7 @@ TEST_P(SimulationRunnerTest, Time)
   EXPECT_EQ(500ms, runner.CurrentInfo().simTime)
     << runner.CurrentInfo().simTime.count();
   EXPECT_EQ(2ms, runner.CurrentInfo().dt);
-  EXPECT_EQ(1ms, runner.UpdatePeriod());
+  EXPECT_EQ(0ms, runner.UpdatePeriod());
   EXPECT_EQ(2ms, runner.StepSize());
 
   sleep = 0;

src/gui/plugins/visualize_lidar/VisualizeLidar.cc

@@ -291,8 +291,13 @@ void VisualizeLidar::Update(const UpdateInfo &,
           for (auto child : children)
           {
             std::string nextstring = lidarURIVec[i+1];
+            auto comp = _ecm.Component<components::Name>(child);
+            if (!comp)
+            {
+              continue;
+            }
             std::string childname = std::string(
-                            _ecm.Component<components::Name>(child)->Data());
+                            comp->Data());
             if (nextstring.compare(childname) == 0)
             {
               parent = child;

src/systems/battery_plugin/LinearBatteryPlugin.cc

@@ -69,6 +69,15 @@ class ignition::gazebo::systems::LinearBatteryPluginPrivate
   /// \param[in] _req This value should be true.
   public: void OnDisableRecharge(const ignition::msgs::Boolean &_req);
 
+  /// \brief Callback connected to additional topics that can start battery
+  /// draining.
+  /// \param[in] _data Message data.
+  /// \param[in] _size Message data size.
+  /// \param[in] _info Information about the message.
+  public: void OnBatteryDrainingMsg(
+    const char *_data, const size_t _size,
+    const ignition::transport::MessageInfo &_info);
+
   /// \brief Name of model, only used for printing warning when battery drains.
   public: std::string modelName;
 
@@ -153,6 +162,9 @@ class ignition::gazebo::systems::LinearBatteryPluginPrivate
 
   /// \brief Battery state of charge message publisher
   public: transport::Node::Publisher statePub;
+
+  /// \brief Whether a topic has received any battery-draining command.
+  public: bool startDrainingFromTopics = false;
 };
 
 /////////////////////////////////////////////////
@@ -340,6 +352,23 @@ void LinearBatteryPlugin::Configure(const Entity &_entity,
             << "in LinearBatteryPlugin SDF" << std::endl;
   }
 
+  // Subscribe to power draining topics, if any.
+  if (_sdf->HasElement("power_draining_topic"))
+  {
+    sdf::ElementConstPtr sdfElem = _sdf->FindElement("power_draining_topic");
+    while (sdfElem)
+    {
+      const auto &topic = sdfElem->Get<std::string>();
+      this->dataPtr->node.SubscribeRaw(topic,
+          std::bind(&LinearBatteryPluginPrivate::OnBatteryDrainingMsg,
+          this->dataPtr.get(), std::placeholders::_1, std::placeholders::_2,
+          std::placeholders::_3));
+      ignmsg << "LinearBatteryPlugin subscribes to power draining topic ["
+             << topic << "]." << std::endl;
+      sdfElem = sdfElem->GetNextElement("power_draining_topic");
+    }
+  }
+
   ignmsg << "LinearBatteryPlugin configured. Battery name: "
          << this->dataPtr->battery->Name() << std::endl;
   igndbg << "Battery initial voltage: " << this->dataPtr->battery->InitVoltage()
@@ -371,6 +400,7 @@ void LinearBatteryPluginPrivate::Reset()
   this->iraw = 0.0;
   this->ismooth = 0.0;
   this->q = this->q0;
+  this->startDrainingFromTopics = false;
 }
 
 /////////////////////////////////////////////////
@@ -395,13 +425,24 @@ void LinearBatteryPluginPrivate::OnDisableRecharge(
   this->startCharging = false;
 }
 
+//////////////////////////////////////////////////
+void LinearBatteryPluginPrivate::OnBatteryDrainingMsg(
+  const char *, const size_t, const ignition::transport::MessageInfo &)
+{
+  this->startDrainingFromTopics = true;
+}
+
 //////////////////////////////////////////////////
 void LinearBatteryPlugin::PreUpdate(
   const ignition::gazebo::UpdateInfo &/*_info*/,
   ignition::gazebo::EntityComponentManager &_ecm)
 {
   IGN_PROFILE("LinearBatteryPlugin::PreUpdate");
-  this->dataPtr->startDraining = false;
+
+  // \todo(anyone) Add in the ability to stop the battery from draining
+  // after it has been started by a topic. See this comment:
+  // https://github.com/ignitionrobotics/ign-gazebo/pull/1255#discussion_r770223092
+  this->dataPtr->startDraining = this->dataPtr->startDrainingFromTopics;
   // Start draining the battery if the robot has started moving
   if (!this->dataPtr->startDraining)
   {

src/systems/battery_plugin/LinearBatteryPlugin.hh

@@ -58,6 +58,11 @@ namespace systems
   ///                 (Required if `<enable_recharge>` is set to true)
   /// - `<fix_issue_225>` True to change the battery behavior to fix some issues
   /// described in https://github.com/ignitionrobotics/ign-gazebo/issues/225.
+  /// - `<power_draining_topic>` A topic that is used to start battery
+  /// discharge. Any message on the specified topic will cause the batter to
+  /// start draining. This element can be specified multiple times if
+  /// multiple topics should be monitored. Note that this mechanism will
+  /// start the battery draining, and once started will keep drainig.
   class LinearBatteryPlugin
       : public System,
         public ISystemConfigure,

test/integration/battery_plugin.cc

@@ -23,6 +23,7 @@
 #include <ignition/common/Console.hh>
 #include <ignition/common/Util.hh>
 #include <ignition/common/Filesystem.hh>
+#include <ignition/transport/Node.hh>
 #include <ignition/utilities/ExtraTestMacros.hh>
 
 #include <sdf/Root.hh>
@@ -136,20 +137,107 @@ TEST_F(BatteryPluginTest, IGN_UTILS_TEST_DISABLED_ON_WIN32(SingleBattery))
   EXPECT_LT(batComp->Data(), 12.592);
 
   // Check there is a single battery matching exactly the one specified
-  int batCount = 0;
+  int linearBatCount = 0;
+  int totalBatCount = 0;
   ecm->Each<components::BatterySoC, components::Name>(
       [&](const Entity &_batEntity, components::BatterySoC *_batComp,
           components::Name *_nameComp) -> bool
       {
-        batCount++;
+        totalBatCount++;
+        if (_nameComp->Data() == "linear_battery")
+        {
+          linearBatCount++;
 
-        EXPECT_NE(kNullEntity, _batEntity);
-        EXPECT_EQ(_nameComp->Data(), "linear_battery");
+          EXPECT_NE(kNullEntity, _batEntity);
+          EXPECT_EQ(_nameComp->Data(), "linear_battery");
 
-        // Check battery component voltage data is lower than initial voltage
-        EXPECT_LT(_batComp->Data(), 12.592);
+          // Check battery component voltage data is lower than initial voltage
+          EXPECT_LT(_batComp->Data(), 12.592);
+        }
 
         return true;
       });
-  EXPECT_EQ(batCount, 1);
+  EXPECT_EQ(linearBatCount, 1);
+  EXPECT_EQ(totalBatCount, 2);
+}
+
+/////////////////////////////////////////////////
+// Battery with  power draining topics
+// See https://github.com/ignitionrobotics/ign-gazebo/issues/1175
+TEST_F(BatteryPluginTest, IGN_UTILS_TEST_DISABLED_ON_WIN32(PowerDrainTopic))
+{
+  const auto sdfPath = common::joinPaths(std::string(PROJECT_SOURCE_PATH),
+    "test", "worlds", "battery.sdf");
+  sdf::Root root;
+  EXPECT_EQ(root.Load(sdfPath).size(), 0lu);
+  EXPECT_GT(root.WorldCount(), 0lu);
+
+  ServerConfig serverConfig;
+  serverConfig.SetSdfFile(sdfPath);
+
+  // A pointer to the ecm. This will be valid once we run the mock system
+  gazebo::EntityComponentManager *ecm = nullptr;
+  this->mockSystem->preUpdateCallback =
+    [&ecm](const gazebo::UpdateInfo &, gazebo::EntityComponentManager &_ecm)
+    {
+      ecm = &_ecm;
+
+      // Check a battery exists
+      EXPECT_TRUE(ecm->HasComponentType(components::BatterySoC::typeId));
+
+      // Find the battery entity
+      Entity batEntity = ecm->EntityByComponents(components::Name(
+        "linear_battery_topics"));
+      EXPECT_NE(kNullEntity, batEntity);
+
+      // Find the battery component
+      EXPECT_TRUE(ecm->EntityHasComponentType(batEntity,
+        components::BatterySoC::typeId));
+      auto batComp = ecm->Component<components::BatterySoC>(batEntity);
+
+      // Check voltage is never zero.
+      // This check is here to guarantee that components::BatterySoC in
+      // the LinearBatteryPlugin is not zero when created. If
+      // components::BatterySoC is zero on start, then the Physics plugin
+      // can disable a joint. This in turn can prevent the joint from
+      // rotating. See https://github.com/ignitionrobotics/ign-gazebo/issues/55
+      EXPECT_GT(batComp->Data(), 0);
+    };
+
+  // Start server
+  Server server(serverConfig);
+  server.AddSystem(this->systemPtr);
+  server.Run(true, 100, false);
+  EXPECT_NE(nullptr, ecm);
+
+  // Check a battery exists
+  EXPECT_TRUE(ecm->HasComponentType(components::BatterySoC::typeId));
+
+  // Find the battery entity
+  Entity batEntity = ecm->EntityByComponents(components::Name(
+    "linear_battery_topics"));
+  EXPECT_NE(kNullEntity, batEntity);
+
+  // Find the battery component
+  EXPECT_TRUE(ecm->EntityHasComponentType(batEntity,
+    components::BatterySoC::typeId));
+  auto batComp = ecm->Component<components::BatterySoC>(batEntity);
+
+  // Check state of charge should be 1, since the batery has not drained
+  // and the <initial_charge> is equivalent ot the <capacity>.
+  EXPECT_DOUBLE_EQ(batComp->Data(), 1.0);
+
+  // Send a message on one of the <power_draining_topic> topics, which will
+  // start the battery draining when the server starts again.
+  ignition::transport::Node node;
+  auto pub = node.Advertise<msgs::StringMsg>("/battery/discharge2");
+  msgs::StringMsg msg;
+  pub.Publish(msg);
+
+  // Run the server again.
+  server.Run(true, 100, false);
+
+  // The state of charge should be <1, since the batery has started
+  // draining.
+  EXPECT_LT(batComp->Data(), 1.0);
 }

test/integration/imu_system.cc

@@ -225,8 +225,6 @@ TEST_F(ImuTest, IGN_UTILS_TEST_DISABLED_ON_WIN32(OrientationDisabled))
   EXPECT_FALSE(server.Running());
   EXPECT_FALSE(*server.Running(0));
 
-  const std::string sensorName = "imu_sensor";
-
   auto topic =
       "world/imu_sensor/model/imu_model/link/link/sensor/imu_sensor/imu";
 

test/integration/scene_broadcaster_system.cc

@@ -518,7 +518,7 @@ TEST_P(SceneBroadcasterTest, IGN_UTILS_TEST_DISABLED_ON_WIN32(StateStatic))
   // Start server
   ignition::gazebo::ServerConfig serverConfig;
   serverConfig.SetSdfFile(std::string(PROJECT_SOURCE_PATH) +
-      "/examples/worlds/empty.sdf");
+      "/test/worlds/empty.sdf");
 
   gazebo::Server server(serverConfig);
   EXPECT_FALSE(server.Running());

test/integration/sensors_system.cc

@@ -87,6 +87,17 @@ void testDefaultTopics()
   std::vector<transport::MessagePublisher> publishers;
   transport::Node node;
 
+  // Sensors are created in a separate thread, so we sleep here to give them
+  // time
+  int sleep{0};
+  int maxSleep{30};
+  for (; sleep < maxSleep && !node.TopicInfo(topics.front(), publishers);
+      ++sleep)
+  {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  ASSERT_LT(sleep, maxSleep);
+
   for (const std::string &topic : topics)
   {
     bool result = node.TopicInfo(topic, publishers);

test/integration/touch_plugin.cc

@@ -298,7 +298,7 @@ TEST_F(TouchPluginTest, IGN_UTILS_TEST_DISABLED_ON_WIN32(SpawnedEntities))
   auto testFunc = [&](const std::string &_box1, const std::string &_box2)
   {
     this->server.reset();
-    this->StartServer("/examples/worlds/empty.sdf");
+    this->StartServer("/test/worlds/empty.sdf");
 
     whiteTouched = false;
     req.set_sdf(_box1);