diff --git a/src/entrypoints/imu-calibration.cpp b/src/entrypoints/imu-calibration.cpp
index d42b4977fefe71c56cc4942a9242d967d4a18f93..c2661049345a7c3cb45f0018b7ceee23d3ff480c 100644
--- a/src/entrypoints/imu-calibration.cpp
+++ b/src/entrypoints/imu-calibration.cpp
@@ -25,6 +25,7 @@
 #include <sensors/calibration/AxisOrientation.h>
 #include <sensors/calibration/SoftAndHardIronCalibration/SoftAndHardIronCalibration.h>
 #include <utils/Debug.h>
+#include <utils/KernelTime.h>
 
 #include <iostream>
 
@@ -108,14 +109,14 @@ void calibrateMagnetometer()
     scheduler.start();
 
     // Wait and then stop the sampling
-    auto startTick = getTick();
+    auto startTick = Kernel::getOldTick();
     auto lastTick  = startTick;
-    while (getTick() - startTick < MAG_CALIBRATION_DURATION * 1e3)
+    while (Kernel::getOldTick() - startTick < MAG_CALIBRATION_DURATION * 1e3)
     {
         mpu.sample();
         calibration.feed(mpu.getLastSample());
-        Thread::sleepUntil(lastTick + IMU_SAMPLE_PERIOD);
-        lastTick = getTick();
+        Kernel::Thread::sleepUntil(lastTick + IMU_SAMPLE_PERIOD);
+        lastTick = Kernel::getOldTick();
     }
 
     scheduler.stop();
