Migrate UUID API, gd32 headers & style cleanup

Rename and consolidate UUID API and gd32 headers, plus broad stylistic and small functional cleanups across ArtNet/E1.31/RDM code.

- Replaced hal::UuidCopy/hal_uuid.h with UuidCopy/uuid.h and moved/renamed uuid.cpp into lib-gd32/src; updated all includes to use "uuid.h" and removed hal namespace usage.
- Renamed various gd32 header include guards to GD32_* (panelled, serialnumber, timing, uart0, watchdog, uuid) and adjusted file paths accordingly.
- Adjusted copyright years and minor header file content (uuid/header comment tweaks).
- Updated network include usages (network.h -> network_udp.h, network_config.h, network_iface.h) and related code to use network::iface::Dhcp()/GetBroadcastIp().
- ArtNet changes: guard time include with DISABLE_RTC, make kArtnetMinHeaderSize unsigned, rename showfile::record -> showfile::Record and update call sites, many small formatting/brace adjustments and minor refactors in poll/input/failsafe/rdm handlers.
- RDM changes: small logic/formatting cleanups in ArtNet RDM controller, discovery and TOD handling; added bounds check for SetBackgroundIntervalMinutes (validates 1..240).
- E1.31 changes: updated includes to new uuid header and calls to UuidCopy.

These changes are mostly API migrations, header hygiene, formatting/consistency improvements and a few defensive checks; no large behavioral changes except the added parameter validation.

Author: vanvught

lib-artnet/src/node/artnetnode.cpp

@@ -30,7 +30,9 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#if !defined(DISABLE_RTC)
 #include <ctime>
+#endif
 #include <cassert>
 
 #include "artnetnode.h"
@@ -67,12 +69,12 @@
 
 #if defined(ARTNET_SHOWFILE)
 namespace showfile {
-void record(const struct artnet::ArtDmx* artdmx, uint32_t millis);
-void record(const struct artnet::ArtSync* artsync, uint32_t millis);
+void Record(const struct artnet::ArtDmx* artdmx, uint32_t millis);
+void Record(const struct artnet::ArtSync* artsync, uint32_t millis);
 } // namespace showfile
 #endif
 
-static constexpr auto kArtnetMinHeaderSize = 12;
+static constexpr auto kArtnetMinHeaderSize = 12U;
 
 ArtNetNode::ArtNetNode() {
     DEBUG_ENTRY();
@@ -765,7 +767,7 @@ void ArtNetNode::InputUdp(const uint8_t* buffer, uint32_t size, uint32_t from_ip
                 state_.art.dmx_ip = ip_address_from_;
 #if defined(ARTNET_SHOWFILE)
                 if (state_.do_record) {
-                    showfile::record(reinterpret_cast<const artnet::ArtDmx*>(buffer), current_millis_);
+                    showfile::Record(reinterpret_cast<const artnet::ArtDmx*>(buffer), current_millis_);
                 }
 #endif
             }
@@ -788,7 +790,7 @@ void ArtNetNode::InputUdp(const uint8_t* buffer, uint32_t size, uint32_t from_ip
                 }
 #if defined(ARTNET_SHOWFILE)
                 if (state_.do_record) {
-                    showfile::record(reinterpret_cast<const artnet::ArtSync*>(buffer), current_millis_);
+                    showfile::Record(reinterpret_cast<const artnet::ArtSync*>(buffer), current_millis_);
                 }
 #endif
             }

lib-artnet/src/node/artnetnodehandlepoll.cpp

@@ -40,33 +40,29 @@
 #include "artnetnode.h"
 #include "artnet.h"
 #include "timing.h"
-#include "network.h"
+#include "network_udp.h"
+#include "network_config.h"
+#include "network_iface.h"
 #include "firmware/debug/debug_debug.h"
 
