Merge pull request #44 from stevenewald/timer

Add virtual timer implementation

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/set.h
 
 # Source and header files
 APP_HEADER_PATHS += ./include

include/drivers/driver_commands.hpp

@@ -11,7 +11,7 @@ void do_async_work();
 
 etl::optional<int> handle_command(DriverCommand type, int arg1, int arg2, int arg3);
 
-void handle_subscribe(
+etl::optional<int> handle_subscribe(
     DriverSubscribe type, ProcessCallbackPtr callback, int arg1, int arg2,
     ProcessId process_id
 );

include/drivers/driver_enums.hpp

@@ -7,10 +7,11 @@ enum class DriverCommand {
     GET_TIME = 0,
     LED_DISPLAY = 1,
     BUTTONS = 2,
-    TERMINAL_OUTPUT = 3
+    TERMINAL_OUTPUT = 3,
+    TIMER_CANCEL = 4,
 };
 
-enum class DriverSubscribe { NOTIFY_BUTTON_PRESS = 0 };
+enum class DriverSubscribe { NOTIFY_BUTTON_PRESS = 0, TIMER_START = 1 };
 
 enum class GPIOConfiguration { OUT, IN_NORES, IN_PDR, IN_PUR };
 

include/drivers/virtual_timer_controller.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "nrf_timer.h"
+#include "stdint.h"
+#include "util.hpp"
+
+namespace edge::drivers {
+extern "C" {
+void TIMER3_IRQHandler(void);
+}
+
+struct timer {
+    uint32_t id;
+
+    ProcessCallbackPtr callback;
+
+    uint32_t timer_value;
+    ProcessId process_id;
+    uint32_t duration;
+    bool periodic;
+};
+
+inline bool operator<(const timer& first, const timer& second)
+{
+    return first.timer_value < second.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;
+    static constexpr size_t MAX_TIMERS = 512;
+    etl::set<timer, MAX_TIMERS> timers_;
+    uint32_t virtual_timer_start(const timer& timer);
+
+public:
+    uint32_t virtual_timer_start(
+        uint32_t microseconds, ProcessCallbackPtr callback, ProcessId timer_creator,
+        bool periodic
+    );
+    void virtual_timer_cancel(uint32_t timer_id);
+
+    static VirtualTimerController& get();
+
+    VirtualTimerController(VirtualTimerController&) = delete;
+    VirtualTimerController(VirtualTimerController&&) = delete;
+    VirtualTimerController& operator=(VirtualTimerController&) = delete;
+    VirtualTimerController& operator=(VirtualTimerController&&) = delete;
+
+    friend void TIMER3_IRQHandler(void);
+
+private:
+    void trigger_ready_timers();
+
+    etl::optional<timer> get_ready_timer();
+
+    void enqueue_next_timer() const;
+
+    uint32_t read_timer() const;
+
+    uint32_t timer_start(
+        uint32_t microseconds, ProcessCallbackPtr callback, ProcessId timer_creator
+    );
+
+    VirtualTimerController();
+    ~VirtualTimerController() = default;
+};
+
+} // namespace edge::drivers

include/ipc/ipc_manager.hpp

@@ -20,7 +20,8 @@ class IPCManager {
     static IPCManager& get();
 
     void register_callback(
-        ProcessId process_id, const ProcessName& process_name, ProcessCallbackPtr callback
+        ProcessId process_id, const ProcessName& process_name,
+        ProcessCallbackPtr callback
     );
     void send_message(const ProcessName& destination_name, int value);
 };

include/userlib/syscalls.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "drivers/driver_enums.hpp"
+#include "stdint.h"
 #include "util.hpp"
 
 namespace edge::userlib {
@@ -26,6 +27,11 @@ void subscribe_ipc(const char* name, void (*callback)(int message));
 
 void set_fault_handler(void (*callback)(FaultType));
 
+uint32_t
+start_timer(void (*callback)(uint32_t), uint32_t microseconds, bool periodic = false);
+
+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
 void debug_print(const char* string);

src/drivers/driver_commands.cpp

@@ -4,6 +4,7 @@
 #include "drivers/driver_enums.hpp"
 #include "drivers/led_display.hpp"
 #include "drivers/timer.hpp"
+#include "drivers/virtual_timer_controller.hpp"
 
 #include <stdio.h>
 
@@ -30,11 +31,16 @@ etl::optional<int> handle_command(DriverCommand type, int arg1, int arg2, int ar
             return ButtonController::get().get_button_pressed(
                 static_cast<ButtonType>(arg1)
             );
+        case DriverCommand::TIMER_CANCEL:
+            VirtualTimerController::get().virtual_timer_cancel(
+                static_cast<uint32_t>(arg1)
+            );
+            break;
     }
     return etl::nullopt;
 }
 
-void handle_subscribe(
+etl::optional<int> handle_subscribe(
     DriverSubscribe type, ProcessCallbackPtr callback, int arg1, int arg2,
     ProcessId process_id
 )
@@ -45,7 +51,12 @@ void handle_subscribe(
                 static_cast<ButtonType>(arg1), callback, process_id
             );
             break;
+        case DriverSubscribe::TIMER_START:
+            return VirtualTimerController::get().virtual_timer_start(
+                static_cast<uint32_t>(arg1), callback, process_id, arg2
+            );
     }
+    return etl::nullopt;
 }
 
 } // namespace edge::drivers