diff --git a/src/shared/diagnostic/CpuMeter/CpuMeter.cpp b/src/shared/diagnostic/CpuMeter/CpuMeter.cpp
index 57990c49ff064d0d5ae08ddf6c703c0c1e87a2c9..880dbaa205a54828be0a56357b6516b4650c367a 100644
--- a/src/shared/diagnostic/CpuMeter/CpuMeter.cpp
+++ b/src/shared/diagnostic/CpuMeter/CpuMeter.cpp
@@ -60,9 +60,9 @@ static void cpuMeterThread(void*)
 {
     for (;;)
     {
-        long long t1 = getTick();
+        long long t1 = Kernel::getOldTick();
         delayMs(period);
-        long long t2 = getTick();
+        long long t2 = Kernel::getOldTick();
 
         update++;
         float delta = t2 - t1;
diff --git a/src/shared/diagnostic/PrintLogger.cpp b/src/shared/diagnostic/PrintLogger.cpp
index 0e23b4cee1c44c7f35e85799a769992aea8fe637..2b74b1df097344bff8d5000f4ef898ac14884bc1 100644
--- a/src/shared/diagnostic/PrintLogger.cpp
+++ b/src/shared/diagnostic/PrintLogger.cpp
@@ -22,6 +22,8 @@
 
 #include "PrintLogger.h"
 
+#include <utils/KernelTime.h>
+
 using miosix::Lock;
 
 namespace Boardcore
@@ -68,7 +70,7 @@ void LogSink::log(const LogRecord& record)
     using namespace fmt::literals;
     if (record.level >= minimumLevel)
     {
-        float ts     = miosix::getTick() / 1000.0f;
+        float ts     = Kernel::getOldTick() / 1000.0f;
         int min      = ts / 60;
         string tsStr = fmt::format("{:02d}:{:06.3f}", min, (ts - min * 60));
 
diff --git a/src/shared/diagnostic/StackLogger.h b/src/shared/diagnostic/StackLogger.h
index c7998375a081783a35ca8044110ebff2b1e31e3e..7be7d81de55cbe2a90c13b6c47cae174d537f7e3 100644
--- a/src/shared/diagnostic/StackLogger.h
+++ b/src/shared/diagnostic/StackLogger.h
@@ -25,6 +25,7 @@
 #include <ActiveObject.h>
 #include <Singleton.h>
 #include <logger/Logger.h>
+#include <utils/KernelTime.h>
 
 #include <map>
 
@@ -54,7 +55,7 @@ public:
     void updateStack(uint8_t threadId)
     {
         StackData d;
-        d.timestamp    = miosix::getTick();
+        d.timestamp    = Kernel::getOldTick();
         d.threadId     = threadId;
         d.minimumStack = miosix::MemoryProfiling::getAbsoluteFreeStack();
 
diff --git a/src/shared/drivers/WIZ5500/WIZ5500.cpp b/src/shared/drivers/WIZ5500/WIZ5500.cpp
index 6b4176df291a6abb4f0c76573b05be7a299dbb9b..89577709c24e8bfdda532bf808b08bb9a85eba0c 100644
--- a/src/shared/drivers/WIZ5500/WIZ5500.cpp
+++ b/src/shared/drivers/WIZ5500/WIZ5500.cpp
@@ -25,6 +25,7 @@
 #include <drivers/interrupt/external_interrupts.h>
 #include <interfaces/endianness.h>
 #include <kernel/scheduler/scheduler.h>
+#include <utils/KernelTime.h>
 
 #include "WIZ5500Defs.h"
 
@@ -444,14 +445,15 @@ void Wiz5500::close(int sock_n, int timeout)
 
 void Wiz5500::waitForINTn(Lock<FastMutex> &l)
 {
-    long long start        = getTick();
+    long long start        = Kernel::getOldTick();
     TimedWaitResult result = TimedWaitResult::NoTimeout;
 
     Unlock<FastMutex> ul(l);
     FastInterruptDisableLock il;
     while (intn.value() != 0 && result == TimedWaitResult::NoTimeout)
     {
-        result = Thread::IRQenableIrqAndTimedWaitMs(il, start + INTN_TIMEOUT);
+        result = Kernel::Thread::IRQenableIrqAndTimedWaitMs(
+            il, start + INTN_TIMEOUT);
     }
 }
 
@@ -493,7 +495,7 @@ int Wiz5500::waitForSocketIrq(miosix::Lock<miosix::FastMutex> &l, int sock_n,
         return 0;
     }
 
-    long long start        = getTick();
+    long long start        = Kernel::getOldTick();
     TimedWaitResult result = TimedWaitResult::NoTimeout;
 
     if (interrupt_service_thread != nullptr)
@@ -507,8 +509,8 @@ int Wiz5500::waitForSocketIrq(miosix::Lock<miosix::FastMutex> &l, int sock_n,
         {
             if (timeout != -1)
             {
-                result =
-                    Thread::IRQenableIrqAndTimedWaitMs(il, start + timeout);
+                result = Kernel::Thread::IRQenableIrqAndTimedWaitMs(
+                    il, start + timeout);
             }
             else
             {
diff --git a/src/shared/drivers/canbus/CanDriver/CanDriver.cpp b/src/shared/drivers/canbus/CanDriver/CanDriver.cpp
index 5aa54ede5fb0799e289635a2714ec866bdc0a561..61c57cb5d6ff6903cf02208c4bd511b9cb4d44af 100644
--- a/src/shared/drivers/canbus/CanDriver/CanDriver.cpp
+++ b/src/shared/drivers/canbus/CanDriver/CanDriver.cpp
@@ -24,6 +24,7 @@
 
 #include <kernel/scheduler/scheduler.h>
 #include <utils/ClockUtils.h>
+#include <utils/KernelTime.h>
 
 #include <algorithm>
 #include <cmath>
@@ -377,7 +378,7 @@ void CanbusDriver::handleRXInterrupt(int fifo)
 
     if ((*RFR & CAN_RF0R_FMP0) > 0)
     {
-        p.timestamp = miosix::getTick();
+        p.timestamp = Kernel::IRQgetOldTick();
 
         status.rxStatus     = *RFR & (CAN_RF0R_FULL0 | CAN_RF0R_FOVR0) >> 3;
         status.errCode      = (can->ESR | CAN_ESR_LEC) >> 4;
diff --git a/src/shared/events/EventBroker.cpp b/src/shared/events/EventBroker.cpp
index 96fe93c762b795ac5f32b32fe90d12db35fc6095..c4f1db75c8c2a7d8c0a1e4456b012486abdcaa02 100644
--- a/src/shared/events/EventBroker.cpp
+++ b/src/shared/events/EventBroker.cpp
@@ -67,10 +67,10 @@ uint16_t EventBroker::postDelayed(const Event& ev, uint8_t topic,
     Lock<FastMutex> lock(mtxDelayedEvents);
 
     // Delay in system ticks
-    long long delayTicks =
-        static_cast<long long>(delayMs * miosix::TICK_FREQ / 1000);
+    long long delayTicks = static_cast<long long>(delayMs);
 
-    DelayedEvent dev{eventCounter++, ev, topic, getTick() + delayTicks};
+    DelayedEvent dev{eventCounter++, ev, topic,
+                     Kernel::getOldTick() + delayTicks};
     bool added = false;
 
     // Add the new event in the list, ordered by deadline (first = nearest
@@ -141,7 +141,7 @@ void EventBroker::run()
     while (!shouldStop())
     {
         while (delayedEvents.size() > 0 &&
-               delayedEvents.front().deadline <= getTick())
+               delayedEvents.front().deadline <= Kernel::getOldTick())
         {
             // Pop the first element
             DelayedEvent dev = delayedEvents.front();
@@ -156,8 +156,7 @@ void EventBroker::run()
         }
 
         // When to wakeup for the next cycle
-        long long sleepUntil =
-            getTick() + EVENT_BROKER_MIN_DELAY * miosix::TICK_FREQ / 1000;
+        long long sleepUntil = Kernel::getOldTick() + EVENT_BROKER_MIN_DELAY;
 
         if (delayedEvents.size() > 0)
         {
@@ -173,7 +172,7 @@ void EventBroker::run()
             Unlock<FastMutex> unlock(lock);
             StackLogger::getInstance().updateStack(THID_EVT_BROKER);
 
-            Thread::sleepUntil(sleepUntil);
+            Kernel::Thread::sleepUntil(sleepUntil);
         }
     }
 }
diff --git a/src/shared/events/EventBroker.h b/src/shared/events/EventBroker.h
index 7437d623070bea3d1636528f1e55f92becb8b224..e9e51f1a063afbb222e5bf9b540a3f2a474a042f 100644
--- a/src/shared/events/EventBroker.h
+++ b/src/shared/events/EventBroker.h
@@ -39,7 +39,6 @@ using std::map;
 using std::vector;
 
 using miosix::FastMutex;
-using miosix::getTick;
 using miosix::Lock;
 using miosix::Thread;
 using miosix::Unlock;
diff --git a/src/shared/logger/Logger.cpp b/src/shared/logger/Logger.cpp
index a1c1da5ea2458b600034e0a8356bfd2061dc9078..714719d89d0a5efdab493bb997d648cd6a275f49 100644
--- a/src/shared/logger/Logger.cpp
+++ b/src/shared/logger/Logger.cpp
@@ -33,6 +33,7 @@
 #include <tscpp/buffer.h>
 #include <utils/Debug.h>
 
+#include <chrono>
 #include <fstream>
 #include <stdexcept>
 
@@ -287,8 +288,8 @@ void Logger::writeThread()
                 return;
 
             // Write data to disk
-            Timer timer;
-            timer.start();
+            using namespace std::chrono;
+            auto start = system_clock::now();
 
             size_t result = fwrite(buffer->data, 1, buffer->size, file);
             if (result != buffer->size)
@@ -301,8 +302,9 @@ void Logger::writeThread()
             else
                 stats.buffersWritten++;
 
-            timer.stop();
-            stats.averageWriteTime = timer.interval();
+            auto interval = system_clock::now() - start;
+            stats.averageWriteTime =
+                duration_cast<milliseconds>(interval).count();
             stats.maxWriteTime =
                 max(stats.maxWriteTime, stats.averageWriteTime);
 
diff --git a/src/shared/radio/MavlinkDriver/MavlinkDriver.h b/src/shared/radio/MavlinkDriver/MavlinkDriver.h
index 81607862cfe14f10b7de94b1faf00bd2fcce23bb..a1186fc2505ea36d780c40b89889ee4adb7572f5 100644
--- a/src/shared/radio/MavlinkDriver/MavlinkDriver.h
+++ b/src/shared/radio/MavlinkDriver/MavlinkDriver.h
@@ -42,6 +42,8 @@ implementation before including MavlinkDriver.h"
 #include <radio/Transceiver.h>
 #include <utils/collections/SyncPacketQueue.h>
 
+#include <functional>
+
 #include "MavlinkStatus.h"
 
 namespace Boardcore
diff --git a/src/shared/radio/SX1278/SX1278Common.cpp b/src/shared/radio/SX1278/SX1278Common.cpp
index a4cc12d11b023225a5504b94801a93956e9772fb..2628cf7a4e5bfd0389f2a53548ec09117a7c085a 100644
--- a/src/shared/radio/SX1278/SX1278Common.cpp
+++ b/src/shared/radio/SX1278/SX1278Common.cpp
@@ -23,6 +23,7 @@
 #include "SX1278Common.h"
 
 #include <kernel/scheduler/scheduler.h>
+#include <utils/KernelTime.h>
 
 namespace Boardcore
 {
@@ -107,10 +108,10 @@ ISX1278::IrqFlags SX1278Common::waitForIrqBusy(LockMode &_guard,
     // otherwise don't do anything with it
     (void)_guard;
 
-    long long start  = miosix::getTick();
+    long long start  = Kernel::getOldTick();
     IrqFlags ret_irq = 0;
 
-    while ((miosix::getTick() - start) < timeout)
+    while ((Kernel::getOldTick() - start) < timeout)
     {
         // Delay between polls
         const unsigned int DELAY = 100;
@@ -143,7 +144,7 @@ bool SX1278Common::waitForIrqInner(LockMode &_guard, bool unlock)
         mutex.unlock();
     }
 
-    int start                      = miosix::getTick();
+    int start                      = Kernel::getOldTick();
     miosix::TimedWaitResult result = miosix::TimedWaitResult::NoTimeout;
 
     {
@@ -151,7 +152,7 @@ bool SX1278Common::waitForIrqInner(LockMode &_guard, bool unlock)
         while (state.irq_wait_thread &&
                result == miosix::TimedWaitResult::NoTimeout)
         {
-            result = miosix::Thread::IRQenableIrqAndTimedWaitMs(
+            result = Kernel::Thread::IRQenableIrqAndTimedWaitMs(
                 lock, start + IRQ_TIMEOUT);
         }
     }
diff --git a/src/shared/radio/SX1278/SX1278Fsk.cpp b/src/shared/radio/SX1278/SX1278Fsk.cpp
index 1cf29fceea9de8e894c51ab6a1b1ba746164595c..4ec53f2d63cea5b4f23f28b08918edfff340158f 100644
--- a/src/shared/radio/SX1278/SX1278Fsk.cpp
+++ b/src/shared/radio/SX1278/SX1278Fsk.cpp
@@ -24,6 +24,7 @@
 
 #include <kernel/scheduler/scheduler.h>
 #include <utils/Debug.h>
+#include <utils/KernelTime.h>
 
 #include <cassert>
 #include <cmath>
@@ -34,7 +35,7 @@ namespace Boardcore
 using namespace SX1278;
 using namespace SX1278::Fsk;
 
-long long now() { return miosix::getTick() * 1000 / miosix::TICK_FREQ; }
+long long now() { return Kernel::getOldTick(); }
 
 // Enable:
 // - PayloadReady, PacketSent on DIO0 (mode 00)
diff --git a/src/shared/radio/Xbee/Xbee.cpp b/src/shared/radio/Xbee/Xbee.cpp
index 35553d134b2a3598838e5c728cc9f327c08f7e55..1f698c1ee15f8d2880532da8bc80638871de4665 100644
--- a/src/shared/radio/Xbee/Xbee.cpp
+++ b/src/shared/radio/Xbee/Xbee.cpp
@@ -64,7 +64,7 @@ bool Xbee::send(uint8_t* pkt, size_t packetLength)
                 MAX_PACKET_PAYLOAD_LENGTH);
         return false;
     }
-    long long startTick = miosix::getTick();
+    long long startTick = Kernel::getOldTick();
 
     TXRequestFrame txReq;
     uint8_t txFrameId  = buildTXRequestFrame(txReq, pkt, packetLength);
@@ -75,7 +75,7 @@ bool Xbee::send(uint8_t* pkt, size_t packetLength)
         writeFrame(txReq);
 
         // Wait for a TX Status frame
-        long long timeoutTick = miosix::getTick() + txTimeout;
+        long long timeoutTick = Kernel::getOldTick() + txTimeout;
 
         while (waitForFrame(FTYPE_TX_STATUS, FRAME_POLL_INTERVAL, timeoutTick))
         {
@@ -106,7 +106,7 @@ bool Xbee::send(uint8_t* pkt, size_t packetLength)
         ++status.txTimeoutCount;
         LOG_ERR(logger, "TX_STATUS timeout");
     }
-    timeToSendStats.add(miosix::getTick() - startTick);
+    timeToSendStats.add(Kernel::getOldTick() - startTick);
 
     StackLogger::getInstance().updateStack(THID_XBEE);
 
@@ -160,7 +160,7 @@ ssize_t Xbee::receive(uint8_t* buf, size_t bufMaxSize)
 
 XbeeStatus Xbee::getStatus()
 {
-    status.timestamp       = miosix::getTick();
+    status.timestamp       = Kernel::getOldTick();
     status.timeToSendStats = timeToSendStats.getStats();
     return status;
 }
@@ -178,7 +178,7 @@ void Xbee::reset()
 
     // When the xbee is ready, we should assert SSEL to tell it to use
     // SPI, and it should provide us with a modem status frame
-    long long timeout = miosix::getTick() + 1000;
+    long long timeout = Kernel::getOldTick() + 1000;
     do
     {
         // Assert SSEL on every iteration as we don't exactly know when the
@@ -200,7 +200,7 @@ void Xbee::reset()
                 break;
         }
         miosix::Thread::sleep(5);
-    } while (miosix::getTick() < timeout);
+    } while (Kernel::getOldTick() < timeout);
 }
 
 void Xbee::wakeReceiver(bool forceReturn)
@@ -293,7 +293,7 @@ bool Xbee::readRXFrame()
 
 void Xbee::writeFrame(APIFrame& frame)
 {
-    frame.timestamp = miosix::getTick();  // Only for logging purposes
+    frame.timestamp = Kernel::getOldTick();  // Only for logging purposes
 
     // Serialize the frame
     uint8_t txBuf[MAX_API_FRAME_SIZE];
@@ -337,7 +337,7 @@ bool Xbee::waitForFrame(uint8_t frameType, unsigned int pollInterval,
         {
             miosix::Thread::sleep(pollInterval);
         }
-    } while (miosix::getTick() < timeoutTick);
+    } while (Kernel::getOldTick() < timeoutTick);
 
     return false;
 }
@@ -380,7 +380,7 @@ bool Xbee::sendATCommand(const char* cmd, ATCommandResponseFrame* response,
 
     bool success = false;
 
-    long long timeoutTick = miosix::getTick() + timeout;
+    long long timeoutTick = Kernel::getOldTick() + timeout;
 
     while (waitForFrame(FTYPE_AT_COMMAND_RESPONSE, FRAME_POLL_INTERVAL,
                         timeoutTick))
@@ -435,7 +435,7 @@ uint8_t Xbee::sendATCommandInternal(uint8_t txFrameId, const char* cmd,
 void Xbee::handleFrame(APIFrame& frame)
 {
     // Set the timestamp to the frame
-    frame.timestamp = miosix::getTick();
+    frame.timestamp = Kernel::getOldTick();
 
     switch (frame.frameType)
     {
diff --git a/src/shared/scheduler/TaskScheduler.cpp b/src/shared/scheduler/TaskScheduler.cpp
index 6e14dfefbd336014d386b89a585950aad993731c..eb63590d3ac89ade8d832fc9b10fdf179f6d6f25 100644
--- a/src/shared/scheduler/TaskScheduler.cpp
+++ b/src/shared/scheduler/TaskScheduler.cpp
@@ -32,14 +32,6 @@ using namespace miosix;
 namespace Boardcore
 {
 
-namespace Constants
-{
-static constexpr unsigned int TICKS_PER_MS =
-    miosix::TICK_FREQ / 1000;  // Number of ticks in a millisecond
-static constexpr unsigned int MS_PER_TICK =
-    1000 / miosix::TICK_FREQ;  // Number of milliseconds in a tick
-}  // namespace Constants
-
 TaskScheduler::EventQueue TaskScheduler::makeAgenda()
 {
     std::vector<Event> agendaStorage{};
@@ -122,7 +114,7 @@ void TaskScheduler::enableTask(size_t id)
     }
 
     task.enabled = true;
-    agenda.emplace(id, getTick() + task.period * Constants::TICKS_PER_MS);
+    agenda.emplace(id, Kernel::getOldTick() + task.period);
     mutex.unlock();
 }
 
@@ -186,7 +178,7 @@ vector<TaskStatsResult> TaskScheduler::getTaskStats()
 
 void TaskScheduler::populateAgenda()
 {
-    int64_t currentTick = getTick();
+    int64_t currentTick = Kernel::getOldTick();
 
     for (size_t id = 1; id < tasks.size(); id++)
     {
@@ -221,7 +213,7 @@ void TaskScheduler::run()
             return;
         }
 
-        int64_t startTick = getTick();
+        int64_t startTick = Kernel::getOldTick();
         Event nextEvent   = agenda.top();
         Task& nextTask    = tasks[nextEvent.taskId];
 
@@ -254,7 +246,7 @@ void TaskScheduler::run()
                 }
 
                 // Enqueue only on a valid task
-                updateStats(nextEvent, startTick, getTick());
+                updateStats(nextEvent, startTick, Kernel::getOldTick());
                 enqueue(nextEvent, startTick);
             }
         }
@@ -262,7 +254,7 @@ void TaskScheduler::run()
         {
             Unlock<FastMutex> unlock(lock);
 
-            Thread::sleepUntil(nextEvent.nextTick);
+            Kernel::Thread::sleepUntil(nextEvent.nextTick);
         }
     }
 }
@@ -274,12 +266,12 @@ void TaskScheduler::updateStats(const Event& event, int64_t startTick,
 
     // Activation stats
     float activationError = startTick - event.nextTick;
-    task.activationStats.add(activationError * Constants::MS_PER_TICK);
+    task.activationStats.add(activationError);
 
     // Period stats
     int64_t lastCall = task.lastCall;
     if (lastCall >= 0)
-        task.periodStats.add((startTick - lastCall) * Constants::MS_PER_TICK);
+        task.periodStats.add((startTick - lastCall));
 
     // Update the last call tick to the current start tick for the next
     // iteration
@@ -314,7 +306,7 @@ void TaskScheduler::enqueue(Event event, int64_t startTick)
                 ((startTick - event.nextTick) / task.period + 1) * task.period;
             break;
         case Policy::RECOVER:
-            event.nextTick += task.period * Constants::TICKS_PER_MS;
+            event.nextTick += task.period;
             break;
     }
 
diff --git a/src/shared/scheduler/TaskScheduler.h b/src/shared/scheduler/TaskScheduler.h
index 6496eb9bf57c065ac76dcd00505da13495ae5b48..84f5c97d7777846582618ab19645f95e55e5ce5c 100644
--- a/src/shared/scheduler/TaskScheduler.h
+++ b/src/shared/scheduler/TaskScheduler.h
@@ -26,6 +26,7 @@
 #include <Singleton.h>
 #include <debug/debug.h>
 #include <diagnostic/PrintLogger.h>
+#include <utils/KernelTime.h>
 #include <utils/Stats/Stats.h>
 
 #include <cstdint>
@@ -114,7 +115,7 @@ public:
      */
     size_t addTask(function_t function, uint32_t period,
                    Policy policy     = Policy::RECOVER,
-                   int64_t startTick = miosix::getTick());
+                   int64_t startTick = Kernel::getOldTick());
 
     /**
      * @brief Enables the task with the given id.
diff --git a/src/shared/sensors/UBXGPS/UBXGPSSpi.cpp b/src/shared/sensors/UBXGPS/UBXGPSSpi.cpp
index d62ace27f44e7525bed0e2f9f4367e8b1430b0e9..1137164b89aaef27cce88a3cd821c51c48e0fa0a 100644
--- a/src/shared/sensors/UBXGPS/UBXGPSSpi.cpp
+++ b/src/shared/sensors/UBXGPS/UBXGPSSpi.cpp
@@ -24,6 +24,7 @@
 
 #include <drivers/timer/TimestampTimer.h>
 #include <interfaces/endianness.h>
+#include <utils/KernelTime.h>
 
 using namespace miosix;
 
@@ -35,8 +36,6 @@ constexpr uint16_t UBXFrame::MAX_FRAME_LENGTH;
 constexpr uint8_t UBXFrame::PREAMBLE[];
 constexpr uint8_t UBXFrame::WAIT;
 
-constexpr float UBXGPSSpi::MS_TO_TICK;
-
 constexpr unsigned int UBXGPSSpi::RESET_SLEEP_TIME;
 constexpr unsigned int UBXGPSSpi::READ_TIMEOUT;
 constexpr unsigned int UBXGPSSpi::MAX_TRIES;
@@ -241,8 +240,8 @@ bool UBXGPSSpi::setPVTMessageRate()
 
 bool UBXGPSSpi::readUBXFrame(UBXFrame& frame)
 {
-    long long start = miosix::getTick();
-    long long end   = start + READ_TIMEOUT * MS_TO_TICK;
+    long long start = Kernel::getOldTick();
+    long long end   = start + READ_TIMEOUT;
 
     {
         spiSlave.bus.configure(spiSlave.config);
@@ -253,7 +252,7 @@ bool UBXGPSSpi::readUBXFrame(UBXFrame& frame)
         bool waiting = false;
         while (i < 2)
         {
-            if (miosix::getTick() >= end)
+            if (Kernel::getOldTick() >= end)
             {
                 // LOG_ERR(logger, "Timeout for read expired");
                 spiSlave.bus.deselect(spiSlave.cs);
diff --git a/src/shared/sensors/UBXGPS/UBXGPSSpi.h b/src/shared/sensors/UBXGPS/UBXGPSSpi.h
index 71739b4a685fb94c553eeb17d4ca315d775cac87..e36b6d5b431ab603acae63f597e5e46a95c7ac6f 100644
--- a/src/shared/sensors/UBXGPS/UBXGPSSpi.h
+++ b/src/shared/sensors/UBXGPS/UBXGPSSpi.h
@@ -141,8 +141,6 @@ private:
 
     PrintLogger logger = Logging::getLogger("ubxgps");
 
-    static constexpr float MS_TO_TICK = miosix::TICK_FREQ / 1000.f;
-
     static constexpr unsigned int RESET_SLEEP_TIME = 1000;  // [ms]
     static constexpr unsigned int READ_TIMEOUT     = 1;     // [ms]
     static constexpr unsigned int MAX_TRIES        = 5;     // [1]
diff --git a/src/shared/sensors/VN100/VN100.cpp b/src/shared/sensors/VN100/VN100.cpp
index 7a808633d782a3b9aa948348c87dbadedf602837..12ebff0ee883897658b221572133527d9ed31f86 100644
--- a/src/shared/sensors/VN100/VN100.cpp
+++ b/src/shared/sensors/VN100/VN100.cpp
@@ -23,6 +23,7 @@
 #include "VN100.h"
 
 #include <drivers/timer/TimestampTimer.h>
+#include <utils/KernelTime.h>
 
 namespace Boardcore
 {
@@ -120,14 +121,14 @@ void VN100::run()
 {
     while (!shouldStop())
     {
-        long long initialTime = miosix::getTick();
+        long long initialTime = Kernel::getOldTick();
         {
             // Sample the data locking the mutex
             miosix::Lock<FastMutex> l(mutex);
             threadSample = sampleData();
         }
         // Sleep for the sampling period
-        miosix::Thread::sleepUntil(initialTime + samplePeriod);
+        Kernel::Thread::sleepUntil(initialTime + samplePeriod);
     }
 }
 
diff --git a/src/shared/sensors/analog/pressure/SoftwareDifferentialPressureSensor.h b/src/shared/sensors/analog/pressure/SoftwareDifferentialPressureSensor.h
index 86df2e1e72728cdc7f43df0652b16c465c11b3ac..84c9bf2e4b897b4c3b63b5488383977fc390d99c 100644
--- a/src/shared/sensors/analog/pressure/SoftwareDifferentialPressureSensor.h
+++ b/src/shared/sensors/analog/pressure/SoftwareDifferentialPressureSensor.h
@@ -23,6 +23,7 @@
 #pragma once
 
 #include <sensors/Sensor.h>
+#include <utils/KernelTime.h>
 
 namespace Boardcore
 {
@@ -67,7 +68,7 @@ public:
         float p1 = first_pressure_sensor->getLastSample().pressure;
         float p2 = second_pressure_sensor->getLastSample().pressure;
 
-        return PressureData{miosix::getTick(), p1 - p2};
+        return PressureData{Kernel::getOldTick(), p1 - p2};
     }
 
 private:
diff --git a/src/shared/utils/Debug.h b/src/shared/utils/Debug.h
index 9056bcdbd40b3d845e95aa9776d0457c8585f79b..8bcf585703b336e4dc8a8ce0feec480e572e96df 100644
--- a/src/shared/utils/Debug.h
+++ b/src/shared/utils/Debug.h
@@ -24,6 +24,7 @@
 
 #ifdef DEBUG
 #include <miosix.h>
+#include <utils/KernelTime.h>
 
 #include <cstdarg>
 #include <cstdio>
@@ -42,13 +43,13 @@ inline void TRACE(const char* format, ...)
     va_list argptr;
     va_start(argptr, format);
 
-    printf("%.2f> ", miosix::getTick() / 1000.0f);
+    printf("%.2f> ", Boardcore::Kernel::getOldTick() / 1000.0f);
     vprintf(format, argptr);
 
     va_end(argptr);
 }
 
-// #define TRACE(...) printf("%.2f> ", miosix::getTick()/1000.0f);
+// #define TRACE(...) printf("%.2f> ", Boardcore::Kernel::getOldTick()/1000.0f);
 // printf(__VA_ARGS__)
 
 #else
diff --git a/src/shared/utils/TestUtils/TestHelper.cpp b/src/shared/utils/TestUtils/TestHelper.cpp
index 6d0111bd1ab69255962dc27b49961a53337c2f9d..ed67fccf551e862b60c7f1ee0dbbdf3e1a912314 100644
--- a/src/shared/utils/TestUtils/TestHelper.cpp
+++ b/src/shared/utils/TestUtils/TestHelper.cpp
@@ -22,13 +22,17 @@
 
 #include "TestHelper.h"
 
-namespace Boardcore
-{
+#include <events/utils/EventCounter.h>
+#include <utils/KernelTime.h>
+
+#include <cmath>
 
-long long tickToMilliseconds(long long tick)
+using miosix::FastMutex;
+using miosix::getTime;
+using miosix::Lock;
+
+namespace Boardcore
 {
-    return tick * 1000 / miosix::TICK_FREQ;
-}
 
 bool expectEvent(uint8_t eventId, uint8_t topic, long long when,
                  long long uncertainty, EventBroker& broker)
@@ -39,28 +43,25 @@ bool expectEvent(uint8_t eventId, uint8_t topic, long long when,
     long long windowStart = when - uncertainty;
     long long windowEnd   = when + uncertainty;
 
-    while (getTick() < windowEnd)
+    while (Kernel::getOldTick() < windowEnd)
     {
         if (c.getCount(eventId) > 0)
         {
-            long long recvTick = getTick();
+            long long recvTick = Kernel::getOldTick();
             if (recvTick < windowStart)
             {
                 TRACE(
                     "[expectEvent] Event %d on topic %d receveid %d ms before "
                     "the opening of "
                     "the window.\n",
-                    eventId, topic,
-                    static_cast<int>(
-                        tickToMilliseconds(windowStart - recvTick)));
+                    eventId, topic, static_cast<int>(windowStart - recvTick));
                 return false;
             }
             TRACE(
                 "[expectEvent] Event %d on topic %d received inside the "
                 "window, %d ms from "
                 "the target time.\n",
-                eventId, topic,
-                static_cast<int>(tickToMilliseconds(abs(recvTick - when))));
+                eventId, topic, static_cast<int>(abs(recvTick - when)));
 
             return true;
         }
@@ -80,8 +81,8 @@ bool waitForEvent(uint8_t event, uint8_t topic, long long timeout,
 {
     EventCounter c{broker};
     c.subscribe(topic);
-    long long end = getTick() + timeout;
-    while (timeout == 0 || getTick() < end)
+    long long end = Kernel::getOldTick() + timeout;
+    while (timeout == 0 || Kernel::getOldTick() < end)
     {
         if (c.getCount(event) > 0)
             return true;
diff --git a/src/shared/utils/TestUtils/TestHelper.h b/src/shared/utils/TestUtils/TestHelper.h
index 2e7592f4273969efca7d3ea6a4d38c70b7d02695..5c0bc73223e65e685e75be001c675946cb3db5ee 100644
--- a/src/shared/utils/TestUtils/TestHelper.h
+++ b/src/shared/utils/TestUtils/TestHelper.h
@@ -25,17 +25,8 @@
 #include <events/EventBroker.h>
 #include <events/FSM.h>
 #include <events/HSM.h>
-#include <events/utils/EventCounter.h>
 #include <miosix.h>
 
-#include <cmath>
-#include <map>
-
-using miosix::FastMutex;
-using miosix::getTick;
-using miosix::Lock;
-using std::map;
-
 namespace Boardcore
 {
 
@@ -45,11 +36,6 @@ namespace Boardcore
  */
 static const int EVENT_TIMING_UNCERTAINTY = 1;
 
-/**
- * @brief Helper function used convert system ticks to milliseconds
- */
-long long tickToMilliseconds(long long tick);
-
 /**
  * Tests if a specific transition occurs in a Finite State Machine
  * in response to an event.
@@ -176,7 +162,7 @@ bool testHSMAsyncTransition(HSM_type& hsm, const Event& ev, uint8_t topic,
  *
  * @param eventId The event to be checked
  * @param topic The topic the event will be posted on
- * @param when Expected time at which the event will be posted, in system ticks
+ * @param when Absolute system time the event will be posted at
  * @param uncertainty Size of the time window
  * @param broker
  * @return True if the event is posted inside the time window
diff --git a/src/shared/utils/TestUtils/TestSensor.h b/src/shared/utils/TestUtils/TestSensor.h
index 07b19e98b8c415c4f98e4388d1e42b02dec8414b..a2eebc7cf59a41d20d4dac5d9fb43055e227a6d0 100644
--- a/src/shared/utils/TestUtils/TestSensor.h
+++ b/src/shared/utils/TestUtils/TestSensor.h
@@ -26,6 +26,7 @@
 #include <sensors/Sensor.h>
 #include <utils/Constants.h>
 #include <utils/Debug.h>
+#include <utils/KernelTime.h>
 
 #include <cmath>
 
@@ -37,12 +38,12 @@ struct TestData : public TimestampData
     float value;
 
     TestData(float v)
-        : TimestampData{static_cast<uint64_t>(miosix::getTick())}, value(v)
+        : TimestampData{static_cast<uint64_t>(Kernel::getOldTick())}, value(v)
     {
     }
 
     TestData()
-        : TimestampData{static_cast<uint64_t>(miosix::getTick())}, value(0.0)
+        : TimestampData{static_cast<uint64_t>(Kernel::getOldTick())}, value(0.0)
     {
     }
 };
@@ -60,9 +61,8 @@ public:
     TestData sampleImpl() override
     {
         TRACE("[TestSensor] sampleImpl() \n");
-        return TestData(
-            10 * sin(Constants::PI * static_cast<float>(miosix::getTick()) /
-                     static_cast<float>(miosix::TICK_FREQ)));
+        return TestData(10 *
+                        sin(Constants::PI * (Kernel::getOldTick() / 1000.f)));
     }
 };
 
diff --git a/src/shared/utils/TestUtils/ThroughputCalculator.h b/src/shared/utils/TestUtils/ThroughputCalculator.h
index 6de5a3fe071ad49f9503cc4622bc013adbded170..bc61cdaf0e5f4620f9be7f9d68201a6dedc7ac8e 100644
--- a/src/shared/utils/TestUtils/ThroughputCalculator.h
+++ b/src/shared/utils/TestUtils/ThroughputCalculator.h
@@ -23,6 +23,7 @@
 #pragma once
 
 #include <miosix.h>
+#include <utils/KernelTime.h>
 
 #include <deque>
 #include <limits>
@@ -53,9 +54,10 @@ public:
      * @brief Creates a new ThroughputCalculator
      *
      * @param expectedPktInterval Expected packet delivery interval for packet
-     * loss estimation
-     * @param windowDuration Duration of the observation window. Longer windows
-     * means more stable values but slow response to abrupt changes
+     * loss estimation in milliseconds
+     * @param windowDuration Duration of the observation window in milliseconds.
+     * Longer windows means more stable values but slow response to abrupt
+     * changes
      */
     ThroughputCalculator(unsigned int expectedPktInterval,
                          unsigned int windowDuration = 2000)
@@ -74,7 +76,7 @@ public:
     {
         Lock<FastMutex> lock(mutexPkt);
 
-        long long ts = miosix::getTick();
+        long long ts = Kernel::getOldTick();
 
         unsigned int interval = 0;
         if (packets.size() > 0)
@@ -95,7 +97,7 @@ public:
     {
         Lock<FastMutex> lock(mutexPkt);
 
-        long long ts = miosix::getTick();
+        long long ts = Kernel::getOldTick();
         removeOldPackets(ts);
 
         float sum = 0;
@@ -113,7 +115,7 @@ public:
     float getPacketLoss()
     {
         Lock<FastMutex> lock(mutexPkt);
-        long long ts = miosix::getTick();
+        long long ts = Kernel::getOldTick();
         removeOldPackets(ts);
 
         float avgInterval = std::numeric_limits<float>::infinity();
@@ -137,7 +139,7 @@ public:
     float getPacketsPerSecond()
     {
         Lock<FastMutex> lock(mutexPkt);
-        long long ts = miosix::getTick();
+        long long ts = Kernel::getOldTick();
         removeOldPackets(ts);
 
         return (float)packets.size() / (windowDuration / 1000.0f);
@@ -170,8 +172,10 @@ private:
         }
     }
 
-    unsigned int expectedPktInterval;
-    unsigned int windowDuration;
+    unsigned int expectedPktInterval;  //!< Expected packet delivery interval in
+                                       //!< milliseconds
+    unsigned int windowDuration;  //!< Duration of the observation window in
+                                  //!< milliseconds
     deque<Packet> packets;
 
     FastMutex mutexPkt;
diff --git a/src/shared/utils/gui/ScreenManager.h b/src/shared/utils/gui/ScreenManager.h
index ce731f437f638bdf904b44e0f5d1fb89ff11a69b..8e69bb22c7db16931991c87d5e84b2e2adeab718 100644
--- a/src/shared/utils/gui/ScreenManager.h
+++ b/src/shared/utils/gui/ScreenManager.h
@@ -23,6 +23,7 @@
 #pragma once
 
 #include <miosix.h>
+#include <utils/KernelTime.h>
 
 #include <deque>
 #include <map>
@@ -82,11 +83,11 @@ protected:
                 screens[activeScreen]->invalidateTree();
             }
 
-            long long start = miosix::getTick();
+            long long start = Kernel::getOldTick();
 
             drawViewTree(screens[activeScreen], dc);
 
-            miosix::Thread::sleepUntil(start + refreshInterval);
+            Kernel::Thread::sleepUntil(start + refreshInterval);
         }
     }
 
@@ -119,7 +120,7 @@ private:
 
     mxgui::DrawingContext dc;
 
-    unsigned int refreshInterval;
+    unsigned int refreshInterval;  ///< Refresh interval in ms
 
     NavController controller;
     std::map<uint8_t, View*> screens;
diff --git a/src/tests/actuators/test-hbridge.cpp b/src/tests/actuators/test-hbridge.cpp
index a2aa0438aa91015c899273a37c38ff87458def55..64cd57ba8c5cdb5cb62c9ef997cd816c27e344a8 100644
--- a/src/tests/actuators/test-hbridge.cpp
+++ b/src/tests/actuators/test-hbridge.cpp
@@ -23,6 +23,7 @@
 #include <actuators/HBridge/HBridge.h>
 #include <miosix.h>
 #include <utils/Debug.h>
+#include <utils/KernelTime.h>
 
 #include <iostream>
 #include <sstream>
@@ -45,14 +46,14 @@ long long measuredTime = 0;
 
 void wait()
 {
-    long long t  = getTick();
+    long long t  = Kernel::getOldTick();
     long long t0 = t;
 
     while (t < t0 + PWM_DURATION)
     {
         Thread::sleep(50);
 
-        t = getTick();
+        t = Kernel::getOldTick();
 
         if (print)
         {
diff --git a/src/tests/algorithms/NAS/test-triad-parafoil.cpp b/src/tests/algorithms/NAS/test-triad-parafoil.cpp
index d3dadc04fe00b89dfcd50293ee4f293b63c7e2c4..e8b323f2e18edbb99a41c52c9035b3c8b4c7e5eb 100644
--- a/src/tests/algorithms/NAS/test-triad-parafoil.cpp
+++ b/src/tests/algorithms/NAS/test-triad-parafoil.cpp
@@ -26,6 +26,7 @@
 #include <sensors/SensorManager.h>
 #include <sensors/calibration/SensorDataExtra/SensorDataExtra.h>
 #include <sensors/calibration/SoftAndHardIronCalibration/SoftAndHardIronCalibration.h>
+#include <utils/KernelTime.h>
 
 #include <cmath>
 #include <iostream>
@@ -47,7 +48,7 @@ int main()
     mpu = new MPU9250(spi1, sensors::mpu9250::cs::getPin());
     mpu->init();
 
-    auto lastTick = getTick();
+    auto lastTick = Kernel::getOldTick();
     while (true)
     {
         mpu->sample();
@@ -73,7 +74,7 @@ int main()
             printf("w%fwa%fab%fbc%fc\n", kalmanState(9), kalmanState(6),
                    kalmanState(7), kalmanState(8));
 
-        Thread::sleepUntil(lastTick + 20);
-        lastTick = getTick();
+        Kernel::Thread::sleepUntil(lastTick + 20);
+        lastTick = Kernel::getOldTick();
     }
 }
diff --git a/src/tests/algorithms/NAS/test-triad.cpp b/src/tests/algorithms/NAS/test-triad.cpp
index af38fb8562e36b60441361b22df41c31715a1645..c9f7b6d119fdb719a3ec09894bac2a464d53ced1 100644
--- a/src/tests/algorithms/NAS/test-triad.cpp
+++ b/src/tests/algorithms/NAS/test-triad.cpp
@@ -26,6 +26,7 @@
 #include <sensors/SensorManager.h>
 #include <sensors/calibration/SensorDataExtra/SensorDataExtra.h>
 #include <sensors/calibration/SoftAndHardIronCalibration/SoftAndHardIronCalibration.h>
+#include <utils/KernelTime.h>
 
 #include <cmath>
 #include <iostream>
@@ -46,7 +47,7 @@ int main()
     imuInit();
     bmx->init();
 
-    auto lastTick = getTick();
+    auto lastTick = Kernel::getOldTick();
     while (true)
     {
         bmx->sample();
@@ -72,8 +73,8 @@ int main()
             printf("w%fwa%fab%fbc%fc\n", kalmanState(9), kalmanState(6),
                    kalmanState(7), kalmanState(8));
 
-        Thread::sleepUntil(lastTick + 20);
-        lastTick = getTick();
+        Kernel::Thread::sleepUntil(lastTick + 20);
+        lastTick = Kernel::getOldTick();
     }
 }
 
diff --git a/src/tests/catch/test-eventbroker.cpp b/src/tests/catch/test-eventbroker.cpp
index 9590563db8b32f2c7694cc4dd4a287580068193d..f498189431e59c3191596bfc80dbfad7f66a4582 100644
--- a/src/tests/catch/test-eventbroker.cpp
+++ b/src/tests/catch/test-eventbroker.cpp
@@ -28,13 +28,14 @@
 #endif
 
 #include <events/EventBroker.h>
+#include <events/utils/EventCounter.h>
 #include <miosix.h>
+#include <utils/KernelTime.h>
 #include <utils/TestUtils/TestHelper.h>
 
 #include <catch2/catch.hpp>
 #include <cstdio>
 
-using miosix::getTick;
 using miosix::Thread;
 
 using namespace Boardcore;
@@ -208,7 +209,7 @@ protected:
 TEST_CASE_METHOD(EventBrokerTestFixture, "EventBroker - Events can be dalayed")
 {
     Event ev{EV_A};
-    long long start = getTick();
+    long long start = Kernel::getOldTick();
 
     // Post delayed event by 1000 ms
     broker.postDelayed(ev, TOPIC_1, 1000);
@@ -222,7 +223,7 @@ TEST_CASE_METHOD(EventBrokerTestFixture,
                  "EventBroker - Delayed events can be removed")
 {
     Event ev{EV_A};
-    long long start = getTick();
+    long long start = Kernel::getOldTick();
 
     // Post delayed event by 1000 ms
     uint16_t delayed = broker.postDelayed(ev, TOPIC_1, 1000);
diff --git a/src/tests/drivers/canbus/CanDriver/SimpleCanManager.h b/src/tests/drivers/canbus/CanDriver/SimpleCanManager.h
index 141c5a60e2fe12c72607cd171f35231313874559..991c9b96a1af3910858e12536e202deb6ea6b92e 100644
--- a/src/tests/drivers/canbus/CanDriver/SimpleCanManager.h
+++ b/src/tests/drivers/canbus/CanDriver/SimpleCanManager.h
@@ -26,6 +26,7 @@
 #include <drivers/canbus/CanDriver/BusLoadEstimation.h>
 #include <drivers/canbus/CanDriver/CanDriver.h>
 #include <miosix.h>
+#include <utils/KernelTime.h>
 #include <utils/collections/SyncCircularBuffer.h>
 
 #include <cstdlib>
@@ -88,7 +89,7 @@ private:
                 }
                 Boardcore::Canbus::CanPacket p = parent.txPackets.pop();
                 parent.canbus.send(p);
-                p.timestamp = miosix::getTick();
+                p.timestamp = Boardcore::Kernel::getOldTick();
                 parent.busLoad.addPacket(p);
             }
         }
diff --git a/src/tests/drivers/canbus/CanDriver/test-can-2way.cpp b/src/tests/drivers/canbus/CanDriver/test-can-2way.cpp
index 3fd1440dd945e7d2fb69dda142fe5972884fcad6..27a5f6190cee47a888abebe4659eb9e7df7fe608 100644
--- a/src/tests/drivers/canbus/CanDriver/test-can-2way.cpp
+++ b/src/tests/drivers/canbus/CanDriver/test-can-2way.cpp
@@ -84,7 +84,7 @@ void handleCanMessage(Canbus::CanRXPacket packet)
             if (msg.id == packet.packet.id)
             {
                 msg.id = 0;
-                msg.ts = getTick() - msg.ts;
+                msg.ts = Kernel::getOldTick() - msg.ts;
                 break;
             }
         }
@@ -114,7 +114,7 @@ void sendNewRequest()
 
     {
         Lock<FastMutex> l(mutexMsgs);
-        msgs.put({packet.id, (uint32_t)getTick()});
+        msgs.put({packet.id, (uint32_t)Kernel::getOldTick()});
     }
 
     canManager->send(packet);
@@ -128,7 +128,7 @@ public:
         unsigned int c = 0;
         while (!shouldStop())
         {
-            uint32_t tick = (uint32_t)getTick();
+            uint32_t tick = (uint32_t)Kernel::getOldTick();
             {
                 Lock<FastMutex> l(mutexMsgs);
                 if (msgs.isFull())
@@ -184,7 +184,7 @@ public:
                     info.loadPercent);
             }
             ++c;
-            Thread::sleepUntil(tick + MSG_DEADLINE);
+            Kernel::Thread::sleepUntil(tick + MSG_DEADLINE);
         }
     }
 
