fastled_delay.h

Go to the documentation of this file.

#pragma once
 
#ifndef __INC_FL_DELAY_H
#define __INC_FL_DELAY_H
 
#include "FastLED.h"
#include "fl/types.h"
#include "fl/force_inline.h"
#include "fl/int.h"

 
FASTLED_NAMESPACE_BEGIN
 
 
#if (!defined(NO_MINIMUM_WAIT) || (NO_MINIMUM_WAIT==0))

template<int WAIT> class CMinWait {
    fl::u16 mLastMicros;
 
public:
    CMinWait() { mLastMicros = 0; }

    void wait() {
        fl::u16 diff;
        do {
            diff = (micros() & 0xFFFF) - mLastMicros;
        } while(diff < WAIT);
    }

    void mark() { mLastMicros = micros() & 0xFFFF; }
};
 
#else
 
// if you keep your own FPS (and therefore don't call show() too quickly for pixels to latch), you may not want a minimum wait.
template<int WAIT> class CMinWait {
public:
    CMinWait() { }
    void wait() { }
    void mark() {}
};
 
#endif
 

 
// Default is now just 'nop', with special case for AVR
 
// ESP32 core has it's own definition of NOP, so undef it first
#ifdef ESP32
#undef NOP
#undef NOP2
#endif
 
#if defined(__AVR__)
#  define FL_NOP __asm__ __volatile__ ("cp r0,r0\n");
#  define FL_NOP2 __asm__ __volatile__ ("rjmp .+0");
#else
#  define FL_NOP __asm__ __volatile__ ("nop\n");
#  define FL_NOP2 __asm__ __volatile__ ("nop\n\t nop\n");
#endif
 
// predeclaration to not upset the compiler
 

template<fl::cycle_t CYCLES> inline void delaycycles();

template<fl::cycle_t CYCLES> inline void delaycycles_min1() {
    delaycycles<1>();
    delaycycles<CYCLES-1>();
}
 
 
// TODO: ARM version of _delaycycles_
 
// usable definition
#if defined(FASTLED_AVR)
// worker template - this will nop for LOOP * 3 + PAD cycles total
template<int LOOP, fl::cycle_t PAD> inline void _delaycycles_AVR() {
    delaycycles<PAD>();
    // the loop below is 3 cycles * LOOP.  the LDI is one cycle,
    // the DEC is 1 cycle, the BRNE is 2 cycles if looping back and
    // 1 if not (the LDI balances out the BRNE being 1 cycle on exit)
    __asm__ __volatile__ (
        "       LDI R16, %0\n"
        "L_%=:  DEC R16\n"
        "       BRNE L_%=\n"
        : /* no outputs */
        : "M" (LOOP)
        : "r16"
        );
}
 
template<fl::cycle_t CYCLES> FASTLED_FORCE_INLINE void delaycycles() {
    _delaycycles_AVR<CYCLES / 3, CYCLES % 3>();
}
 
 
 
#else
// template<int LOOP, fl::cycle_t PAD> inline void _delaycycles_ARM() {
//  delaycycles<PAD>();
//  // the loop below is 3 cycles * LOOP.  the LDI is one cycle,
//  // the DEC is 1 cycle, the BRNE is 2 cycles if looping back and
//  // 1 if not (the LDI balances out the BRNE being 1 cycle on exit)
//  __asm__ __volatile__ (
//      "       mov.w r9, %0\n"
//      "L_%=:  subs.w r9, r9, #1\n"
//      "       bne.n L_%=\n"
//      : /* no outputs */
//      : "M" (LOOP)
//      : "r9"
//      );
// }
 
 
template<fl::cycle_t CYCLES> FASTLED_FORCE_INLINE void delaycycles() {
    // _delaycycles_ARM<CYCLES / 3, CYCLES % 3>();
    FL_NOP; delaycycles<CYCLES-1>();
}
 
 
 
 
#endif
 
// pre-instantiations for values small enough to not need the loop, as well as sanity holders
// for some negative values.
 
// These are hidden from Doxygen because they match the expected behavior of the class. 
template<> FASTLED_FORCE_INLINE void delaycycles<-10>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-9>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-8>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-7>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-6>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-5>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-4>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-3>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-2>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<-1>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<0>() {}
template<> FASTLED_FORCE_INLINE void delaycycles<1>() {FL_NOP;}
template<> FASTLED_FORCE_INLINE void delaycycles<2>() {FL_NOP2;}
template<> FASTLED_FORCE_INLINE void delaycycles<3>() {FL_NOP;FL_NOP2;}
template<> FASTLED_FORCE_INLINE void delaycycles<4>() {FL_NOP2;FL_NOP2;}
template<> FASTLED_FORCE_INLINE void delaycycles<5>() {FL_NOP2;FL_NOP2;FL_NOP;}
#if defined(ESP32)
template<> FASTLED_FORCE_INLINE void delaycycles<4294966398>() {
    // specialization for a gigantic amount of cycles, apparently this is needed
    // or esp32 will blow the stack with cycles = 4294966398.
    const fl::u32 termination = 4294966398 / 10;
    const fl::u32 remainder = 4294966398 % 10;
    for (fl::u32 i = 0; i < termination; i++) {
        FL_NOP; FL_NOP; FL_NOP; FL_NOP; FL_NOP;
        FL_NOP; FL_NOP; FL_NOP; FL_NOP; FL_NOP;
    }
 
    // remainder
    switch (remainder) {
        case 9: FL_NOP;
        case 8: FL_NOP;
        case 7: FL_NOP;
        case 6: FL_NOP;
        case 5: FL_NOP;
        case 4: FL_NOP;
        case 3: FL_NOP;
        case 2: FL_NOP;
        case 1: FL_NOP;
    }
}
#endif

 

 
// Macro to convert from nano-seconds to clocks and clocks to nano-seconds
// #define NS(_NS) (_NS / (1000 / (F_CPU / 1000000L)))

#define F_CPU_MHZ (F_CPU / 1000000L)
 
// #define NS(_NS) ( (_NS * (F_CPU / 1000000L))) / 1000

#define NS(_NS) (((_NS * F_CPU_MHZ) + 999) / 1000)
#define CLKS_TO_MICROS(_CLKS) ((long)(_CLKS)) / (F_CPU / 1000000L)

#define NO_TIME(A, B, C) (NS(A) < 3 || NS(B) < 3 || NS(C) < 6)

 
FASTLED_NAMESPACE_END
 
#endif