src/drivers/virtual_timer_controller.cpp

@@ -0,0 +1,108 @@
+#include "drivers/virtual_timer_controller.hpp"
+
+#include "nrf52833.h"
+#include "scheduler/pending_process_callbacks.hpp"
+#include "util.hpp"
+
+namespace edge::drivers {
+
+extern "C" {
+void TIMER3_IRQHandler(void)
+{
+    VirtualTimerController& vtc = VirtualTimerController::get();
+    vtc.TIMER->EVENTS_COMPARE[2] = 0;
+    vtc.trigger_ready_timers();
+}
+}
+
+VirtualTimerController::VirtualTimerController()
+{
+    TIMER->BITMODE = 0x3;
+    TIMER->MODE = 0x0;
+    TIMER->PRESCALER = 0x4;
+    TIMER->TASKS_START = 1;
+    TIMER->INTENSET = 0x40000;
+    NVIC_EnableIRQ(TIMER3_IRQn);
+}
+
+etl::optional<timer> VirtualTimerController::get_ready_timer()
+{
+    auto begin = timers_.begin();
+    if (!timers_.empty() && begin->timer_value <= read_timer()) {
+        auto ret = etl::make_optional<timer>(*begin);
+        timers_.erase(begin);
+        return ret;
+    }
+    return etl::nullopt;
+};
+
+void VirtualTimerController::enqueue_next_timer() const
+{
+    if (!timers_.empty())
+        TIMER->CC[2] = timers_.begin()->timer_value;
+}
+
+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 (ready_timer.periodic) {
+            ready_timer.timer_value += ready_timer.duration;
+            virtual_timer_start(ready_timer);
+        }
+        ready_timer_opt = get_ready_timer();
+    }
+    enqueue_next_timer();
+}
+
+VirtualTimerController& VirtualTimerController::get()
+{
+    static VirtualTimerController controller;
+    return controller;
+}
+
+uint32_t VirtualTimerController::read_timer() const
+{
+    TIMER->TASKS_CAPTURE[1] = 1;
+    return TIMER->CC[1];
+}
+
+uint32_t VirtualTimerController::virtual_timer_start(const timer& timer)
+{
+    timers_.insert(timer);
+    enqueue_next_timer();
+    return timer.id;
+}
+
+uint32_t VirtualTimerController::virtual_timer_start(
+    uint32_t microseconds, ProcessCallbackPtr cb, ProcessId timer_creator, bool periodic
+)
+{
+    static uint32_t timer_offset = 0;
+    ++timer_offset;
+
+    uint32_t curr_time = read_timer();
+    uint32_t timer_id = curr_time + timer_offset;
+
+    timer new_timer{timer_id,      cb,           curr_time + microseconds,
+                    timer_creator, microseconds, periodic};
+
+    return virtual_timer_start(new_timer);
+}
+
+void VirtualTimerController::virtual_timer_cancel(uint32_t timer_id)
+{
+    for (auto it = timers_.begin(); it != timers_.end(); ++it) {
+        if (it->id == timer_id) {
+            timers_.erase(it);
+            return;
+        }
+    }
+    enqueue_next_timer();
+}
+
+} // namespace edge::drivers

src/ipc/ipc_manager.cpp

