Improve FSM event handling in MIDAS FSW

[mpkarpov-ui]

Currently, the way that MIDAS handles FSM-triggered code is by setting a flag in the commands struct, and then consuming these flags in a context that is more convenient to work in.

This isn't great for code readability and being able to extend our infrastructure. For instance, the flag listed above is triggered when a high acceleration is detected (which usually indicates launch but can be a false positive) to set camera feeds. If we wanted MIDAS to perform other actions when detecting launch, we would have to either

• 1. Use the same block, and thus put unrelated code into a block that has to do with command_flags.FSM_should_set_cam_feed_cam1
• 2. Create a new command and set it in the same place as the flag above, which is wasteful.

The likely best approach here is to make this system more robust and allow for certain events to be triggered at arbitrary times and dispatch functions which make working with the data more streamlined.

Your task: Make a system that is simple to use and expand that allows you and other teams (mainly GNC) to write code that triggers when certain FSM conditions are met.

This is an open-ended problem:

There is likely not one "best solution", but the general flow of this system should be something like the following pseudo code:

void launch_detect_dispatch(RocketSystems* arg) {
  arg->b2b.camera.camera_off(SIDE_CAMERA);
}

struct midas_event_triggers {
  MidasEvent launch_detect = MidasEvent(launch_detect_dispatch);
}

Then, in a file like fsm.cpp

...
events.launch_detect.dispatch();
...

Which will automatically call launch_detect_dispatch. This can be done by making MidasEvent have an internal flag and checking it in systems.cpp or whatever method you come up with! It should be straightforward to add new events and triggers for them.

[MichaelCyrwus]

I was interested in this issue and was wondering whether implementing a publisher subscriber pattern would be good for something like this? I just want to be sure before doing anything.

[mpkarpov-ui]

In my personal opinion I think pub/sub isn't really the best approach for this-- you're realistically not going to have more than one function linked per event (we want to be able to see everything that happens in one place), so a single-event dispatch would probably work best.

[MichaelCyrwus]

So I have a rough idea of what might need to be done and I first tried to implement a pseudocode to see if I have the right idea/approach.

I created three different (most likely temporary) header folders called "rocket_systems.h", "midas_event.h", and "event_handlers.h", where each of them contain the respective pseudocode.

rocket_systems.h

# pragma once

struct RocketSystems{
    // Input the GNC data, camera controllers, and other necessary subsystem components here
};

midas_event.h

#pragma once

#include <functional>
#include "rocket_systems.h"

// The signature for the callback functions
using MidasEventCallback = std::functional<void(RocketSystems*)>;

class MidasEvent{
    public:

    // Taking a function and storing it
    // Registering the callback
    MidasEvent(MidasEventCallback callback) : m_callback(callback) {}

    // Executing the stored callback function
    void dispatch(RocketSystems* systems) {
        // Execute if the function is not null
        if(m_callback) {
                m_callback(systems);
        }
    }

    private:
        // The stored event callback
        MidasEventCallback m_callback;
};

event_handlers.h

#pragma once

#include "midas_event.h"
#include "rocket_systems.h"

void launch_detect_dispatch(RocketSystems* arg) {
    arg->b2b.camera.camera_on(SIDE_CAMERA);
}

struct MidasEventTriggers {
    MidasEvent launch_detect_dispatch = MidasEvent(launch_detect_dispatch);
};

The event_handler.h would contain all of the possible past flags in this new context and (I would hope) makes it easier for anyone needing to create a new one to use this.
Sorry if this looks really rough, I'm still trying to figure my way around and appreciate any and all help. Thanks in adnvance!

[mpkarpov-ui]

So a couple comments--

RocketSystems is already a struct that exists in MIDAS code and should be what you're passing to all of these dispatch functions. It's passed into every flight code thread as the arg parameter.. for example systems.cpp:78:

DECLARE_THREAD(orientation, RocketSystems* arg) {

RocketSystems is realistically just a big struct that has all of the data we could possibly care about on the rocket, so it's nice to pass around. It's defined in systems.h, and an instance is always created at startup in main.cpp:22.

I think what would make the most sense is to either
(a) have events be a struct under RocketSystems itself, so that threads can call arg->events.launch_detect.dispatch() (or similar), or
(b) have a global events struct where every function has a reference to the global RocketSystems struct.

Both work, and hypothetically would allow for threads to invoke events. I'm personally a fan of option b but as long as it's easy to use I don't really care. The ideal method of operation is (pseudocode)

void tick_fsm(MidasEvents& events) {
   ...
   if(condition_for_launch_detect_met) {
    events.launch_detect.dispatch();
  }
}

Let me know if you have any other questions!

[ishrakj]

My idea thus far is this:

I created a MIDAS_Events struct in "rocket_state.h" and a "MIDAS_Events.cpp" file. MIDAS_Events contains function headers and "MIDAS_Events.cpp" contains their definitions. The idea here is that each function corresponds to transiting from one state to another (e.g. safe_to_pyroTest() is called in fsm.cpp inside the if statement where the state changes from STATE_SAFE to STATE_PYRO_TEST). The functions take in the CommandFlags struct initialized in fsm.cpp as a reference and changes whatever we want. So instead of directly changing the flags in fsm.cpp, we instead call the corresponding MIDAS_Events function and change the flags in that function definition.

I was under the impression that we want to adjust the command flags when we are transitioning from one state to another, but upon rereading the issue, it seems like we want to be able to adjust the flags at any arbitrary time/condition. Is this correct? If so, I have 2 more questions:

1. How do we pass on to our dispatch/MIDAS_Events object what flags we want to change?
2. How do we pass on what conditions must be met to change those flags?