temp

Author: stevenewald

Makefile

@@ -14,6 +14,7 @@ ETL_INCLUDES += ./external/etl/include/etl/string_stream.h
 ETL_INCLUDES += ./external/etl/include/etl/to_string.h
 ETL_INCLUDES += ./external/etl/include/etl/delegate.h
 ETL_INCLUDES += ./external/etl/include/etl/unordered_map.h
+ETL_INCLUDES += ./external/etl/include/etl/priority_queue.h
 
 # Source and header files
 APP_HEADER_PATHS += ./include

include/drivers/virtual_timer_controller.hpp

@@ -3,36 +3,50 @@
 #include "nrf_timer.h"
 #include "stdint.h"
 
+namespace edge::drivers {
 extern "C" {
 void TIMER3_IRQHandler(void);
 }
 
-namespace edge::drivers {
+struct timer {
+    uint32_t id;
+
+    void* callback;
+
+    uint32_t timer_value;
+
+    bool operator<(const timer& other) const { return timer_value < other.timer_value; }
+};
 
 // Reserves Timer 3
 class VirtualTimerController {
     static constexpr nrf_timer_frequency_t TIMER_FREQUENCY = NRF_TIMER_FREQ_16MHz;
+    inline static NRF_TIMER_Type* const TIMER = NRF_TIMER3;
+    etl::priority_queue<timer, 32> timers_;
+
+    void trigger_ready_timers();
+    bool has_ready_timer() const;
 
 public:
-    uint32_t read_timer();
+    uint32_t read_timer() const;
 
     uint32_t virtual_timer_start(uint32_t microseconds, void* callback);
 
     void virtual_timer_cancel(uint32_t timer_id);
 
     static VirtualTimerController& get();
 
-    ~VirtualTimerController() = default;
-
-    inline static NRF_TIMER_Type* const TIMER = NRF_TIMER3;
-
     uint32_t timer_start(uint32_t microseconds, void* callback);
 
-    void update_ll();
+    VirtualTimerController(VirtualTimerController&) = delete;
+    VirtualTimerController(VirtualTimerController&&) = delete;
+    VirtualTimerController& operator=(VirtualTimerController&) = delete;
+    VirtualTimerController& operator=(VirtualTimerController&&) = delete;
 
-    friend void ::TIMER3_IRQHandler(void);
+    friend void TIMER3_IRQHandler(void);
 
 private:
+    ~VirtualTimerController() = default;
     VirtualTimerController();
 };
 

include/drivers/virtual_timer_linked_list.hpp

@@ -27,9 +27,9 @@ void subscribe_ipc(const char* name, void (*callback)(int message));
 
 void set_fault_handler(void (*callback)(FaultType));
 
-uint32_t start_vtimer(void (*callback)(), uint32_t microseconds);
+uint32_t start_timer(void (*callback)(uint32_t), uint32_t microseconds);
 
-void cancel_vtimer(uint32_t timer_id);
+void cancel_timer(uint32_t timer_id);
 
 // We need a syscall for this because SVC will not be preempted by SysTick
 // Technically this is insecure - it's mostly for debugging

include/userlib/syscalls.hpp

@@ -1,6 +1,5 @@
 #include "drivers/virtual_timer_controller.hpp"
 
-#include "drivers/virtual_timer_linked_list.hpp"
 #include "nrf52833.h"
 #include "scheduler/pending_process_callbacks.hpp"
 
@@ -9,10 +8,9 @@ namespace edge::drivers {
 extern "C" {
 void TIMER3_IRQHandler(void)
 {
-    VirtualTimerController vtc = VirtualTimerController::get();
+    VirtualTimerController& vtc = VirtualTimerController::get();
     vtc.TIMER->EVENTS_COMPARE[2] = 0;
-    vtc.update_ll();
-    return;
+    vtc.trigger_ready_timers();
 }
 }
 
@@ -26,31 +24,20 @@ VirtualTimerController::VirtualTimerController()
     NVIC_EnableIRQ(TIMER3_IRQn);
 }
 
-void VirtualTimerController::update_ll()
+bool VirtualTimerController::has_ready_timer() const
 {
-    __disable_irq();
-    node_t* ptr = list_get_first();
-    if (!ptr) {
-        return;
-    }
-    uint32_t val = ptr->timer_value;
-    uint32_t current_time = read_timer();
-    while (val < current_time) {
-        list_remove_first();
+    return !timers_.empty() && timers_.top().timer_value <= read_timer();
+};
+
+void VirtualTimerController::trigger_ready_timers()
+{
+    while (has_ready_timer()) {
+        timer t{timers_.top()};
+        timers_.pop();
         PendingProcessCallbacks::get().add_ready_callback(
-            0, reinterpret_cast<void (*)(int, int)>(ptr->callback)
+            0, reinterpret_cast<void (*)(int, int)>(t.callback)
         );
-        free(ptr);
-
-        ptr = list_get_first();
-        if (!ptr) {
-            break;
-        }
-        val = ptr->timer_value;
-        current_time = read_timer();
     }
-    __enable_irq();
-    return;
 }
 
 VirtualTimerController& VirtualTimerController::get()
@@ -59,78 +46,26 @@ VirtualTimerController& VirtualTimerController::get()
     return controller;
 }
 
-uint32_t VirtualTimerController::read_timer()
+uint32_t VirtualTimerController::read_timer() const
 {
     TIMER->TASKS_CAPTURE[1] = 1;
     return TIMER->CC[1];
 }
 
 uint32_t VirtualTimerController::timer_start(uint32_t microseconds, void* cb)
 {
-    __disable_irq();
-    node_t* node_ptr = new node_t;
     uint32_t curr_time = read_timer();
-    uint32_t time = curr_time + microseconds;
-    node_ptr->timer_value = time;
-
-    node_ptr->callback = cb;
+    timers_.emplace(0, cb, curr_time + microseconds);
 
-    uint32_t node_id = (uint32_t)node_ptr;
-    node_ptr->id = node_id;
-
-    node_ptr->freq = microseconds;
-    list_insert_sorted(node_ptr);
-    update_ll();
-
-    TIMER->CC[2] = list_get_first()->timer_value;
-
-    __enable_irq();
-    return node_id;
+    TIMER->CC[2] = timers_.top().timer_value;
+    return 0;
 }
 
 uint32_t VirtualTimerController::virtual_timer_start(uint32_t microseconds, void* cb)
 {
     return timer_start(microseconds, cb);
 }
 
-void VirtualTimerController::virtual_timer_cancel(uint32_t timer_id)
-{
-    __disable_irq();
-    node_t* ptr = list_get_first();
-    if (!ptr) {
-        __enable_irq();
-        return;
-    }
-    if (ptr->id == timer_id) {
-        list_remove(ptr);
-        delete ptr;
-        update_ll();
-        ptr = list_get_first();
-        if (ptr) {
-            TIMER->CC[2] = list_get_first()->timer_value;
-        }
-        else {
-            TIMER->CC[2] = 0;
-        }
-        __enable_irq();
-        return;
-    }
-
-    while ((ptr->next != nullptr) && (ptr->id != timer_id)) {
-        ptr = ptr->next;
-    }
-
-    list_remove(ptr);
-    delete ptr;
-    update_ll();
-    __enable_irq();
-    ptr = list_get_first();
-    if (ptr) {
-        TIMER->CC[2] = list_get_first()->timer_value;
-    }
-    else {
-        TIMER->CC[2] = 0;
-    }
-}
+void VirtualTimerController::virtual_timer_cancel(uint32_t timer_id) {}
 
 } // namespace edge::drivers

src/drivers/virtual_timer_controller.cpp

@@ -2,7 +2,7 @@
 
 #include <cstdio>
 
-void static callback(void)
+void static callback(uint32_t id)
 {
     edge::userlib::set_led(3, 3, true);
     edge::userlib::debug_print("Callback!\n");
@@ -37,9 +37,9 @@ void exception_task(void)
     set_fault_handler(fault_handler);
 
     trigger_faults();
-    start_vtimer(&callback, 100000);
-    auto id = start_vtimer(&callback, 100000);
-    cancel_vtimer(id);
+    auto id = start_timer(&callback, 1000000);
+    // cancel_timer(id);
+    id = start_timer(&callback, 2000000);
 
     set_led(2, 2, true);
 

src/drivers/virtual_timer_linked_list.cpp

@@ -85,7 +85,7 @@ int USER_CODE get_time_us()
     RETURN_REGISTER(r0);
 }
 
-uint32_t USER_CODE start_vtimer(void (*callback)(), uint32_t microseconds)
+uint32_t USER_CODE start_timer(void (*callback)(uint32_t), uint32_t microseconds)
 {
     SET_REGISTER(r0, (int)drivers::DriverCommand::TIMER_START);
     SET_REGISTER(r1, (int)callback);
@@ -94,7 +94,7 @@ uint32_t USER_CODE start_vtimer(void (*callback)(), uint32_t microseconds)
     RETURN_REGISTER(r0);
 }
 
-void USER_CODE cancel_vtimer(uint32_t timer_id)
+void USER_CODE cancel_timer(uint32_t timer_id)
 {
     SET_REGISTER(r0, (int)drivers::DriverCommand::TIMER_CANCEL);
     SET_REGISTER(r1, (int)timer_id);