Centralize unique ID memory access

Extract repeated unique ID base address definitions from macaddress.cpp, serialnumber.cpp, and uuid.cpp into a new gd32_unique_id.h header. This reduces code duplication and centralizes MCU variant-specific memory addresses. Update files to use helper functions (Word0, Word1, Word2) instead of inline memory casting.

Author: vanvught

lib-gd32/include/gd32_unique_id.h

@@ -0,0 +1,55 @@
+/**
+ * @file gd32_unique_id.h
+ *
+ */
+/* Copyright (C) 2026 by Arjan van Vught mailto:info@gd32-dmx.org
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*/
+
+#ifndef GD32_UNIQUE_ID_H_
+#define GD32_UNIQUE_ID_H_
+
+#include <cstdint>
+
+namespace gd32::uid {
+#if defined(GD32H7XX)
+static constexpr uintptr_t kBase = 0x1FF0F7E8;
+#elif defined(GD32F4XX)
+static constexpr uintptr_t kBase = 0x1FFF7A10;
+#else
+static constexpr uintptr_t kBase = 0x1FFFF7E8;
+#endif
+
+static inline uint32_t Word(uint32_t index) {
+    return *reinterpret_cast<volatile const uint32_t*>(kBase + (index * sizeof(uint32_t)));
+}
+
+static inline uint32_t Word0() {
+    return Word(0);
+}
+static inline uint32_t Word1() {
+    return Word(1);
+}
+static inline uint32_t Word2() {
+    return Word(2);
+}
+} // namespace gd32::uid
+
+#endif // GD32_UNIQUE_ID_H_

lib-gd32/src/macaddress.cpp

@@ -30,25 +30,18 @@
 #include <cstdint>
 
 #include "firmware/debug/debug_debug.h"
+#include "gd32_unique_id.h"
 
 void MacAddress(uint8_t paddr[]) {
-#if defined(GD32H7XX)
-    const auto kMacaddressHigh = *reinterpret_cast<volatile uint32_t*>(0x1FF0F7E8);
-    const auto kMacAddressLow = *reinterpret_cast<volatile uint32_t*>(0x1FF0F7EC);
-#elif defined(GD32F4XX)
-    const auto kMacaddressHigh = *reinterpret_cast<volatile uint32_t*>(0x1FFF7A10);
-    const auto kMacAddressLow = *reinterpret_cast<volatile uint32_t*>(0x1FFF7A14);
-#else
-    const auto kMacaddressHigh = *reinterpret_cast<volatile uint32_t*>(0x1FFFF7E8);
-    const auto kMacAddressLow = *reinterpret_cast<volatile uint32_t*>(0x1FFFF7EC);
-#endif
+    const auto kId0 = gd32::uid::Word0();
+    const auto kId1 = gd32::uid::Word1();
 
     paddr[0] = 2;
-    paddr[1] = static_cast<uint8_t>((kMacAddressLow >> 0) & 0xFF);
-    paddr[2] = static_cast<uint8_t>((kMacaddressHigh >> 24) & 0xFF);
-    paddr[3] = static_cast<uint8_t>((kMacaddressHigh >> 16) & 0xFF);
-    paddr[4] = static_cast<uint8_t>((kMacaddressHigh >> 8) & 0xFF);
-    paddr[5] = static_cast<uint8_t>((kMacaddressHigh >> 0) & 0xFF);
+    paddr[1] = static_cast<uint8_t>((kId1 >> 0) & 0xFF);
+    paddr[2] = static_cast<uint8_t>((kId0 >> 24) & 0xFF);
+    paddr[3] = static_cast<uint8_t>((kId0 >> 16) & 0xFF);
+    paddr[4] = static_cast<uint8_t>((kId0 >> 8) & 0xFF);
+    paddr[5] = static_cast<uint8_t>((kId0 >> 0) & 0xFF);
 
     DEBUG_PRINTF("%02x:%02x:%02x:%02x:%02x:%02x", paddr[0], paddr[1], paddr[2], paddr[3], paddr[4], paddr[5]);
 }

lib-gd32/src/serialnumber.cpp

@@ -26,18 +26,13 @@
 #include <cstdint>
 
 #include "serialnumber.h"
+#include "gd32_unique_id.h"
 
 void SerialNumber(uint8_t sn[kSnSize]) {
-#if defined(GD32H7XX)
-    const auto kMacaddressHigh = *reinterpret_cast<volatile uint32_t*>(0x1FF0F7E8);
-#elif defined(GD32F4XX)
-    const auto kMacaddressHigh = *reinterpret_cast<volatile uint32_t*>(0x1FFF7A10);
-#else
-    const auto kMacaddressHigh = *reinterpret_cast<volatile uint32_t*>(0x1FFFF7E8);
-#endif
+    const auto kId0 = gd32::uid::Word0();
 
-    sn[0] = static_cast<uint8_t>((kMacaddressHigh >> 0) & 0xFF);
-    sn[1] = static_cast<uint8_t>((kMacaddressHigh >> 8) & 0xFF);
-    sn[2] = static_cast<uint8_t>((kMacaddressHigh >> 16) & 0xFF);
-    sn[3] = static_cast<uint8_t>((kMacaddressHigh >> 24) & 0xFF);
+    sn[0] = static_cast<uint8_t>((kId0 >> 0) & 0xFF);
+    sn[1] = static_cast<uint8_t>((kId0 >> 8) & 0xFF);
+    sn[2] = static_cast<uint8_t>((kId0 >> 16) & 0xFF);
+    sn[3] = static_cast<uint8_t>((kId0 >> 24) & 0xFF);
 }

