Teensy Timer Tricks

[recri]

The Teensy has two nifty timing classes named elapsedMillis and elapsedMicros. The classes are used to count milliseconds or microseconds. The implementation is a wrapper around a uint32_t which stores the 'epoch' we are counting from. The only overhead is a call to millis() or micros() when you reference the timer. They're nifty because they spare you worrying about those times when micros() and millis() roll over from 0xffffffff to 0

  static elapsedMicros timer; /* allocate the timer */
  if (timer >= 200) { /* test for expiration */
    /* perform 200 microsecond period task */
    timer = 0; /* reset the timer for the next period */
  }

You can also set a negative count and fire at the zero crossing, but you need to cast the timer to a signed value when you read it.

  static elapsedMicros timer; /* allocate the timer */
  if ((int)timer >= 0) { /* test for expiration */
    /* perform 200 microsecond period task */
    timer = -200; /* reset the timer for the next period */
  }

The documentation is https://www.pjrc.com/teensy/td_timing_elaspedMillis.html

The C++ source the next version of hasak uses for an elapsedSamples class is a straightforward hack on elapsedMillis.

class elapsedSamples
{
private:
	unsigned long s;
public:
	elapsedSamples(void) { s = samples(); }
	elapsedSamples(unsigned long val) { s = samples() - val; }
	elapsedSamples(const elapsedSamples &orig) { s = orig.s; }
	operator unsigned long () const { return samples() - s; }
	elapsedSamples & operator = (const elapsedSamples &rhs) { s = rhs.s; return *this; }
	elapsedSamples & operator = (unsigned long val) { s = samples() - val; return *this; }
	elapsedSamples & operator -= (unsigned long val)      { s += val ; return *this; }
	elapsedSamples & operator += (unsigned long val)      { s -= val ; return *this; }
	elapsedSamples operator - (int val) const           { elapsedSamples r(*this); r.s += val; return r; }
	elapsedSamples operator - (unsigned int val) const  { elapsedSamples r(*this); r.s += val; return r; }
	elapsedSamples operator - (long val) const          { elapsedSamples r(*this); r.s += val; return r; }
	elapsedSamples operator - (unsigned long val) const { elapsedSamples r(*this); r.s += val; return r; }
	elapsedSamples operator + (int val) const           { elapsedSamples r(*this); r.s -= val; return r; }
	elapsedSamples operator + (unsigned int val) const  { elapsedSamples r(*this); r.s -= val; return r; }
	elapsedSamples operator + (long val) const          { elapsedSamples r(*this); r.s -= val; return r; }
	elapsedSamples operator + (unsigned long val) const { elapsedSamples r(*this); r.s -= val; return r; }
};

I can see how to write a C preprocessor macro to generate these for arbitrary name and counter function. But it seems there should be a C++ template class definition that takes a class name and a static counter function and generates elapsedAnyCounter's.

[softerhardware]

This is good to know. I remember some place having to worry about rollover.

73,

Steve
kf7o

[dl1ycf]

What I am looking for is a function call that will execute a given function at some later time, without taking care of that. So, if the
PTT lead-in time is 150 milli-seconds, instead of turning the CW digital output "high" and sending a MIDI "key-down" message,
I want exactly this to happen in 150 milli-seconds. But because it will be interrupt-driven, I do not know if you can do MIDI with it. The goal is to delay all the Key-up/down events by the lead-in time while doing the PTT and the side tone without delay.