Планировщики – это одни из основных компонентов операционных систем, так как они распределяет процессорное время между задачами (процессами), создавая иллюзию параллельной работы. Планировщики подразделяются на кооперативные и вытесняющие.  

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

   В случае с вытесняющими планировщиками, задачам отводится определенный квант времени. По завершению выделенного времени планировщик прерывает выполнение задачи, сохраняет ее контекст и запускает на выполнение другую задачу. Спустя какое-то время, первоначальная задача будет снова запущена на выполнение с того места, на котором она была остановлена. Реализация такого планировщика более трудоемка.

 

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

   Для каждой задачи мы определяем две основные вещи – задержку перед самым первым выполнением задачи и период ее выполнения. Во время каждого прерывания таймера, запускается планировщик, который уменьшает значения счетчиков задач и помечает те из них, которые готовы к выполнению. 

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

   Давайте начнем с рассмотрения задачи. Посмотрите на следующее описание.

#include <ioavr.h>

#include <intrinsics.h>

 

typedef unsigned char u8;

typedef unsigned int u16;

typedef struct task

{

   // указатель на функцию

   void (*pfunc) (void);

   // задержка перед первым запуском задачи

   u16 delay;

   // период запуска задачи

   u16 period;

   // флаг готовности задачи к запуску

   u8 run;

}task;

 

#define StartFrom       0x3D

#define MAXnTASKS       8

 

volatile task TaskArray[MAXnTASKS];

   Мы определяем новый тип данных, именуемый task. Это структура, которая содержит в себе основные параметры задачи:  указатель на функцию, временные параметры и флаг ее готовности. 

 

   Каждая задача выполняет свою функцию и чтобы это обобщить, мы используем такую вещь, как указатель - void (*pfunc) (void). Как видно из описания, это указатель на функцию, которая не принимает аргументы и ничего не возвращает. Следует оставить функции задач именно в таком виде. Если у вас есть потребность в коммуникации задач между собой, нужно обеспечить ее с помощью глобальных переменных. 

   Задержка до первоначального выполнения задачи и интервал между последующими запусками (переменные dalay и period)задаются в виде количества «тиков» системного таймера, в роли которого у нас выступает 8-ми разрядный таймер Т0.

 

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

   Частота работы системного таймера должна быть подобрана таким образом, чтобы даже самая продолжительная задача успевала завершиться в пределах одного цикла. В данном случае я выбрал 25-ти миллисекундный интервал, но он может быть и меньше.

 

Перейдем к функции инициализации планировщика.

void InitScheduler (void)

{

   u8 i;

   

   // устанавливаем прескалер - 1024

   TCCR0 |= (1<<CS02)|(1<<CS00);

   // очищаем флаг прерывания таймера Т0

   TIFR = 1<<TOV0;

   // разрешаем прерывание по переполнению

   TIMSK |= 1<<TOIE0;

    // загружаем начальное зн. в счетный регистр

   TCNT0 = StartFrom;

 

   // очищаем массив задач

   for (i=0; i<MAXnTASKS; i++) DeleteTask(i);

}

 

void DeleteTask (u8 j)

{

   TaskArray[j].pfunc = 0x0000;

   TaskArray[j].delay = 0;

   TaskArray[j].period = 0;

   TaskArray[j].run = 0;

}

   Здесь мы просто конфигурируем таймер Т0 и очищаем массив задач с помощью функции DeleteTask().

 

   Для добавления задач используется функция AddTask(). Она определяет доступную позицию в массиве задач и помещает в нее новую задачу.

void AddTask (void (*taskfunc)(void), u16 taskdelay, u16 taskperiod)

