Further architectural adaptions

ckormanyos · ckormanyos · commit e24409ce932b · 2026-02-12T15:19:09.000+01:00
diff --git a/ref_app/src/mcal/xtensa_esp32_p4/mcal_gpt.cpp b/ref_app/src/mcal/xtensa_esp32_p4/mcal_gpt.cpp
@@ -8,14 +8,10 @@
 #include <mcal_gpt.h>
 #include <mcal_reg.h>
 
-#include <util/utility/util_two_part_data_manipulation.h>
-
 #include <interrupt.h>
 
-#include <cstddef>
 #include <cstdint>
 #include <limits>
-#include <type_traits>
 
 extern "C"
 {
@@ -24,33 +20,33 @@ extern "C"
 
 namespace
 {
-  constexpr unsigned TIMEOUT_1S { 320000000u };
+  constexpr std::uint32_t TIMEOUT_1S { UINT32_C(320000000) };
 }
 
 void mcal::gpt::init(const config_type*)
 {
   // Set the MTIME timeout.
-  CLINT_MTIMECMP = (uint64_t) UINT64_C(0xFFFFFFFFFFFFFFFF);
+  CLINT_MTIMECMP = (std::numeric_limits<std::uint64_t>::max)();
 }
 
 mcal::gpt::value_type mcal::gpt::secure::get_time_elapsed()
 {
-  const std::uint64_t tick_unscaled_01 = (uint64_t) CLINT_MTIME;
-  const std::uint64_t tick_unscaled_02 = (uint64_t) CLINT_MTIME;
+  const std::uint64_t tick_unscaled_01 = (std::uint64_t) CLINT_MTIME;
+  const std::uint64_t tick_unscaled_02 = (std::uint64_t) CLINT_MTIME;
 
   const std::uint64_t tick_unscaled =
-    (uint64_t) (((uint32_t) tick_unscaled_02 > (uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (uint64_t) CLINT_MTIME);
+    (std::uint64_t) (((std::uint32_t) tick_unscaled_02 > (std::uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (std::uint64_t) CLINT_MTIME);
 
   return (std::uint64_t) ((std::uint64_t) (tick_unscaled + 160U) / 320U);
 }
 
 mcal::gpt::value_type mcal::gpt::secure::get_time_elapsed_core1()
 {
-  const std::uint64_t tick_unscaled_01 = (uint64_t) CLINT_MTIME;
-  const std::uint64_t tick_unscaled_02 = (uint64_t) CLINT_MTIME;
+  const std::uint64_t tick_unscaled_01 = (std::uint64_t) CLINT_MTIME;
+  const std::uint64_t tick_unscaled_02 = (std::uint64_t) CLINT_MTIME;
 
   const std::uint64_t tick_unscaled =
-    (uint64_t) (((uint32_t) tick_unscaled_02 > (uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (uint64_t) CLINT_MTIME);
+    (std::uint64_t) (((std::uint32_t) tick_unscaled_02 > (std::uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (std::uint64_t) CLINT_MTIME);
 
   return (std::uint64_t) ((std::uint64_t) (tick_unscaled + 160U) / 320U);
 }
diff --git a/ref_app/src/mcal/xtensa_esp32_p4/mcal_gpt.h b/ref_app/src/mcal/xtensa_esp32_p4/mcal_gpt.h
@@ -24,13 +24,6 @@
         static auto get_time_elapsed() -> value_type;
         static auto get_time_elapsed_core1() -> value_type;
       };
-
-      struct timer_core1_backend
-      {
-        using tick_type = std::uint64_t;
-
-        static auto get_now() -> tick_type { return static_cast<tick_type>(mcal::gpt::secure::get_time_elapsed_core1()); }
-      };
     }
   }
 
diff --git a/ref_app/target/micros/xtensa_esp32_p4/startup/Code/Appli/main.cpp b/ref_app/target/micros/xtensa_esp32_p4/startup/Code/Appli/main.cpp
@@ -15,19 +15,12 @@
   
 ******************************************************************************************/
 
-#include <riscv-csr.h>
-#include <interrupt.h>
 #include <gpio.h>
 
 #include <mcal_gpt.h>
 
 #include <util/utility/util_time.h>
 
-#include <cstdint>
-
-constexpr unsigned TIMEOUT_500MS { 160000000u };
-constexpr unsigned TIMEOUT_1S    { 320000000u };
-
 extern "C"
 {
   uint32_t osGetActiveCore(void);
@@ -40,9 +33,9 @@ auto main(void) -> int __attribute__((used,noinline));
 
 auto main(void) -> int
 {
-  const std::uint32_t core_id { osGetActiveCore() };
+  const bool core_id_is_zero { (std::uint32_t { UINT8_C(0) } == osGetActiveCore()) };
 
-  if(std::uint32_t { UINT8_C(0) } == core_id)
+  if(core_id_is_zero)
   {
     gpio_cfg_output(7);
     gpio_cfg_output(8);
@@ -69,41 +62,52 @@ auto main(void) -> int
   }
 
   // Go to the core-specific main subroutines.
-  if(std::uint32_t { UINT8_C(0) } == core_id)
+  if(core_id_is_zero)
   {
-    mcal::gpt::init(nullptr);
-
     ::main_core0();
   }
   else
   {
-    mcal::gpt::init(nullptr);
-
     ::main_core1();
   }
 }
 
 namespace local
 {
+  struct timer_core1_backend
+  {
+    using tick_type = std::uint64_t;
+
+    static auto get_now() -> tick_type { return static_cast<tick_type>(mcal::gpt::secure::get_time_elapsed_core1()); }
+  };
+
   using timer_type = util::timer<std::uint64_t>;
 
-  using timer_core1_type = util::timer<std::uint64_t, mcal::gpt::timer_core1_backend>;
+  constexpr typename timer_type::tick_type
+    led_timeout
+    {
+      static_cast<typename timer_type::tick_type>(timer_type::seconds(UINT8_C(1)))
+    };
+
+  using timer_core1_type = util::timer<std::uint64_t, timer_core1_backend>;
 } // namespace local
 
 auto main_core0() -> void
 {
   gpio_toggle_output_level(54);
 
-  local::timer_type led_timer(local::timer_type::seconds(1U));
+  mcal::gpt::init(nullptr);
 
-  // Endless loop: Never return or break.
-  while(1)
+  local::timer_type local_led_timer(local::led_timeout);
+
+  // Endless LED tollge-loop: Never return or break.
+  for(;;)
   {
-    if(led_timer.timeout())
+    if(local_led_timer.timeout())
     {
       gpio_toggle_output_level(54);
 
-      led_timer.start_interval(local::timer_type::seconds(1U));
+      local_led_timer.start_interval(local::led_timeout);
     }
   }
 }
@@ -112,16 +116,18 @@ auto main_core1() -> void
 {
   gpio_toggle_output_level(19);
 
-  local::timer_core1_type led_timer(local::timer_type::seconds(1U));
+  mcal::gpt::init(nullptr);
+
+  local::timer_core1_type local_led_timer(local::led_timeout);
 
-  // Endless loop: Never return or break.
-  while(1)
+  // Endless LED tollge-loop: Never return or break.
+  for(;;)
   {
-    if(led_timer.timeout())
+    if(local_led_timer.timeout())
     {
       gpio_toggle_output_level(19);
 
-      led_timer.start_interval(local::timer_type::seconds(1U));
+      local_led_timer.start_interval(local::led_timeout);
     }
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,10 @@`
`8`	`8`	`#include <mcal_gpt.h>`
`9`	`9`	`#include <mcal_reg.h>`
`10`	`10`
`11`		`-#include <util/utility/util_two_part_data_manipulation.h>`
`12`		`-`
`13`	`11`	`#include <interrupt.h>`
`14`	`12`
`15`		`-#include <cstddef>`
`16`	`13`	`#include <cstdint>`
`17`	`14`	`#include <limits>`
`18`		`-#include <type_traits>`
`19`	`15`
`20`	`16`	`extern "C"`
`21`	`17`	`{`
`@@ -24,33 +20,33 @@ extern "C"`
`24`	`20`
`25`	`21`	`namespace`
`26`	`22`	`{`
`27`		`- constexpr unsigned TIMEOUT_1S { 320000000u };`
	`23`	`+ constexpr std::uint32_t TIMEOUT_1S { UINT32_C(320000000) };`
`28`	`24`	`}`
`29`	`25`
`30`	`26`	`void mcal::gpt::init(const config_type*)`
`31`	`27`	`{`
`32`	`28`	`// Set the MTIME timeout.`
`33`		`- CLINT_MTIMECMP = (uint64_t) UINT64_C(0xFFFFFFFFFFFFFFFF);`
	`29`	`+ CLINT_MTIMECMP = (std::numeric_limits<std::uint64_t>::max)();`
`34`	`30`	`}`
`35`	`31`
`36`	`32`	`mcal::gpt::value_type mcal::gpt::secure::get_time_elapsed()`
`37`	`33`	`{`
`38`		`- const std::uint64_t tick_unscaled_01 = (uint64_t) CLINT_MTIME;`
`39`		`- const std::uint64_t tick_unscaled_02 = (uint64_t) CLINT_MTIME;`
	`34`	`+ const std::uint64_t tick_unscaled_01 = (std::uint64_t) CLINT_MTIME;`
	`35`	`+ const std::uint64_t tick_unscaled_02 = (std::uint64_t) CLINT_MTIME;`
`40`	`36`
`41`	`37`	`const std::uint64_t tick_unscaled =`
`42`		`- (uint64_t) (((uint32_t) tick_unscaled_02 > (uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (uint64_t) CLINT_MTIME);`
	`38`	`+ (std::uint64_t) (((std::uint32_t) tick_unscaled_02 > (std::uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (std::uint64_t) CLINT_MTIME);`
`43`	`39`
`44`	`40`	`return (std::uint64_t) ((std::uint64_t) (tick_unscaled + 160U) / 320U);`
`45`	`41`	`}`
`46`	`42`
`47`	`43`	`mcal::gpt::value_type mcal::gpt::secure::get_time_elapsed_core1()`
`48`	`44`	`{`
`49`		`- const std::uint64_t tick_unscaled_01 = (uint64_t) CLINT_MTIME;`
`50`		`- const std::uint64_t tick_unscaled_02 = (uint64_t) CLINT_MTIME;`
	`45`	`+ const std::uint64_t tick_unscaled_01 = (std::uint64_t) CLINT_MTIME;`
	`46`	`+ const std::uint64_t tick_unscaled_02 = (std::uint64_t) CLINT_MTIME;`
`51`	`47`
`52`	`48`	`const std::uint64_t tick_unscaled =`
`53`		`- (uint64_t) (((uint32_t) tick_unscaled_02 > (uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (uint64_t) CLINT_MTIME);`
	`49`	`+ (std::uint64_t) (((std::uint32_t) tick_unscaled_02 > (std::uint32_t) tick_unscaled_01) ? tick_unscaled_01 : (std::uint64_t) CLINT_MTIME);`
`54`	`50`
`55`	`51`	`return (std::uint64_t) ((std::uint64_t) (tick_unscaled + 160U) / 320U);`
`56`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,13 +24,6 @@`
`24`	`24`	`static auto get_time_elapsed() -> value_type;`
`25`	`25`	`static auto get_time_elapsed_core1() -> value_type;`
`26`	`26`	`};`
`27`		`-`
`28`		`- struct timer_core1_backend`
`29`		`- {`
`30`		`- using tick_type = std::uint64_t;`
`31`		`-`
`32`		`- static auto get_now() -> tick_type { return static_cast<tick_type>(mcal::gpt::secure::get_time_elapsed_core1()); }`
`33`		`- };`
`34`	`27`	`}`
`35`	`28`	`}`
`36`	`29`
Original file line number	Diff line number	Diff line change
`@@ -15,19 +15,12 @@`
`15`	`15`
`16`	`16`	`******************************************************************************************/`
`17`	`17`
`18`		`-#include <riscv-csr.h>`
`19`		`-#include <interrupt.h>`
`20`	`18`	`#include <gpio.h>`
`21`	`19`
`22`	`20`	`#include <mcal_gpt.h>`
`23`	`21`
`24`	`22`	`#include <util/utility/util_time.h>`
`25`	`23`
`26`		`-#include <cstdint>`
`27`		`-`
`28`		`-constexpr unsigned TIMEOUT_500MS { 160000000u };`
`29`		`-constexpr unsigned TIMEOUT_1S { 320000000u };`
`30`		`-`
`31`	`24`	`extern "C"`
`32`	`25`	`{`
`33`	`26`	`uint32_t osGetActiveCore(void);`
`@@ -40,9 +33,9 @@ auto main(void) -> int __attribute__((used,noinline));`
`40`	`33`
`41`	`34`	`auto main(void) -> int`
`42`	`35`	`{`
`43`		`- const std::uint32_t core_id { osGetActiveCore() };`
	`36`	`+ const bool core_id_is_zero { (std::uint32_t { UINT8_C(0) } == osGetActiveCore()) };`
`44`	`37`
`45`		`- if(std::uint32_t { UINT8_C(0) } == core_id)`
	`38`	`+ if(core_id_is_zero)`
`46`	`39`	`{`
`47`	`40`	`gpio_cfg_output(7);`
`48`	`41`	`gpio_cfg_output(8);`
`@@ -69,41 +62,52 @@ auto main(void) -> int`
`69`	`62`	`}`
`70`	`63`
`71`	`64`	`// Go to the core-specific main subroutines.`
`72`		`- if(std::uint32_t { UINT8_C(0) } == core_id)`
	`65`	`+ if(core_id_is_zero)`
`73`	`66`	`{`
`74`		`- mcal::gpt::init(nullptr);`
`75`		`-`
`76`	`67`	`::main_core0();`
`77`	`68`	`}`
`78`	`69`	`else`
`79`	`70`	`{`
`80`		`- mcal::gpt::init(nullptr);`
`81`		`-`
`82`	`71`	`::main_core1();`
`83`	`72`	`}`
`84`	`73`	`}`
`85`	`74`
`86`	`75`	`namespace local`
`87`	`76`	`{`
	`77`	`+ struct timer_core1_backend`
	`78`	`+ {`
	`79`	`+ using tick_type = std::uint64_t;`
	`80`	`+`
	`81`	`+ static auto get_now() -> tick_type { return static_cast<tick_type>(mcal::gpt::secure::get_time_elapsed_core1()); }`
	`82`	`+ };`
	`83`	`+`
`88`	`84`	`using timer_type = util::timer<std::uint64_t>;`
`89`	`85`
`90`		`- using timer_core1_type = util::timer<std::uint64_t, mcal::gpt::timer_core1_backend>;`
	`86`	`+ constexpr typename timer_type::tick_type`
	`87`	`+ led_timeout`
	`88`	`+ {`
	`89`	`+ static_cast<typename timer_type::tick_type>(timer_type::seconds(UINT8_C(1)))`
	`90`	`+ };`
	`91`	`+`
	`92`	`+ using timer_core1_type = util::timer<std::uint64_t, timer_core1_backend>;`
`91`	`93`	`} // namespace local`
`92`	`94`
`93`	`95`	`auto main_core0() -> void`
`94`	`96`	`{`
`95`	`97`	`gpio_toggle_output_level(54);`
`96`	`98`
`97`		`- local::timer_type led_timer(local::timer_type::seconds(1U));`
	`99`	`+ mcal::gpt::init(nullptr);`
`98`	`100`
`99`		`- // Endless loop: Never return or break.`
`100`		`- while(1)`
	`101`	`+ local::timer_type local_led_timer(local::led_timeout);`
	`102`	`+`
	`103`	`+ // Endless LED tollge-loop: Never return or break.`
	`104`	`+ for(;;)`
`101`	`105`	`{`
`102`		`- if(led_timer.timeout())`
	`106`	`+ if(local_led_timer.timeout())`
`103`	`107`	`{`
`104`	`108`	`gpio_toggle_output_level(54);`
`105`	`109`
`106`		`- led_timer.start_interval(local::timer_type::seconds(1U));`
	`110`	`+ local_led_timer.start_interval(local::led_timeout);`
`107`	`111`	`}`
`108`	`112`	`}`
`109`	`113`	`}`
`@@ -112,16 +116,18 @@ auto main_core1() -> void`
`112`	`116`	`{`
`113`	`117`	`gpio_toggle_output_level(19);`
`114`	`118`
`115`		`- local::timer_core1_type led_timer(local::timer_type::seconds(1U));`
	`119`	`+ mcal::gpt::init(nullptr);`
	`120`	`+`
	`121`	`+ local::timer_core1_type local_led_timer(local::led_timeout);`
`116`	`122`
`117`		`- // Endless loop: Never return or break.`
`118`		`- while(1)`
	`123`	`+ // Endless LED tollge-loop: Never return or break.`
	`124`	`+ for(;;)`
`119`	`125`	`{`
`120`		`- if(led_timer.timeout())`
	`126`	`+ if(local_led_timer.timeout())`
`121`	`127`	`{`
`122`	`128`	`gpio_toggle_output_level(19);`
`123`	`129`
`124`		`- led_timer.start_interval(local::timer_type::seconds(1U));`
	`130`	`+ local_led_timer.start_interval(local::led_timeout);`
`125`	`131`	`}`
`126`	`132`	`}`
`127`	`133`	`}`