Rename DMX/RDM APIs to Transmit/Direction

Refactor DMX/RDM public APIs for clarity and consistency in lib-dmx include headers (h3/multi/dmx.h and h3/single/dmx.h).

- Replace dmx::PortDirection with dmx::Direction and rename getter GetPortDirection -> PortDirection
- Rename DMX transmit-related APIs: SetDmxBreakTime/GetDmxBreakTime -> SetTransmitBreakTime/TransmitBreakTime (and similarly for MAB, Period, Slots)
- Rename send templates: SetSendData* -> SetTransmitDataWithSC / SetTransmitDataWithoutSC and update inline template name
- Rename RDM send APIs to RdmTransmit / RdmTransmitDiscoveryRespondMessage and add RDM receive declarations
- Update port_direction_ member type to dmx::Direction and adjust related declarations

This is an API-breaking rename; update callsites accordingly (e.g. SetDmxBreakTime -> SetTransmitBreakTime, GetDmxSlots -> TransmitSlots, RdmSend -> RdmTransmit, SetSendDataWithoutSC -> SetTransmitDataWithoutSC).

Author: vanvught

lib-artnet/include/artnetnode.h

@@ -125,7 +125,7 @@ struct Node
         uint8_t sw;            ///< Bits 3-0 of the 15 bit Port-Address for a given port are encoded into the bottom 4 bits of this field.
         uint8_t sub_switch;    ///< Bits 7-4 of the 15 bit Port-Address are encoded into the bottom 4 bits of this field.
         uint8_t net_switch;    ///< Bits 14-8 of the 15 bit Port-Address are encoded into the bottom 7 bits of this field.
-        dmxnode::PortDirection direction;
+        dmxnode::Direction direction;
         artnet::PortProtocol protocol; ///< Art-Net 4
         bool local_merge;
     } port[dmxnode::kMaxPorts] ALIGNED;
@@ -210,11 +210,11 @@ class ArtNetNode
     void SetUniverse(uint32_t port_index, uint16_t universe);
     uint16_t GetUniverse(uint32_t port_index) const;
 
-    void SetDirection(uint32_t port_index, dmxnode::PortDirection port_direction);
-    dmxnode::PortDirection GetDirection(uint32_t port_index) const;
+    void SetDirection(uint32_t port_index, dmxnode::Direction port_direction);
+    dmxnode::Direction GetDirection(uint32_t port_index) const;
 
-    void SetUniverse(uint32_t port_index, dmxnode::PortDirection port_direction, uint16_t universe);
-    bool GetUniverse(uint32_t port_index, uint16_t& universe, dmxnode::PortDirection port_direction);
+    void SetUniverse(uint32_t port_index, dmxnode::Direction port_direction, uint16_t universe);
+    bool GetUniverse(uint32_t port_index, uint16_t& universe, dmxnode::Direction port_direction);
 
     void SetMergeMode(uint32_t port_index, dmxnode::MergeMode merge_mode);
     dmxnode::MergeMode GetMergeMode(uint32_t port_index) const;
@@ -259,10 +259,10 @@ class ArtNetNode
     uint32_t GetActiveInputPorts() const { return state_.enabled_input_ports; }
     uint32_t GetActiveOutputPorts() const { return state_.enabled_output_ports; }
 
-    dmxnode::PortDirection GetPortDirection(uint32_t port_index) const;
+    dmxnode::Direction PortDirection(uint32_t port_index) const;
 
     bool GetPortAddress(uint32_t port_index, uint16_t& address) const;
-    bool GetPortAddress(uint32_t port_index, uint16_t& address, dmxnode::PortDirection port_direction) const;
+    bool GetPortAddress(uint32_t port_index, uint16_t& address, dmxnode::Direction port_direction) const;
 
     bool GetOutputPort(uint16_t universe, uint32_t& port_index);
 

lib-artnet/include/artnetnode4_inline_impl.h

