Use 'speed' instead of 'notch'

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.30.0
+- Use 'speed' instead of 'notch'
+- Update to ZTL 0.18.0
+
 ## 0.29.1
 - Don't receive packets <=3 bytes
 

CMakeLists.txt

@@ -10,7 +10,7 @@ endif()
 FetchContent_Declare(
   CMakeModules
   GIT_REPOSITORY https://github.com/ZIMO-Elektronik/CMakeModules
-  GIT_TAG v0.1.2
+  GIT_TAG v0.2.1
   SOURCE_DIR ${CMAKE_BINARY_DIR}/CMakeModules)
 FetchContent_MakeAvailable(CMakeModules)
 
@@ -78,7 +78,7 @@ if(NOT TARGET static_math)
 endif()
 
 if(NOT TARGET ZTL::ZTL)
-  cpmaddpackage("gh:ZIMO-Elektronik/ZTL@0.17.0")
+  cpmaddpackage("gh:ZIMO-Elektronik/ZTL@0.18.0")
 endif()
 
 target_link_libraries(DCC INTERFACE static_math ZTL::ZTL)

README.md

@@ -191,8 +191,8 @@ private:
   // Set direction (1 forward, -1 backward)
   void direction(uint32_t addr, int32_t dir);
 
-  // Set notch (0-255)
-  void notch(uint32_t addr, int32_t notch);
+  // Set speed (0-255)
+  void speed(uint32_t addr, int32_t speed);
 
   // Emergency stop
   void emergencyStop(uint32_t addr);

examples/repl/decoder.cpp

@@ -17,8 +17,8 @@ void Decoder::direction(uint32_t addr, int32_t dir) {
                    << (dir == 1 ? "forward" : "backward") << PROMPTENDL;
 }
 
