examples/mb/CMakeLists.txt

@@ -20,16 +20,14 @@ if (NOT ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "MICROBLAZE" ))
 endif()
 
 message(STATUS "will use stdlib++ from '${LIBSTDCPP_HOME}'")
-add_library(microblaze common.cpp)
+add_library(board board.cpp)
 
 target_include_directories(rotor_light PUBLIC "${LIBSTDCPP_HOME}/include")
-
-target_include_directories(microblaze PUBLIC "${LIBSTDCPP_HOME}/include")
-target_link_libraries(microblaze rotor_light)
-
+target_include_directories(board PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(board rotor_light)
 
 add_executable(blink-led blink-led.cpp)
-target_link_libraries(blink-led microblaze)
+target_link_libraries(blink-led board)
 
 add_executable(ping-pong-poll ping-pong-poll.cpp)
-target_link_libraries(ping-pong-poll microblaze)
+target_link_libraries(ping-pong-poll board)

examples/mb/blink-led.cpp

@@ -1,20 +1,14 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2022 Aliaksei Makarau
 
-#include "common.h"
-#include "rotor-light.hpp"
-
-#include "xparameters.h"
-#include "xgpio.h"
-
-#define GPIO_OUTPUT_DEVICE_ID	XPAR_GPIO_0_DEVICE_ID
-#define LED_CHANNEL           1
+#include "board.h"
+#include <rotor-light.hpp>
 
 namespace rl = rotor_light;
 
 namespace message {
 
-struct BlinkCommand: rl::Message {
+struct BlinkCommand : rl::Message {
   static constexpr auto type_id = __LINE__;
   using rl::Message::Message;
   rl::MessageTypeId get_type_id() const override { return type_id; }
@@ -22,9 +16,6 @@ struct BlinkCommand: rl::Message {
 
 } // namespace message
 
-XGpio xil_gpio;
-uint32_t gpio_flag = 0xFFFF;
-
 struct Blinker : rl::Actor<2> {
   using Parent = Actor<2>;
 
@@ -35,43 +26,46 @@ struct Blinker : rl::Actor<2> {
 
   void advance_start() override {
     Parent::advance_start();
-    add_event(delay, [](void *data) { static_cast<Blinker *>(data)->blink(); }, this);
+    blink();
   }
 
   void blink() {
-    XGpio_Out32(xil_gpio.BaseAddress + XGPIO_DATA_OFFSET, gpio_flag);
-    gpio_flag ^= 0xFFFF;
-    add_event(delay, [](void *data) { static_cast<Blinker *>(data)->blink(); }, this);
+    Board::toggle_led();
+    add_event(
+        delay,
+        [](void *data) {
+          auto self = static_cast<Blinker *>(data);
+          self->send<message::BlinkCommand>(0, self->id);
+        },
+        this);
   }
 
-  void on_blink_command(message::BlinkCommand &msg) {
-    blink();
-  }
+  void on_blink_command(message::BlinkCommand &msg) { blink(); }
 
   rl::Duration delay;
 };
 
-static void app_hw_init();
-
-using Supervisor =
-    rl::Supervisor<rl::SupervisorBase::min_handlers_amount, Blinker>;
-using Storage =
-    rl::traits::MessageStorage<rl::message::ChangeState,
-                               rl::message::ChangeStateAck,
-                               message::BlinkCommand>;
+using Storage = rl::traits::MessageStorage<rl::message::ChangeState,
+                                           rl::message::ChangeStateAck,
+                                           message::BlinkCommand>;
 using Queue = rl::Queue<Storage, 5>; /* upto 5 messages in 1 queue */
 using Planner = rl::Planner<2>;      /* upto 2 time events */
+using Supervisor =
+    rl::Supervisor<rl::SupervisorBase::min_handlers_amount, Blinker>;
 
-Queue queue;
-Planner planner;
-rl::Context context{&queue, &planner, &get_now};
 Supervisor sup;
 
 int main(int, char **) {
-  app_hw_init();
+  Board::init_start();
+  Board::enable_timer();
+  Board::enable_interrupts();
 
   /* setup */
+  Queue queue;
+  Planner planner;
+  rl::Context context{&queue, &planner, &Board::get_now};
   sup.bind(context);
+
   auto blinker = sup.get_child<0>();
   blinker->delay = rl::Duration{1};
   /* let it polls timer */
@@ -81,11 +75,3 @@ int main(int, char **) {
   sup.process();
   return 0;
 }
-
-static void app_hw_init() {
-  XGpio_Initialize(&xil_gpio, GPIO_OUTPUT_DEVICE_ID);
-  XGpio_SetDataDirection(&xil_gpio, LED_CHANNEL, 0x0);
-
-	microblaze_enable_interrupts();
-  enable_timer();
-}

examples/mb/common.cpp

@@ -1,52 +1,53 @@
-#include "common.h"
+#include "board.h"
+#include <string.h>
 
 #include "xparameters.h"
 #include "xtmrctr.h"
 #include "xintc.h"
+#include "xgpio.h"
 
-#define TMRCTR_DEVICE_ID    XPAR_TMRCTR_0_DEVICE_ID
-#define TMRCTR_BASEADDR     XPAR_TMRCTR_0_BASEADDR
-#define INTC_DEVICE_ID      XPAR_INTC_0_DEVICE_ID
-#define TMRCTR_INTERRUPT_ID XPAR_MICROBLAZE_0_AXI_INTC_AXI_TIMER_0_INTERRUPT_INTR
-#define TIMER_CNTR_0        0
+#define TMRCTR_DEVICE_ID      XPAR_TMRCTR_0_DEVICE_ID
+#define TMRCTR_BASEADDR       XPAR_TMRCTR_0_BASEADDR
+#define INTC_DEVICE_ID        XPAR_INTC_0_DEVICE_ID
+#define TMRCTR_INTERRUPT_ID   XPAR_MICROBLAZE_0_AXI_INTC_AXI_TIMER_0_INTERRUPT_INTR
+#define TIMER_CNTR_0          0
+#define GPIO_OUTPUT_DEVICE_ID	XPAR_GPIO_0_DEVICE_ID
+#define LED_CHANNEL           1
 
 // reset after 1 sec
-#define RESET_VALUE	        (0xFFFFFFFF - XPAR_AXI_TIMER_0_CLOCK_FREQ_HZ)
+#define RESET_VALUE	          (0xFFFFFFFF - XPAR_AXI_TIMER_0_CLOCK_FREQ_HZ)
 
 XIntc InterruptController;
 XTmrCtr xil_timer;
+XGpio GpioOutput;
 
 void TimerCounterHandler(void *CallBackRef, u8 TmrCtrNumber);
 
+static uint32_t gpio_flag = 0xFFFF;
 std::uint64_t gpt_system_tick = 0;
 
-void adjust_timer(const rotor_light::Duration &value) {
-  gpt_system_tick += value;
+void Board::toggle_led() {
+  XGpio_Out32(GpioOutput.BaseAddress + XGPIO_DATA_OFFSET, gpio_flag);
+  gpio_flag ^= 0xFFFF;
 }
 
-// return seconds from the Big Start
-rl::TimePoint get_now() {
-  return gpt_system_tick;
-}
+void Board::init_start() {
+  XGpio_Initialize(&GpioOutput, GPIO_OUTPUT_DEVICE_ID);
+  XGpio_SetDataDirection(&GpioOutput, LED_CHANNEL, 0x0);
 
-void enable_timer() {
   XTmrCtr_Initialize(&xil_timer, TMRCTR_DEVICE_ID);
   XTmrCtr_SelfTest(&xil_timer, TIMER_CNTR_0);
+
   XIntc_Initialize(&InterruptController, INTC_DEVICE_ID);
   XIntc_Connect(&InterruptController,
                 TMRCTR_INTERRUPT_ID,
                 (XInterruptHandler)XTmrCtr_InterruptHandler,
                 (void*) &xil_timer);
 
-  XIntc_Start(&InterruptController, XIN_REAL_MODE);
-
-  XIntc_Enable(&InterruptController, TMRCTR_INTERRUPT_ID);
-
   Xil_ExceptionInit();
   Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
                                (Xil_ExceptionHandler) XIntc_InterruptHandler,
                                &InterruptController);
-  Xil_ExceptionEnable();
 
   XTmrCtr_SetHandler(&xil_timer,
                      TimerCounterHandler,
@@ -55,14 +56,39 @@ void enable_timer() {
                       TIMER_CNTR_0,
                       XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION);
   XTmrCtr_SetResetValue(&xil_timer, TIMER_CNTR_0, RESET_VALUE);
+}
+
+void Board::enable_interrupts() {
+	microblaze_enable_interrupts();
+
+  XIntc_Start(&InterruptController, XIN_REAL_MODE);
+  XIntc_Enable(&InterruptController, TMRCTR_INTERRUPT_ID);
+  Xil_ExceptionEnable();
+}
+
+void Board::disable_interrupts() {
+	microblaze_disable_interrupts();
+}
+
+void Board::enable_timer() {
   XTmrCtr_Start(&xil_timer, TIMER_CNTR_0);
 }
 
-void disable_timer() {
+void Board::disable_timer() {
   XTmrCtr_Stop(&xil_timer, TIMER_CNTR_0);
   XIntc_Disable(&InterruptController, TMRCTR_INTERRUPT_ID);
 }
 
+rl::TimePoint Board::get_now() {
+  return gpt_system_tick;
+}
+
+void adjust_timer(const rotor_light::Duration &value) {
+  gpt_system_tick += value;
+}
+
+void Board::delay() {}
+
 // on interrupt add 1 second
 void TimerCounterHandler(void *CallBackRef, u8 TmrCtrNumber)
 {

examples/mb/board.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "rotor-light.hpp"
+
+namespace rl = rotor_light;
+
+struct Board {
+  static constexpr uint32_t samples = 10;
+
+  static void init_start();
+
+  static void disable_interrupts();
+
+  static void enable_interrupts();
+
+  static void enable_timer();
+
+  static void disable_timer();
+
+  static rl::TimePoint get_now();
+
+  static void toggle_led();
+
+  static void delay();
+};

examples/mb/ping-pong-poll.cpp

@@ -1,14 +1,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2022 Aliaksei Makarau
 
-#include "common.h"
-#include "rotor-light.hpp"
-
-#include "xparameters.h"
-#include "xgpio.h"
-
-#define GPIO_OUTPUT_DEVICE_ID	XPAR_GPIO_0_DEVICE_ID
-#define LED_CHANNEL           1
+#include "board.h"
 
 namespace rl = rotor_light;
 
@@ -26,9 +19,6 @@ struct Pong : rl::Message {
 };
 } // namespace message
 
-XGpio xil_gpio;
-uint32_t gpio_flag = 0xFFFF;
-
 struct Pinger : rl::Actor<2> {
   using Parent = Actor<2>;
 
@@ -43,9 +33,7 @@ struct Pinger : rl::Actor<2> {
   }
 
   void ping() {
-    /* toggle led */
-    XGpio_Out32(xil_gpio.BaseAddress + XGPIO_DATA_OFFSET, gpio_flag);
-    gpio_flag ^= 0xFFFF;
+    Board::toggle_led();
     send<message::Ping>(0, ponger_id);
   }
 
@@ -64,10 +52,7 @@ struct Ponger : rl::Actor<2> {
     subscribe(&Ponger::on_ping);
     Parent::initialize();
   }
-  void on_ping(message::Ping &) {
-    //
-    send<message::Pong>(0, pinger_id);
-  }
+  void on_ping(message::Ping &) { send<message::Pong>(0, pinger_id); }
   rl::ActorId pinger_id;
 };
 
@@ -79,20 +64,19 @@ using Storage = rl::traits::MessageStorage<rl::message::ChangeState,
 using Queue = rl::Queue<Storage, 5>; /* upto 5 messages in 1 queue */
 using Planner = rl::Planner<1>;      /* upto 1 time event */
 
-static void app_hw_init();
-
-/* allocate */
-Queue queue;
-Planner planner;
-rl::Context context{&queue, &planner, &get_now};
 Supervisor sup;
 
 int main(int, char **) {
-
-  app_hw_init();
+  Board::init_start();
+  Board::enable_timer();
+  Board::enable_interrupts();
 
   /* setup */
+  Queue queue;
+  Planner planner;
+  rl::Context context{&queue, &planner, &Board::get_now};
   sup.bind(context);
+
   auto pinger = sup.get_child<0>();
   auto ponger = sup.get_child<1>();
   pinger->ponger_id = ponger->get_id();
@@ -104,11 +88,3 @@ int main(int, char **) {
   sup.process();
   return 0;
 }
-
-static void app_hw_init() {
-  XGpio_Initialize(&xil_gpio, GPIO_OUTPUT_DEVICE_ID);
-  XGpio_SetDataDirection(&xil_gpio, LED_CHANNEL, 0x0);
-
-	microblaze_enable_interrupts();
-  enable_timer();
-}

examples/mb/toolchain.cmake

@@ -30,7 +30,8 @@ set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 
-add_compile_options("-Wall"
+add_compile_options(
+  "-Wall"
   "-I${XIL_STANDALONE_BSP_INCLUDE}"
   "-fmessage-length=0"
   "-mno-xl-reorder"

examples/ping-pong-throughput.cpp

@@ -4,13 +4,6 @@
 #include "board.h"
 #include "rotor-light.hpp"
 
-#ifdef __MICROBLAZE__
-
-#include "xgpio.h"
-#include "xparameters.h"
-
-#endif
-
 namespace rl = rotor_light;
 
 namespace message {
@@ -73,26 +66,6 @@ using Storage = rl::traits::MessageStorage<rl::message::ChangeState,
                                            message::Ping, message::Pong>;
 using Queue = rl::Queue<Storage, 5>; /* upto 5 messages in 1 queue */
 
-#ifdef __arm__
-constexpr uint32_t amount = 1000000;
-void on_start() {}
-void on_finish() {}
-
-#elif __MICROBLAZE__
-#define GPIO_OUTPUT_DEVICE_ID XPAR_GPIO_0_DEVICE_ID
-#define LED_CHANNEL 1
-
-XGpio GpioOutput;
-
-constexpr uint32_t amount = 100000;
-void on_start() {
-  XGpio_Out32(GpioOutput.BaseAddress + XGPIO_DATA_OFFSET, 0xFFFF);
-}
-void on_finish() {
-  XGpio_Out32(GpioOutput.BaseAddress + XGPIO_DATA_OFFSET, 0x0000);
-}
-#endif
-
 Supervisor sup;
 
 int main(int, char **) {
@@ -100,13 +73,6 @@ int main(int, char **) {
   Board::enable_timer();
   Board::enable_interrupts();
 
-#ifdef __MICROBLAZE__
-  if (XGpio_Initialize(&GpioOutput, GPIO_OUTPUT_DEVICE_ID) != XST_SUCCESS) {
-    return XST_FAILURE;
-  }
-  XGpio_SetDataDirection(&GpioOutput, LED_CHANNEL, 0x0);
-#endif
-
   while (true) {
     Queue queue;
     rl::Context context{&queue, nullptr, nullptr};