Для arduino же подход гораздо проще чем корутины: setup / loop
Первая функция вызывается при инициализации, а вторая "постоянно" либо с постоянной частотой (например 1000 раз в сек как в realtime контроллерах). Для постепенно исполняемых функций надо примерно 16 строк:

loop-fn.h

#ifndef __LOOP_FN_H__
#define __LOOP_FN_H__

typedef int loop_t;

#define LOOP_RESET(loop) { loop=0; }
#if defined(__COUNTER__) && __COUNTER__!=__COUNTER__
#define LOOP_BEGIN(loop) { enum { __loop_base=__COUNTER__ }; \
    loop_t *__loop=&(loop); __loop_switch: \
    switch(*__loop) { default: *__loop=0; case 0: {
#define LOOP_POINT() { enum { __loop_case=__COUNTER__-__loop_base }; \
    *__loop=__loop_case; goto __loop_leave; case __loop_case:{} }
#else
#define LOOP_BEGIN(loop) { loop_t *__loop=&(loop); __loop_switch: \
    switch(*__loop){ default: case 0: *__loop=__LINE__; case __LINE__:{
#define LOOP_POINT() { *__loop=__LINE__; goto __loop_leave; case __LINE__:{} }
#endif
#define LOOP_END() { __loop_end: *__loop=-1; case -1: return 0; } \
    }} __loop_leave: return 1; }

#endif

loop-fn-example.c

#include <stdio.h>
#include "loop-fn.h"

typedef struct fn1_s {
    loop_t loop;
    int i;
} fn1_t;
int fn1_setup(fn1_t *self); /* return 0 if no error */
int fn1_loop(fn1_t *self); /* return 0 when done */

int fn1_setup(fn1_t *self) {
    LOOP_RESET(self->loop);
    return 0;
}

int fn1_loop(fn1_t *self) {
    LOOP_BEGIN(self->loop)
    printf("fn1.1\n");
    LOOP_POINT()
    for(self->i=0;self->i<3;self->i++) {
        printf("fn1.2.%d\n",self->i+1);
        LOOP_POINT()
    }
    printf("fn1.3\n");
    LOOP_END()
}

void test() {
    fn1_t s[1]; int i,r;
    fn1_setup(s);
    for(i=0;i<10;i++) {
        printf("%2d: ",(int)s->loop);
        r=fn1_loop(s); if (r==0) break;
    }
}

int main(int argc, char** argv) {
    test();
    return 0;
}
/* output:
 0: fn1.1
 1: fn1.2.1
 2: fn1.2.2
 2: fn1.2.3
 2: fn1.3
*/

Основные проблемы начинаются дальше, т.к. помимо самой многозадачности надо поддерживать некоторые правила. Без которых будет всё очень печально. И самое главное, что за выделение ресурсов должен отвечать не исполняющий код, а тот кто это код запустил исполняться. То есть если подзадача остановилась, есть возможность освободить все ресурсы которые были выделены в том числе и дочерние подзадачи. То есть структурная многозадачность должна быть как в erlang. Если исполнителя надо прибить или ограничить в ресурсах то это не вызывает UB или головной боли. Из плюсов простота и есть полный контроль над происходящим и можно сохранять состояние на диск или передавать по сети. Никакие корутины таким похвастаться не могут. И еще если потоков миллионы то задержки и ожидания делаются более хитрым способом.