diff --git a/src/tests/drivers/canbus/CanDriver/test-can-filters.cpp b/src/tests/drivers/canbus/CanDriver/test-can-filters.cpp
index b6c3f6b667ffcac3ff1021d99634f5430ec08b78..3be71dbab2e7be6d5ee44ee0d1297e45c5169356 100644
--- a/src/tests/drivers/canbus/CanDriver/test-can-filters.cpp
+++ b/src/tests/drivers/canbus/CanDriver/test-can-filters.cpp
@@ -24,6 +24,7 @@
 #include <diagnostic/PrintLogger.h>
 #include <drivers/canbus/CanDriver/BusLoadEstimation.h>
 #include <drivers/canbus/CanDriver/CanDriver.h>
+#include <utils/KernelTime.h>
 
 #include <string>
 
@@ -109,7 +110,7 @@ int main()
 
     for (;;)
     {
-        p.timestamp = miosix::getTick();
+        p.timestamp = Kernel::getOldTick();
 
         p.id = 365854720;
         c->send(p);
diff --git a/src/tests/drivers/canbus/CanDriver/test-can-loopback.cpp b/src/tests/drivers/canbus/CanDriver/test-can-loopback.cpp
index 06559020e6eaee2e933d2ce66696ec2a1c5baf44..f8ae585aa82387c48bc7f7fd2843eb3df54813be 100644
--- a/src/tests/drivers/canbus/CanDriver/test-can-loopback.cpp
+++ b/src/tests/drivers/canbus/CanDriver/test-can-loopback.cpp
@@ -24,6 +24,7 @@
 #include <diagnostic/PrintLogger.h>
 #include <drivers/canbus/CanDriver/BusLoadEstimation.h>
 #include <drivers/canbus/CanDriver/CanDriver.h>
+#include <utils/KernelTime.h>
 
 #include <string>
 
@@ -64,14 +65,14 @@ public:
     {
         while (!shouldStop())
         {
-            long long start                     = miosix::getTick();
+            long long start                     = Kernel::getOldTick();
             BusLoadEstimation::BusLoadInfo info = ble.getLoadInfo();
             LOG_INFO(l,
                      "payload rate: {:.2f} kbps, total rate: {:.2f} kbps, "
                      "utilization: {:.2f}%",
                      info.payloadBitRate / 1000.0f, info.totalBitRate / 1000.0f,
                      info.loadPercent);
-            Thread::sleepUntil(start + 1000);
+            Kernel::Thread::sleepUntil(start + 1000);
         }
     }
 
@@ -122,7 +123,7 @@ int main()
     {
 
         // printPacket("TX", p);
-        p.timestamp = miosix::getTick();
+        p.timestamp = Kernel::getOldTick();
         c->send(p);
         load.addPacket(p);
         // Thread::sleep(1);
diff --git a/src/tests/drivers/test-dsgamma.cpp b/src/tests/drivers/test-dsgamma.cpp
index 1445ae8a674aaa467b3713faf1f8eef368ab9694..e454bb5b028c35e4458450b23c4d0a790017aa51 100644
--- a/src/tests/drivers/test-dsgamma.cpp
+++ b/src/tests/drivers/test-dsgamma.cpp
@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <utils/Debug.h>
+#include <utils/KernelTime.h>
 
 using namespace Boardcore;
 using namespace std;
@@ -95,12 +96,12 @@ int main()
                     if (c == 255)
                     {
                         TRACE("Starting!\n", 0);
-                        startT = miosix::getTick();
+                        startT = Kernel::getOldTick();
                         // printf("%c", c);
                         //  inputBuf[index] = c;
                         ++index;
                         state = ST_WAIT_END_FRAME;
-                        endT  = miosix::getTick();
+                        endT  = Kernel::getOldTick();
                     }
                     break;
                 }
@@ -140,7 +141,7 @@ int main()
                         printf("Packet end %d. lost: %d\n", pktCount,
                                lostBytes);
                         ++pktCount;
-                        // endT = miosix::getTick();
+                        // endT = Kernel::getOldTick();
                         state = ST_WAIT_START_FRAME;
                     }
 