@@ -12,7 +12,8 @@ IPCManager& IPCManager::get()
 }
 
 void IPCManager::register_callback(
-    ProcessId process_id, const ProcessName& new_process_name, ProcessCallbackPtr callback
+    ProcessId process_id, const ProcessName& new_process_name,
+    ProcessCallbackPtr callback
 )
 {
     ipc_communicators.set_callback(process_id, callback);

src/scheduler/user_callback_storage.cpp

@@ -20,7 +20,7 @@ void UserCallbackStorage::set_callback(ProcessId id, ProcessCallbackPtr ptr)
 void UserCallbackStorage::call_callback(ProcessId id, int arg1, int arg2)
 {
     if (!has_callback(id)) {
-		panic("Attempted to call callback when it has not been set");
+        panic("Attempted to call callback when it has not been set");
     }
 
     PendingProcessCallbacks::get().add_ready_callback(id, callbacks_[id], arg1, arg2);

src/svc/svc.cpp

@@ -29,7 +29,7 @@ etl::optional<int> handle_driver_command(exception_stack_registers* stack_regs)
     );
 }
 
-void handle_driver_subscribe(exception_stack_registers* stack_regs)
+etl::optional<int> handle_driver_subscribe(exception_stack_registers* stack_regs)
 {
     auto type = static_cast<drivers::DriverSubscribe>(stack_regs->R0);
     auto callback = reinterpret_cast<ProcessCallbackPtr>(stack_regs->R1);
@@ -82,8 +82,7 @@ etl::optional<int> handle_call(exception_stack_registers* stack_regs)
         case SystemCallType::COMMAND:
             return handle_driver_command(stack_regs);
         case SystemCallType::SUBSCRIBE:
-            handle_driver_subscribe(stack_regs);
-            break;
+            return handle_driver_subscribe(stack_regs);
         case edge::SystemCallType::IPC:
             handle_ipc(stack_regs);
             break;
@@ -106,8 +105,8 @@ __attribute__((used)) void SVC_Handler(void)
     exception_stack_registers* stack_regs;
     asm("MRS %0,PSP" : "=r"(stack_regs));
     auto ret_opt = handle_call(stack_regs);
-    if (ret_opt) {
-        stack_regs->R0 = *ret_opt;
+    if (ret_opt.has_value()) {
+        stack_regs->R0 = ret_opt.value();
     }
 }
 }

src/user_programs/user_program_exception.cpp

@@ -1,5 +1,19 @@
 #include "userlib/syscalls.hpp"
 
+#include <cstdio>
+
+void callback(uint32_t id)
+{
+    static int b = 0;
+    edge::userlib::set_led(3, 3, ++b % 2 == 0);
+}
+
+void callback2(uint32_t id)
+{
+    static int b = 0;
+    edge::userlib::set_led(1, 1, ++b % 2 == 0);
+}
+
 void exception_task(void)
 {
     auto trigger_faults = []() {
@@ -29,6 +43,9 @@ void exception_task(void)
     set_fault_handler(fault_handler);
 
     trigger_faults();
+    start_timer(callback, 100000, true);
+    auto id2 = start_timer(callback2, 750000, true);
+    cancel_timer(id2);
 
     set_led(2, 2, true);
 

src/user_programs/user_program_ipc_part_1.cpp

@@ -1,5 +1,3 @@
-#include "nrf52833.h"
-#include "nrf_delay.h"
 #include "userlib/syscalls.hpp"
 
 #include <stdio.h>

src/userlib/syscalls.cpp

@@ -85,6 +85,24 @@ int USER_CODE get_time_us()
     RETURN_REGISTER(r0);
 }
 
+uint32_t USER_CODE
+start_timer(void (*callback)(uint32_t), uint32_t microseconds, bool periodic)
+{
+    SET_REGISTER(r0, (int)drivers::DriverSubscribe::TIMER_START);
+    SET_REGISTER(r1, (int)callback);
+    SET_REGISTER(r2, (int)microseconds);
+    SET_REGISTER(r3, (int)periodic);
+    TRIGGER_SVC(SystemCallType::SUBSCRIBE);
+    RETURN_REGISTER(r0);
+}
+
+void USER_CODE cancel_timer(uint32_t timer_id)
+{
+    SET_REGISTER(r0, (int)drivers::DriverCommand::TIMER_CANCEL);
+    SET_REGISTER(r1, (int)timer_id);
+    TRIGGER_SVC(SystemCallType::COMMAND);
+}
+
 void USER_CODE debug_print(const char* val)
 {
     SET_REGISTER(r0, (int)drivers::DriverCommand::TERMINAL_OUTPUT);