Normalize style and fix printf type safety

Refactors several modules for consistent C++ style and safer formatting. The changes standardize brace/enum naming in ConfigStore and firmware install state handling, add explicit casts for `%u`/`%x` debug output across flash/network/emac/NTP paths, and tidy small API details (e.g. constexpr inline usage, parameter naming, missing `<cstdarg>` include). It also switches UTC offset initialization to `global::SetUtcOffsetIfValid`.

Author: vanvught

lib-configstore/include/configstore.h

@@ -158,10 +158,9 @@ void fmc_erase_sector_by_address(uint32_t address) {
         }
         /* lock the flash program erase controller */
         fmc_lock();
-        printf("\r\nAddress 0x%08X is located in the : SECTOR_NUMBER_%d !\n", address, sector_info.sector_name);
-        printf("\r\nSector range: 0x%08X to 0x%08X\n", sector_info.sector_start_addr, sector_info.sector_end_addr);
-        printf("\r\nSector size: %d KB\n", (sector_info.sector_size / 1024));
-        printf("\r\nErase success!\n");
-        printf("\r\n");
+        printf("Address 0x%08X is located in the : SECTOR_NUMBER_%u !\n", static_cast<unsigned>(address), static_cast<unsigned>(sector_info.sector_name));
+        printf("Sector range: 0x%08X to 0x%08X\n", static_cast<unsigned>(sector_info.sector_start_addr), static_cast<unsigned>(sector_info.sector_end_addr));
+        printf("Sector size: %u KB\n", static_cast<unsigned>(sector_info.sector_size / 1024));
+        puts("Erase success!\n");
     }
 }

lib-flashcode/src/gd32/f4xx/fmc_operation.cpp

@@ -2,7 +2,7 @@
  * @file firmware.cpp
  *
  */