lib-gd32/src/softuart0/uart0.cpp

@@ -22,61 +22,61 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
- 
+
 #include <cstdint>
 
 #include "gd32.h"
 
-#if defined(GD32H7XX)
-#define TIMERx            TIMER15
-#define RCU_TIMERx        RCU_TIMER15
+#if defined(GD32H7XX) // GD32H7XX
+#define TIMERx TIMER15
+#define RCU_TIMERx RCU_TIMER15
 #define TIMERx_IRQHandler TIMER15_IRQHandler
-#define TIMERx_IRQn       TIMER15_IRQn
-#elif defined(GD32F30X)
-#define TIMERx            TIMER7
-#define RCU_TIMERx        RCU_TIMER7
-#if defined (GD32F30X_XD)
+#define TIMERx_IRQn TIMER15_IRQn
+#elif defined(GD32F30X) // GD32F30X
+#define TIMERx TIMER7
+#define RCU_TIMERx RCU_TIMER7
+#if defined(GD32F30X_XD) // GD32F30X_XD
 #define TIMERx_IRQHandler TIMER7_UP_TIMER12_IRQHandler
-#define TIMERx_IRQn       TIMER7_UP_TIMER12_IRQn
+#define TIMERx_IRQn TIMER7_UP_TIMER12_IRQn
 #else
 #define TIMERx_IRQHandler TIMER7_UP_IRQHandler
-#define TIMERx_IRQn       TIMER7_UP_IRQn
+#define TIMERx_IRQn TIMER7_UP_IRQn
 #endif
 #else
-#define TIMERx            TIMER9
-#define RCU_TIMERx        RCU_TIMER9
+#define TIMERx TIMER9
+#define RCU_TIMERx RCU_TIMER9
 #define TIMERx_IRQHandler TIMER0_UP_TIMER9_IRQHandler
-#define TIMERx_IRQn       TIMER0_UP_TIMER9_IRQn
+#define TIMERx_IRQn TIMER0_UP_TIMER9_IRQn
 #endif
 
 #if defined(GD32H7XX)
-#define TIMER_CLOCK_FREQ  (AHB_CLOCK_FREQ)
+#define TIMER_CLOCK_FREQ (AHB_CLOCK_FREQ)
 #elif defined(GD32F4XX)
-#define TIMER_CLOCK_FREQ  (APB2_CLOCK_FREQ * 2)
+#define TIMER_CLOCK_FREQ (APB2_CLOCK_FREQ * 2)
 #else
-#define TIMER_CLOCK_FREQ  (APB2_CLOCK_FREQ)
+#define TIMER_CLOCK_FREQ (APB2_CLOCK_FREQ)
 #endif
 
 #if !defined(SOFTUART_TX_PINx)
-#define SOFTUART_TX_PINx          GPIO_PIN_9
-#define SOFTUART_TX_GPIOx         GPIOA
-#define SOFTUART_TX_RCU_GPIOx     RCU_GPIOA
+#define SOFTUART_TX_PINx GPIO_PIN_9
+#define SOFTUART_TX_GPIOx GPIOA
+#define SOFTUART_TX_RCU_GPIOx RCU_GPIOA
 #endif
 
 #if defined(SOFTUART0_ENABLE_RX)
 #if !defined(SOFTUART_RX_PINx)
-#define SOFTUART_RX_PINx          GPIO_PIN_10
-#define SOFTUART_RX_GPIOx         GPIOA
-#define SOFTUART_RX_RCU_GPIOx     RCU_GPIOA
+#define SOFTUART_RX_PINx GPIO_PIN_10
+#define SOFTUART_RX_GPIOx GPIOA
+#define SOFTUART_RX_RCU_GPIOx RCU_GPIOA
 #if defined(GD32H7XX)
 #error
 #else