-template <uint8_t N> static inline void Uitoa(uint32_t v, uint8_t* p)
-{
+template <uint8_t N> 
+static inline void Uitoa(uint32_t v, uint8_t* p) {
     static_assert(N >= 1);
     auto* o = p + (N - 1);
-    do
-    {
+    do {
         *o-- = static_cast<uint8_t>('0' + (v % 10U));
         v /= 10U;
     } while ((o >= p) && (v > 0));
 
     // If there are remaining digits, fill with zeros
-    while (o >= p)
-    {
+    while (o >= p) {
         *o-- = '0';
     }
 }
 
-/*
- * Table 3 – NodeReport Codes
- */
-static const char* GetReportCodeString(artnet::ReportCode code)
-{
-    switch (code)
-    {
+// Table 3 – NodeReport Codes
+static const char* GetReportCodeString(artnet::ReportCode code) {
+    switch (code) {
         case artnet::ReportCode::kRcdebug:
             return "Booted in debug mode (Only used in development)";
         case artnet::ReportCode::kRcpowerok:
@@ -113,8 +109,7 @@ static const char* GetReportCodeString(artnet::ReportCode code)
  * xxxx is a hex status code as defined in Table 3.
  * yyyy is a decimal counter that increments every time the Node sends an ArtPollResponse.
  */
-static void CreateNodeReport(uint8_t* node_report, artnet::ReportCode code, uint32_t counter)
-{
+static void CreateNodeReport(uint8_t* node_report, artnet::ReportCode code, uint32_t counter) {
     [[maybe_unused]] const auto* begin = node_report;
 
     *node_report++ = '#';
@@ -134,18 +129,15 @@ static void CreateNodeReport(uint8_t* node_report, artnet::ReportCode code, uint
     strncpy(reinterpret_cast<char*>(node_report), preport_string, kRemainingSize);
 }
 
-union uip
-{
+union uip {
     uint32_t u32;
     uint8_t u8[4];
 } static ip;
 
-void ArtNetNode::ProcessPollReply(uint32_t port_index)
-{
+void ArtNetNode::ProcessPollReply(uint32_t port_index) {
     // preventing: src/node/artnetnodehandlepoll.cpp:157:36: error: array subscript 2 is above array bounds of 'artnetnode::OutputPort [2]'
     // [-Werror=array-bounds=]
-    if (__builtin_expect(port_index >= dmxnode::kMaxPorts, 0))
-    {
+    if (__builtin_expect(port_index >= dmxnode::kMaxPorts, 0)) {
 #ifndef NDEBUG
         assert(0 && "port_index >= dmxnode::kMaxPorts");
         return;
@@ -154,11 +146,9 @@ void ArtNetNode::ProcessPollReply(uint32_t port_index)
 #endif
     }
 
-    if (node_.port[port_index].direction == dmxnode::Direction::kOutput)
-    {
+    if (node_.port[port_index].direction == dmxnode::Direction::kOutput) {
 #if (ARTNET_VERSION >= 4)
-        if (node_.port[port_index].protocol == artnet::PortProtocol::kSacn)
-        {
+        if (node_.port[port_index].protocol == artnet::PortProtocol::kSacn) {
             constexpr auto kMask = artnet::GoodOutput::kOutputIsMerging | artnet::GoodOutput::kDataIsBeingTransmitted | artnet::GoodOutput::kOutputIsSacn;
             auto good_output = output_port_[port_index].good_output;
             good_output &= static_cast<uint8_t>(~kMask);
@@ -167,12 +157,9 @@ void ArtNetNode::ProcessPollReply(uint32_t port_index)
         }
 #endif
 #if defined(RDM_CONTROLLER)
-        if (rdm_controller_.IsRunning(port_index))
-        {
+        if (rdm_controller_.IsRunning(port_index)) {
             GoodOutputBClear(port_index, artnet::GoodOutputB::kDiscoveryNotRunning);
-        }
-        else
-        {
+        } else {
             GoodOutputBSet(port_index, artnet::GoodOutputB::kDiscoveryNotRunning);
         }
 #endif
@@ -187,11 +174,9 @@ void ArtNetNode::ProcessPollReply(uint32_t port_index)
     }
 
 #if defined(ARTNET_HAVE_DMXIN)
-    if (node_.port[port_index].direction == dmxnode::Direction::kInput)
-    {
+    if (node_.port[port_index].direction == dmxnode::Direction::kInput) {
 #if (ARTNET_VERSION >= 4)
-        if (node_.port[port_index].protocol == artnet::PortProtocol::kSacn)
-        {
+        if (node_.port[port_index].protocol == artnet::PortProtocol::kSacn) {
             input_port_[port_index].good_input |= artnet::GoodInput::kInputIsSacn;
         }
 #endif
@@ -207,12 +192,10 @@ void ArtNetNode::ProcessPollReply(uint32_t port_index)
 #endif
 }
 
-void ArtNetNode::SendPollReply(uint32_t port_index, uint32_t destination_ip, artnet::ArtPollQueue* queue)
-{
+void ArtNetNode::SendPollReply(uint32_t port_index, uint32_t destination_ip, artnet::ArtPollQueue* queue) {
     assert(port_index < dmxnode::kMaxPorts);
 
-    if (node_.port[port_index].direction == dmxnode::Direction::kDisable)
-    {
+    if (node_.port[port_index].direction == dmxnode::Direction::kDisable) {
         return;
     }
 
@@ -222,13 +205,9 @@ void ArtNetNode::SendPollReply(uint32_t port_index, uint32_t destination_ip, art
     memcpy(art_poll_reply_.bind_ip, ip.u8, sizeof(art_poll_reply_.bind_ip));
 #endif
 
-    if (queue != nullptr)
-    {
-        if (!((node_.port[port_index].port_address >= queue->art_poll_reply.target_port_address_bottom) &&
-              (node_.port[port_index].port_address <= queue->art_poll_reply.target_port_address_top)))
-        {
-            DEBUG_PRINTF("NOT: 	%u >= %u && %u <= %u", node_.port[port_index].port_address, queue->art_poll_reply.target_port_address_bottom,
-                         node_.port[port_index].port_address, queue->art_poll_reply.target_port_address_top);
+    if (queue != nullptr) {
+        if (!((node_.port[port_index].port_address >= queue->art_poll_reply.target_port_address_bottom) && (node_.port[port_index].port_address <= queue->art_poll_reply.target_port_address_top))) {
+            DEBUG_PRINTF("NOT: 	%u >= %u && %u <= %u", node_.port[port_index].port_address, queue->art_poll_reply.target_port_address_bottom, node_.port[port_index].port_address, queue->art_poll_reply.target_port_address_top);
             return;
         }
     }
@@ -241,24 +220,22 @@ void ArtNetNode::SendPollReply(uint32_t port_index, uint32_t destination_ip, art
     const auto* const kPortName = DmxNode::Instance().GetPortName(port_index);
     memcpy(art_poll_reply_.port_name, kPortName, artnet::kPortNameLength);
 
-    if (__builtin_expect((dmxnode_output_type_ != nullptr), 1))
-    {
+    if (__builtin_expect((dmxnode_output_type_ != nullptr), 1)) {
         const auto kRefreshRate = dmxnode_output_type_->GetRefreshRate();
         art_poll_reply_.refresh_rate_lo = static_cast<uint8_t>(kRefreshRate);
         art_poll_reply_.refresh_rate_hi = static_cast<uint8_t>(kRefreshRate >> 8);
         const auto kUserData = dmxnode_output_type_->GetUserData();
         art_poll_reply_.user_lo = static_cast<uint8_t>(kUserData);
         art_poll_reply_.user_hi = static_cast<uint8_t>(kUserData >> 8);
     }
-	
-	art_poll_reply_.status2 &= static_cast<uint8_t>(~artnet::Status2::kIpDhcp);
-	art_poll_reply_.status2 |= network::iface::Dhcp() ? artnet::Status2::kIpDhcp : artnet::Status2::kIpManualy;
+
+    art_poll_reply_.status2 &= static_cast<uint8_t>(~artnet::Status2::kIpDhcp);
+    art_poll_reply_.status2 |= network::iface::Dhcp() ? artnet::Status2::kIpDhcp : artnet::Status2::kIpManualy;
 
     ProcessPollReply(port_index);
 
     state_.art.poll_reply_count++;
-    if (state_.art.poll_reply_count == 10000)
-    {
+    if (state_.art.poll_reply_count == 10000) {
         state_.art.poll_reply_count = 0;
     }
 
@@ -268,80 +245,60 @@ void ArtNetNode::SendPollReply(uint32_t port_index, uint32_t destination_ip, art
     state_.is_changed = false;
 }
 
-void ArtNetNode::HandlePoll()
-{
+void ArtNetNode::HandlePoll() {
     const auto* const kArtPoll = reinterpret_cast<artnet::ArtPoll*>(receive_buffer_);
 
     state_.send_art_poll_reply_on_change = ((kArtPoll->flags & artnet::Flags::kSendArtpOnChange) == artnet::Flags::kSendArtpOnChange);
 
     // If any controller requests diagnostics, the node will send diagnostics. (ArtPoll->Flags->2).
-    if (kArtPoll->flags & artnet::Flags::kSendDiagMessages)
-    {
+    if (kArtPoll->flags & artnet::Flags::kSendDiagMessages) {
         state_.send_art_diag_data = true;
 
-        if (state_.art.poll_ip == 0)
-        {
+        if (state_.art.poll_ip == 0) {
             state_.art.poll_ip = ip_address_from_;
-        }
-        else if (!state_.is_multiple_controllers_req_diag && (state_.art.poll_ip != ip_address_from_))
-        {
+        } else if (!state_.is_multiple_controllers_req_diag && (state_.art.poll_ip != ip_address_from_)) {
             // If there are multiple controllers requesting diagnostics, diagnostics shall be broadcast.
             state_.art.diag_ip = network::GetBroadcastIp();
             state_.is_multiple_controllers_req_diag = true;
         }
 
-        if (state_.is_multiple_controllers_req_diag)
-        {
+        if (state_.is_multiple_controllers_req_diag) {
             // The lowest minimum value of Priority shall be used. (Ignore ArtPoll->diag_priority).
             state_.diag_priority = std::min(state_.diag_priority, kArtPoll->diag_priority);
-        }
-        else
-        {
+        } else {
             state_.diag_priority = kArtPoll->diag_priority;
         }
 
         // If there are multiple controllers requesting diagnostics, diagnostics shall be broadcast. (Ignore ArtPoll->Flags->3).
-        if (!state_.is_multiple_controllers_req_diag && (kArtPoll->flags & artnet::Flags::kSendDiagUnicast))
-        {
+        if (!state_.is_multiple_controllers_req_diag && (kArtPoll->flags & artnet::Flags::kSendDiagUnicast)) {
             state_.art.diag_ip = ip_address_from_;
-        }
-        else
-        {
+        } else {
             state_.art.diag_ip = network::GetBroadcastIp();
         }
-    }
-    else
-    {
+    } else {
         state_.send_art_diag_data = false;
         state_.art.diag_ip = 0;
     }
 
     auto target_port_address_bottom = artnet::kPortAddressFirst;
     auto target_port_address_top = artnet::kPortAddressLast;
 
-    if (kArtPoll->flags & artnet::Flags::kUseTargetPortAddress)
-    {
-        target_port_address_top =
-            static_cast<uint16_t>((static_cast<uint16_t>(kArtPoll->target_port_address_top_hi) >> 8) | kArtPoll->target_port_address_top_lo);
-        target_port_address_bottom =
-            static_cast<uint16_t>((static_cast<uint16_t>(kArtPoll->target_port_address_bottom_hi) >> 8) | kArtPoll->target_port_address_bottom_lo);
+    if (kArtPoll->flags & artnet::Flags::kUseTargetPortAddress) {
+        target_port_address_top = static_cast<uint16_t>((static_cast<uint16_t>(kArtPoll->target_port_address_top_hi) >> 8) | kArtPoll->target_port_address_top_lo);
+        target_port_address_bottom = static_cast<uint16_t>((static_cast<uint16_t>(kArtPoll->target_port_address_bottom_hi) >> 8) | kArtPoll->target_port_address_bottom_lo);
     }
 
     PollReplyQueueAdd(target_port_address_bottom, target_port_address_top);
 }
 
-void ArtNetNode::PollReplyQueueAdd(uint16_t target_port_address_bottom, uint16_t target_port_address_top)
-{
-    for (auto& entry : state_.art.poll_reply_queue)
-    {
-        if ((entry.art_poll_reply_ip_address == ip_address_from_) && (entry.art_poll_millis != 0)) [[unlikely]]
-        {
+void ArtNetNode::PollReplyQueueAdd(uint16_t target_port_address_bottom, uint16_t target_port_address_top) {
+    for (auto& entry : state_.art.poll_reply_queue) {
+        if ((entry.art_poll_reply_ip_address == ip_address_from_) && (entry.art_poll_millis != 0)) [[unlikely]] {
             DEBUG_PRINTF("PollReply already queued for " IPSTR, IP2STR(entry.art_poll_reply_ip_address));
             return;
         }
 
-        if (entry.art_poll_millis == 0)
-        {
+        if (entry.art_poll_millis == 0) {
             entry.art_poll_millis = timing::Millis();
             entry.art_poll_reply_ip_address = ip_address_from_;
             entry.art_poll_reply.target_port_address_top = target_port_address_top;

lib-artnet/src/node/dmxin/handleinput.cpp

@@ -30,27 +30,22 @@
 #if (ARTNET_VERSION >= 4) && defined(E131_HAVE_DMXIN)
 #include "e131bridge.h"
 #endif
-
 #include "firmware/debug/debug_debug.h"
 
-/**
- * A Controller or monitoring device on the network can
- * enable or disable individual DMX512 inputs on any of the network nodes.
- * This allows the Controller to directly control network traffic and
- * ensures that unused inputs are disabled and therefore not wasting bandwidth.
- */
+// A Controller or monitoring device on the network can
+// enable or disable individual DMX512 inputs on any of the network nodes.
+// This allows the Controller to directly control network traffic and
+// ensures that unused inputs are disabled and therefore not wasting bandwidth.
 
-void ArtNetNode::HandleInput()
-{
+void ArtNetNode::HandleInput() {
     DEBUG_ENTRY();
 
     const auto* const kArtInput = reinterpret_cast<artnet::ArtInput*>(receive_buffer_);
 
 #if (ARTNET_VERSION >= 4)
     // Art-Net 4: BindIndex is used to discriminate packets from the same IP.
     // Treat bind_index == 0 as legacy / invalid for strict Art-Net 4 behavior.
-    if (kArtInput->bind_index == 0) [[unlikely]]
-    {
+    if (kArtInput->bind_index == 0) [[unlikely]] {
         DEBUG_EXIT();
         return;
     }
@@ -59,26 +54,20 @@ void ArtNetNode::HandleInput()
     const auto kPortIndex = static_cast<uint32_t>(kArtInput->bind_index > 0 ? kArtInput->bind_index - 1 : 0);
 
     // Bounds check
-    if (kPortIndex >= dmxnode::kMaxPorts) [[unlikely]]
-    {
+    if (kPortIndex >= dmxnode::kMaxPorts) [[unlikely]] {
         DEBUG_EXIT();
         return;
     }
 
     // Controllers might send NumPortsLo = 4
     // We only act on Input[0] because bind_index selects the logical port instance.
-    if (kArtInput->num_ports_lo >= 1)
-    {
-        if (node_.port[kPortIndex].direction == dmxnode::Direction::kInput)
-        {
+    if (kArtInput->num_ports_lo >= 1) {
+        if (node_.port[kPortIndex].direction == dmxnode::Direction::kInput) {
             const auto kDisabled = (kArtInput->input[0] & 0x01U) != 0U;
 
-            if (kDisabled)
-            {
+            if (kDisabled) {
                 input_port_[kPortIndex].good_input |= static_cast<uint8_t>(artnet::GoodInput::kDisabled);
-            }
-            else
-            {
+            } else {
                 input_port_[kPortIndex].good_input &= static_cast<uint8_t>(~static_cast<uint8_t>(artnet::GoodInput::kDisabled));
             }
 #if (ARTNET_VERSION >= 4) && defined(E131_HAVE_DMXIN)
@@ -87,8 +76,7 @@ void ArtNetNode::HandleInput()
         }
     }
 
-    if (state_.send_art_poll_reply_on_change)
-    {
+    if (state_.send_art_poll_reply_on_change) {
         SendPollReply(kPortIndex, ip_address_from_);
     }