Диспетчер Задач для Микроконтроллера16.11.2023 02:15

Постановка задачи

В программировании микроконтроллеров часто нужно написать простые тестировочные прошивки. При этом надо некоторые функции вызывать чаще, а некоторые реже. Вот например как тут

Для этого конечно можно запустить FreeRTOS, однако тогда код не будет переносим на другие RTOS, например Zephyr RTOS/TI-RTOS/RTEMS/Keil RTX/Azure RTOS или SafeRTOS. Потом прошивку как код часто приходится частично отлаживать на PC, а там никакой RTOS в помине нет.

Поэтому надо держать наготове какой-нибудь простенький универсальный переносимый кооперативный NoRTOS планировщик с минимальной диагностикой и возможностью в run-time отключать какие-то отдельные задачи для отладки оставшихся.

Проще говоря нужен диспетчер задач для микроконтроллера.

Определимся с терминологией

Кооперативный планировщик — это такой способ управления задачами, при котором задачи сами вручную передают управления другим задачам.

Супер-цикл — тело оператора бесконечного цикла в NoRTOS прошивках. Обычно бесконечный цикл в прошивках можно найти по таким операторам как for (;;){} или while (1){}

Bare-Bone сборка — это сборка прошивки на основе API какой-нибудь RTOS, где только один поток и этот поток прокручивает супер-цикл с кооперативным планировщиком. Эта сборка нужна главным образом только для отладки RTOS: настройки стека, очередей и прочего.

Ядром любого планировщика является генератор или источник стабильного тактирования. Желательно с высокой разрешающей способностью. Микросекундный таймер. Это может быть SysTick таймер с пересчетом в микросекунды или отдельный аппаратный таймер общего назначения. Обычно аппаратных таймеров от 3х до 14ти в зависимости от модели конкретного микроконтроллера. Также важно, чтобы таймер возрастал. Так проще и интуитивно понятнее писать код нам человекам, так как мы привыкли к тому что время оно всегда непрерывно идет вперед, а не назад.

Для определенности будем считать, что все задачи имеют одинаковых прототип

 bool task_proc(void);

Сначала надо определить типы данных.

#ifndef TASK_GENERAL_TYPES_H
#define TASK_GENERAL_TYPES_H

/*Mainly for NoRtos builds but also for so-called RTOS Bare-Bone build*/
#include 

#include "task_const.h"
#include "limiter.h"

typedef struct  {
    uint64_t period_us;
    bool init;
#ifdef HAS_LIMITER
    Limiter_t limiter;
#endif
    const char* const name;
} TaskConfig_t;

#endif /* TASK_GENERAL_TYPES_H */

Ключевым компонентом планировщика, его ядром является программный компонент называемый Limiter. Это такой программный компонент, который не позволит вызывать функцию function чаще чем установлено в конфиге. Например вызывать функцию не чаще чем раз в секунду или не чаще чем раз в 10 ms.

#ifndef LIMITER_TYPES_H
#define LIMITER_TYPES_H

#include 
#include 

#include "data_types.h"

typedef bool (*TaskFunc_t)(void);

typedef struct {
    bool init;
    bool on_off;
    uint32_t call_cnt;
    uint64_t start_time_next_us;
    U64Value_t duration_us;
    U64Value_t start_period_us;
    uint64_t run_time_total_us;
    uint64_t start_time_prev_us;
    TaskFunc_t function;
} Limiter_t;

#endif /* LIMITER_TYPES_H */

Вот API планировщика. Механизм очень прост. Limiter измеряет время с момента подачи питания up_time_us, смотрит на расписание следующего запуска start_time_next_us и, если текущее время (up_time_us) больше времени запуска, назначает следующее время запуска и запускает задачу (limiter_task_frame).

bool inline limiter(Limiter_t* const Node, uint32_t period_us, uint64_t up_time_us) {
    bool res = false;
    if(Node->on_off) {
        if(Node->start_time_next_us < up_time_us) {
            Node->start_time_next_us = up_time_us + period_us;
            res = limiter_task_frame(Node);
        }

        if(up_time_us < Node->start_time_prev_us) {
            LOG_DEBUG(LIMITER, "UpTimeOverflow %llu", up_time_us);
            Node->start_time_next_us = up_time_us + period_us;
        }
        Node->start_time_prev_us = up_time_us;
    }
    return res;
}

Limiter также ведёт аналитику. Измеряет время старта и окончания задачи, вычисляет продолжительность исполнения задачи (duration), вычисляет минимум (run_time.min) и максимум (duration.max), суммирует общее время, которое данная задача исполнялась на процессоре (run_time_total).

static inline bool limiter_task_frame(Limiter_t* const Node) {
    bool res = false;
    if(Node) {
        uint64_t start_us = 0;
        uint64_t stop_us = 0;
        uint64_t duration_us = 0;
        uint64_t period_us = 0;

        start_us = limiter_get_time_us();

        if(Node->start_time_prev_us < start_us) {
            period_us = start_us - Node->start_time_prev_us;
            res = true;
        } else {
            period_us = 0; /*(0x1000000U + start) - TASK_ITEM.start_time_prev; */
            res = false;
        }

        Node->start_time_prev_us = start_us;
        if(res) {
           	data_u64_update(&Node->start_period_us, period_us);
        }
        

        res = true;
#ifdef HAS_FLASH
        res = is_flash_addr((uint32_t)Node->function);
#endif /*HAS_FLASH*/
        if(res) {
            Node->call_cnt++;
            res = Node->function();
        } else {
            res = false;
        }

        stop_us = limiter_get_time_us();

        if(start_us < stop_us) {
            duration_us = stop_us - start_us;
            res = true;
            data_u64_update(&Node->duration_us, duration_us);
            Node->run_time_total_us += duration_us;
        } else {
            duration_us = 0;
            res = false;
        }
    }
    return res;
}

Стоит заметить, что перед непосредственным запуском конкретной задачи Limiter может проверить, что указатель на функцию в самом деле принадлежит Nor-Flash памяти микроконтроллера.

В основном супер цикле достаточно только перечислить те задачи, которые будут исполняться. Вот функция одной итерации супер-цикла.

bool inline tasks_proc(uint64_t loop_start_time_us){
    bool res = false;
    uint32_t cnt = task_get_cnt();
    uint32_t t = 0;
    for (t=0; t

_Noreturn void super_cycle_start(void) {
    LOG_INFO(SUPER_CYCLE, "Start");
    super_cycle_init();

    SuperCycle.start_time_ms = time_get_ms();
    LOG_INFO(SUPER_CYCLE, "Started, UpTime: %u ms", SuperCycle.start_time_ms);
  
    for(;;) {
    	super_cycle_iteration();
    }
}