-#define SOFTUART_RX_TIMERx                  TIMER0
-#define SOFTUART_RX_RCU_TIMERx              RCU_TIMER0
-#define SOFTUART_RX_EXTIx_IRQHandler        EXTI10_15_IRQHandler
-#define SOFTUART_RX_EXTIx_IRQn              EXTI10_15_IRQn
-#define SOFTUART_RX_GPIO_PORT_SOURCE_GPIOx  GPIO_PORT_SOURCE_GPIOB
-#define SOFTUART_RX_GPIO_PIN_SOURCE_x       GPIO_PIN_SOURCE_14
+#define SOFTUART_RX_TIMERx TIMER11
+#define SOFTUART_RX_RCU_TIMERx RCU_TIMER11
+#define SOFTUART_RX_EXTIx_IRQHandler EXTI10_15_IRQHandler
+#define SOFTUART_RX_EXTIx_IRQn EXTI10_15_IRQn
+#define SOFTUART_RX_GPIO_PORT_SOURCE_GPIOx GPIO_PORT_SOURCE_GPIOB
+#define SOFTUART_RX_GPIO_PIN_SOURCE_x GPIO_PIN_SOURCE_14
 #endif
 #endif // !defined(SOFTUART_RX_PINx)
 static_assert(TIMERx != SOFTUART_RX_TIMERx);
@@ -92,7 +92,7 @@ static constexpr uint32_t kTimerPeriod = ((TIMER_CLOCK_FREQ / kBaudRate) - 1U);
 static constexpr uint32_t kBufferSize = 128U;
 
 enum class TxState { kIdle, kStartBit, kData, kStopBit };
-enum class RxState { kIdle, kVerifyStart, kData, kStopBit };
+enum class RxState { kIdle, kStart, kData, kStop };
 
 struct CircularBuffer {
     uint8_t buffer[kBufferSize];
@@ -108,6 +108,8 @@ static volatile uint8_t s_tx_shift;
 #if defined(SOFTUART0_ENABLE_RX)
 static volatile CircularBuffer s_rx_buffer __attribute__((aligned(4)));
 static volatile RxState s_rx_state;
+static volatile uint8_t s_rx_data;
+static volatile uint8_t s_rx_shift;
 #endif // defined(SOFTUART0_ENABLE_RX)
 
 extern "C" {
@@ -156,6 +158,35 @@ void TIMERx_IRQHandler() {
 }
 #if defined(SOFTUART0_ENABLE_RX)
 void SOFTUART_RX_EXTIx_IRQHandler() {
+    if (RESET == exti_interrupt_flag_get(EXTI_14)) {
+        return;
+    }
+
+    exti_interrupt_flag_clear(EXTI_14);
+
+    if (s_rx_state != RxState::kIdle) {
+        return;
+    }
+
+    if ((GPIO_ISTAT(SOFTUART_RX_GPIOx) & SOFTUART_RX_PINx) != 0U) {
+        return;
+    }
+
+    s_rx_state = RxState::kStart;
+    s_rx_data = 0;
+    s_rx_shift = 0;
+
+    exti_interrupt_disable(EXTI_14);
+
+    timer_disable(SOFTUART_RX_TIMERx);
+    timer_counter_value_config(SOFTUART_RX_TIMERx, 0);
+
+    // First sample = middle of first data bit
+    // = 1.5 bit times after falling edge.
+    timer_channel_output_pulse_value_config(SOFTUART_RX_TIMERx, TIMER_CH_0, (kTimerPeriod * 3U) / 2U);
+
+    timer_interrupt_flag_clear(SOFTUART_RX_TIMERx, TIMER_INT_FLAG_CH0);
+    timer_enable(SOFTUART_RX_TIMERx);
 }
 #endif
 }

lib-gd32/src/uuid.cpp

@@ -23,41 +23,19 @@
  * THE SOFTWARE.
  */
 
-#if !defined(__clang__)
-#pragma GCC push_options
-#pragma GCC optimize("O2")
-#pragma GCC optimize("no-tree-loop-distribute-patterns")
-#pragma GCC optimize("-funroll-loops")
-#endif
-
 #include <cstdint>
 #include <cstring>
 #include <uuid/uuid.h>
 
-#include "gd32.h" // IWYU pragma: keep
-
-typedef union pcast32 {
-    uuid_t uuid;
-    uint32_t u32[4];
-} _pcast32;
+#include "gd32_unique_id.h"
 
 void UuidCopy(uuid_t out) {
-    _pcast32 cast;
+    uint32_t words[4];
 
-#if defined(GD32H7XX)
-    cast.u32[0] = REG32(0x1FF0F7E8);
-    cast.u32[1] = REG32(0x1FF0F7EC);
-    cast.u32[2] = REG32(0x1FF0F7F0);
-#elif defined(GD32F4XX)
-    cast.u32[0] = REG32(0x1FFF7A10);
-    cast.u32[1] = REG32(0x1FFF7A14);
-    cast.u32[2] = REG32(0x1FFF7A18);
-#else
-    cast.u32[0] = REG32(0x1FFFF7E8);
-    cast.u32[1] = REG32(0x1FFFF7EC);
-    cast.u32[2] = REG32(0x1FFFF7F0);
-#endif
-    cast.u32[3] = cast.u32[0] + cast.u32[1] + cast.u32[2];
+    words[0] = gd32::uid::Word0();
+    words[1] = gd32::uid::Word1();
+    words[2] = gd32::uid::Word2();
+    words[3] = words[0] + words[1] + words[2];
 
-    memcpy(out, cast.uuid, sizeof(uuid_t));
+    memcpy(out, words, sizeof(uuid_t));
 }