Seeking suggestions on how to implement this reactive behavior

[HenrikNilssonCode]

Hi!

I'm looking for suggestions on how to implement the following behavior for an autonomous drone.

The drone should ensure some things before performing the actual mission, like ensuring that it is in autonomous mode and that is it safe to fly. Conditions can change at any time and should therefore be checked continuously. Any change to the previous conditions should abort later actions. I first implemented it like this following the principle of Backchaining:

(Note that this is a work in progress and that more conditions and actions will be added)

After reading some more, I realised that having multiple asynchronous actions is not allowed in a ReactiveSequence, but it this moment I don't see an alternative way of implementing this as all my actions will be asynchronous. Say that BatteryLevelOK is false; the resulting ticking of Hover and it returning RUNNING causes the [ReactiveSequence]: only a single child can return RUNNING to be thrown once "be in autonomous mode" is ticked again.

Reading #71, #83 and #93, I understand that a related discussion to my question has been ongoing, though I have not been able to find any suggestions on how to implement this. In a way, all I want to ensure is that only one action is performed at one time and that no later actions are allowed to be performed before the previous conditions are met, even as they change.

Your input will be greatly appreciated, thanks in advance!

[HenrikNilssonCode]

It's tempting to disable the multiple running check but I am not sure that I qualify for "You can disabled that check, if you know what you are doing". Though I think that I have handled/will handle the concurrent running of nodes correctly, the comments of "to work properly, this node should not have more than a single asynchronous child." do scare me a bit. Looking at the implementation I see nothing obvious that breaks when you have multiple running children, apart from that the running_child_ member will only be set for the first running child. I can however not find where this member is actually read, apart from checking that only one child is running, which might be its only purpose?

Disabling the exception seems to work fine, but actions are not halted before new actions run, only after. This seems to mirror what's described in #83, am I correct?

[facontidavide]

If you disable that, you code will likely break.

The correct pattern to address this is:

It is NOT obvious why, I should write an article about that.
In short, if you remove the Sequence and just add the two AsyncActions, the AsyncActionD will be restarted every single time and AsyncActionE will "starve", i.e. will not receive ticks that allow it to continue/complete its execution.

Feel free to write a unit test to verify that yourself, if you don't believe that :)

[HenrikNilssonCode]

I think I understand, lets see.

So to have multiple actions react to a set of conditions, you put the individual conditions under a ReactiveSequence and the actions under a (Async)Sequence of that ReactiveSequence, as your image shows. This allows both AsyncActionD and AsyncActionE to run simultaneously. Putting the async actions directly under the ReactiveSequence, as shown below, would starve AsyncActionE (it would not be ticked). To my understanding, this would not trigger the exception as AsyncActionE would never be ticked at all.

In my case, I do not want actions to run simultaneously. Imagine instead that we have this structure:

Here, CondD "guards" AsyncActionD. If CondD is SUCCESS, AsyncActionD will not run, meaning that AsyncActionE will run instead. When CondD is FAILURE, AsyncActionD is run as a fallback, and AsyncActionE does not run. It is starved, which here is what I seek.

The problem here is that for one tick (exactly when the guarding condition CondD has changed from SUCCESS to FAILURE), both AsyncActionE and AsyncActionD will be in state RUNNING (the ReactiveFallback will also be in state RUNNING, triggering the exception) and AsyncActionE will only be halted after AsyncActionD has returned RUNNING.

Have I understood correctly, or did I misunderstand your response?
Thanks for taking your time to respond!

[lyd00116]

you can use switch to cancale AsyncActionE and start running AsyncActionD
the CondD output a value, and it is the input to the switch.
Switch control the two AsyncAction

[facontidavide]

To better understand your use case...

Imagine that you are doing a Hover. What should happen if any of the ready_for_autonomy conditions become false?

What is the expected behavior?

[HenrikNilssonCode]

When any of those conditions change, we should halt any running action (Hover in this case) and do Wait.

All the conditions under ready for autonomy can only be changed by either the pilot or by a crash, so to ensure safety I want the drone to go limp (Wait) immediately if any of those conditions change. This means aborting the Hover.

[asasine]

Halting any running actions was the old behavior of ReactiveSequence and was changed. We use backchaining extensively in our system and that change has broken many of our behaviors when updating to v3.8.6 and v4.

[RRinsy]

I am facing the same question. I wander if there is any solution?

[facontidavide]

There is a solution and I will implement it soon. but If you care about this please provide a PR with a unit test or a meaning example

[HenrikNilssonCode]

Behaviour changed in #770 after discussion in issue 775 to allow for the halting behaviour I sought, meaning that my original idea is now the solution to my question. Read the mentioned threads above.