non_blocking_delay.hpp

Go to the documentation of this file.

#ifndef SBL_CORE_PATTERNS_TIMING_NON_BLOCKING_DELAY_HPP_
#define SBL_CORE_PATTERNS_TIMING_NON_BLOCKING_DELAY_HPP_
 
/**
 * @file non_blocking_delay.hpp
 * @brief Non-blocking delay utilities for cooperative scheduling
 * @ingroup patterns
 *
 * Provides non-blocking delay mechanisms that allow other tasks
 * to run while waiting. Essential for building responsive embedded
 * systems without RTOS overhead.
 */
 
#include <sbl/hal/timing/system_time.hpp>
#include <cstdint>
 
namespace sbl {
namespace core {
namespace patterns {
namespace timing {
 
/**
 * @brief Simple non-blocking delay using system time
 *
 * Template-based non-blocking delay that uses HAL system time interface.
 * Applications typically use this through board-provided timing utilities.
 *
 * @tparam SystemTimeImpl HAL system time implementation
 */
template<typename SystemTimeImpl>
class NonBlockingDelay {
public:
    /**
     * @brief Constructor with delay period
     * @param delay_ms Delay period in milliseconds
     */
    explicit NonBlockingDelay(uint32_t delay_ms) 
        : period_(delay_ms), last_trigger_(0), active_(false) {}
    
    /**
     * @brief Start the delay timer
     */
    void start() {
        last_trigger_ = SystemTimeImpl::millis();
        active_ = true;
    }
    
    /**
     * @brief Check if delay period has elapsed
     * @return true if delay period has elapsed
     */
    bool ready() const {
        if (!active_) return false;
        return (SystemTimeImpl::millis() - last_trigger_) >= period_;
    }
    
    /**
     * @brief Reset the delay timer for next period
     */
    void reset() {
        last_trigger_ = SystemTimeImpl::millis();
    }
    
    /**
     * @brief Stop the delay timer
     */
    void stop() {
        active_ = false;
    }
    
    /**
     * @brief Check if timer is active
     */
    bool isActive() const {
        return active_;
    }
    
    /**
     * @brief Update delay period
     * @param delay_ms New delay period in milliseconds
     */
    void setPeriod(uint32_t delay_ms) {
        period_ = delay_ms;
    }
    
    /**
     * @brief Get current delay period
     * @return Current delay period in milliseconds
     */
    uint32_t getPeriod() const {
        return period_;
    }
 
private:
    uint32_t period_;       // Delay period in milliseconds
    uint32_t last_trigger_; // Last trigger time
    bool active_;           // Whether timer is active
};
 
/**
 * @brief Interval timer for periodic tasks
 *
 * Similar to NonBlockingDelay but automatically resets after each period.
 * Useful for periodic tasks like blinking LEDs, sampling sensors, etc.
 *
 * @tparam SystemTimeImpl HAL system time implementation
 */
template<typename SystemTimeImpl>
class IntervalTimer {
public:
    /**
     * @brief Constructor with interval period
     * @param interval_ms Interval period in milliseconds
     */
    explicit IntervalTimer(uint32_t interval_ms)
        : interval_(interval_ms), last_trigger_(0), active_(false) {}
    
    /**
     * @brief Start the interval timer
     */
    void start() {
        last_trigger_ = SystemTimeImpl::millis();
        active_ = true;
    }
    
    /**
     * @brief Check if interval has elapsed and auto-reset
     * @return true if interval has elapsed (resets automatically)
     */
    bool tick() {
        if (!active_) return false;
        
        uint32_t now = SystemTimeImpl::millis();
        if ((now - last_trigger_) >= interval_) {
            last_trigger_ = now;  // Auto-reset
            return true;
        }
        return false;
    }
    
    /**
     * @brief Stop the interval timer
     */
    void stop() {
        active_ = false;
    }
    
    /**
     * @brief Update interval period
     * @param interval_ms New interval in milliseconds
     */
    void setInterval(uint32_t interval_ms) {
        interval_ = interval_ms;
    }
    
    /**
     * @brief Get current interval
     * @return Current interval in milliseconds
     */
    uint32_t getInterval() const {
        return interval_;
    }
 
private:
    uint32_t interval_;     // Interval in milliseconds
    uint32_t last_trigger_; // Last trigger time
    bool active_;           // Whether timer is active
};
 
} // namespace timing
} // namespace patterns
} // namespace core
} // namespace sbl
 
#endif // SBL_CORE_PATTERNS_TIMING_NON_BLOCKING_DELAY_HPP_