@@ -156,7 +157,7 @@ int main()
                 }
                 case ST_SEND_DATA:
                 {
-                    endT = miosix::getTick();
+                    endT = Kernel::getOldTick();
                     end  = true;
                     break;
                     /*  uint8_t buf[] = {0x23, 0x23, 0x23, 0x23, 0x23};
diff --git a/src/tests/drivers/test-mavlink.cpp b/src/tests/drivers/test-mavlink.cpp
index 8e70f5a51d734894a0d0a4d42dd0d9a97964c744..9ef16888f6aa2df0fb8b01ad6102bcac23c0ccd8 100644
--- a/src/tests/drivers/test-mavlink.cpp
+++ b/src/tests/drivers/test-mavlink.cpp
@@ -63,7 +63,7 @@ int main()
     {
         // Create a Mavlink message
         mavlink_message_t pingMsg;
-        mavlink_msg_ping_tc_pack(1, 1, &pingMsg, miosix::getTick());
+        mavlink_msg_ping_tc_pack(1, 1, &pingMsg, Kernel::getOldTick());
 
         // Send the message
         mavlink->enqueueMsg(pingMsg);
diff --git a/src/tests/drivers/timer/test-counted-pwm.cpp b/src/tests/drivers/timer/test-counted-pwm.cpp
index 497f33a868dc16002ab73a87f5e23613fa1eaeca..1338389edad03bcdff5b168b3da0a1195f7af406 100644
--- a/src/tests/drivers/timer/test-counted-pwm.cpp
+++ b/src/tests/drivers/timer/test-counted-pwm.cpp
@@ -22,6 +22,7 @@
 
 #include <drivers/timer/CountedPWM.h>
 #include <miosix.h>
+#include <utils/KernelTime.h>
 
 #include <thread>
 
@@ -56,8 +57,8 @@ int main()
             while (true)
             {
                 printf("[%.2f] Counter: %d\tTarget: %ld\tIs generating: %d\n",
-                       getTick() / 1000.0, pwm.getCurrentCount(), TIM4->CCR1,
-                       pwm.isGenerating());
+                       Kernel::getOldTick() / 1000.0, pwm.getCurrentCount(),
+                       TIM4->CCR1, pwm.isGenerating());
                 Thread::sleep(250);
             }
         });
diff --git a/src/tests/drivers/timer/test-timestamptimer.cpp b/src/tests/drivers/timer/test-timestamptimer.cpp
index 3ba13168412061eafaff618405be23b7e1ecc240..3580a59f0b7000800c79002f40aa7e2d147972c3 100644
--- a/src/tests/drivers/timer/test-timestamptimer.cpp
+++ b/src/tests/drivers/timer/test-timestamptimer.cpp
@@ -23,6 +23,7 @@
 #include <drivers/timer/TimerUtils.h>
 #include <drivers/timer/TimestampTimer.h>
 #include <miosix.h>
+#include <utils/KernelTime.h>
 
 using namespace miosix;
 using namespace Boardcore;
@@ -43,7 +44,7 @@ int main()
 
     for (int i = 0; i < 10; i++)
     {
-        long long prevTick = getTick();
+        long long prevTick = Kernel::getOldTick();
 
         uint64_t timestamp = TimestampTimer::getTimestamp();
 
@@ -51,7 +52,7 @@ int main()
         printf("%12llu us, %12.3f ms, %12.6f s, %12lld tick \n", timestamp,
                timestamp / 1e3, timestamp / 1e6, prevTick);
 
-        Thread::sleepUntil(prevTick + 1000);
+        Kernel::Thread::sleepUntil(prevTick + 1000);
     }
 
     printf("Now resetting the TimestampTimer\n");
@@ -60,7 +61,7 @@ int main()
 
     while (true)
     {
-        long long prevTick = getTick();
+        long long prevTick = Kernel::getOldTick();
 
         uint64_t timestamp = TimestampTimer::getTimestamp();
 
@@ -68,7 +69,7 @@ int main()
         printf("%12llu us, %12.3f ms, %12.6f s, %12lld tick \n", timestamp,
                timestamp / 1e3, timestamp / 1e6, prevTick);
 
-        Thread::sleepUntil(prevTick + 1000);
+        Kernel::Thread::sleepUntil(prevTick + 1000);
     }
 }
 
diff --git a/src/tests/drivers/xbee/XbeeTransceiver.h b/src/tests/drivers/xbee/XbeeTransceiver.h
index 3e41850e557367880e47fde90bcd57fc11788527..085e218a03de00625baca9b3fa8d340dfb476a82 100644
--- a/src/tests/drivers/xbee/XbeeTransceiver.h
+++ b/src/tests/drivers/xbee/XbeeTransceiver.h
@@ -35,7 +35,6 @@
 #include "ActiveObject.h"
 #include "XbeeTestData.h"
 
-using miosix::getTick;
 using std::bind;
 using std::function;
 
@@ -111,22 +110,22 @@ public:
 protected:
     void run() override
     {
-        long long loopStartTs = miosix::getTick();
+        long long loopStartTs = Kernel::getOldTick();
         while (!shouldStop())
         {
-            data.timeSinceLastSend = miosix::getTick() - loopStartTs;
-            loopStartTs            = miosix::getTick();
+            data.timeSinceLastSend = Kernel::getOldTick() - loopStartTs;
+            loopStartTs            = Kernel::getOldTick();
 
             // Create packet
             memcpy(buf, &PACKET_FIRST_INT, sizeof(uint32_t));
             memset32(buf + sizeof(uint32_t), packetCounter++,
                      data.packetSize - sizeof(uint32_t));
 
-            long long sendStartTs = miosix::getTick();
+            long long sendStartTs = Kernel::getOldTick();
 
             bool result = xbee.send(buf, data.packetSize);
 
-            data.timeToSend = miosix::getTick() - sendStartTs;
+            data.timeToSend = Kernel::getOldTick() - sendStartTs;
             data.timestamp  = sendStartTs;
 
             if (result)
@@ -141,7 +140,7 @@ protected:
 
             logger.log(data);
 
-            miosix::Thread::sleepUntil(loopStartTs + interval.getInterval());
+            Kernel::Thread::sleepUntil(loopStartTs + interval.getInterval());
         }
     }
 
@@ -183,11 +182,11 @@ protected:
     {
         while (!shouldStop())
         {
-            long long start = miosix::getTick();
+            long long start = Kernel::getOldTick();
 
             size_t len = xbee.receive(buf, RCV_BUF_SIZE);
 
-            data.lastPacketTimestamp = miosix::getTick();
+            data.lastPacketTimestamp = Kernel::getOldTick();
             data.timestamp           = start;
 
             ++data.rcvCount;
diff --git a/src/tests/drivers/xbee/gui/StatusScreen.h b/src/tests/drivers/xbee/gui/StatusScreen.h
index 1c7a40b5c196ffe7ab85fbe6e87eddaa8265dc79..b79055d9b342c938a3cce93d573664aa9dae5cff 100644
--- a/src/tests/drivers/xbee/gui/StatusScreen.h
+++ b/src/tests/drivers/xbee/gui/StatusScreen.h
@@ -24,6 +24,7 @@
 
 #include <logger/Logger.h>
 #include <mxgui/display.h>
+#include <utils/KernelTime.h>
 #include <utils/TestUtils/ThroughputCalculator.h>
 #include <utils/gui/GridLayout.h>
 #include <utils/gui/OptionView.h>
@@ -255,7 +256,7 @@ struct StatusScreen
         tvRxPps.setText(strBuf);
 
         tvRxTimeSinceLastRx.setText(
-            tickToHMS(miosix::getTick() - rxd.lastPacketTimestamp));
+            tickToHMS(Kernel::getOldTick() - rxd.lastPacketTimestamp));
     }
 
     VerticalLayout root{10};
diff --git a/src/tests/drivers/xbee/test-xbee-bidir.cpp b/src/tests/drivers/xbee/test-xbee-bidir.cpp
index def6764fda67deaf5aa1bae13881ea50e9ccdf03..2066c9bd9782600f41d414dcc0808c0812e5689e 100644
--- a/src/tests/drivers/xbee/test-xbee-bidir.cpp
+++ b/src/tests/drivers/xbee/test-xbee-bidir.cpp
@@ -33,6 +33,7 @@
 #include <radio/Xbee/APIFramesLog.h>
 #include <radio/Xbee/ATCommands.h>
 #include <radio/Xbee/Xbee.h>
+#include <utils/KernelTime.h>
 
 #include <cstdio>
 #include <stdexcept>
@@ -161,7 +162,7 @@ int main()
     config.packetSize   = 256;
     config.sendInterval = 333;
     config.txEnabled    = RUN_SENDER;
-    config.timestamp    = getTick();
+    config.timestamp    = Kernel::getOldTick();
 
     configure();
 
@@ -209,7 +210,7 @@ int main()
     // cppcheck-suppress knownConditionTrueFalse
     while (getUserBtnValue() == 0)
     {
-        long long loopStart = getTick();
+        long long loopStart = Kernel::getOldTick();
 
         DataRateResult resRcv = trans->getReceiver().getDataRate();
         DataRateResult resSnd = trans->getSender().getDataRate();
@@ -220,7 +221,7 @@ int main()
         logger.log(xbeeDriver->getStatus());
         logger.log(logger.getStats());
 
-        long long tick = getTick();
+        long long tick = Kernel::getOldTick();
         unsigned int h = tick / (1000 * 3600);
         unsigned int m = (tick - h * 1000 * 3600) / (1000 * 60);
         float s        = (tick - h * 1000 * 3600 - m * 1000 * 60) / 1000.0f;
@@ -245,7 +246,7 @@ int main()
         }
         printf("\n");
 
-        Thread::sleepUntil(loopStart + 1000);
+        Kernel::Thread::sleepUntil(loopStart + 1000);
     }
 
     trans->stop();
diff --git a/src/tests/drivers/xbee/test-xbee-gui.cpp b/src/tests/drivers/xbee/test-xbee-gui.cpp
index bc0d694aa9c2b460f7304bdb4d213ea7c169235b..7a7309ae904cc7beef2a6ba3fa5239a766641ec8 100644
--- a/src/tests/drivers/xbee/test-xbee-gui.cpp
+++ b/src/tests/drivers/xbee/test-xbee-gui.cpp
@@ -28,6 +28,7 @@
 #include <radio/Xbee/ATCommands.h>
 #include <radio/Xbee/Xbee.h>
 #include <utils/ButtonHandler/ButtonHandler.h>
+#include <utils/KernelTime.h>
 
 #include <array>
 #include <cstdio>
@@ -105,7 +106,7 @@ protected:
 
                 gui->screenEnergy.updateScan(scan);
 
-                EnergyScanData data{getTick(), scan};
+                EnergyScanData data{Kernel::getOldTick(), scan};
                 logger.log(data);
             }
         }
@@ -180,7 +181,7 @@ int main()
     // Main loop: updates the information in the GUI
     for (;;)
     {
-        long long start = getTick();
+        long long start = Kernel::getOldTick();
         // Update display values
         switch (gui->screenManager.getScreen())
         {
@@ -209,7 +210,7 @@ int main()
         }
 
         logger.log(logger.getStats());
-        Thread::sleepUntil(start + 500);
+        Kernel::Thread::sleepUntil(start + 500);
     }
 }
 
@@ -219,7 +220,7 @@ void onStartButtonClick(View* btn __attribute__((unused)), Interaction action)
     {
 
         XbeeConfig cfg = gui->screenConfig.config;
-        cfg.timestamp  = getTick();
+        cfg.timestamp  = Kernel::getOldTick();
         logger.log(cfg);
 
         gui->screenConfig.btnStart.setText("Starting...");
@@ -265,7 +266,7 @@ void onMarkButtonClick(View* btn __attribute__((unused)), Interaction action)
 {
     if (action == Interaction::CLICK)
     {
-        Mark m{getTick(), markCounter++};
+        Mark m{Kernel::getOldTick(), markCounter++};
         logger.log(m);
 
         TextView* tvBtn = dynamic_cast<TextView*>(btn);
diff --git a/src/tests/logger/test-logger.cpp b/src/tests/logger/test-logger.cpp
index a22753780bcfb70d7ef88080e3474cc7cd4898fe..49f61ff2eb980a21422a4fcc0e481650d2da11db 100644
--- a/src/tests/logger/test-logger.cpp
+++ b/src/tests/logger/test-logger.cpp
@@ -24,6 +24,7 @@
 
 #include <diagnostic/CpuMeter/CpuMeter.h>
 #include <logger/Logger.h>
+#include <utils/KernelTime.h>
 
 using namespace Boardcore;
 using namespace std;
@@ -33,9 +34,9 @@ void logThread(void*)
 {
     Logger& log      = Logger::getInstance();
     const int period = 5;
-    for (auto t = getTick();; t += period)
+    for (auto t = Kernel::getOldTick();; t += period)
     {
-        Thread::sleepUntil(t);
+        Kernel::Thread::sleepUntil(t);
         for (int i = 0; i < 5; i++)
         {
             Dummy d;
diff --git a/src/tests/logger/test-logger.h b/src/tests/logger/test-logger.h
index 3bfddd562b1bb6f859b245ef9b3b023c0a649b1d..0aabc6e0308a9c32b6d154e8b84271409dd33197 100644
--- a/src/tests/logger/test-logger.h
+++ b/src/tests/logger/test-logger.h
@@ -27,6 +27,7 @@
 
 #ifdef _MIOSIX
 #include <miosix.h>
+#include <utils/KernelTime.h>
 #endif  //_MIOSIX
 
 namespace Boardcore
@@ -38,7 +39,7 @@ public:
     Dummy()
     {
 #ifdef _MIOSIX
-        timestamp = miosix::getTick();
+        timestamp = Kernel::getOldTick();
 #else   //_MIOSIX
         timestamp = 0;
 #endif  //_MIOSIX
diff --git a/src/tests/radio/sx1278/fsk/test-sx1278-mavlink.cpp b/src/tests/radio/sx1278/fsk/test-sx1278-mavlink.cpp
index 794a7378cbfa51eb08e0afd0f2ff19040e215d9b..fcf6a8e4db76a48d32a8f12be6e3c856fff5c40f 100644
--- a/src/tests/radio/sx1278/fsk/test-sx1278-mavlink.cpp
+++ b/src/tests/radio/sx1278/fsk/test-sx1278-mavlink.cpp
@@ -24,6 +24,7 @@
 #include <drivers/timer/TimestampTimer.h>
 #include <radio/SX1278/SX1278Frontends.h>
 #include <radio/SX1278/SX1278Fsk.h>
+#include <utils/KernelTime.h>
 #include <utils/collections/CircularBuffer.h>
 
 #include <thread>
@@ -176,7 +177,7 @@ void flightTmLoop()
 
     while (1)
     {
-        long long start = miosix::getTick;
+        long long start = Kernel::getOldTick();
 
         {
             Lock<FastMutex> l(mutex);
@@ -204,7 +205,7 @@ void flightTmLoop()
 
         channel->enqueueMsg(msg);
 
-        Thread::sleepUntil(start + FLIGHT_TM_PERIOD);
+        Kernel::Thread::sleepUntil(start + FLIGHT_TM_PERIOD);
         i += 1;
     }
 }
diff --git a/src/tests/radio/sx1278/lora/test-sx1278-mavlink.cpp b/src/tests/radio/sx1278/lora/test-sx1278-mavlink.cpp
index 38398038442bab4e9df06774eef23d7be96ca75b..0ccf2f6e2b778f4d876a93c87992be782d3b075e 100644
--- a/src/tests/radio/sx1278/lora/test-sx1278-mavlink.cpp
+++ b/src/tests/radio/sx1278/lora/test-sx1278-mavlink.cpp
@@ -23,6 +23,7 @@
 #include <drivers/interrupt/external_interrupts.h>
 #include <radio/SX1278/SX1278Frontends.h>
 #include <radio/SX1278/SX1278Lora.h>
+#include <utils/KernelTime.h>
 
 #include <thread>
 
@@ -136,7 +137,7 @@ void flightTmLoop()
 {
     while (1)
     {
-        long long start = miosix::getTick();
+        long long start = Kernel::getOldTick();
 
         mavlink_message_t msg;
         mavlink_rocket_flight_tm_t tm = {0};
@@ -145,7 +146,7 @@ void flightTmLoop()
         channel->enqueueMsg(msg);
         printf("Enqueued flight_tm_tm!\n");
 
-        Thread::sleepUntil(start + FLIGHT_TM_PERIOD);
+        Kernel::Thread::sleepUntil(start + FLIGHT_TM_PERIOD);
     }
 }
 
@@ -153,7 +154,7 @@ void statsTmLoop()
 {
     while (1)
     {
-        long long start = miosix::getTick();
+        long long start = Kernel::getOldTick();
 
         mavlink_message_t msg;
         mavlink_rocket_stats_tm_t tm = {0};
@@ -162,7 +163,7 @@ void statsTmLoop()
         channel->enqueueMsg(msg);
         printf("Enqueued stats_tm!\n");
 
-        Thread::sleepUntil(start + STATS_TM_PERIOD);
+        Kernel::Thread::sleepUntil(start + STATS_TM_PERIOD);
     }
 }
 
diff --git a/src/tests/sensors/test-l3gd20-fifo.cpp b/src/tests/sensors/test-l3gd20-fifo.cpp
index faa927dbb0f1cbd1b7791821286eb5f06fa0a2e0..ffd75c0409838c05d2e57c398f28d217d65755b2 100644
--- a/src/tests/sensors/test-l3gd20-fifo.cpp
+++ b/src/tests/sensors/test-l3gd20-fifo.cpp
@@ -54,6 +54,7 @@
 #include <drivers/timer/GeneralPurposeTimer.h>
 #include <drivers/timer/TimestampTimer.h>
 #include <sensors/L3GD20/L3GD20.h>
+#include <utils/KernelTime.h>
 
 #include <array>
 
@@ -166,7 +167,7 @@ int main()
     int fifoNum = 0;
     while (dataCounter < NUM_SAMPLES)
     {
-        long lastTick = miosix::getTick();
+        long lastTick = Kernel::getOldTick();
 
         // Read the fifo
         uint64_t update = TimestampTimer::getTimestamp();
@@ -207,7 +208,7 @@ int main()
         // we have 7 samples (~ 9 ms) of wiggle room before we start losing
         // data, in case we sleep a bit too much (may happen if an higher
         // priority thread has a long task to perform)
-        Thread::sleepUntil(lastTick + 25.5 * 1000 / SAMPLE_FREQUENCY);
+        Kernel::Thread::sleepUntil(lastTick + 25.5 * 1000 / SAMPLE_FREQUENCY);
     }
 
     // Dump buffer content as CSV on the serial (might take a while)
diff --git a/src/tests/sensors/test-l3gd20.cpp b/src/tests/sensors/test-l3gd20.cpp
index 1ce300bf7a435490c3afc4ecb11e284d40d2bbf3..8d5b573849513728cc9b8822f233fe98dfb34785 100644
--- a/src/tests/sensors/test-l3gd20.cpp
+++ b/src/tests/sensors/test-l3gd20.cpp
@@ -33,6 +33,7 @@
 #include <drivers/spi/SPIDriver.h>
 #include <drivers/timer/TimestampTimer.h>
 #include <sensors/L3GD20/L3GD20.h>
+#include <utils/KernelTime.h>
 
 #include <array>
 
@@ -138,7 +139,7 @@ int main()
     // Collect NUM_SAMPLE samples
     while (dataCounter < NUM_SAMPLES)
     {
-        long lastTick = miosix::getTick();
+        long lastTick = Kernel::getOldTick();
 
         // Read data from the sensor
         gyro->sample();
@@ -152,7 +153,7 @@ int main()
 
         // Wait until SAMPLE_PERIOD milliseconds from the start of this
         // iteration have passed (SAMPLE_PERIOD = 1000 / SAMPLE_RATE)
-        Thread::sleepUntil(lastTick + 1000 / SAMPLE_RATE);
+        Kernel::Thread::sleepUntil(lastTick + 1000 / SAMPLE_RATE);
     }
 
     // Dump buffer content as CSV on the serial (might take a while)