Make Encoder pure abstract

Author: Olav de Haas

march_hardware/CMakeLists.txt

@@ -110,8 +110,9 @@ if(CATKIN_ENABLE_TESTING)
         test/error/test_hardware_exception.cpp
         test/error/test_motion_error.cpp
         test/mocks/MockAbsoluteEncoder.cpp
-        test/mocks/MockIncrementalEncoder.cpp
+        test/mocks/MockEncoder.cpp
         test/mocks/MockIMotionCube.cpp
+        test/mocks/MockIncrementalEncoder.cpp
         test/mocks/MockJoint.cpp
         test/mocks/MockTemperatureGES.cpp
         test/mocks/MockTemperatureSensor.cpp

march_hardware/include/march_hardware/encoder/AbsoluteEncoder.h

@@ -14,17 +14,7 @@ class AbsoluteEncoder : public Encoder
   AbsoluteEncoder(size_t number_of_bits, int32_t lower_limit_iu, int32_t upper_limit_iu, double lower_limit_rad,
                   double upper_limit_rad, double lower_soft_limit_rad, double upper_soft_limit_rad);
 
-  /*
-   * Reads out the encoder from the slave and transforms the result to radians.
-   * @param actual_position_byte_offset the byte offset in the slave register for the IU position
-   * @returns The current position of the encoder in radians
-   */
-  double getAngleRad(uint8_t byte_offset) const;
-
-  /*
-   * Converts encoder Internal Units (IU) to radians.
-   */
-  double toRad(int32_t iu) const;
+  double toRad(int32_t iu) const override;
 
   /*
    * Converts radians to encoder Internal Units (IU).

march_hardware/include/march_hardware/encoder/Encoder.h

@@ -2,7 +2,7 @@
 
 #ifndef MARCH_HARDWARE_ENCODER_H
 #define MARCH_HARDWARE_ENCODER_H
-
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 
@@ -20,6 +20,20 @@ class Encoder
    */
   int32_t getAngleIU(uint8_t byte_offset) const;
 
+  /*
+   * Reads out the encoder from the slave and transforms the result to radians.
+   * @param byte_offset the byte offset in the slave register for the IU position
+   * @returns The current position of the encoder in radians
+   */
+  double getAngleRad(uint8_t byte_offset) const;
+
+  /*
+   * Converts encoder Internal Units (IU) to radians.
+   * This is a pure virtual function and must be implemented by subclasses,
+   * since each type of encoder has a different way of calculating radians.
+   */
+  virtual double toRad(int32_t iu) const = 0;
+
   size_t getTotalPositions() const;
 
   int getSlaveIndex() const;
@@ -28,6 +42,8 @@ class Encoder
   static const size_t MIN_RESOLUTION = 1;
   static const size_t MAX_RESOLUTION = 32;
 
+  static constexpr double PI_2 = 2 * M_PI;
+
 private:
   /*
    * Returns the total number of positions possible on an encoder

march_hardware/include/march_hardware/encoder/IncrementalEncoder.h

@@ -13,20 +13,20 @@ class IncrementalEncoder : public Encoder
 public:
   IncrementalEncoder(size_t number_of_bits, double transmission);
 
-  double getAngleRad(uint8_t byte_offset);
-
-  double toRad(int32_t iu);
+  double toRad(int32_t iu) const override;
 
   /** @brief Override comparison operator */
   friend bool operator==(const IncrementalEncoder& lhs, const IncrementalEncoder& rhs)
   {
-    return lhs.getSlaveIndex() == rhs.getSlaveIndex() && lhs.getTotalPositions() == rhs.getTotalPositions();
+    return lhs.getSlaveIndex() == rhs.getSlaveIndex() && lhs.getTotalPositions() == rhs.getTotalPositions() &&
+           lhs.transmission_ == rhs.transmission_;
   }
   /** @brief Override stream operator for clean printing */
   friend std::ostream& operator<<(std::ostream& os, const IncrementalEncoder& encoder)
   {
     return os << "slaveIndex: " << encoder.getSlaveIndex() << ", "
-              << "totalPositions: " << encoder.getTotalPositions();
+              << "totalPositions: " << encoder.getTotalPositions() << ", "
+              << "transmission: " << encoder.transmission_;
   }
 
 private:

march_hardware/src/encoder/AbsoluteEncoder.cpp

@@ -1,22 +1,17 @@
 // Copyright 2019 Project March.
 #include "march_hardware/encoder/AbsoluteEncoder.h"
-#include "march_hardware/EtherCAT/EthercatIO.h"
 #include "march_hardware/error/hardware_exception.h"
 
