What is "Super Loop" in Embedded C programming language?

Question

What is Super Loop in Embedded C programming language?

Answer 1

This refers to the eternal loop usually located in main() of a "bare metal" system (no OS), since such systems can never return from main. A typical bare metal embedded system looks like this:

void main (void)
{
  // various initializations

  for(;;) // "super loop" or "main loop"
  {
    // do stuff
  }
}

Answer 2

MCU is device which runs continuously or better, it executes instructions when power is on (in general).

So while loop is here to force MCU to do something, even if loop is empty, it will just circle around.

But it must do something as it is not the same as PC program where you have return at the end of main function.

If you wouldn't have super loop then MCU can get instruction from FLASH/RAM (whatever..) and do something stupid things as MCU don't know what it is executing. It just executes code you provide him.

By using super loop, you guarantee MCU won't just uncontrollable execute some instructions and maybe go to fail-safe area. Of course this can happen even if you have super loop but this is other topic.

int main() {
    //Init if you have something
    while (1) {
        //DO stuff always
    }
    return 0; //This should never happen!
}

Answer 3

Super loop is an infinite loop which is suitable only in embedded c programming because there you have to run your code for very very long time and wants explicitly terminate when the behavior is change for your robot or whatever. Superloop be like

while(1){

// Your code

// exit condition

}

for(;;) {

}

Answer 4

Super loop (or superloop) is a design pattern that often is chosen by embedded real-time firmware developers for very small systems (especially, "bare metal" systems) in which simplicity is an important design goal.

The super loop ("super" means "above" in Latin) is the program's top-level loop. An especially simple implementation might look like this:

int main() {
    initializeGlobalState();
    while (1) {
        sampleInputs();
        updateGlobalStateBasedOnNewInputs();
        updateOutputs();
    }

    // can't ever get here but the compiler may require a `return` statement.
    return 0;
}

Simplicity is the goal, but the pattern allows for small complications. For example, one could implement a rudimentary priority scheme:

initializeGlobalState();
while (1) {
    sampleHighPriorityInputs();
    if (updateStateBasedOnNewHighPriorityInputs()) {
        updateOutputs();
        continue;
    }
    sampleOtherInputs();
    updateGlobalStateBasedOnNewOtherInputs();
    updateOutputs();
}

One can do scheduling:

initializeGlobalState();
while (1) {
    timeNow=readFreeRunningTimer();
    sampleInputs();
    updateGlobalState();
    if (timeNow > task1_dueDate) {
        doTask1();
        task1_dueDate += task1_fixedPeriod;
    }
    if (timeNow > task2_dueDate) {
        doTask2();
        task2_dueDate = computeTask2DueDateBasedOnGlobalStateOrInputs();
    }
    ...
    updateOutputs();
}

One can slow things down to save power:

initializeGlobalState();
enableHeartbeatInterrupt();
while (1) {
    ...
    WAIT_FOR_INTERRUPT;
}

Other complications are possible, but the down side of superloop is, it becomes unwieldy and brittle if you try to add too many of them. When that happens, the developer may find themselves wishing they had built the project on a Real-time OS and/or an application framework.