delay.h

Go to the documentation of this file.

#pragma once
 
#ifndef __INC_FL_DELAY_H
#define __INC_FL_DELAY_H

 
#include "platforms/cycle_type.h"
#include "fl/stl/compiler_control.h"
#include "fl/stl/int.h"
#include "fl/stl/type_traits.h"
// ============================================================================
// Platform-specific includes via trampoline header
// ============================================================================
 
#include "platforms/delay.h"  // IWYU pragma: keep
#include "fl/stl/noexcept.h"
 
namespace fl {
 
namespace detail {

constexpr fl::u32 cycles_from_ns(fl::u32 ns, fl::u32 hz) FL_NOEXCEPT {
  // Round up: cycles = ceil(ns * hz / 1e9)
  // Using: (ns * hz + 999'999'999) / 1'000'000'000
  return ((fl::u64)ns * (fl::u64)hz + 999999999UL) / 1000000000UL;
}

constexpr fl::u32 cycles_from_ns_default(fl::u32 ns) FL_NOEXCEPT {
  return cycles_from_ns(ns, GET_CPU_FREQUENCY());
}
 
} // namespace detail

template<fl::u32 NS>
FASTLED_FORCE_INLINE void delayNanoseconds() FL_NOEXCEPT {
  // Delegate to platform-specific implementation with compile-time constant
  // Platform-specific delayNanoseconds_impl() functions are provided by platforms/delay.h
  delayNanoseconds_impl(NS);
}

void delayNanoseconds(fl::u32 ns) FL_NOEXCEPT;

void delayNanoseconds(fl::u32 ns, fl::u32 hz) FL_NOEXCEPT;
 
// ============================================================================
// Clock cycle-counted delay loop (delaycycles)
// ============================================================================

template<cycle_t CYCLES> void delaycycles() FL_NOEXCEPT;

template<cycle_t CYCLES> inline void delaycycles_min1() FL_NOEXCEPT {
  delaycycles<1>();
  delaycycles<CYCLES - 1>();
}
 
// ============================================================================
// Millisecond and Microsecond delay wrappers
// ============================================================================
 
namespace detail {

void delay_impl(u32 ms, bool run_async = true) FL_NOEXCEPT;
 
}  // namespace detail

template<int Dummy = 0>
inline void delay(u32 ms, bool run_async = true) FL_NOEXCEPT {
    (void)Dummy;
    detail::delay_impl(ms, run_async);
}

void delayMillis(u32 ms) FL_NOEXCEPT;

void delayMicroseconds(u32 us) FL_NOEXCEPT;

inline void delayUs(u32 us) FL_NOEXCEPT {
  delayMicroseconds(us);
}

inline void delayMs(u32 ms, bool run_async = true) FL_NOEXCEPT {
  detail::delay_impl(ms, run_async);
}

template<u32 NS> inline void delayNs() FL_NOEXCEPT {
  delayNanoseconds<NS>();
}

inline void delayNs(u32 ns) FL_NOEXCEPT {
  delayNanoseconds(ns);
}

inline void delayNs(u32 ns, u32 hz) FL_NOEXCEPT {
  delayNanoseconds(ns, hz);
}
 
}  // namespace fl
 
#endif // __INC_FL_DELAY_H