Default to not changing the analog domain

include/ur_client_library/rtde/rtde_writer.h

@@ -119,12 +119,14 @@ class RTDEWriter
    *
    * \param output_pin The pin to change
    * \param value The new value, it should be between 0 and 1, where 0 is 4mA and 1 is 20mA.
-   * \param type The domain for the output can be eitherAnalogOutputType::CURRENT or  AnalogOutputType::VOLTAGE
+   * \param type The domain for the output can be eitherAnalogOutputType::CURRENT or  AnalogOutputType::VOLTAGE or
+   * AnalogOutputType::UNKNOWN. In the latter case the domain is left untouched and the domain configured on the teach
+   * pendant will be used.
    *
    * \returns Success of the package creation
    */
   bool sendStandardAnalogOutput(uint8_t output_pin, double value,
-                                const AnalogOutputType type = AnalogOutputType::CURRENT);
+                                const AnalogOutputType type = AnalogOutputType::UNKNOWN);
 
   /*!
    * \brief Creates a package to request setting a new value for an input_bit_register

include/ur_client_library/ur/datatypes.h

@@ -79,8 +79,9 @@ enum class SafetyStatus : int8_t  // Only available on 3.10/5.4
   SYSTEM_THREE_POSITION_ENABLING_STOP = 13
 };
 
-enum class AnalogOutputType : uint8_t
+enum class AnalogOutputType : int8_t
 {
+  UNKNOWN = -1,
   CURRENT = 0,
   VOLTAGE = 1
 };

src/rtde/rtde_writer.cpp

@@ -224,11 +224,14 @@ bool RTDEWriter::sendStandardAnalogOutput(uint8_t output_pin, double value, cons
   std::lock_guard<std::mutex> guard(package_mutex_);
   uint8_t mask = pinToMask(output_pin);
 
-  auto output_type_bits = [](const uint8_t pin, const uint8_t type) { return type << pin; };
-  uint8_t output_type = output_type_bits(output_pin, toUnderlying(type));
   bool success = true;
   success = package_.setData("standard_analog_output_mask", mask);
-  success = success && package_.setData("standard_analog_output_type", output_type);
+  if (type != AnalogOutputType::UNKNOWN)
+  {
+    auto output_type_bits = [](const uint8_t pin, const uint8_t type) { return type << pin; };
+    uint8_t output_type = output_type_bits(output_pin, toUnderlying(type));
+    success = success && package_.setData("standard_analog_output_type", output_type);
+  }
   success = success && package_.setData("standard_analog_output_0", value);
   success = success && package_.setData("standard_analog_output_1", value);
 

tests/test_rtde_writer.cpp

@@ -260,15 +260,14 @@ TEST_F(RTDEWriterTest, send_tool_digital_output)
   EXPECT_FALSE(writer_->sendToolDigitalOutput(pin, send_pin_value));
 }
 
-TEST_F(RTDEWriterTest, send_standard_analog_output)
+TEST_F(RTDEWriterTest, send_standard_analog_output_unknown_domain)
 {
+  waitForMessageCallback(1000);
+
   uint8_t expected_standard_analog_output_mask = 1;
-  AnalogOutputType type = AnalogOutputType::VOLTAGE;
 
   uint8_t pin = 0;
   double send_analog_output = 1;
-  // Neglecting the type parameter should result in type current == 0
-  uint8_t expected_standard_analog_output_type = 0;
   EXPECT_TRUE(writer_->sendStandardAnalogOutput(pin, send_analog_output));
 
   waitForMessageCallback(1000);
@@ -282,31 +281,74 @@ TEST_F(RTDEWriterTest, send_standard_analog_output)
   uint8_t received_standard_analog_output_mask = std::get<uint8_t>(parsed_data_["standard_analog_output_mask"]);
   uint8_t received_standard_analog_output_type = std::get<uint8_t>(parsed_data_["standard_analog_output_type"]);
 
+  EXPECT_EQ(send_analog_output, received_analog_output);
+  EXPECT_EQ(expected_standard_analog_output_mask, received_standard_analog_output_mask);
+  // The test server sets this to 0 if not given
+  EXPECT_EQ(0, received_standard_analog_output_type);
+}
+
+TEST_F(RTDEWriterTest, send_standard_analog_output_voltage)
+{
+  uint8_t pin = 0;
+  AnalogOutputType type = AnalogOutputType::VOLTAGE;
+  double send_analog_output = 1;
+
+  uint8_t expected_standard_analog_output_mask = 1;
+  uint8_t expected_standard_analog_output_type = 1;
+
+  EXPECT_TRUE(writer_->sendStandardAnalogOutput(pin, send_analog_output, type));
+
+  waitForMessageCallback(1000);
+
+  double received_analog_output = std::get<double>(parsed_data_["standard_analog_output_0"]);
+  uint8_t received_standard_analog_output_mask = std::get<uint8_t>(parsed_data_["standard_analog_output_mask"]);
+  uint8_t received_standard_analog_output_type = std::get<uint8_t>(parsed_data_["standard_analog_output_type"]);
+
   EXPECT_EQ(send_analog_output, received_analog_output);
   EXPECT_EQ(expected_standard_analog_output_mask, received_standard_analog_output_mask);
   EXPECT_EQ(expected_standard_analog_output_type, received_standard_analog_output_type);
 
-  pin = 0;
-  type = AnalogOutputType::VOLTAGE;
-  expected_standard_analog_output_mask = 1;
-  expected_standard_analog_output_type = 1;
+  pin = 1;
+  expected_standard_analog_output_mask = 2;
+  expected_standard_analog_output_type = 2;
 
   EXPECT_TRUE(writer_->sendStandardAnalogOutput(pin, send_analog_output, type));
 
   waitForMessageCallback(1000);
 
-  received_analog_output = std::get<double>(parsed_data_["standard_analog_output_0"]);
+  received_analog_output = std::get<double>(parsed_data_["standard_analog_output_1"]);
   received_standard_analog_output_mask = std::get<uint8_t>(parsed_data_["standard_analog_output_mask"]);
   received_standard_analog_output_type = std::get<uint8_t>(parsed_data_["standard_analog_output_type"]);
 
   EXPECT_EQ(send_analog_output, received_analog_output);
   EXPECT_EQ(expected_standard_analog_output_mask, received_standard_analog_output_mask);
   EXPECT_EQ(expected_standard_analog_output_type, received_standard_analog_output_type);
+}
+
+TEST_F(RTDEWriterTest, send_standard_analog_output_current)
+{
+  uint8_t pin = 0;
+  AnalogOutputType type = AnalogOutputType::CURRENT;
+  double send_analog_output = 1;
+
+  uint8_t expected_standard_analog_output_mask = 1;
+  uint8_t expected_standard_analog_output_type = 0;
+
+  EXPECT_TRUE(writer_->sendStandardAnalogOutput(pin, send_analog_output, type));
+
+  waitForMessageCallback(1000);
+
+  double received_analog_output = std::get<double>(parsed_data_["standard_analog_output_0"]);
+  uint8_t received_standard_analog_output_mask = std::get<uint8_t>(parsed_data_["standard_analog_output_mask"]);
+  uint8_t received_standard_analog_output_type = std::get<uint8_t>(parsed_data_["standard_analog_output_type"]);
+
+  EXPECT_EQ(send_analog_output, received_analog_output);
+  EXPECT_EQ(expected_standard_analog_output_mask, received_standard_analog_output_mask);
+  EXPECT_EQ(expected_standard_analog_output_type, received_standard_analog_output_type);
 
   pin = 1;
-  type = AnalogOutputType::VOLTAGE;
   expected_standard_analog_output_mask = 2;
-  expected_standard_analog_output_type = 2;
+  expected_standard_analog_output_type = 0;
 
   EXPECT_TRUE(writer_->sendStandardAnalogOutput(pin, send_analog_output, type));
 
@@ -319,8 +361,14 @@ TEST_F(RTDEWriterTest, send_standard_analog_output)
   EXPECT_EQ(send_analog_output, received_analog_output);
   EXPECT_EQ(expected_standard_analog_output_mask, received_standard_analog_output_mask);
   EXPECT_EQ(expected_standard_analog_output_type, received_standard_analog_output_type);
+}
 
-  // Changing pins above 1, should return false.
+TEST_F(RTDEWriterTest, send_standard_analog_output_illegal_input_fails)
+{
+  uint8_t pin = 0;
+  double send_analog_output = 1;
+
+  // Pin should be either 0 or 1
   pin = 2;
   EXPECT_FALSE(writer_->sendStandardAnalogOutput(pin, send_analog_output));