Timer: Create task scheduler

[ETSells]

Version: v2.7.0

Describe the feature you'd like
We can use a timer to periodically generate interrupt signals (think ~every 10 ms or so) that goes through a table of actions and performs a task if the current systick is greater than or equal to the scheduled systick. This table should be of known size at compile time with an entry for every task that may be scheduled. On duplicate entries, the scheduled systick should be overwritten, requiring scheduled tasks to check if there's already something scheduled before doing so.

This kind of system could be great for scheduling specific telemetry or CAN messages going forward, but the initial application would be for SunDevilRocketry/Flight-Computer-Firmware#266. We could schedule a task a certain number of milliseconds after starting parachute deployment to de-assert the deployment pin.

Describe alternatives you've considered
The alternative for the immediate application (#266) is to check the ignition pin assertion synchronously in the flight loop. I would be okay with this implementation, it's up to @NArmistead if he wants to overcomplicate it a bit in the name of SDR OS (lmao).

Alternative (mutually exclusive): SunDevilRocketry/driver#37

Additional context
N/A

Points of Contact
FC Rev. 2 Project Lead: @NArmistead
Mod Library Maintainer: @ETSells

[ETSells]

This issue should be considered mutually exclusive to SunDevilRocketry/driver#37.

[NArmistead]

I think this is worth investing in because it could be useful for all kinds of things, like non-blocking buzzer beeps. Possible implementation could be to pass a function pointer and a systick? Ig then we would have to create wrapper functions for anything that takes an argument. (imagine if we had lambda functions lmaoooo)

[ETSells]

dude at this point we're just making our own single-purpose RTOS

[ETSells]

<!-- header -->
typedef enum {
TASK_TYPE_DROGUE_DEASSERT,
TASK_TYPE_MAIN_DEASSERT,
TASK_TYPE_TELEMETRY_SEND_ID,
} TASK_TYPE;

typedef struct SCHEDULED_TASK = {
TASK_TYPE task;
uint32_t scheduled_systick;
task_callback callback;
} SCHEDULED_TASK;

// return an error if scheduled_systick != 0; set a triggered task's systick to 0 on completion
TASK_STATUS schedule_task(TASK_TYPE task, uint32_t scheduled_systick);

<!-- project source file or include file -->
SCHEDULED_TASK task_table[] = 
{
{TASK_TYPE_DROGUE_DEASSERT, NULL, (insert function ptr here -- known at compile time?)},
(...)
}

[NArmistead]

Is the enum and table for keeping track of what's been completed?

[ETSells]

Ideally on a full system, what we'd want is a dynamically resizable queue. Since we don't do dynamic memory allocation on the FC by convention (and pretty much by rule), I'd want to use the table to ensure we know exactly how much space the table can take up at compile time. The enum would be used as a key for insertions into the table, and on each interrupt, we'd check every index of the table to determine if a task needs to be triggered. Once a task returns, we keep searching for the next.

[ETSells]

Alternatively we could use a pool allocator, but that raises questions for what happens if it gets full. We'd need to manage priorities and/or find a way to prove we'd never exceed the size of the pool.