@@ -85,18 +85,18 @@ inline void ArtNetNode::SetPortProtocol4(uint32_t port_index, artnet::PortProtoc
     node_.port[port_index].protocol = port_protocol;
 
     if (port_protocol == artnet::PortProtocol::kSacn) {
-        if (node_.port[port_index].direction == dmxnode::PortDirection::kOutput) {
+        if (node_.port[port_index].direction == dmxnode::Direction::kOutput) {
             output_port_[port_index].good_output |= artnet::GoodOutput::kOutputIsSacn;
         }
 
         SetUniverse4(port_index);
         E131Bridge::SetDirection(port_index, node_.port[port_index].direction);
     } else {
-        if (node_.port[port_index].direction == dmxnode::PortDirection::kOutput) {
+        if (node_.port[port_index].direction == dmxnode::Direction::kOutput) {
             output_port_[port_index].good_output &= static_cast<uint8_t>(~artnet::GoodOutput::kOutputIsSacn);
         }
 
-        E131Bridge::SetDirection(port_index, dmxnode::PortDirection::kDisable);
+        E131Bridge::SetDirection(port_index, dmxnode::Direction::kDisable);
     }
 
     if (state_.status == artnet::Status::kOn) {
@@ -132,7 +132,7 @@ inline uint8_t ArtNetNode::GetGoodOutput4(uint32_t port_index) {
     assert(port_index < dmxnode::kMaxPorts);
 
     uint16_t universe;
-    const auto kIsActive = E131Bridge::GetUniverse(port_index, universe, dmxnode::PortDirection::kOutput);
+    const auto kIsActive = E131Bridge::GetUniverse(port_index, universe, dmxnode::Direction::kOutput);
 
     DEBUG_PRINTF("Port %u, Active %c, Universe %d, %s", port_index, kIsActive ? 'Y' : 'N', universe, dmxnode::GetMergeMode(E131Bridge::GetMergeMode(port_index), true));
 

lib-artnet/include/artnetnode_inline_impl.h

@@ -87,12 +87,12 @@ inline uint16_t ArtNetNode::GetUniverse(uint32_t port_index) const {
     return 0;
 }
 
-inline dmxnode::PortDirection ArtNetNode::GetDirection(uint32_t port_index) const {
+inline dmxnode::Direction ArtNetNode::GetDirection(uint32_t port_index) const {
     assert(port_index < dmxnode::kMaxPorts);
     return node_.port[port_index].direction;
 }
 
-inline bool ArtNetNode::GetUniverse(uint32_t port_index, uint16_t& universe, dmxnode::PortDirection port_direction) {
+inline bool ArtNetNode::GetUniverse(uint32_t port_index, uint16_t& universe, dmxnode::Direction port_direction) {
     if (node_.port[port_index].protocol == artnet::PortProtocol::kArtnet) {
         return ArtNetNode::GetPortAddress(port_index, universe, port_direction);
     }
@@ -201,26 +201,26 @@ inline void ArtNetNode::GoodOutputBClear(uint32_t port_index, uint8_t b) {
     output_port_[port_index].good_output_b &= static_cast<uint8_t>(~b);
 }
 
-inline dmxnode::PortDirection ArtNetNode::GetPortDirection(uint32_t port_index) const {
+inline dmxnode::Direction ArtNetNode::PortDirection(uint32_t port_index) const {
     assert(port_index < dmxnode::kMaxPorts);
     return node_.port[port_index].direction;
 }
 
 inline bool ArtNetNode::GetPortAddress(uint32_t port_index, uint16_t& address) const {
     assert(port_index < dmxnode::kMaxPorts);
 
-    if (node_.port[port_index].direction == dmxnode::PortDirection::kDisable) {
+    if (node_.port[port_index].direction == dmxnode::Direction::kDisable) {
         return false;
     }
 
     address = node_.port[port_index].port_address;
     return true;
 }
 
-inline bool ArtNetNode::GetPortAddress(uint32_t port_index, uint16_t& address, dmxnode::PortDirection port_direction) const {
+inline bool ArtNetNode::GetPortAddress(uint32_t port_index, uint16_t& address, dmxnode::Direction port_direction) const {
     assert(port_index < dmxnode::kMaxPorts);
 
-    if (port_direction == dmxnode::PortDirection::kDisable) {
+    if (port_direction == dmxnode::Direction::kDisable) {
         return false;
     }
 
@@ -230,7 +230,7 @@ inline bool ArtNetNode::GetPortAddress(uint32_t port_index, uint16_t& address, d
 
 inline bool ArtNetNode::GetOutputPort(uint16_t universe, uint32_t& port_index) {
     for (port_index = 0; port_index < dmxnode::kMaxPorts; port_index++) {
-        if (node_.port[port_index].direction != dmxnode::PortDirection::kOutput) {
+        if (node_.port[port_index].direction != dmxnode::Direction::kOutput) {
             continue;
         }
         if ((node_.port[port_index].protocol == artnet::PortProtocol::kArtnet) && (universe == node_.port[port_index].port_address)) {
@@ -264,7 +264,7 @@ inline void ArtNetNode::Run() {
     }
 
     if (kDeltaMillis >= (1U * 1000U)) {
-        state_.receiving_dmx &= static_cast<uint8_t>(~(1U << static_cast<uint8_t>(dmxnode::PortDirection::kOutput)));
+        state_.receiving_dmx &= static_cast<uint8_t>(~(1U << static_cast<uint8_t>(dmxnode::Direction::kOutput)));
     }
 
 #if (DMXNODE_PORTS > 0)
@@ -312,8 +312,9 @@ inline void ArtNetNode::Run() {
 
 #if defined(RDM_CONTROLLER)
     if (__builtin_expect((state_.is_rdm_enabled), 0)) {
+#if defined(ARTNET_HAVE_DMXIN)
         HandleRdmIn();
-
+#endif
         rdm_controller_.Run();
     }
 #endif

lib-artnet/include/artnetstore.h

@@ -130,7 +130,7 @@ inline void SaveSwitch(uint32_t port_index, [[maybe_unused]] uint8_t sw)
     DEBUG_EXIT();
 }
 
-inline void SaveDirection(uint32_t port_index, dmxnode::PortDirection direction)
+inline void SaveDirection(uint32_t port_index, dmxnode::Direction direction)
 {
     DEBUG_ENTRY();
     DEBUG_PRINTF("%u, %u", port_index, static_cast<uint32_t>(direction));
@@ -157,7 +157,7 @@ inline void SaveDirection(uint32_t port_index, dmxnode::PortDirection direction)
 
     auto direction_store = ConfigStore::Instance().DmxNodeGet(&common::store::DmxNode::direction);
 
-    common::PortSet<dmxnode::PortDirection>(port_index, direction, direction_store);
+    common::PortSet<dmxnode::Direction>(port_index, direction, direction_store);
 
     ConfigStore::Instance().DmxNodeUpdate(&common::store::DmxNode::direction, direction_store);