В продолжение темы. Сколько процессорного времени использует ОСь FreeRTOS, и вообще, насколько сильно загружен процессор выполняя текущие задачи?
Вычислить процент загрузки процессора относительно не сложно. Необходимо посчитать сколько тактов процессор выполнял полезную работу, а сколько спал ничего не делая. Достаточно вычислить последнее, а первое не обязательно, ведь нам известна частота тактирования ядра и если ее поделить на число тактов "сна" процессора, то получим соотношение "полезная работа"/"сон" из которого можно получить загрузку в процентах.
Теперь осталось определится чем считать такты ядра. Конечно для этого можно использовать один из таймеров, но это не всегда возможно, т. к. они могут быть заняты. Нужен какой-то счетчик (желательно большой разрядности) который не жалко использовать для таких целей и который тактируется непосредственно от ядра. Оказывается есть такой. Как известно в ядре ARM Cortex-M3 присутствует модуль отладки (точнее это не отдельный модуль, а часть ядра). Нужный нам счетчик находится в блоке DWT и называется CYCCNT. Он 32-ух разрядный и тактируется непосредственно от ядра - то что нам нужно. Осталось дело за малым - программно запустить модуль отладки и активировать счетчик. Для этой цели в начало кода нужно добавить строки

    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; // Включаем TRACE
    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;            // Разрешаем DWT счетчик CYCCNT

Блок DWT кроме счетчика CYCCNT считающего такты ядра, содержит и другие, судя по их названию и по документации, считающие сколько ассемблерных инструкций было выполнено, сколько тактов процессор выполнял прерывания, спал и т. д.

Но к сожалению из них ничего дельного прочитать не получилось. Видно что данные в них меняются, но счетчики часто обнуляется. Возможно это потому что код выполнялся под управлением отладчика и он использовал эти регистры. Но в данном случае они нам не нужны. Достаточно CYCCNT который не обнуляется отладчиком.
Вернемся к теме вычисления загрузки процессора. В коде в первом сообщении есть функция

void vApplicationIdleHook(void) // Функция вызывается когда МК делать нечего, т. е. все задачи неактивны.
{
   __WFI();  // Отправляем МК спать до ближайшего прерывания.
}

Из комментариев думаю понятно для чего она нужна. Ее код выполняется когда другие задачи находятся в режиме ожидания и их код не выполняется. Функция __WFI() приостанавливает работу ядра до ближайшего прерывания. Чтобы определить загрузку процессора нужно перед вызовом __WFI() сохранить в 32-ух битной переменой число из счетчика CYCCNT, а после того как ядро "проснется" по прерыванию, нужно еще раз сохранить число из CYCCNT и из него вычесть ранее сохраненное и таким образом узнаем сколько тактов ядро "спало", т. е. не выполняло полезной работы. Чем больше это число тем меньше загрузка процессора.
Для этого код функции vApplicationIdleHook нужно немного доработать.

void vApplicationIdleHook(void) // Функция вызывается когда МК делать нечего, т. е. все задачи неактивны.
{
    if (Start_SleepTime == 0)
        Start_SleepTime = DWT->CYCCNT;  // Запоминаем время перехода в спячку.

    __WFI();  // Отправляем МК спать до ближайшего прерывания.
}

Перед вызовом __WFI() и при условии что в Start_SleepTime будет 0, в переменной сохраняется число тактов из счетчика CYCCNT. На первый взгляд логично было бы после вызова __WFI() еще раз прочитать число тактов из CYCCNT и вычислить сколько ядро было в "спячке", но это не так. Считывать нужно в прерывании, которое "разбудило" ядро, иначе результат получится совсем не тот что ожидаем. Во всех возможных обработчиках прерываний это делать слишком накладно. Допуская небольшую ошибку вычислений (такты потраченные на прерывания будут засчитаны за сон) это можно сделать только в обработчике системного таймера.

void vApplicationTickHook(void) // Вызывается при каждом прерывании системного таймера.
{
    static uint32_t Count, SleepTime;

    if (Start_SleepTime)
    {
        SleepTime += DWT->CYCCNT - Start_SleepTime;
        Start_SleepTime = 0;
    }

    if (++Count >= configTICK_RATE_HZ) // Прошла секунда.
    {
        Count = 0;

        if (SleepTime != 0)
        {
            CPU_Load = 100 - 100.0f / (SystemCoreClock / (float)SleepTime); // Загрузка CPU в процентах.
        }
        else CPU_Load = 100;

        SleepTime = 0;
    }
}

В начале функции проверяется чтобы Start_SleepTime был не 0, что означает что в vApplicationIdleHook было сохранено число из CYCCNT. Существует низкая вероятность (один шанс из больше чем 4 миллиарда) того что в момент чтения из CYCCNT в нем окажется 0 (счетчик 32-ух битный и при тактовой частоте ядра 72 МГц, он переполняется каждую минуту) и это приведет к ошибке вычисления, но из-за низкой вероятности этим можно пренебречь.
Дальше по коду, используя переменную-счетчик Count отсчитываются секундные интервалы и кадую секунду вычисляется загрузка процессора в процентах, путем деления частоты ядра на количество тактов в течение которого ядро "спало".
В таком виде задач как в первом сообщении, загрузка процессора ими и ОСью составляет 0.2% что относительно не много.
Если код одной из задач изменить

void Task_4(void const *argument) // Задача 4.
{
  while(1)
  {
      static volatile uint32_t i;
      for (i=0; i<100; i++);
      vTaskDelay(1);
  }
}

то нагрузка на процессор возрастет и составит почти 3%. При текущей конфигурации ОСи переключающей задачи 1000 раз в секунду, этот цикл выполнится также 1000 раз, а значит это эквивалентно циклу со счетом до 100 тысяч.
Увеличение числа в цикле до 1000 (что эквивалентно миллиону) создаст нагрузку 19.2%.
Если же увеличить до 5800 (эквивалентно 5800000) это почти полностью загрузит процессор - 97.8%.

Файлы http://pure-basic.narod.ru/forum_files/ … U_Load.zip