periodic_signal.hpp

Go to the documentation of this file.

#ifndef PERIODIC_SIGNAL_HPP
#define PERIODIC_SIGNAL_HPP
 
#include <algorithm>
#include <chrono>
#include <cmath>

enum class OperationMode {
    PERFECT_DELTAS,
    MEASURED_DELTAS,
};

 
class PeriodicSignal {
  public:
    explicit PeriodicSignal(int rate_limit_hz, OperationMode mode = OperationMode::MEASURED_DELTAS)
        : period_duration(std::chrono::duration<double>(1.0 / rate_limit_hz)),
          start_time(std::chrono::steady_clock::now()), signal_count(0), last_signal_time(start_time),
          last_delta_time(0.0), mode(mode) {}

    bool process_and_get_signal() {
        auto now = std::chrono::steady_clock::now();
 
        // Compute how many full periods have elapsed since start
        double elapsed_seconds = std::chrono::duration<double>(now - start_time).count();
        int expected_signal_count = static_cast<int>(elapsed_seconds / period_duration.count());
 
        // If we've reached or passed at least one new signal since last time
        if (expected_signal_count > signal_count) {
            // Move signal count to the latest one
            signal_count = expected_signal_count;
            last_delta_time = std::chrono::duration<double>(now - last_signal_time).count();
            last_signal_time = now;
            return true;
        }
        return false;
    }

    double get_last_delta_time() const {
        if (mode == OperationMode::PERFECT_DELTAS) {
            return period_duration.count();
        }
        return last_delta_time;
    }

    bool enough_time_has_passed() const {
        auto now = std::chrono::steady_clock::now();
        double elapsed_seconds = std::chrono::duration<double>(now - start_time).count();
        int expected_signal_count = static_cast<int>(elapsed_seconds / period_duration.count());
        return expected_signal_count > signal_count;
    }

    double get_cycle_progress() const {
        auto now = std::chrono::steady_clock::now();
        double elapsed_seconds = std::chrono::duration<double>(now - start_time).count();
        double cycle_position = std::fmod(elapsed_seconds, period_duration.count());
        return std::clamp(cycle_position / period_duration.count(), 0.0, 1.0);
    }
 
  private:
    OperationMode mode;
    std::chrono::duration<double> period_duration;
    std::chrono::steady_clock::time_point start_time;
    std::chrono::steady_clock::time_point last_signal_time;
    int signal_count;
    double last_delta_time;
};
 
#endif // PERIODIC_SIGNAL_HPP