-void Decoder::notch(uint32_t addr, int32_t notch) {
-  cli::Cli::cout() << "Address " << addr << ": set speed " << notch
+void Decoder::speed(uint32_t addr, int32_t speed) {
+  cli::Cli::cout() << "Address " << addr << ": set speed " << speed
                    << PROMPTENDL;
 }
 

examples/repl/decoder.hpp

@@ -12,8 +12,8 @@ struct Decoder : dcc::rx::CrtpBase<Decoder> {
   // Set direction (1 forward, -1 backward)
   void direction(uint32_t addr, int32_t dir);
 
-  // Set notch (0-255)
-  void notch(uint32_t addr, int32_t notch);
+  // Set speed (0-255)
+  void speed(uint32_t addr, int32_t speed);
 
   // Emergency stop
   void emergencyStop(uint32_t addr);

include/dcc/rx/crtp_base.hpp

@@ -393,12 +393,12 @@ struct CrtpBase : bidi::CrtpBase<T> {
       case 0b0011'1111u: {
         auto const dir{chunk[1uz] & ztl::make_mask(7u) ? 1 : -1};
         // Halt
-        if (!(chunk[1uz] & 0b0111'1111u)) directionNotch(addr, dir, 0);
+        if (!(chunk[1uz] & 0b0111'1111u)) directionSpeed(addr, dir, 0);
         // Emergency stop
         else if (!(chunk[1uz] & 0b0111'1110u)) impl().emergencyStop(addr);
         else {
-          auto const notch{scale_notch<126>((chunk[1uz] & 0b0111'1111) - 1)};
-          directionNotch(addr, dir, notch);
+          auto const speed{scale_speed<126>((chunk[1uz] & 0b0111'1111) - 1)};
+          directionSpeed(addr, dir, speed);
         }
         break;
       }
@@ -428,30 +428,30 @@ struct CrtpBase : bidi::CrtpBase<T> {
   /// \param  chunk Raw data
   void speedAndDirection(uint32_t addr, std::span<uint8_t const> chunk) {
     auto const dir{chunk[0uz] & ztl::make_mask(5u) ? 1 : -1};
-    int32_t notch{};
+    int32_t speed{};
 
     // Halt
-    if (!(chunk[0uz] & 0b0000'1111u)) notch = 0;
+    if (!(chunk[0uz] & 0b0000'1111u)) speed = 0;
     // Emergency stop
     else if (!(chunk[0uz] & 0b0000'1110u)) return impl().emergencyStop(addr);
-    else notch = (chunk[0uz] & 0b0000'1111) - 1;
+    else speed = (chunk[0uz] & 0b0000'1111) - 1;
 
     // 14 speed steps and F0
     if (_f0_exception) {
-      notch = scale_notch<14>(notch);
+      speed = scale_speed<14>(speed);
       auto const mask{ztl::make_mask(0u)};
       auto const state{chunk[0uz] & ztl::make_mask(4u) ? ztl::make_mask(0u)
                                                        : 0u};
       impl().function(addr, mask, state);
     }
     // 28 speed steps
     else {
-      notch <<= 1u;
-      if (notch && !(chunk[0uz] & ztl::make_mask(4u))) --notch;
-      notch = scale_notch<28>(notch);
+      speed <<= 1u;
+      if (speed && !(chunk[0uz] & ztl::make_mask(4u))) --speed;
+      speed = scale_speed<28>(speed);
     }
 
-    directionNotch(addr, dir, notch);
+    directionSpeed(addr, dir, speed);
   }
 
   /// Execute function group
@@ -750,17 +750,17 @@ struct CrtpBase : bidi::CrtpBase<T> {
     }
   }
 
-  /// Set direction and notch
+  /// Set direction and speed
   ///
   /// \param  addr  Address
   /// \param  dir   Direction
-  /// \param  notch Notch
-  void directionNotch(uint32_t addr, int32_t dir, int32_t notch) {
+  /// \param  speed Speed
+  void directionSpeed(uint32_t addr, int32_t dir, int32_t speed) {
     auto const reverse{addr == _addrs.primary
                          ? impl().readCv(29u - 1u) & ztl::make_mask(0u)
                          : impl().readCv(19u - 1u) & ztl::make_mask(7u)};
     impl().direction(addr, reverse ? dir * -1 : dir);
-    impl().notch(addr, notch);
+    impl().speed(addr, speed);
   }
 
   /// Update quality of service (roughly every second)

include/dcc/rx/decoder.hpp

@@ -20,13 +20,13 @@ concept Decoder = Readable<T> && Writable<T> &&
                   requires(T t,
                            uint32_t addr,
                            int32_t dir,
-                           int32_t notch,
+                           int32_t speed,
                            uint32_t mask,
                            uint32_t state,
                            bool service_mode,
                            std::span<uint8_t const> chunk) {
                     { t.direction(addr, dir) } -> std::same_as<void>;
-                    { t.notch(addr, notch) } -> std::same_as<void>;
+                    { t.speed(addr, speed) } -> std::same_as<void>;
                     { t.emergencyStop(addr) } -> std::same_as<void>;
                     { t.function(addr, mask, state) } -> std::same_as<void>;
                     { t.serviceModeHook(service_mode) } -> std::same_as<void>;

include/dcc/utility.hpp

@@ -34,24 +34,24 @@ constexpr auto data2uint32(uint8_t const* data) {
                                data[2uz] << 8u | data[3uz] << 0u);
 }
 
-/// Scale notch from 14, 28 or 126 steps to 255
+/// Scale speed from 14, 28 or 126 steps to 255
 ///
 /// \tparam Scale Scaling
-/// \param  notch Notch
-/// \raturn Scaled notch
+/// \param  speed Speed
+/// \raturn Scaled speed
 template<int32_t Scale>
-constexpr int32_t scale_notch(int32_t notch)
+constexpr int32_t scale_speed(int32_t speed)
   requires(Scale == 14 || Scale == 28 || Scale == 126)
 {
   // Zero stays zero
-  if (!notch) return 0;
+  if (!speed) return 0;
   // One shares the same internal minimum across all scales
   constexpr int32_t max{255}, min{ztl::lerp<int32_t>(1, 0, 126, 0, max)};
-  if (notch == 1) return min;
+  if (speed == 1) return min;
   if constexpr (Scale == 14 || Scale == 28)
-    return ztl::lerp<int32_t>(notch, 1, Scale, min, max);
+    return ztl::lerp<int32_t>(speed, 1, Scale, min, max);
   else if constexpr (Scale == 126)
-    return ztl::lerp<int32_t>(notch, 0, Scale, 0, max);
+    return ztl::lerp<int32_t>(speed, 0, Scale, 0, max);
 }
 
 }  // namespace dcc

tests/CMakeLists.txt

@@ -3,7 +3,7 @@ include(GoogleTest)
 file(GLOB_RECURSE SRC *.cpp)
 add_executable(DCCTests ${SRC})
 
-sanatize("address,undefined")
+sanitize("address,undefined")
 
 target_common_warnings(DCCTests PRIVATE)
 

tests/rx/advanced_operations.cpp

@@ -5,7 +5,7 @@ TEST_F(RxTest, _126_speed_steps_fwd) {
   Expectation read_cv{
     EXPECT_CALL(_mock, readCv(_)).WillOnce(Return(_cvs[29uz - 1uz]))};
   Expectation dir{EXPECT_CALL(_mock, direction(3u, 1))};
-  Expectation notch{EXPECT_CALL(_mock, notch(3u, _))};
+  Expectation speed{EXPECT_CALL(_mock, speed(3u, _))};
   Receive(dcc::make_advanced_operations_speed_packet(3u, 1, 10u));
   Execute();
 }
@@ -16,7 +16,7 @@ TEST_F(RxTest, _126_speed_steps_bwd) {
     Expectation read_cv{
       EXPECT_CALL(_mock, readCv(_)).WillOnce(Return(_cvs[29uz - 1uz]))};
     Expectation dir{EXPECT_CALL(_mock, direction(3u, -1))};
-    Expectation notch{EXPECT_CALL(_mock, notch(3u, _))};
+    Expectation speed{EXPECT_CALL(_mock, speed(3u, _))};
     Receive(dcc::make_advanced_operations_speed_packet(3u, -1, 10u));
     Execute();
   }
@@ -26,7 +26,7 @@ TEST_F(RxTest, _126_speed_steps_bwd) {
     Expectation read_cv{
       EXPECT_CALL(_mock, readCv(_)).WillOnce(Return(_cvs[29uz - 1uz]))};
     Expectation dir{EXPECT_CALL(_mock, direction(3u, -1))};
-    Expectation notch{EXPECT_CALL(_mock, notch(3u, _))};
+    Expectation speed{EXPECT_CALL(_mock, speed(3u, _))};
     Receive(dcc::make_advanced_operations_speed_packet(3u, 0, 10u));
     Execute();
   }

tests/rx/rx_mock.hpp

@@ -4,7 +4,7 @@
 
 struct RxMock : dcc::rx::CrtpBase<RxMock> {
   MOCK_METHOD(void, direction, (uint32_t, int32_t));
-  MOCK_METHOD(void, notch, (uint32_t, int32_t));
+  MOCK_METHOD(void, speed, (uint32_t, int32_t));
   MOCK_METHOD(void, emergencyStop, (uint32_t));
   MOCK_METHOD(void, function, (uint32_t, uint32_t, uint32_t));
   MOCK_METHOD(void, serviceModeHook, (bool));

tests/rx/scale_speed.cpp

@@ -0,0 +1,33 @@
+#include <gtest/gtest.h>
+#include <dcc/dcc.hpp>
+
+using dcc::scale_speed;
+
+TEST(receive_scale_speed, zero) {
+  EXPECT_EQ(scale_speed<14>(0), 0);
+  EXPECT_EQ(scale_speed<28>(0), 0);
+  EXPECT_EQ(scale_speed<126>(0), 0);
+}
+
+TEST(receive_scale_speed, one) {
+  EXPECT_EQ(scale_speed<14>(1), scale_speed<126>(1));
+  EXPECT_EQ(scale_speed<28>(1), scale_speed<126>(1));
+}
+
+TEST(receive_scale_speed, two) {
+  EXPECT_EQ(scale_speed<14>(2), 21);
+  EXPECT_EQ(scale_speed<28>(2), 11);
+  EXPECT_EQ(scale_speed<126>(2), 4);
+}
+
+TEST(receive_scale_speed, three) {
+  EXPECT_EQ(scale_speed<14>(3), 40);
+  EXPECT_EQ(scale_speed<28>(3), 20);
+  EXPECT_EQ(scale_speed<126>(3), 6);
+}
+
+TEST(receive_scale_speed, max) {
+  EXPECT_EQ(scale_speed<14>(14), 255);
+  EXPECT_EQ(scale_speed<28>(28), 255);
+  EXPECT_EQ(scale_speed<126>(126), 255);
+}