Real-time Operating System

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
while (1) {
    // Only _tick() each state machine (task) if it's time is up.
    if (Blink_elapsedTime >= Blink_period) {
        Blink_tick();
        Blink_elapsedTime = 0;
    }

    // Multiple tasks have the same form,
    // but different variable names / values.
    if (ButtonInput_elapsedTime >= ButtonInput_period) {
        ButtonInput_tick();
        ButtonInput_elapsedTime = 0;
    }

    // Wait for the timer ISR to set the flag.
    while (!TimerFlag){}
    TimerFlag = 0;

    // Update each task's time-since-last-finished.
    Task0_elapsedTime += timerPeriod;
    Task1_elapsedTime += timerPeriod;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
typedef struct task {
    int state;                  // note-1
    unsigned int period;        // note-2
    unsigned int elapsedTime;   // note-2
    int (*tick)(int);           // note-3
} task_t;


int Blink_tick(int state) {
    switch (state) {
        //...
        state = ...
        ...
    return state;
}


task_t Blink_task;
task_t ButtonInput_task;


// Configure the Blink state machine's struct
Blink_task.state = Blink_SMStart;
Blink_task.period = 1500;
Blink_task.elapsedTime = 1500;  // same as period -> triggered at startup
Blink_task.tick = &Blink_tick;  // note-3, getting the *address* of the function

// Configure the ButtonInput state machine's struct
ButtonInput_task.state = ButtonInput_SMStart;
ButtonInput_task.period = 500;
ButtonInput_task.elapsedTime = 500;  // same as period -> triggered at startup
ButtonInput_task.tick = &ButtonInput_tick;  // note-3, getting the *address* of the function




while (1) {
    /*                             /1 Call the tick() function
     *         /3 To get the       |   /2 with the current state
     *         |  next state       |   |
     *         v                   v   v                         */
    Blink_task.state = Blink_task.tick(Blink_task.state);
    ...
}

1
2
// TODO: this is nonsense in C
task_t tasks[] = {Blink_task, ButtonInput_task};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// Get the length of the tasks[] array.
// This is computed by the compiler during compiling.
const unsigned int NUM_TASKS = sizeof tasks / sizeof tasks[0];

for (i=0; i < NUM_TASKS; i++) {
    if (tasks[i].elapsedTime >= tasks[i].period) {
        tasks[i].state = tasks[i].tick(tasks[i].state);
        tasks[i].elapsedTime = 0;
    }
    tasks[i].elapsedTime += timerPeriod;
}