-/* Copyright (C) 2025 by Arjan van Vught mailto:info@gd32-dmx.org
+/* Copyright (C) 2025-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
@@ -33,76 +33,75 @@
 
 #include "firmware.h"
 #include "ubootheader.h"
- #include "firmware/debug/debug_debug.h"
+#include "firmware/debug/debug_debug.h"
 
 namespace firmware {
 enum class State {
-	IDLE, START, CONTINUE
+	kIdle, kStart, kContinue
 };
 
-static auto s_State = State::IDLE;
+static auto s_State = State::kIdle;
 static uint32_t s_nCRC;
 
-bool firmware_install_start(const uint8_t *pBuffer, const uint32_t nBufferSize) {
+bool firmware_install_start(const uint8_t *buffer, uint32_t buffer_size) {
 	DEBUG_ENTRY();
-	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(pBuffer), nBufferSize);
+	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(buffer), static_cast<unsigned>(buffer_size));
 
-	assert(s_State == State::IDLE);
-	s_State = State::START;
+	assert(s_State == State::kIdle);
+	s_State = State::kStart;
 
-	assert(sizeof(struct TImageHeader) <= nBufferSize);
+	assert(sizeof(struct TImageHeader) <= buffer_size);
 
-	UBootHeader uBootHeader(pBuffer);
-	uBootHeader.Dump();
+	UBootHeader uboot_header(buffer);
+	uboot_header.Dump();
 
-	const auto isValid = uBootHeader.IsValid();
-	DEBUG_PRINTF("Firmware is valid? %s", isValid ? "Yes" : "No");
+	const auto kIsValid = uboot_header.IsValid();
+	DEBUG_PRINTF("Firmware is valid? %s", kIsValid ? "Yes" : "No");
 
-	if (!isValid) {
+	if (!kIsValid) {
 		DEBUG_EXIT();
 		return false;
 	}
 
-	const uint32_t nFirmwareChunk = nBufferSize - sizeof(struct TImageHeader);
+	const uint32_t kFirmwareChunk = buffer_size - sizeof(struct TImageHeader);
 
-	if (nFirmwareChunk > 0) {
-		DEBUG_PRINTF("Firmware: Chunk = %u", nFirmwareChunk);
+	if (kFirmwareChunk > 0) {
+		DEBUG_PRINTF("Firmware: Chunk = %u", static_cast<unsigned>(kFirmwareChunk));
 
-		const auto *pFirmware = pBuffer + sizeof(struct TImageHeader);
+		const auto *firmware = buffer + sizeof(struct TImageHeader);
 
-		s_nCRC = crc32(0, pFirmware, nFirmwareChunk);
+		s_nCRC = crc32(0, firmware, kFirmwareChunk);
 	}
 
 	DEBUG_EXIT();
 	return true;
 }
 
-bool firmware_install_continue(const uint8_t *pBuffer, const uint32_t nBufferSize) {
+bool firmware_install_continue(const uint8_t *buffer, uint32_t buffer_size) {
 	DEBUG_ENTRY();
-	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(pBuffer), nBufferSize);
+	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(buffer), static_cast<unsigned>(buffer_size));
 
-	assert((s_State == State::START) || (s_State == State::CONTINUE));
-	s_State = State::CONTINUE;
+	assert((s_State == State::kStart) || (s_State == State::kContinue));
+	s_State = State::kContinue;
 
-	s_nCRC = crc32(s_nCRC, pBuffer, nBufferSize);
+	s_nCRC = crc32(s_nCRC, buffer, buffer_size);
 
 	DEBUG_EXIT();
 	return true;
 }
 
-bool firmware_install_end(const uint8_t *pBuffer, const uint32_t nBufferSize) {
+bool firmware_install_end(const uint8_t *buffer, uint32_t buffer_size) {
 	DEBUG_ENTRY();
-	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(pBuffer), nBufferSize);
+	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(buffer), static_cast<unsigned>(buffer_size));
 
-	assert(s_State == State::CONTINUE);
-	s_State = State::IDLE;
+	assert(s_State == State::kContinue);
+	s_State = State::kIdle;
 
-	s_nCRC = crc32(s_nCRC, pBuffer, nBufferSize);
+	s_nCRC = crc32(s_nCRC, buffer, buffer_size);
 
-	DEBUG_PRINTF("CRC: %x", s_nCRC);
+	DEBUG_PRINTF("CRC: %x", static_cast<unsigned>(s_nCRC));
 
 	DEBUG_EXIT();
 	return true;
 }
-
 }  // namespace firmware

lib-flashcodeinstall/src/firmware.cpp

@@ -28,6 +28,7 @@
 
 #include <cstdint>
 #include <cstdio>
+#include <cstdarg>
 
 #include "gd32_uart.h"
 #if defined(CONFIG_USART0_ENABLE_TX_DMA) || defined(CONFIG_USART0_ENABLE_RX_DMA)

lib-gd32/src/uart0/uart0.cpp

@@ -46,15 +46,15 @@ void SetDomainName(const char* domainname);
 const char* DomainName();
 
 #if defined(H3) || defined(GD32)
-[[nodiscard]] inline constexpr const char* InterfaceName() {
+[[nodiscard]] constexpr const char* InterfaceName() {
     return "eth0";
 }
 #else
 const char* InterfaceName();
 #endif
 
 #if defined(H3) || defined(GD32)
-inline constexpr uint32_t InterfaceIndex() {
+constexpr uint32_t InterfaceIndex() {
     return 1;
 }
 #else
@@ -73,21 +73,25 @@ void SetAutoIp();
 bool AutoIp();
 
 // DHCP
-inline constexpr bool IsDhcpCapable() {
+constexpr bool IsDhcpCapable() {
     return true;
 }
 
-inline constexpr bool IsDhcpKnown() {
+constexpr bool IsDhcpKnown() {
     return true;
 }
 
 void EnableDhcp();
 bool Dhcp();
 
 inline char AddressingMode() {
-    if (AutoIp()) return 'Z';                     // Zeroconf
-    if (IsDhcpKnown()) return Dhcp() ? 'D' : 'S'; // DHCP or Static
-    return 'U';                                   // Unknown
+    if (AutoIp()) {
+        return 'Z'; // Zeroconf
+    }
+    if (IsDhcpKnown()) {
+        return Dhcp() ? 'D' : 'S'; // DHCP or Static
+    }
+    return 'U'; // Unknown
 }
 
 struct Counters {
@@ -99,7 +103,7 @@ struct Counters {
     } tx;
 };
 
-void GetCounters(Counters& out);
+void GetCounters(Counters& counters);
 } // namespace network::iface
 
 #endif // NETWORK_IFACE_H_

lib-network/include/network_iface.h

@@ -87,7 +87,7 @@ namespace net::globals::ptp {
 extern uint32_t timestamp[2];
 } // namespace net::globals::ptp
 
-#define _NTPFRAC_(x) (4294U * (x) + ((1981U * (x)) >> 11) + ((2911U * (x)) >> 28))
+#define _NTPFRAC_(x) ((4294U * (x)) + ((1981U * (x)) >> 11) + ((2911U * (x)) >> 28))
 #define NTPFRAC(x) _NTPFRAC_(x / 1000)
 // The reverse of the above, needed if we want to set our microsecond
 // clock (via clock_settime) based on the incoming time in NTP format.
@@ -130,7 +130,15 @@ static void Print([[maybe_unused]] const char* text, [[maybe_unused]] const stru
 #ifndef NDEBUG
     const auto kSeconds = static_cast<time_t>(timestamp->seconds - ntp::kJan1970);
     const auto* local_time = localtime(&kSeconds);
-    printf("%s %02d:%02d:%02d.%06d %04d [%u][0x%.8x]\n", text, local_time->tm_hour, local_time->tm_min, local_time->tm_sec, USEC(timestamp->fraction), local_time->tm_year + 1900, timestamp->seconds, timestamp->fraction);
+    printf("%s %02d:%02d:%02d.%06d %04d [%u][0x%.8x]\n", 
+      text, 
+      static_cast<int>(local_time->tm_hour), 
+      static_cast<int>(local_time->tm_min), 
+      static_cast<int>(local_time->tm_sec), 
+      static_cast<int>(USEC(timestamp->fraction)), 
+      local_time->tm_year + 1900, 
+      static_cast<int>(timestamp->seconds), 
+      static_cast<unsigned>(timestamp->fraction));
 #endif
 }
 
@@ -237,9 +245,13 @@ static void Send() {
     network::udp::SendWithTimestamp(s_ntp_client.handle, reinterpret_cast<const uint8_t*>(&s_ntp_client.request), kRequestSize, s_ntp_client.server_ip, network::iana::Ports::kPortNtp);
 
 #ifndef NDEBUG
-    printf("Request:  org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n", __builtin_bswap32(s_ntp_client.request.origin_timestamp_s), __builtin_bswap32(s_ntp_client.request.origin_timestamp_f),
-           __builtin_bswap32(s_ntp_client.request.receive_timestamp_s), __builtin_bswap32(s_ntp_client.request.receive_timestamp_f), __builtin_bswap32(s_ntp_client.request.transmit_timestamp_s),
-           __builtin_bswap32(s_ntp_client.request.transmit_timestamp_f));
+    printf("Request:  org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n",
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.origin_timestamp_s)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.origin_timestamp_f)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.receive_timestamp_s)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.receive_timestamp_f)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.transmit_timestamp_s)),  // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.transmit_timestamp_f))); // NOLINT
 #endif
 
     if (s_ntp_client.state.x > 0) {
@@ -273,10 +285,12 @@ static inline int32_t AbsInt32(int32_t x) {
 }
 
 static void UpdatePtpTime() {
-    int32_t diff_seconds1, diff_nano_seconds1;
+    int32_t diff_seconds1;
+    int32_t diff_nano_seconds1;
     Difference(s_ntp_client.t1, s_ntp_client.t2, diff_seconds1, diff_nano_seconds1);
 
-    int32_t diff_seconds2, diff_nano_seconds2;
+    int32_t diff_seconds2;
+    int32_t diff_nano_seconds2;
     Difference(s_ntp_client.t4, s_ntp_client.t3, diff_seconds2, diff_nano_seconds2);
 
     const auto kOffsetSeconds = static_cast<int64_t>(diff_seconds1) + static_cast<int64_t>(diff_seconds2);
@@ -292,7 +306,7 @@ static void UpdatePtpTime() {
     gd32::ptp::ptptime ptp_get;
     Gd32PtpGetTime(&ptp_get);
 
-    s_ntp_client.request.reference_timestamp_s = __builtin_bswap32(static_cast<uint32_t>(ptp_get.tv_sec) + ntp::kJan1970);
+    s_ntp_client.request.reference_timestamp_s = __builtin_bswap32(ptp_get.tv_sec + ntp::kJan1970);
     s_ntp_client.request.reference_timestamp_f = __builtin_bswap32(NTPFRAC(ptp_get.tv_nsec));
 
     if ((ptp_offset.tv_sec == 0) && (ptp_offset.tv_nsec > -999999) && (ptp_offset.tv_nsec < 999999)) {
@@ -350,7 +364,13 @@ static void UpdatePtpTime() {
         sign = '-';
     }
 
-    printf(" %s : offset=%c%d.%09d delay=%d.%09d\n", s_ntp_client.state.mode == ntp::Modes::kBasic ? "Basic" : "Interleaved", sign, ptp_offset.tv_sec, ptp_offset.tv_nsec, ptp_delay.tv_sec, ptp_delay.tv_nsec);
+    printf(" %s : offset=%c%d.%09d delay=%d.%09d\n", 
+      s_ntp_client.state.mode == ntp::Modes::kBasic ? "Basic" : "Interleaved", 
+      sign, 
+      static_cast<int>(ptp_offset.tv_sec), 
+      static_cast<int>(ptp_offset.tv_nsec), 
+      static_cast<int>(ptp_delay.tv_sec), 
+      static_cast<int>(ptp_delay.tv_nsec));
 #endif
 }
 
@@ -369,8 +389,13 @@ static void UpdatePtpTime() {
 static void Process() {
     const auto* const kReply = s_ntp_client.reply;
 #ifndef NDEBUG
-    printf("Response: org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n", __builtin_bswap32(kReply->origin_timestamp_s), __builtin_bswap32(kReply->origin_timestamp_f), __builtin_bswap32(kReply->receive_timestamp_s),
-           __builtin_bswap32(kReply->receive_timestamp_f), __builtin_bswap32(kReply->transmit_timestamp_s), __builtin_bswap32(kReply->transmit_timestamp_f));
+    printf("Response: org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n",
+           static_cast<unsigned>(__builtin_bswap32(kReply->origin_timestamp_s)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->origin_timestamp_f)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->receive_timestamp_s)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->receive_timestamp_f)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->transmit_timestamp_s)),  // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->transmit_timestamp_f))); // NOLINT
 #endif
     // If the origin timestamp is equal to the transmit timestamp, the response is in the basic mode.
     if ((kReply->origin_timestamp_s == s_ntp_client.request.transmit_timestamp_s) && (kReply->origin_timestamp_f == s_ntp_client.request.transmit_timestamp_f)) {

lib-network/src/apps/ntp/gd32/ptp/ntpclient.cpp

@@ -244,7 +244,7 @@ template <network::arp::EthSend S> static void Query(uint32_t destination_ip, vo
             network::memory::Allocator::Instance().Free(record_found->packet.p);
         }
 
-        printf("size=%u\n", size);
+        printf("size=%u\n", static_cast<unsigned>(size));
         assert(size <= network::memory::kBlockSize);
         record_found->packet.p = network::memory::Allocator::Instance().Allocate();
         assert(record_found->packet.p != nullptr);

lib-network/src/core/ipv4/arp.cpp

@@ -39,6 +39,6 @@ void emac_debug_run() {
 #endif
 
     if ((rxfifo_drop != 0) || (rxdma_drop != 0)) {
-        printf("%u: RxFIFO: %u RxDMA: %u\n", ++s_counter, rxfifo_drop, rxdma_drop);
+        printf("%u: RxFIFO: %u RxDMA: %u\n", static_cast<unsigned>(++s_counter), static_cast<unsigned>(rxfifo_drop), static_cast<unsigned>(rxdma_drop));
     }
 }

lib-network/src/emac/gd32/emac_debug.cpp

@@ -359,7 +359,7 @@ void Send(uint32_t length) {
 
 // Transmits an Ethernet frame with data copying.
 void Send(void* buffer, uint32_t length) {
-    DEBUG_PRINTF("%p -> %u", buffer, length);
+    DEBUG_PRINTF("%p -> %u", buffer, static_cast<unsigned>(length));
 
     assert(nullptr != buffer);
     assert(length <= ENET_MAX_FRAME_SIZE);

lib-network/src/emac/gd32/emac_eth.cpp

@@ -66,7 +66,7 @@ bool Config(uint16_t address) {
 
     const auto kAhbClk = rcu_clock_freq_get(CK_AHB);
 
-    DEBUG_PRINTF("kAhbClk=%u", kAhbClk);
+    DEBUG_PRINTF("kAhbClk=%u", static_cast<unsigned>(kAhbClk));
 
 #if defined GD32F10X_CL
     if (ENET_RANGE(kAhbClk, 20000000U, 35000000U)) {
@@ -163,7 +163,7 @@ bool Config(uint16_t address) {
         }
 
         if (!(value & emac::mmi::BMCR_RESET)) {
-            DEBUG_PRINTF("%u", millis() - kMillis);
+            DEBUG_PRINTF("%u", static_cast<unsigned>(millis() - kMillis));
             DEBUG_EXIT();
             return true;
         }
@@ -175,7 +175,7 @@ bool Config(uint16_t address) {
         return false;
     }
 
-    DEBUG_PRINTF("%u", millis() - kMillis);
+    DEBUG_PRINTF("%u", static_cast<unsigned>(millis() - kMillis));
     DEBUG_EXIT();
     return true;
 }