Capturing variables for timer callbacks?

[BostonBoston]

In my application I wanted to create a non blocking way to pulse a relay for a specified duration, my initial though was to capture the pin data needed to pulse and give it to a timer callback, looking something like this:

auto lambda = [relay, this]()
  {
    this->m_relayControl.TogglePin(CAT9555::Register::OutputPort0, static_cast<CAT9555::Pin>(relay));
    this->m_timer.unregister_timer(this->m_toggleid);
    Serial2.println("Pulse End");
  };
auto callback = etl::delegate<void(void)>::create(lambda);

m_toggleid = m_timer.register_timer(callback, ms, etl::timer::mode::Single_Shot);
bool res = m_timer.start(m_toggleid);

The idea being that I set the relay, then when the timer expires it toggles the state, this does not work, I think related to a note I read in the docs about etl::delegate being non owning.

Is there anything I can do to accomplish what I wish? Or will I need to create a free function for each relay and assign them through control flow.

[KammutierSpule]

Is lambda created locally? not sure how it works and where it must leave. it should not stay in the stack.

Also, this->m_timer.unregister_timer(this->m_toggleid); from current time design, it is not possible to change anything on timer object. have a look: #952

[BostonBoston]

I've modified my code to move a lot out of local scope, but im still encountering an issue I don't understand. Here is a larger view of what I am working with:

class RelayClass
{
public:
  RelayClass(etl::callback_timer<5>& timer) :
  m_timer(timer),
  m_relayControl(CAT9555()) {};

  void PulseRelay(uint8_t relay, uint32_t ms);
  void TestMethod(uint8_t relay);

private:
  etl::callback_timer<NumTimers>& m_timer;
  etl::timer::id::type m_toggleid;
  uint8_t m_toggledRelay;
  CAT9555 m_relayControl;
  etl::delegate<void(void)> m_relayCallback;
};

void RelayClass::TestMethod(uint8_t relay)
{
  Serial2.println("test");
}

void RelayClass::PulseRelay(uint8_t relay, uint32_t ms)
{
  m_relayCallback = [this](){
    this->m_relayControl.TogglePin(CAT9555::Register::OutputPort0, static_cast<CAT9555::Pin>(this->m_toggledRelay));
    Serial2.println("Pulse End");
  };

  m_toggledRelay = relay;
  m_toggleid = m_timer.register_timer(m_relayCallback, ms, etl::timer::mode::Single_Shot);
  m_relayControl.TogglePin(CAT9555::Register::OutputPort0, relay);

  Serial2.print("Pulse Start, time: ");
  Serial2.println(ms);
}

My problem is that when my callback contains that call to TogglePin which is a member method of my CAT9555 class the device freezes, but when the callback is this->TestMethod(this->m_toggledRelay); it works perfectly fine, additionally the first call to TogglePin also works as expected.

[BostonBoston]

Now I need to issue a correction to my last statement, the TestMethod does not work as expected, when I print the value of relay to serial in PulseRelay I get 1 in my test case, which is expected, when the callback executes I added another serial print there and the value of relay is 0, or in some cases random.

[relativityspace-jsmith]

The issue here is that the lambda itself has scope to be managed. When you create a lambda with

auto someLambda = [this](){
    this->m_relayControl.TogglePin(CAT9555::Register::OutputPort0, static_cast<CAT9555::Pin>(this->m_toggledRelay));
    Serial2.println("Pulse End");
};

you are basically creating an instance of an anonymous class:

class AnonymousLambdaClass {
     RelayClass * thisPtr;

     AnonymousLambdaClass(RelayClass * thisPtr): thisPtr(thisPtr) {}

    void operator() {
        thisPtr->m_relayControl.TogglePin(CAT9555::Register::OutputPort0, static_cast<CAT9555::Pin>(thisPtr->m_toggledRelay));
        Serial2.println("Pulse End");
    }
}
auto someLambda = AnonymousLambdaClass(this);

which means that the code you have is doing:

m_relayCallback = AnonymousLambdaClass(this);

etl::delegate is non-owning, meaning that it just stores a reference to the lambda, it doesn't own it. This means that you are storing a reference to a stack-allocated temporary variable (AnonymousLambdaClass(this)) which soon goes out of scope. Then, when the delegate fires, it tries to call garbage memory as the lambda class, likely causing a crash.

To fix this, you need to actually save the lambda somewhere where it won't go out of scope for as long as the delegate is pointed to it. This is difficult to do with classes; it's probably just easier to make a private function and set up the delegate to point to it. Anyway hope that makes sense, I ran into the same issue myself a while back and it was hella confusing,

[BostonBoston]

This is going beyond my comprehension of this library, do you have a direct suggestion that may work in my case?
I tried making my callback just a private method that access only member variables of it's class and that still causes me issues.

[KammutierSpule]

the lambda issue is a "C++ issue" it self. I suggest to implement it without lambdas, It is also more clear about the behavior. Next you can focus on other issues.

mind my previous comment that you can't change timers inside timers callback.