Merge pull request #45 from stevenewald/echavemann/led-matrix-redo

LED Matrix Controller

Author: stevenewald

Makefile

@@ -7,6 +7,7 @@ SOFTDEVICE_MODEL = blank
 
 # ETL
 ETL_INCLUDES = ./external/etl/include/etl/array.h
+ETL_INCLUDES = ./external/etl/include/etl/variant.h
 ETL_INCLUDES += ./external/etl/include/etl/vector.h
 ETL_INCLUDES += ./external/etl/include/etl/optional.h
 ETL_INCLUDES += ./external/etl/include/etl/string.h

include/drivers/driver_commands.hpp

@@ -6,9 +6,6 @@
 
 namespace edge::drivers {
 
-// SHOULD BE DEPRECATED SOON
-void do_async_work();
-
 etl::optional<int> handle_command(DriverCommand type, int arg1, int arg2, int arg3);
 
 etl::optional<int> handle_subscribe(

include/drivers/led_display.hpp include/drivers/led_matrix_controller.hpp

@@ -1,11 +1,12 @@
 #pragma once
 #include "drivers/gpio_pin.hpp"
+#include "drivers/virtual_timer_controller.hpp"
 #include "microbit_v2.h"
 
 namespace edge::drivers {
 
 // Synchronous
-class LedDisplay {
+class LedMatrixController {
     static constexpr uint8_t WIDTH = 5;
     static constexpr uint8_t HEIGHT = 5;
 
@@ -27,15 +28,21 @@ class LedDisplay {
         GPIOPin{LED_COL5, GPIOConfiguration::OUT}
     };
 
-    void set_output(uint8_t row, uint8_t col, bool enabled);
-
 public:
-    LedDisplay();
+    static LedMatrixController& get();
 
     void set_led(uint8_t row, uint8_t col, bool enabled);
 
-    void do_async_work();
+    LedMatrixController(LedMatrixController&) = delete;
+    LedMatrixController(LedMatrixController&&) = delete;
+    LedMatrixController& operator=(VirtualTimerController&) = delete;
+    LedMatrixController& operator=(VirtualTimerController&&) = delete;
+
+    friend void handle_matrix_controller();
+
+private:
+    LedMatrixController();
+    ~LedMatrixController() = default;
 };
 
-extern LedDisplay led_display;
 } // namespace edge::drivers

include/drivers/virtual_timer_controller.hpp

@@ -12,7 +12,7 @@ void TIMER3_IRQHandler(void);
 struct timer {
     uint32_t id;
 
-    ProcessCallbackPtr callback;
+    etl::variant<KernelCallbackPtr, ProcessCallbackPtr> callback;
 
     uint32_t timer_value;
     ProcessId process_id;
@@ -35,8 +35,9 @@ class VirtualTimerController {
 
 public:
     uint32_t virtual_timer_start(
-        uint32_t microseconds, ProcessCallbackPtr callback, ProcessId timer_creator,
-        bool periodic
+        uint32_t microseconds,
+        etl::variant<KernelCallbackPtr, ProcessCallbackPtr> callback,
+        ProcessId timer_creator, bool periodic
     );
     void virtual_timer_cancel(uint32_t timer_id);
 

include/util.hpp

@@ -7,6 +7,7 @@ namespace edge {
 
 // Arg1 and arg2 are optional
 using ProcessCallbackPtr = void (*)(int arg1, int arg2);
+using KernelCallbackPtr = etl::delegate<void()>;
 
 using ProcessId = uint8_t;
 

src/drivers/driver_commands.cpp

@@ -2,24 +2,19 @@
 
 #include "drivers/button_driver.hpp"
 #include "drivers/driver_enums.hpp"
-#include "drivers/led_display.hpp"
+#include "drivers/led_matrix_controller.hpp"
 #include "drivers/virtual_timer_controller.hpp"
+#include "util.hpp"
 
 #include <stdio.h>
 
 namespace edge::drivers {
 
-// Runs on context switch
-void do_async_work()
-{
-    led_display.do_async_work();
-}
-
 etl::optional<int> handle_command(DriverCommand type, int arg1, int arg2, int arg3)
 {
     switch (type) {
         case DriverCommand::LED_DISPLAY:
-            led_display.set_led(arg1, arg2, arg3);
+            LedMatrixController::get().set_led(arg1, arg2, arg3);
             break;
         case DriverCommand::GET_TIME:
             return VirtualTimerController::get().read_timer();
@@ -52,7 +47,7 @@ etl::optional<int> handle_subscribe(
             break;
         case DriverSubscribe::TIMER_START:
             return VirtualTimerController::get().virtual_timer_start(
-                static_cast<uint32_t>(arg1), callback, process_id, arg2
+                static_cast<uint32_t>(arg1), callback, 0, arg2
             );
     }
     return etl::nullopt;

src/drivers/led_display.cpp

@@ -0,0 +1,54 @@
+#include "drivers/led_matrix_controller.hpp"
+
+#include "drivers/virtual_timer_controller.hpp"
+#include "nrf_delay.h"
+#include "userlib/syscalls.hpp"
+#include "util.hpp"
+
+namespace edge::drivers {
+
+void handle_matrix_controller()
+{
+    static uint8_t row_index = 0;
+    LedMatrixController& controller = LedMatrixController::get();
+
+    etl::for_each(
+        controller.led_rows.begin(), controller.led_rows.end(),
+        [](auto& led_row) { led_row.clear(); }
+    );
+
+    for (uint8_t col_index = 0; col_index < 5; ++col_index) {
+        bool state = controller.led_enabled[row_index][col_index];
+        if (!state) {
+            controller.led_cols[col_index].set();
+        }
+        else {
+            controller.led_cols[col_index].clear();
+        }
+    }
+    controller.led_rows[row_index].set();
+    row_index++;
+    row_index = row_index % 5;
+}
+
+LedMatrixController::LedMatrixController()
+{
+    etl::for_each(led_rows.begin(), led_rows.end(), [](auto& row) { row.clear(); });
+    etl::for_each(led_cols.begin(), led_cols.end(), [](auto& col) { col.set(); });
+    VirtualTimerController::get().virtual_timer_start(
+        100, etl::delegate<void()>::create<handle_matrix_controller>(), 0, true
+    );
+}
+
+LedMatrixController& LedMatrixController::get()
+{
+    static LedMatrixController controller;
+    return controller;
+}
+
+void LedMatrixController::set_led(uint8_t row, uint8_t col, bool enabled)
+{
+    led_enabled[row][col] = enabled;
+}
+
+} // namespace edge::drivers

src/drivers/led_matrix_controller.cpp

@@ -47,9 +47,15 @@ void VirtualTimerController::trigger_ready_timers()
     etl::optional<timer> ready_timer_opt = get_ready_timer();
     while (ready_timer_opt.has_value()) {
         timer& ready_timer = ready_timer_opt.value();
-        PendingProcessCallbacks::get().add_ready_callback(
-            ready_timer.process_id, ready_timer.callback, ready_timer.id
-        );
+        if (etl::holds_alternative<KernelCallbackPtr>(ready_timer.callback)) {
+            etl::get<KernelCallbackPtr>(ready_timer.callback)();
+        }
+        else {
+            PendingProcessCallbacks::get().add_ready_callback(
+                ready_timer.process_id,
+                etl::get<ProcessCallbackPtr>(ready_timer.callback), ready_timer.id
+            );
+        }
         if (ready_timer.periodic) {
             ready_timer.timer_value += ready_timer.duration;
             virtual_timer_start(ready_timer);
@@ -79,7 +85,8 @@ uint32_t VirtualTimerController::virtual_timer_start(const timer& timer)
 }
 
 uint32_t VirtualTimerController::virtual_timer_start(
-    uint32_t microseconds, ProcessCallbackPtr cb, ProcessId timer_creator, bool periodic
+    uint32_t microseconds, etl::variant<KernelCallbackPtr, ProcessCallbackPtr> cb,
+    ProcessId timer_creator, bool periodic
 )
 {
     static uint32_t timer_offset = 0;

src/drivers/virtual_timer_controller.cpp

@@ -16,7 +16,7 @@ int main(void)
 
     edge::FaultHandler::get();
 
-    // edge::scheduler.add_task(exception_task);
+    edge::scheduler.add_task(exception_task);
 
     edge::scheduler.add_task(ipc_part1);
     edge::scheduler.add_task(ipc_part2);

src/entrypoint.cpp

@@ -99,9 +99,6 @@ __attribute__((naked, used)) void PendSV_Handler()
 
     asm volatile("CPSIE I");
 
-    // Always want to call drivers on context switch
-    drivers::do_async_work();
-
     // Return in thumb/process mode and restore using extended stack frame
     asm volatile("ldr r0,=0xffffffed\n"
                  "bx r0");

src/scheduler/scheduler.cpp

@@ -4,14 +4,16 @@
 
 void callback(uint32_t id)
 {
-    static int b = 0;
-    edge::userlib::set_led(3, 3, ++b % 2 == 0);
+    static bool b = false;
+    edge::userlib::set_led(2, 2, b);
+	b=!b;
 }
 
 void callback2(uint32_t id)
 {
-    static int b = 0;
-    edge::userlib::set_led(1, 1, ++b % 2 == 0);
+    static bool b = false;
+    edge::userlib::set_led(2, 2, b);
+	b=!b;
 }
 
 void exception_task(void)
@@ -47,8 +49,6 @@ void exception_task(void)
     auto id2 = start_timer(callback2, 750000, true);
     cancel_timer(id2);
 
-    set_led(2, 2, true);
-
     while (1) {
         yield();
     }