{

   u8 n=0;

 

   Например, если вы добавите следующие задачи в массив задач (AddTask (TestA, 0, 3), AddTask (TestB, 1, 4), AddTask (TestC, 4, 0)), то получите изображенный на рисунке  режим работы. 

   Самое время обсудить обработчик прерывания таймера и что в нем должно происходить. 

#pragma vector=TIMER0_OVF_vect

__interrupt void Timer0ovf(void)

{

   u8 m;

  

   //перезагрузка таймера Т0

   TCNT0 = StartFrom;

   

   for (m=0; m<MAXnTASKS; m++)

   {

      if (TaskArray[m].pfunc)

      {  

         //если подошло время запуска задачи 

         if (TaskArray[m].delay == 0) 

         {

            //устанавливаем флаг и перезаписываем счетчик 

            TaskArray[m].run = 1;

            TaskArray[m].delay = TaskArray[m].period;

         }

         else TaskArray[m].delay--;

      }

   }

}

 

   Что ж, это элементарно. Мы просто уменьшаем задержку для каждой задачи и помечаем задачи, готовые к запуску. Заметьте, что обработчик прерывания не вызывает никакие задачи, потому что должен работать быстро. Задачи запускаются из главного цикла программы с помощью специальной функции, называемой диспетчером. 

   Как видно из кода, переменная, в которой хранилась задержка первоначального запуска задачи, используется в качестве счетчика времени. После ее обнуления, она инициализируется значением переменной period. 

    

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

void DispatchTask (void)

{

   u8 k;

        

   for (k=0; k<MAXnTASKS; k++)

   {

      if (TaskArray[k].run == 1)

      {

         // запуск задачи

         (*TaskArray[k].pfunc)();

         // очистка флага задачи

         TaskArray[k].run = 0;

      }

   }

}

   Всесторонние испытания и доработку планировщика я оставляю на ваше усмотрение. 

   В качестве примера использования описанного планировщика, я предлагаю тестовый проект с тремя задачами. Задачи ничего полезного не делают, только выводят в последовательный порт определенные цифры. 

#include <ioavr.h>

#include <intrinsics.h>

#define sei() __enable_interrupt()

 

typedef unsigned char u8;

typedef unsigned int u16;

typedef struct task

{

   void (*pfunc) (void);

   u16 delay;

   u16 period;

   u8 run;

}task;

 

#define StartFrom       0x3D

#define MAXnTASKS       8

#define UBRRvalue 0x0033

 

volatile task TaskArray[MAXnTASKS];

 

void InitUART (u16 baud);

void TransmitByte (u8 data);

void InitScheduler (void);

void UpdateScheduler(void);

void DeleteTask (u8 index);

void AddTask (void (*taskfunc)(void), u16 taskdelay, u16 taskperiod);

void DispatchTask (void);

 

void TestA (void);

void TestB (void);

void TestC (void);

 

int main(void)

{

   InitUART (UBRRvalue);

   InitScheduler();

        

   // Добавление задач       

   AddTask (TestA, 0, 3);

   AddTask (TestB, 1, 4);

   AddTask (TestC, 4, 0);

        

   sei();

        

   while (1) 

   {

      DispatchTask();

   }            

}

 

void InitUART (u16 baud)

{

   UBRRH = (u8)(baud>>8);                                                        

   UBRRL = (u8)baud;

   UCSRB = (1<<RXEN)|(1<<TXEN);              

   UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);

}

 

void TransmitByte (u8 data)

{

   while ( !( UCSRA & (1<<UDRE)) );

   UDR = data;

}

 

void InitScheduler (void)

{

   u8 i;

   

   TCCR0 |= (1<<CS02)|(1<<CS00);

   TIFR = 1<<TOV0;

   TIMSK |= 1<<TOIE0;

   TCNT0 = StartFrom;

 

   for (i=0; i<MAXnTASKS; i++) DeleteTask(i);

}

 

void DeleteTask (u8 j)

{

   TaskArray[j].pfunc = 0x0000;

   TaskArray[j].delay = 0;

   TaskArray[j].period = 0;

   TaskArray[j].run = 0;

}

 

void AddTask (void (*taskfunc)(void), u16 taskdelay, u16 taskperiod)

{

   u8 n=0;

 

   while ((TaskArray[n].pfunc != 0) && (n < MAXnTASKS)) n++;

 

   if (n < MAXnTASKS)

   {

      TaskArray[n].pfunc = taskfunc;

      TaskArray[n].delay = taskdelay;

      TaskArray[n].period = taskperiod;

      TaskArray[n].run = 0;   

   }

}

 

 

#pragma vector=TIMER0_OVF_vect

__interrupt void Timer0ovf(void)

{

   u8 m;

 

   TransmitByte('-'); 

   

   TCNT0 = StartFrom;

   

   for (m=0; m<MAXnTASKS; m++)

   {

      if (TaskArray[m].pfunc)

      {   

         if (TaskArray[m].delay == 0) 

         {

            TaskArray[m].run = 1;

            TaskArray[m].delay = TaskArray[m].period;

         }

         else TaskArray[m].delay--;

      }

   }

}

 

void DispatchTask (void)

{

   u8 k;

   

   for (k=0; k<MAXnTASKS; k++)

   {

      if (TaskArray[k].run == 1)

      {

         (*TaskArray[k].pfunc)();

         TaskArray[k].run = 0;

      }

   }

}

 

void TestA (void)

{

   TransmitByte('1'); 

}

 

void TestB (void)

{

   TransmitByte('2'); 

}

 

void TestC (void)

{

   TransmitByte('3'); 

}

   Если вы подключите вашу любимую терминальную программу и получите следующий ряд… -1 -2 - - -13 -3 -23 -3 -13 -3 -3 -23 -13 -3 -3 -3 -123 -3 -3 -3 -13 -23 -3 -3 -13 -3 -23 -3 -13 -3 -3 -23 -13 -3 -3 -3 -123 ... это значит, что планировщик работает.

 

   Напоследок скажу, не желательно использовать с этой схемой прерывания. Единственное прерывание, которое должно здесь быть – это прерывание переполнения таймера. Если вы задействуете другие прерывания, задачи  не смогут запускаться в точно заданное время!

Файлы

Планировщик. Проект для IARAVR
Планировщик. Проект для WINAVR
Планировщик. Проект для CodeVisionAVR