-#include <cmath>
-
 #include <ros/ros.h>
 
 namespace march
 {
-const double PI_2 = 2 * M_PI;
-
 AbsoluteEncoder::AbsoluteEncoder(size_t number_of_bits, int32_t lower_limit_iu, int32_t upper_limit_iu,
                                  double lower_limit_rad, double upper_limit_rad, double lower_soft_limit_rad,
                                  double upper_soft_limit_rad)
   : Encoder(number_of_bits), lower_limit_iu_(lower_limit_iu), upper_limit_iu_(upper_limit_iu)
 {
-  this->zero_position_iu_ = this->lower_limit_iu_ - lower_limit_rad * Encoder::getTotalPositions() / PI_2;
+  this->zero_position_iu_ = this->lower_limit_iu_ - lower_limit_rad * this->getTotalPositions() / PI_2;
   this->lower_soft_limit_iu_ = this->fromRad(lower_soft_limit_rad);
   this->upper_soft_limit_iu_ = this->fromRad(upper_soft_limit_rad);
 
@@ -42,19 +37,14 @@ AbsoluteEncoder::AbsoluteEncoder(size_t number_of_bits, int32_t lower_limit_iu,
   }
 }
 
-double AbsoluteEncoder::getAngleRad(uint8_t byte_offset) const
+double AbsoluteEncoder::toRad(int32_t iu) const
 {
-  return this->toRad(Encoder::getAngleIU(byte_offset));
+  return (iu - this->zero_position_iu_) * PI_2 / this->getTotalPositions();
 }
 
 int32_t AbsoluteEncoder::fromRad(double rad) const
 {
-  return (rad * Encoder::getTotalPositions() / PI_2) + this->zero_position_iu_;
-}
-
-double AbsoluteEncoder::toRad(int32_t iu) const
-{
-  return (iu - this->zero_position_iu_) * PI_2 / Encoder::getTotalPositions();
+  return (rad * this->getTotalPositions() / PI_2) + this->zero_position_iu_;
 }
 
 bool AbsoluteEncoder::isWithinHardLimitsIU(int32_t iu) const

march_hardware/src/encoder/Encoder.cpp

@@ -21,6 +21,11 @@ int32_t Encoder::getAngleIU(uint8_t byte_offset) const
   return return_byte.i;
 }
 
+double Encoder::getAngleRad(uint8_t byte_offset) const
+{
+  return this->toRad(Encoder::getAngleIU(byte_offset));
+}
+
 size_t Encoder::getTotalPositions() const
 {
   return this->total_positions_;

march_hardware/src/encoder/IncrementalEncoder.cpp

@@ -1,22 +1,15 @@
 // Copyright 2019 Project March.
 #include "march_hardware/encoder/IncrementalEncoder.h"
 
-#include <cmath>
-
 namespace march
 {
 IncrementalEncoder::IncrementalEncoder(size_t number_of_bits, double transmission)
   : Encoder(number_of_bits), transmission_(transmission)
 {
 }
 
-double IncrementalEncoder::getAngleRad(uint8_t byte_offset)
-{
-  return this->toRad(Encoder::getAngleIU(byte_offset));
-}
-
-double IncrementalEncoder::toRad(int32_t iu)
+double IncrementalEncoder::toRad(int32_t iu) const
 {
-  return iu * this->transmission_ * 2 * M_PI / Encoder::getTotalPositions();
+  return iu * this->transmission_ * PI_2 / this->getTotalPositions();
 }
 }  //  namespace march

march_hardware/test/encoder/TestEncoder.cpp

@@ -1,36 +1,43 @@
 // Copyright 2020 Project March.
-#include "march_hardware/encoder/Encoder.h"
+#include "../mocks/MockEncoder.cpp"
 #include "march_hardware/error/hardware_exception.h"
 
 #include <cmath>
 
 #include <gtest/gtest.h>
 
+/**
+ * This test fixture uses the MockEncoder to test non virtual methods
+ * of the Encoder abstract class. Otherwise it is not possible to
+ * instantiate a pure abstract class. So as long as the non virtual
+ * methods are tested all is ok.
+ */
 class TestEncoder : public testing::Test
 {
 protected:
   const size_t resolution = 12;
-  march::Encoder encoder = march::Encoder(this->resolution);
 };
 
 TEST_F(TestEncoder, ResolutionBelowRange)
 {
-  ASSERT_THROW(march::Encoder(0), march::error::HardwareException);
+  ASSERT_THROW(MockEncoder(0), march::error::HardwareException);
 }
 
 TEST_F(TestEncoder, ResolutionAboveRange)
 {
-  ASSERT_THROW(march::Encoder(50), march::error::HardwareException);
+  ASSERT_THROW(MockEncoder(50), march::error::HardwareException);
 }
 
 TEST_F(TestEncoder, SetSlaveIndex)
 {
+  MockEncoder encoder(this->resolution);
   const int expected = 10;
-  this->encoder.setSlaveIndex(expected);
-  ASSERT_EQ(expected, this->encoder.getSlaveIndex());
+  encoder.setSlaveIndex(expected);
+  ASSERT_EQ(expected, encoder.getSlaveIndex());
 }
 
 TEST_F(TestEncoder, CorrectTotalPositions)
 {
-  ASSERT_EQ(std::pow(2, this->resolution), this->encoder.getTotalPositions());
+  MockEncoder encoder(this->resolution);
+  ASSERT_EQ(std::pow(2, this->resolution), encoder.getTotalPositions());
 }

march_hardware/test/mocks/MockEncoder.cpp

@@ -0,0 +1,13 @@
+#include "march_hardware/encoder/Encoder.h"
+
+#include <gmock/gmock.h>
+
+class MockEncoder : public march::Encoder
+{
+public:
+  MockEncoder(size_t number_of_bits) : Encoder(number_of_bits)
+  {
+  }
+
+  MOCK_CONST_METHOD1(toRad, double(int32_t));
+};