AudioTimerZephyr.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTimerBase.h"
 
#if defined(IS_ZEPHYR) || defined(DOXYGEN)
 
#include <zephyr/kernel.h>
 
namespace audio_tools {
 
class AudioTimerDriverZephyr : public AudioTimerDriverBase {
 public:
  AudioTimerDriverZephyr() = default;
 
  ~AudioTimerDriverZephyr() { end(); }
 
  bool begin(repeating_timer_callback_t callback_f, uint32_t time,
             TimeUnit unit = MS) override {
    TRACED();
 
    if (callback_f == nullptr || time == 0) {
      LOGE("Invalid callback or time");
      return false;
    }
 
    // Stop any existing timer
    if (is_running) {
      end();
    }
 
    // Convert time to microseconds for Zephyr
    switch (unit) {
      case MS:
        period_us = static_cast<uint64_t>(time) * 1000ULL;
        break;
      case US:
        period_us = time;
        break;
      case HZ:
        // Convert Hz to microseconds: period = 1'000'000 / frequency
        period_us = (time > 0) ? (1000000ULL / static_cast<uint64_t>(time))
                               : 1000ULL;
        break;
    }
 
    if (period_us == 0) {
      period_us = 1;
    }
 
    LOGI("Timer every: %llu us", period_us);
 
    callback = callback_f;
 
    // Create the timer if needed
    if (!timer_initialized) {
      // Initialize timer and work item
      k_timer_init(&timer, timerExpiredCallback, nullptr);
      k_timer_user_data_set(&timer, this);
      k_work_init(&work, workCallback);
      timer_initialized = true;
    }
 
    // Start the timer: first expiration after period, then repeat every period
    k_timer_start(&timer, K_USEC(period_us), K_USEC(period_us));
    is_running = true;
 
    LOGD("Timer started");
    return true;
  }
 
  bool end() override {
    TRACED();
    if (is_running) {
      k_timer_stop(&timer);
      is_running = false;
      LOGD("Timer stopped");
    }
    return true;
  }
 
  void setTimerFunction(TimerFunction function) override {
    timer_function = function;
    LOGD("Timer function mode set to: %d", function);
  }
 
  void setIsSave(bool is_save) override {
    setTimerFunction(is_save ? TimerCallbackInThread : DirectTimerCallback);
  }
 
 protected:
  struct k_timer timer = {};
  struct k_work work = {};
  bool timer_initialized = false;
  bool is_running = false;
  repeating_timer_callback_t callback = nullptr;
  uint64_t period_us = 0;
  TimerFunction timer_function = DirectTimerCallback;
 
  inline void executeCallback() {
    if (callback != nullptr) {
      callback(callbackParameter());
    }
  }
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Winvalid-offsetof"
 
  static void workCallback(k_work* work_ptr) {
    auto* self = CONTAINER_OF(work_ptr, AudioTimerDriverZephyr, work);
    if (self != nullptr) {
      self->executeCallback();
    }
  }
 
  #pragma GCC diagnostic pop
 
 
  static void timerExpiredCallback(struct k_timer* timer_ptr) {
    auto* self = static_cast<AudioTimerDriverZephyr*>(
        k_timer_user_data_get(timer_ptr));
    if (self == nullptr) return;
 
    if (self->timer_function == TimerCallbackInThread) {
      k_work_submit(&self->work);
    } else {
      self->executeCallback();
    }
  }
};
 
using AudioTimerDriver = AudioTimerDriverZephyr;
 
}  // namespace audio_tools
 
#endif