PIC24 osa:ref:services

Сервисы OSA в алфавитном порядке

2010-06-12T16:33:06+03:00

Сервисы OSA в алфавитном порядке

OSA : Бинарные семафоры

2009-12-12T02:12:41+03:00

OSA : Бинарные семафоры

Бинарные семафоры - системные переменные, способные принимать значения "0" и "1". Это самый простой способ обмена информацией между задачами, а также для синхронизации между ними. Для экономии RAM в OSA все бинарные семафоры являются битовыми полями в переменных, создаваемых самой системой. Программист должен только указать, сколько памяти выделить под бинарные семафоры, задав в файле OSAcfg.h константу OS_BSEMS. Поэтому память под бинарные семафоры резервируется на этапе компиляции и их нельзя создавать или удалять в ходе работы программы.

Идентификация

При обращении к системным сервисам, управляющим бинарными семафорами, нужно указывать номер используемого семафора от 0 до (OS_BSEMS-1), т.е. его идентификатор. Идентефикаторы семафорам удобно присваивать в виде enum, тогда есть гарантия, что они не будут пересекаться:

enum OSA_BINSEMS_ENUM
{
    BS_BUTTON_PRESSED,
    BS_USART_FREE,
    BS_WRITE_COMPLETE,
    . . .
};

Такой подход не очень удобен, особенно, если предполагается использование отдельно написанных модулей, но является очень экономным к ресурсам ПИКа (и ROM, и RAM, и скорость): на 8 бинарных семафоров требуется всего один байт ОЗУ. Если же требуются независимые семафоры, то можно использовать счетные семафоры с сервисом установки семафора OS_Csem_Set.

Работа с бинарными семафорами

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

Ниже приведен небольшой пример использования бинарного семафора для разделения доступа к общему ресурсу - внешенй EEPROM:

#include <osa.h>
 
enum OSA_BINSEMS_ENUM {
    BS_EEPROM_FREE
};
 
void Task1 (void)
{
    for (;;) {
        ...
        OS_Bsem_Wait(BS_EEPROM_FREE);     // Ждем, когда остальные задачи отпустят eeprom
 
        // Когда попадаем сюда, eeprom свободен, а семафор сброшен, что не позволит другим
        // задачам начать работу с eeprom
        eeprom_read(1);
        eeprom_read(2);
        OS_Bsem_Set(BS_EEPROM_FREE);      // После выполнения операций с EEPROM освобождаем ресурс
        ...
    }
}
 
void Task2 (void)
{
    for (;;) {
        ...
        OS_Bsem_Wait(BS_EEPROM_FREE);     // Ждем, когда остальные задачи отпустят eeprom
 
        // Когда попадаем сюда, eeprom свободен, а семафор сброшен, что не позволит другим
        // задачам начать работу с eeprom
        eeprom_write(5, 10);
        OS_Delay(5);                     // Ждем окончания записи. При ожидании задержки
                                         // управление передается планировщику, который может
                                         // в свою очередь передать управление задаче Task1. И чтобы
                                         // Task1 не полезла в EEPROM, ресурс заблокирован бинарынм
                                         // семафором
        eeprom_write(6, 20);
        OS_Delay(5);
        OS_Bsem_Set(BS_EEPROM_FREE);      // После выполнения операций с EEPROM освобождаем ресурс
        ...
    }
}

Размещение в памяти

Для PIC16 программист может выбрать, в каком банке RAM будут храниться бинарные семафоры. Для этого есть константа OS_BANK_BSEMS, которая может принимать значения от 0 до 3. Все бинарные семафоры размещаются в одном банке; нельзя половину опрелелить,например, в bank0, а оставшиеся - в bank2. В памяти бинарные семафоры представлены как массив unsigned char, поэтому эта структура неделима.

Сервисы для работы с двоичными семафорами.

Сервис	Аргументы	Описание
Управление
OS_Bsem_Set	`(bsem)`	Устанавливает семафор
OS_Bsem_Reset	`(bsem)`	Сбрасывает семафор
OS_Bsem_Switch	`(bsem)`	Переключает семафор в противоположное состояние
Проверка
`bool` OS_Bsem_Check	`(bsem)`	Смотрим, установлен ли конкретный семафор
Ожидание
OS_Bsem_Wait	`(bsem)`	Ожидаем установку семафора.
OS_Bsem_Wait_TO	`(bsem, timeout)`	Ожидаем установку семафора с таймаутом.

CЕРВИСЫ OSA (ПАМЯТКА)

2010-06-12T16:32:35+03:00

CЕРВИСЫ OSA (ПАМЯТКА)

Алфавитный указатель

Ниже приведен полный перечень сервисов OSA. В правой графе стоят пиктограммы, отображающие свойства сервисов:

	Использует системный таймер
	Нельзя вызывать из прерывания
	Разрешен вызов только в контексте задачи
	Разрешается вызов из задачи и функций, вызываемых задачей (любой вложенности)
	Переключает контекст
	Разрешен вызов только в прерывании
	Есть расширенный сервис с суффиксом _I для работы в прерывании

Системные сервисы

Сервис	Аргументы	Описание	Свойства
Системные
OS_Sched		Основная работа операционки, вызывается в главном цикле функции main()
OS_Run		Запускает ядро операционки в работу.	main()
OS_Init		Инициализация переменных системы.
OS_Timer		Обработка всех таймеров
Ожидание
OS_Yield		Передача управления планировщику
OS_Delay	`(delaytime)`	Выдерживаем паузу внутри задачи
OS_Wait	`(condition)`	Ожидаем выполнения условия
OS_Wait_TO	`(condition, timeout)`	Ожидаем выполнения условия с таймаутом
Проверка состояния
`bool` OS_IsTimeout		Проверка, вышли ли из ожидания по таймауту
`bool` OS_IsError		Проверка, была ли ошибка
`bool` OS_IsEventError		Проверка, была ли ошибка события
`bool` OS_IsInCriticalSection		Возвращает 1, если одна из задач находится в критической секции.
Прерывания
OS_EnterInt		Должна выполняться при входе в прерывание (сохраняет FSR)
OS_LeaveInt		Должна выполняться перед выходом из прерывания (восстанавливает FSR)
`char` OS_DI		Запретить прерывания. Текущие значения GIEx сохраняются
OS_EI		Разрешить прерывания
OS_RI	`(char)`	Восстановить сохраненные в OS_DI() значения GIEx.
OS_EnterCriticalSection		Вход в критическую секцию
OS_LeaveCriticalSection		Выход из критической секции

Управление задачами

Сервис	Аргументы	Описание	Свойства
Создание/удаление
OS_Task_Define	`(TaskName)`	Для CCS: сообщает компилятору, что функция вызывается по указателю.	main()
OS_Task_Create	`(priority, TaskName)`	Инициализируем конкретную задачу.
OS_Task_Replace	`(priority, TaskName)`	Заменить текущую задачу на новую.
OS_Task_Delete	`(tp)`	Удалить задачу
Управление состоянием
`OST_TASK_POINTER` OS_Task_GetCur		Получить указатель на дескриптор текущей задачи
`OST_TASK_POINTER` OS_Task_GetCreated		Получить указатель на дескриптор только что созданной задачи
OS_Task_Pause	`(tp)`	Приостановить задачу
OS_Task_Continue	`(tp)`	Продолжить выполнение ранее приостановленной задачи
`char` OS_Task_GetPriority	`(tp)`	Возвращает приоритет текущей задачи
OS_Task_SetPriority	`(tp, priority)`	Изменить приоритет текущей задачи
OS_Task_IsPaused	`(tp)`	Проверить, приостановлена ли задача

Двоичные семафоры

Сервис	Аргументы	Описание
Управление
OS_Bsem_Set	`(bsem)`	Устанавливает семафор
OS_Bsem_Reset	`(bsem)`	Сбрасывает семафор
OS_Bsem_Switch	`(bsem)`	Переключает семафор в противоположное состояние
Проверка
OST_WORD OS_Bsem_Check	`(bsem)`	Смотрим, установлен ли конкретный семафор
Ожидание
OS_Bsem_Wait	`(bsem)`	Ожидаем установку семафора.
OS_Bsem_Wait_TO	`(bsem, timeout)`	Ожидаем установку семафора с таймаутом.

Счетные семафоры

Сервис	Аргументы	Описание
Создание
OS_Csem_Create	`(csem)`	Подготавливает счетный семафор к работе (обнуляет его)
Управление
OS_Csem_Signal	`(csem)`	Увеличивает значение семафора на 1 (с ожиданием при переполнении)
OS_Csem_Signal_Now	`(csem)`	Увеличивает значение семафора на 1 (без ожидания при переполнении).
OS_Csem_Set	`(csem)`	Устанавливаем счетный семафор в 1.
OS_Csem_SetValue	`(csem, value)`	Устанавливаем счетный семафор в конкретное значение value.
OS_Csem_Reset	`(csem)`	Обнуляем счетный семафор
Проверка
OS_Csem_Accept	`(csem)`	Принимаем счетный семафор (уменьшаем его на 1).
`bool` OS_Csem_Check	`(csem)`	Смотрим, установлен ли семафор (д.б. != 0)
Ожидание
OS_Csem_Wait	`(csem)`	Ожидаем установки семафора в ненулевое значение. Уменьшает значение семафора на 1.
OS_Csem_Wait_TO	`(csem, timeout)`	Ожидаем установки семафора с таймаутом.

Сообщения

Сервис	Аргументы	Описание
Создание
OS_Msg_Create	`(msg_cb)`	Создает сообщение.
Отправка
OS_Msg_Send	`(msg_cb, message)`	Отправляем сообщение msg_cb (тип OST_MSG_CB) с ожиданием освобождения
OS_Msg_Send_TO	`(msg_cb, message, timeout)`	То же, что и OS_Msg_Send с выходом по таймауту
OS_Msg_Send_Now	`(msg_cb, message)`	Отправляем сообщение msg_cb без ожидания освобождения
Проверка
`bool` OS_Msg_Check	`(msg_cb)`	Проверить, активно ли сообщение (присутствует ли оно).
OS_Msg_Accept	`(msg_cb, os_msg_type_var)`	Принять существующее сообщение.
Ожидание
OS_Msg_Wait	`(msg_cb, os_msg_type_var)`	Ожидаем сообщение msg_cb.
OS_Msg_Wait_TO	`(msg_cb, os_msg_type_var, timeout)`	То же, что и OS_Msg_Wait, с выходом по таймауту

Короткие сообщения

Сервис	Аргументы	Описание
Создание
OS_Smsg_Create	`(smsg)`	Создает короткое сообщение (фактически - просто обнуляет его)
Отправка
OS_Smsg_Send	`(smsg, smessage)`	Отправляем сообщение smsg с содержимым smessage с ожиданием освобождения
OS_Smsg_Send_TO	`(smsg, smessage, timeout)`	То же, что и OS_Smsg_Send, но с выходом по таймауту
OS_Smsg_Send_Now	`(smsg, smessage)`	Отправляем короткое сообщение smsg с содержимым smessage без ожидания освобождения
Проверка
`bool` OS_Smsg_Check	`(smsg)`	Проверить, активно ли сообщение (присутствует ли оно).
OS_Smsg_Accept	`(smsg, os_smsg_type_var)`	Принять существующее сообщение
Ожидание
OS_Smsg_Wait	`(smsg, os_smsg_type_var)`	Ожидаем короткое сообщение smsg.
OS_Smsg_Wait_TO	`(smsg, os_smsg_type_var, timeout)`	То же, что и OS_Smsg_Wait, с выходом по таймауту

Очередь сообщений

Сервис	Аргументы	Описание
Создание
OS_Queue_Create	`(queue, buffer, size)`	Создаем очередь сообщений queue, указывая буфер и его размер
Отправка
OS_Queue_Send	`(queue, message)`	Отправляем сообщение с содержимым message в очередь queue с ожиданием свободной ячейки
OS_Queue_Send_TO	`(queue, message, timeout)`	То же, что и OS_Queue_Send, но с выходом по таймауту
OS_Queue_Send_Now	`(queue, message)`	Отправляем сообщение с содержимым message в очередь queue без ожидания свободной ячейки
Проверка
`bool` OS_Queue_Check	`(queue)`	Проверить, есть ли сообщение в очереди.
`bool` OS_Queue_IsFull	`(queue)`	Проверка переполненности буфера
Ожидание
OS_Queue_Wait	`(queue, os_msg_type_var)`	Ожидаем сообщение из очереди queue
OS_Queue_Wait_TO	`(queue, os_msg_type_var, timeout)`	То же, что и OS_Queue_Wait, но с выходом по таймауту

Очередь коротких сообщений

Сервис	Аргументы	Описание
Создание
OS_Squeue_Create	`(squeue, buffer, size)`	Создаем очередь коротких сообщений squeue, указывая буфер и его размер
Отправка
OS_Squeue_Send	`(squeue, smessage)`	Отправляем сообщение с содержимым smessage в очередь squeue с ожиданием свободной ячейки
OS_Squeue_Send_TO	`(squeue, smessage, timeout)`	То же, что и OS_Squeue_Send, но с выходом по таймауту
OS_Squeue_Send_Now	`(squeue, smessage)`	Отправляем сообщение с содержимым smessage в очередь squeue без ожидания свободной ячейки
Проверка
`bool` OS_Squeue_Check	`(squeue)`	Проверить, есть ли сообщение в очереди.
`bool` OS_Squeue_IsFull	`(squeue)`	Проверка переполненности буфера. Возвращает true, если в очереди нет места.
Ожидание
OS_Squeue_Wait	`(squeue, os_smsg_type_var)`	Ожидаем сообщение из очереди squeue
OS_Squeue_Wait_TO	`(squeue, os_smsg_type_var, timeout)`	То же, что и OS_Squeue_Wait, но с выходом по таймауту

Флаги

Сервис	Аргументы	Описание
Создание
OS_Flag_Create	`(flags)`	Создает флаги (фактически просто сбрасывает все флаги)
Управление
OS_Flag_Init	`(flags, value)`	Устанавливает все флаги в заданное значение
OS_Flag_Set	`(flags, mask)`	Установка флагов по маске
OS_Flag_Clear	`(flags, mask)`	Сброс флагов по маске
Проверка
`bool` OS_Flag_Check_AllOn	`(flags, mask)`	Проверить, все ли флаги по маске установлены
`bool` OS_Flag_Check_On	`(flags, mask)`	Проверить, есть ли хотя бы один установленный флаг по маске
`bool` OS_Flag_Check_AllOff	`(flags, mask)`	Проверить, все ли флаги по маске сброшены
`bool` OS_Flag_Check_Off	`(flags, mask)`	Проверить, есть ли хотя бы один сброшенный флаг по маске
Ожидание
OS_Flag_Wait_AllOn	`(flags, mask)`	Ожидаем установки всех флагов по маске
OS_Flag_Wait_On	`(flags, mask)`	Ожидаем установки хотя бы одного флага из маски
OS_Flag_Wait_AllOff	`(flags, mask)`	Ожидаем сброса всех флагов по маске
OS_Flag_Wait_Off	`(flags, mask)`	Ожидаем сброса хотя бы одного флага из маски
OS_Flag_Wait_AllOn_TO	`(flags, mask, timeout)`	Ожидаем установки всех флагов по маске с выходом по таймауту
OS_Flag_Wait_On_TO	`(flags, mask, timeout)`	Ожидаем установки хотя бы одного флага из маски с выходом по таймауту
OS_Flag_Wait_AllOff_TO	`(flags, mask, timeout)`	Ожидаем сброса всех флагов по маске с выходом по таймауту
OS_Flag_Wait_Off_TO	`(flags, mask, timeout)`	Ожидаем сброса хотя бы одного флага из маски с выходом по таймауту

Таймеры

Таймеры задач

Сервис	Аргументы	Описание
Управление
OS_Ttimer_Run	`(time)`	Запустить таймер текущей задачи на отсчет времени time. Флаг переполнения сбрасывается.
OS_Ttimer_Break	`(qtimer)`	Останавливаем таймер. Флаг переполнения устанавливается
OS_Ttimer_Wait	`()`	Ожидаем завершения счета таймера текущей задачи.
OS_Ttimer_Delay	`(delay)`	(то же, что и OS_Delay) Выдержать задержку с применением таймера текущей задачи
Проверка
`_OST_TTIMER` OS_Ttimer_Get	`()`	Получить оставшееся время счета (необходимо запрещать прерывания или приостанавливать счет)
`bool` OS_Ttimer_Check	`()`	Проверить, закончил ли таймер текущей задачи счет.
`bool` OS_Ttimer_IsRun	`()`	Проверить, считает ли таймер текущей задачи
Дополнительно
OS_Ttimer_Pause	`()`	Останавливаем таймер текущей задачи. Флаг переполнения утсанавливается.
OS_Ttimer_Continue	`()`	Восстанавливаем счет таймера.

Статические таймеры

Сервис	Аргументы	Описание
Создание/удаление
OS_Stimer_Alloc	`(var_stimer_id)`	Выделяет не занятый на данный момент времени таймер и возвращает его номер
OS_Stimer_Free	`(stimer_id)`	Помечает таймер как свободный
`bool` OS_Stimer_Found	`()`	Проверяет, есть ли свободный статический таймер
Управление
OS_Stimer_Run	`(stimer_id, time)`	Запустить таймер stimer_id на отсчет времени time. Флаг переполнения сбрасывается.
OS_Stimer_Break	`(qtimer)`	Останавливаем таймер. Флаг переполнения устанавливается
OS_Stimer_Wait	`(stimer_id)`	Ожидаем завершения счета таймера.
OS_Stimer_Delay	`(stimer_id, delay)`	Выдержать задержку с применением статического таймера stimer_id
Проверка
`_OST_STIMER` OS_Stimer_Get	`(stimer_id)`	Получить оставшееся время счета (необходимо запрещать прерывания)
`bool` OS_Stimer_Check	`(stimer_id)`	Проверить, было ли переполнение.
`bool` OS_Stimer_IsRun	`(stimer_id)`	Проверить, считает ли таймер
Дополнительно
OS_Stimer_Pause	`(stimer_id)`	Останавливаем таймер. Флаг переполнения утсанавливается.
OS_Stimer_Continue	`(stimer_id)`	Восстанавливаем счет таймера.

Очередь таймеров

Сервис	Аргументы	Описание
Создание/Удаление
OS_Qtimer_Create	`(qtimer)`	Добавляет qtimer в очередь активных таймеров. После создания таймер обнулен остановлен, флаг переполнения сброшен.
OS_Qtimer_Delete	`(qtimer)`	Удаляет qtimer из очереди активных таймеров.
Управление
OS_Qtimer_Run	`(qtimer, time)`	Запустить qtimer на отсчет времени time с момента вызова этого сервиса. Флаг переполнения сбрасывается.
OS_Qtimer_Break	`(qtimer)`	Останавливаем таймер. Флаг переполнения устанавливается
OS_Qtimer_Wait	`(qtimer)`	Ожидаем завершения счета таймера.
OS_Qtimer_Delay	`(qtimer, time)`	Выдержать задержку с использованием таймера qtimer
Проверка
`_OST_QTIMER` OS_Qtimer_Get	`(qtimer)`	Получить оставшееся время счета (необходимо запрещать прерывания)
`bool` OS_Qtimer_Check	`(qtimer)`	Проверить, было ли переполнение.
`bool` OS_Qtimer_IsRun	`(qtimer)`	Проверить, считает ли таймер

Таймеры (устаревшие)

Динамические таймеры

Сервис	Аргументы	Описание
Создание/Удаление
OS_Dtimer_Create	`(dtimer)`	Добавляет dtimer в очередь активных таймеров. После создания таймер обнулен остановлен, флаг переполнения сброшен.
OS_Dtimer_Delete	`(dtimer)`	Удаляет dtimer из очереди активных таймеров.
Управление
OS_Dtimer_Run	`(dtimer, newtime)`	Запустить dtimer на отсчет времени newtime с момента вызова этого сервиса. Флаг переполнения сбрасывается.
OS_Dtimer_Break	`(dtimer)`	Останавливаем таймер. Он остается активным, но не увеличивается при выполнении OS_Timer(). Флаг переполнения устанавливается.
OS_Dtimer_Wait	`(dtimer)`	Ожидаем завершения счета таймера.
OS_Dtimer_Delay	`(dtimer, delay)`	Выдержать задержку с использованием динамического таймера dtimer
Проверка
`_OST_DTIMER` OS_Dtimer_Get	`(dtimer)`	Получить оставшееся время счета (необходимо запрещать прерывания)
`bool` OS_Dtimer_Check	`(dtimer)`	Проверить, было ли переполнение.
`bool` OS_Dtimer_IsRun	`(dtimer)`	Проверить, считает ли таймер
Дополнительно
OS_Dtimer_Pause	`(dtimer)`	Останавливаем таймер. Он остается активным, но не увеличивается при выполнении OS_Timer(). Флаг переполнения остается без изменений.
OS_Dtimer_Continue	`(dtimer)`	Восстанавливаем счет таймера.
OS_Dtimer_Update	`(dtimer, time)`	Запустить таймер на отсчет времени time с момента последнего переполнения. Флаг переполнения сбрасывается.
OS_Dtimer_Add	`(dtimer, addtime)`	Добавить время к таймеру во время счета. Флаг переполнения остается без изменений.
`bool` OS_Dtimer_IsActive	`(dtimer)`	Проверить, есть ли таймер в списке активных таймеров.
`bool` OS_Dtimer_IsStopped	`(dtimer)`	Проверить, остановлен ли таймер

Статические таймеры старого типа

Сервис	Аргументы	Описание
Управление
OS_Oldtimer_Run8	`(timer8_id, time)`	Запустить 8-разрядный таймер для отсчета
OS_Oldtimer_Run16	`(timer16_id, time)`	Запустить 16-разрядный таймер для отсчета
OS_Oldtimer_Run24	`(timer24_id, time)`	Запустить 24-разрядный таймер для отсчета
OS_Oldtimer_Run32	`(timer32_id, time)`	Запустить 32-разрядный таймер для отсчета
OS_Oldtimer_Stop	`(timer_id)`	Останавливаем таймер (при этом устанавливается флаг Timeout для этого таймера)
Проверка
`bool` OS_Oldtimer_Check	`(timer_id)`	Проверить, закончил ли таймер счет.
Ожидание
OS_Oldtimer_Wait	`(timer_id)`	Ожидаем завершения счета таймера

OSA : Счетные семафоры

2009-12-12T18:41:24+03:00

OSA : Счетные семафоры

Введение

Счетные семафоры - переменные типа unsigned char, unsigned int или unsigned long (в зависимости от установки константы OS_CSEM_SIZE в OSAcfg.h). Для того чтобы использовать счетные семафоры, в OSAcfg.h нужно определить константу OS_ENABLE_CSEM.

В программе счетный семафор определяется как переменная:

OST_CSEM  mycsem;

Для HT-PICC16 счетные семафоры можно размещать только в банках bank0 и bank1.

Функционально счетные семафоры отличаются от бинарных тем, что могут принимать любое значение в диапазоне от 0 до максимального значения, допустимого типом семафора (255, 65535, 4294967295).

Перед работой со счетным семафором, его необходимо создать сервисом OS_Csem_Create. После создания семафор имеет нулевое значение. Задача, ожидающая семафор, будет находиться в режиме ожидания до тех пор, пока семафор не станет ненулевым. Как только задача дождется этого события, она переходит в состояние готовности и при получении управления вычитает из семафора 1.

Значение семафора может быть изменено одним из сервисов установки значения. Следует обратить внимание на то, что эти сервисы делятся на 2 подгруппы: обычные (можно использовать только вне прерываний) и для работы в прерывании. Для того, чтобы пользоваться счетными семафорами внутри прерываний, в файле OSAcfg.h нужно определить константу OS_ENABLE_INT

Отдельно можно выделить сервис OS_Csem_Signal. Этот сервис увеличивает счетный семафор на 1. Но если на момент вызова сервиса семафор уже имеет максимально допустимое значение, то установится флаг bEventError (проверяется сервисом OS_IsEventError), а семафор останется неизменным.

Все сервисы для работы со счетными семафорами.

Сервис	Аргументы	Описание
Создание
OS_Csem_Create	`(csem)`	Подготавливает счетный семафор к работе (обнуляет его)
Управление
OS_Csem_Signal	`(csem)`	Увеличивает значение семафора на 1 (с ожиданием при переполнении)
OS_Csem_Signal_Now	`(csem)`	Увеличивает значение семафора на 1 (без ожидания при переполнении).
OS_Csem_Set	`(csem)`	Устанавливаем счетный семафор в 1.
OS_Csem_SetValue	`(csem, value)`	Устанавливаем счетный семафор в конкретное значение value.
OS_Csem_Reset	`(csem)`	Обнуляем счетный семафор
Проверка
OS_Csem_Accept	`(csem)`	Принимаем счетный семафор (уменьшаем его на 1).
`bool` OS_Csem_Check	`(csem)`	Смотрим, установлен ли семафор (д.б. != 0)
Ожидание
OS_Csem_Wait	`(csem)`	Ожидаем установки семафора в ненулевое значение. Уменьшает значение семафора на 1.
OS_Csem_Wait_TO	`(csem, timeout)`	Ожидаем установки семафора с таймаутом.

OSA : Критичекие секции

2009-12-12T02:11:16+03:00

OSA : Критичекие секции

Введение

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

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

Для того, чтобы пользоваться сервисами работы с критическими секциями, в OSAcfg.h нужно определить константу OS_ENABLE_CRITICAL_SECTION

Для защиты критических секций есть два сервиса:

OS_EnterCriticalSection - вход в критическую секцию и OS_LeaveCriticalSection - выход из критической секции.

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

Входя в критическую секцию, нужно помнить некоторые правила, описанные ниже.

Сохранение текущего состояния флагов GIEx

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

Системный таймер в критической секции

Использовать задержки OS_Delay, таймеры, а также ожидать события с таймаутами можно только в том случае, если вызов сервиса OS_Timer находится вне прерывания, иначе система будет ждать до бесконечности. (Либо после входа в критическую секцию разрешать прерывания сервисом OS_EI, если логика программы позволяет в данной ситуации оставить прерывания.) Избежать этого можно, продублировав вызов OS_Timer в основном цикле (там же, где вызывается OS_Sched).

void interrupt int_routine (void)
{
    OS_EnterInt();
    if (TMR2IF)       // Эта часть программы не отработает в
    {                 // критической секции
         TMR2IF = 0;
         OS_Timer();  // Этот вызов обрабатывается вне критической секции
    }
    OS_LeaveInt();
}
 
void Task1 (void)
{
    for (;;) {
        . . .
        OS_EnterCriticalSection();
        OS_Delay(100);
        OS_LeaveCriticalSection();
        . . .
    }
}
 
void main (void)
{
    OS_Init();
    OS_Task_Create(0, Task1);
    for (;;)
    {
        OS_Sched();
        if (OS_IsInCriticalSection()) {
            if (TMR2IF) {
                TMR2IF = 0;
                OS_Timer();    // Этот вызов обрабатывается в критической секции
            }
        }
    }
}

Ожидание событий в критической секции

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

void Task1 (void)
{
    for (;;) {
        . . .
        // Неправильный подход
        OS_EnterCriticalSection();
        OS_Bsem_Wait(BS_USART_FREE);
        . . .
        // Правильный подход
        OS_Bsem_Wait(BS_USART_FREE);
        OS_EnterCriticalSection();
        . . .
    }
}

Сервисы для критических секций

Сервис	Аргументы	Описание	Свойства
`bool` OS_IsInCriticalSection		Возвращает 1, если одна из задач находится в критической секции.
OS_EnterCriticalSection		Вход в критическую секцию
OS_LeaveCriticalSection		Выход из критической секции

OSA : Флаги

2009-12-12T02:13:38+03:00

OSA : Флаги

Введение

Флаги, по сути, очень похожи на бинарные семафоры. Есть две принципиальные разницы:

одним сервисом можно обработать несколько флагов сразу (например, можно ждать установки хотя бы одного из нескольких флагов или установки сразу нескольких);
после завершения ожидания флаги, в отличие от бинарных семафоров, не сбрасываются.

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

#include <osa.h>
 
OST_FLAG8   F_Sensors;
 
#define  TEMPERATURE_MEASURED   0x01
#define  PRESSURE_MEASURED      0x02
#define  HUMIDITY_MEASURED      0x04
 
void Task_Calc (void)
{
    for (;;) {
        // Ждем завершения измерений
        OS_Flag_Wait_11(F_Sensors, TEMPERATURE_MEASURED | PRESSURE_MEASURED | HUMIDITY_MEASURED);
        OS_Flag_Set_0(F_Sensors, TEMPERATURE_MEASURED | PRESSURE_MEASURED | HUMIDITY_MEASURED);
 
        // Теперь можно начинать расчеты
        ...
    }
}

Другим примером может служить постановка автомобильной сигнализации на охрану. Она может произойти при получении команды с брелока, но только после того, как все двери и багажник будут закрыты. Фрагмен задачи может выглядеть так:

#include <osa.h>
 
OST_FLAG8    F_Doors;      // Флаги, отражающие состояние каждой двери: 1 - открыта, 0 - закрыта
                           // Устанавливаются и сбрасываются в задаче обработки датчиков
 
#define DOORS_MASK   0x0F  // Маска битов, отражающих состояние дверей
#define TRUNK_MASK   0x30  // Маска битов, отражающих состояние капота и багажника
 
void Task_Guard (void)
{
    for (;;) {
        OS_Bsem_Wait(BS_CMD_GUARD);    // Получили команду с брелока "Постановка на охрану"
 
        // Ждем, когда будут закрыты все двери, капот и багажник
        OS_Flag_Wait_00(F_Doors, DOORS_MASK | TRUNK_MASK);
 
        // Начиная отсюда, переходим в режим охраны:
        // подаем звуковые и световые сигналы, берем под охрану все датчики и пр.
        ...
    }
}

Объявление флагов

Флаги могут быть 8-, 16- и 32-разрядные. В программе объявляются так:

OST_FLAG      MyFlag1;	//  8-разрядные флаги
OST_FLAG16    MyFlag2;	// 16-разрядные флаги
OST_FLAG32    MyFlag3;	// 32-разрядные флаги

Флаги можно определять в любом банке памяти, например:

bank2    OST_FLAG16   MyFlag;

В программе могут одновременно использоваться флаги разных разрядностей.

Для работы с флагами их нужно создать сервисом OS_Flag_Create. Этого можно и не делать, но тогда их начальное значение будет не определено. Ниже приведены все системные сервисы для работы с флагами.

Сервисы для работы с флагами.

Сервис	Аргументы	Описание
Создание
OS_Flag_Create	`(flags)`	Создает флаги (фактически просто сбрасывает все флаги)
Управление
OS_Flag_Init	`(flags, value)`	Устанавливает все флаги в заданное значение
OS_Flag_Set_1	`(flags, mask)`	Установка флагов по маске
OS_Flag_Set_0	`(flags, mask)`	Сброс флагов по маске
Проверка
`bool` OS_Flag_Check_11	`(flags, mask)`	Проверить, все ли флаги по маске установлены
`bool` OS_Flag_Check_1x	`(flags, mask)`	Проверить, есть ли хотя бы один установленный флаг по маске
`bool` OS_Flag_Check_00	`(flags, mask)`	Проверить, все ли флаги по маске сброшены
`bool` OS_Flag_Check_0x	`(flags, mask)`	Проверить, есть ли хотя бы один сброшенный флаг по маске
Ожидание
OS_Flag_Wait_11	`(flags, mask)`	Ожидаем установки всех флагов по маске
OS_Flag_Wait_1x	`(flags, mask)`	Ожидаем установки хотя бы одного флага из маски
OS_Flag_Wait_00	`(flags, mask)`	Ожидаем сброса всех флагов по маске
OS_Flag_Wait_0x	`(flags, mask)`	Ожидаем сброса хотя бы одного флага из маски
OS_Flag_Wait_11_TO	`(flags, mask, timeout)`	Ожидаем установки всех флагов по маске с выходом по таймауту
OS_Flag_Wait_1x_TO	`(flags, mask, timeout)`	Ожидаем установки хотя бы одного флага из маски с выходом по таймауту
OS_Flag_Wait_00_TO	`(flags, mask, timeout)`	Ожидаем сброса всех флагов по маске с выходом по таймауту
OS_Flag_Wait_0x_TO	`(flags, mask, timeout)`	Ожидаем сброса хотя бы одного флага из маски с выходом по таймауту

CЕРВИСЫ OSA

2010-10-07T13:54:41+03:00

OSA : Очереди сообщений

2010-06-12T16:32:01+03:00

OSA : Очереди сообщений

Введение

Очереди сообщений являются самым универсальным и очень полезным инструментом ОС для обмена информацией между задачами. Очереди позволяют передавать следующее сообщение, не дожидаясь освобождения предыдущего. Очереди сообщений поддерживаются и для указателей на сообщения и для коротких сообщений. Для использования очередей сообщений в программе нужно в файл OSAcfg.h вставить определение констант:

#define OS_ENABLE_QUEUE
                          // Если собираемся использовать очереди
                          // указателей на сообщения
#define OS_ENABLE_SQUEUE
                          // Если собираемся использовать очереди
                          // коротких сообщений

Определение этих констант скажет компилятору, что в генерируемый код нужно добавить функции для работы с очередями.

В программе очереди объявляются через типы OST_QUEUE и OST_SQUEUE:

OST_QUEUE  queue;    // Очередь указателей на сообщения
OST_SQUEUE squeue;   // Очередь коротких сообщений

Эти определения создают в памяти дескрипторы для работы с очередями, которые содержат информацию о размере очереди, ее заполненности, а также сам указатель на очередь. Для работы с очередями нужно также выделять RAM-память для самой очереди (буфер, куда будут помещаться сообщения).

OST_MSG   msg_queue[10];         // Буфер для очереди из 10 сообщений
OST_SMSG  smsg_queue[15];        // Буфер для очереди из 15 коротких сообщений

Перед работой с очередью, она должна быть создана, т.е. должен быть инициализирован дескриптор очереди:

    OS_Queue_Create(queue, msg_queue, 10);  // Создаем очередь queue на 10 сообщений.
                                         // Сообщения, отправляемые в очередь, будут
                                         // храниться в массиве msg_queue.

Только после вызова этого сервиса можно отправлять сообщения в очередь и принимать их.

Для PIC16 дескриптор очереди и буфер очереди могут находиться только в банках bank0 и bank1.

Объединение

Если в программе предполагается использование очередей обоих типов и есть уверенность в том, что размерности OST_MSG и OST_SMSG одинаковы, то можно в OSAcfg.h определить константу:

#define OS_QUEUE_SQUEUE_IDENTICAL

Это объединит функции обработки очередей разных типов, тем самым сэкономится ROM-память.

Сервисы для работы с очередями сообщений

Очередь сообщений

Сервис	Аргументы	Описание
Создание
OS_Queue_Create	`(queue, buffer, size)`	Создаем очередь сообщений queue, указывая буфер и его размер
Отправка
OS_Queue_Send	`(queue, message)`	Отправляем сообщение с содержимым message в очередь queue с ожиданием свободной ячейки
OS_Queue_Send_TO	`(queue, message, timeout)`	То же, что и OS_Queue_Send, но с выходом по таймауту
OS_Queue_Send_Now	`(queue, message)`	Отправляем сообщение с содержимым message в очередь queue без ожидания свободной ячейки
Проверка
`bool` OS_Queue_Check	`(queue)`	Проверить, есть ли сообщение в очереди.
`bool` OS_Queue_IsFull	`(queue)`	Проверка переполненности буфера
Ожидание
OS_Queue_Wait	`(queue, os_msg_type_var)`	Ожидаем сообщение из очереди queue
OS_Queue_Wait_TO	`(queue, os_msg_type_var, timeout)`	То же, что и OS_Queue_Wait, но с выходом по таймауту

Очередь коротких сообщений

Сервис	Аргументы	Описание
Создание
OS_Squeue_Create	`(squeue, buffer, size)`	Создаем очередь коротких сообщений squeue, указывая буфер и его размер
Отправка
OS_Squeue_Send	`(squeue, smessage)`	Отправляем сообщение с содержимым smessage в очередь squeue с ожиданием свободной ячейки
OS_Squeue_Send_TO	`(squeue, smessage, timeout)`	То же, что и OS_Squeue_Send, но с выходом по таймауту
OS_Squeue_Send_Now	`(squeue, smessage)`	Отправляем сообщение с содержимым smessage в очередь squeue без ожидания свободной ячейки
Проверка
`bool` OS_Squeue_Check	`(squeue)`	Проверить, есть ли сообщение в очереди.
`bool` OS_Squeue_IsFull	`(squeue)`	Проверка переполненности буфера. Возвращает true, если в очереди нет места.
Ожидание
OS_Squeue_Wait	`(squeue, os_smsg_type_var)`	Ожидаем сообщение из очереди squeue
OS_Squeue_Wait_TO	`(squeue, os_smsg_type_var, timeout)`	То же, что и OS_Squeue_Wait, но с выходом по таймауту

OSA : Сообщения

2010-05-04T09:55:23+03:00

OSA : Сообщения

Введение

Сообщения - один из способов обмена информацией между задачами. Телом сообщения может быть все, что угодно: принятые по USART или прочитанные из EEPROM данные, состояния внешних датчиков, информация о нажатых кнопках и пр. В OSA предусмотрены два типа сообщений: указатели на сообщения и короткие однобайтовые сообщения.

Первые - наиболее общие, которые позволяют обмениваться любой информацией, любого размера и содержания. Между задачами идет обмен указателями на тела сообщений. Вторые - однобайтовые сообщения, которые могут принимать значения от 1 до 255 (0 - сообщение отсутствует). Этот тип сообщения реализован в OSA для экономии RAM. В отличие от указателя на сообщение, который занимает в памяти 2 байта (для PIC16) или 3 байта (для остальных пиков), короткое сообщение занимает 1 байт. Ниже будут рассмотрены оба типа сообщений.

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

Указатели на сообщения

Тип указателя определен по умолчанию как void*. Но его можно изменить, задав константу OST_MSG в файле OSAcfg.h. Например, его можно задать так:

#define OS_MSG_TYPE    const char *

и передавать в сообщениях текстовые строки.

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

Для отправки сообщения существуют 3 сервиса: OS_Msg_Send, OS_Msg_Send_TO и OS_Msg_Send_Now.

OS_Msg_Send перед отправкой проверяет, свободно ли сообщение. Если нет (задача, которой сообщения отсылаются, по какой-то причине еще не обработала предыдущее), то сервис переводит задачу в состояние ожидания до тех пор, пока сообщение не освободится. Как только сообщение освободится, задача переводится в состояние готовности, и при получении управления она отправит новое сообщение.

OS_Msg_Send_TO - то же, что и OS_Msg_Send, только может выйти по таймауту, если предыдущее сообщение долго не освобождается.

OS_Msg_Send_Now перед отправкой сообщения не обращает внимания на то, занято сообщение или свободно. Предыдущее сообщение, если оно еще не обработано, затирается новым.

Для проверки занятости сообщения есть сервис OS_Msg_Check, который возвращает ноль, если сообщение свободно.

Ниже приведен пример использования указателя на сообщение:

OST_MSG_CB    msg_cb;
 
void Task_USARTReceive (void)
{
    static char BUF[10];        // Буфер для приема данных по UART
    static char Message[10];    // Тело сообщения
 
    OS_Msg_Create(msg_cb);         // Создаем сообщение перед работой с ним
    for (;;){
        ...
        // Получаем данные и пишем их в буфер BUF
        ...
        // Проверяем, обработалось ли предыдущее сообщение
        OS_Cond_Wait(!OS_Msg_Check(msg_cb));
        // Когда попали сюда, му уже уверены, что предыдущее сообщение
        // обработано и Message[] уже не содержит никакой полезной информации
 
        // Теперь копируем данные из буфера в тело сообщения Message[]
        memcpy(Message, BUF, 10);
        // и отправляем сообщение
        OS_Msg_Send(msg_cb, (OST_MSG)Message);
        ...
    }
}
 
. . .
 
void Task_Work (void)
{
    OST_MSG msg;
    for (;;) {
        OS_Msg_Wait(msg_cb, msg);
        // Здесь msg уже является указателем на Message
        // из задачи Task_USARTReceive.
        // После выполнения этого сервиса сообщение освобождается.
        ...
    }
}

Короткие однобайтовые сообщения

Тип короткого сообщения по умолчанию unsigned char, однако, он может быть изменен в файле OSAcfg.h заданием константы OST_SMSG:

#define OS_SMSG_TYPE    unsigned long  // изменение типа SMSG

Если его изменять, то теряется преимущество в использовании RAM. Тем не менее, это иногда может оказаться полезным с точки зрения функционирования программы. Например, при использовании указателя на сообщение, телом которого является unsigned long, мы не можем изменять содержимое тела сообщения, пока сообщение не будет получено и обработано другой задачей (в пердыдущем примере Message[]). В случае с короткими сообщениями это ограничение снимается, т.к. все тело сообщения записывается в переменную сообщения.

Нельзя задавать типом короткого сообщения структуры, массивы и объединения. Короткому однобайтовому сообщени можно давать только числовой тип: char, int long, bit, а также float и double.

Во всем остальном работа с короткими сообщениями повторяет работу с указателями на сообщения.Ниже приведен пример использования короткого сообщения:

OST_SMSG  smsg_Buttons;
. . .
 
void Task_Buttons (void)
{
    OS_Smsg_Create(smsg_Buttons);
    for (;;) {
        . . .
        if (!RB0 || !RB1 || !RB2)
            OS_Smsg_Send(smsg_Buttons, (OST_SMSG)PORTB & 0x07);
        ...
    }
}
 
...
 
void Task_Work (void)
{
    OST_SMSG smsg;
    for (;;) {
        OS_Smsg_Wait(smsg_Buttons, smsg);
        // Обработка нажатой кнопки
        if (smsg & 0x01) ...;
        if (smsg & 0x02) ...;
        if (smsg & 0x04) ...;
        ...
    }
}

Сервисы для работы с сообщниями

Сообщения

Сервис	Аргументы	Описание
Создание
OS_Msg_Create	`(msg_cb)`	Создает сообщение.
Отправка
OS_Msg_Send	`(msg_cb, message)`	Отправляем сообщение msg_cb (тип OST_MSG_CB) с ожиданием освобождения
OS_Msg_Send_TO	`(msg_cb, message, timeout)`	То же, что и OS_Msg_Send с выходом по таймауту
OS_Msg_Send_Now	`(msg_cb, message)`	Отправляем сообщение msg_cb без ожидания освобождения
Проверка
`bool` OS_Msg_Check	`(msg_cb)`	Проверить, активно ли сообщение (присутствует ли оно).
OS_Msg_Accept	`(msg_cb, os_msg_type_var)`	Принять существующее сообщение.
Ожидание
OS_Msg_Wait	`(msg_cb, os_msg_type_var)`	Ожидаем сообщение msg_cb.
OS_Msg_Wait_TO	`(msg_cb, os_msg_type_var, timeout)`	То же, что и OS_Msg_Wait, с выходом по таймауту

Короткие сообщения

Сервис	Аргументы	Описание
Создание
OS_Smsg_Create	`(smsg)`	Создает короткое сообщение (фактически - просто обнуляет его)
Отправка
OS_Smsg_Send	`(smsg, smessage)`	Отправляем сообщение smsg с содержимым smessage с ожиданием освобождения
OS_Smsg_Send_TO	`(smsg, smessage, timeout)`	То же, что и OS_Smsg_Send, но с выходом по таймауту
OS_Smsg_Send_Now	`(smsg, smessage)`	Отправляем короткое сообщение smsg с содержимым smessage без ожидания освобождения
Проверка
`bool` OS_Smsg_Check	`(smsg)`	Проверить, активно ли сообщение (присутствует ли оно).
OS_Smsg_Accept	`(smsg, os_smsg_type_var)`	Принять существующее сообщение
Ожидание
OS_Smsg_Wait	`(smsg, os_smsg_type_var)`	Ожидаем короткое сообщение smsg.
OS_Smsg_Wait_TO	`(smsg, os_smsg_type_var, timeout)`	То же, что и OS_Smsg_Wait, с выходом по таймауту

OSA : Системные сервисы

2010-03-10T14:36:20+03:00

OSA : Системные сервисы

Общие системные сервисы

Сервис	Описание	Свойства
OS_Init()	Инициализация переменных системы. Должна вызываться один раз в начале программы (до основного цикла).

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

Сервис	Описание	Свойства
OS_Timer()	Обработка всех таймеров (вставляется в периодическое место в программе, например, в прерывание по таймеру). Эта функция должна использоваться, если в программе есть OS_Delay, работа с пользовательскими таймерами или ожидание событий с таймаутом.

Этот сервис должен использоваться, если в программе есть одно из ниже перечисленного:

использование сервиса OS_Delay;
работа со статическими или динамическими таймерами;
ожидание событий с таймаутом.

Для использования таймера в файле конфигурации OSAcfg.h нужно определить константу OS_ENABLE_TIMER. Вызов этого сервиса нужно вставлять в периодическое место в программе, например, в прерывание по таймеру.

Период вызова сервиса OS_Timer называется системным тиком и является внутренней системной единицей времени.

Сервис OS_Timer управляет:

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

При каждом вызове OS_Timer() все активные таймеры увеличиваются на 1 (все неактивные - пропускаются), кроме 24-битных статических таймеров, которые уменьшаются 1 раз в 256 вызовов (см. 2.12.2.1).

Пример использования:

void interrupt isr()
{
 
    if (T0IE && T0IF) {
        TMR0 -= 250;
        T0IF = 0;
        OS_Timer();
    }
}

Сервис	Описание	Свойства
OS_Yield ()	Передача управления планировщику

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

Сервисы ожидания

Сервис	Описание	Свойства
OS_Delay (delaytime)	Выдерживаем паузу внутри задачи (в тиках - периодах вызова OS_Timer)

Переводит задачу в состояние ожидания на время, заданное параметром delaytime. Параметр задается в системных тиках - периодах вызова сервиса OS_Timer.

Например, если в задаче требуется выводить индикацию температуры раз в секунду, то можно воспользоваться этим сервисом (в этом примере предполагаем, что системный тик, т.е. интервал вызова OS_Timer() равен 10 мс):

void Task_Indicate (void)
{
    for (;;) {
        OS_Delay(100);			// Задержка = 100 * 10 мс = 1 сек
        IndicateTemerature();		// Отображаем температуру
    }
}

Используя этот сервис (и вообще, все сервисы ожидания с таймаутами), следует быть внимательным и помнить, что OS_Timer, который отсчитывает системные тики для них, - дискретный. Следовательно, точность задания задержки равна одному тику системного таймера. Если системный тик равен 10 мс, то OS_Delay(1) - может прождать 10 мс, а может и ничего не прождать (зависит от того, через какое время произойдет вызов OS_Timer()). Поэтому нужно либо быть уверенным в том, что длительность задержки не существенна для конкретной задачи, либо сократить интервал вызова OS_Timer и увеличить параметр delaytime в OS_Delay. Например, участив в 10 раз вызов OS_Timer, т.е. превратив системный тик в 1 мс (вместо 10 мс) мы можем написать: OS_Delay(10) - и быть уверенными, что задержка будет 9-10мс.

Сервис	Описание	Свойства
OS_Wait (condition)	Ожидаем выполнения условия

Переводит задачу в режим ожидания до тех пор, пока не будет выполнено заданное условие. Условием condition в данном случае может быть любое выражение перечислимого типа (bool, char, int и т.д.). Как только условие выполняется, задача переходит в состояние готовности и, как только становится самой приоритетной из всех готовых, получает управление. Исключение - состязяние приоритетов.

    ...
    OS_Wait(m_nInPulseCounter >= 10 || m_bButtonPressed);
    ...

В этом примере m_nInPulseCounter и m_bButtonPressed - некие внешние глобальные переменные, которые изменяются где угодно в программе (например, в прерывании). Программа будет в режиме ожидания, пока условие не выполнится (в нашем примере, пока не придет больше 10 импульсов, или пока не будет нажата кнопка).

Сервис	Описание	Свойства
OS_Wait_TO (condition, timeout)	Ожидаем выполнения условия с таймаутом

То же самое, что и OS_Wait, но с дополнительным условием выхода - таймаутом. Задача переводится в состояние ожидание до тех пор, пока не быдет выполнено условие condition или пока не пройдет время timeout. Таймаут задается в системных тиках.

    ...
    OS_Wait_TO(m_bButtonPressed, 100);
    if (OS_IsTimeout()) ...;
    ...

В данном примере мы в течение 100 тиков (если 1 тик = 10мс, то в течение секунды) ждем нажатия кнопки. После выхода из ожидания проверяем, по какой причине вышли из ожидания: по выполнению условия или по таймауту.

Состояние системы

Все сервисы проверки состояния системы вызвращают либо 0 либо 1, в зависимости от состояния внутренних системных флагов.

Сервис	Описание	Свойства
bool OS_IsTimeout ()	Проверка, вышли ли из ожидания по таймауту

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

Сервис	Описание	Свойства
bool OS_IsError ()	Проверка, была ли ошибка

Системными ошибками счиатаюстя:

Ошибка создания задачи (нет свободного дескриптора)

Сервис	Описание	Свойства
bool OS_IsEventError ()	Проверка, была ли ошибка события

Ошибками события считаются:

Попытка увеличить счетный семафор, если он уже имеет максимальное значение
Выход по таймауту из ожидания события (от OS_IsTimeout отличается тем, что доступен в любом месте программы, а не только внутри задачи)
Посылка сообщения в очередь, когда в ней нет свободного места

Сервис	Описание	Свойства
bool OS_IsInCriticalSection ()	Возвращает 1, если одна из задач находится в критической секции.

Сервисы управления прерываниями

Сервис	Описание	Свойства
OS_EnterInt ()	Для PICC и PICC18: Должна выполняться при входе в прерывание (сохраняет FSR)

Сервис	Описание	Свойства
OS_LeaveInt ()	Для PICC и PICC18: Должна выполняться перед выходом из прерывания (восстанавливает FSR)

OS_EnterInt вставляется в самом начале прерывания, сразу после описания переменных функции прерывания, а OS_LeaveInt - в самом конце перед закрывающей скобкой "}". Например:

void interrupt int_routine (void)
{
    char  var1, var2;
    int   var3;
    OS_EnterInt();
    ...                // Здесь делается проверка флагов прерываний
    ...                // и обработка
    OS_LeaveInt();
}

Сервис	Описание	Свойства
char OS_DI ()	Запретить прерывания. Текущие значения GIEx сохраняются

Этот сервис не просто запрещает прерывания, а еще возвращает состояние битов GIEx. Для PIC18 при IPEN=1 запрещаются (и, соответственно, сохраняются) GIEH и GIEL, а при IPEN=0 - только GIE.

Сервис	Описание	Свойства
OS_EI ()	Разрешить прерывания

Сервис OS_EI() разрешает прерывания. Для PIC18 при IPEN=1 разрешаются и GIEH и GIEL, а при IPEN=0 - только GIE.

Сервис	Описание	Свойства
OS_RI (char)	Восстановить сохраненные в OS_DI() значения GIEx.

Сервис OS_RI(char) восстанавливает прерывания из параметра char (полученного сервисом OS_DI()). Для PIC18 при IPEN=1 восстанавливаются и GIEH и GIEL, а при IPEN=0 - только GIE.

Этот сервис восстанавливает только единичное значение флагов! Т.е. если флаг GIE == 0 был сохранен сервисом OS_DI, потом установлен сервисом OS_EI, то при выполнении сервиса OS_RI он не установится обратно в 0.

Ниже приведен пример использования этих сервисов при генерации одиночного импульса длительностью 5 тактов:

{
    char gie_temp;
    ...
    gie_temp = OS_DI();
    RB0 = 1;
    NOP();
    NOP();
    NOP();
    NOP();
    RB0 = 0;
    OS_RI(gie_temp);
    ...
}

Системные сервисы

Сервис	Аргументы	Описание	Свойства
Системные
OS_Sched		Основная работа операционки, вызывается в главном цикле функции main()
OS_Run		Запускает ядро операционки в работу.	main()
OS_Init		Инициализация переменных системы.
OS_Timer		Обработка всех таймеров
Ожидание
OS_Yield		Передача управления планировщику
OS_Delay	`(delaytime)`	Выдерживаем паузу внутри задачи
OS_Wait	`(condition)`	Ожидаем выполнения условия
OS_Wait_TO	`(condition, timeout)`	Ожидаем выполнения условия с таймаутом
Проверка состояния
`bool` OS_IsTimeout		Проверка, вышли ли из ожидания по таймауту
`bool` OS_IsError		Проверка, была ли ошибка
`bool` OS_IsEventError		Проверка, была ли ошибка события
`bool` OS_IsInCriticalSection		Возвращает 1, если одна из задач находится в критической секции.
Прерывания
OS_EnterInt		Должна выполняться при входе в прерывание (сохраняет FSR)
OS_LeaveInt		Должна выполняться перед выходом из прерывания (восстанавливает FSR)
`char` OS_DI		Запретить прерывания. Текущие значения GIEx сохраняются
OS_EI		Разрешить прерывания
OS_RI	`(char)`	Восстановить сохраненные в OS_DI() значения GIEx.
OS_EnterCriticalSection		Вход в критическую секцию
OS_LeaveCriticalSection		Выход из критической секции

OSA : Задачи

2010-06-23T17:38:31+03:00

OSA : Задачи

Введение

Любая задача в ОСРВ OSA - это функция, тело которой содержит бесконечный цикл. Внутри цикла должен быть хотя бы один вызов сервиса ОС, который переключает контекст задач, иначе планировщик (а следовательно, и все остальные задачи) никогда не получит управление обратно.

Простейшая задача может выглядеть так:

void SimpleTask (void)
{
    for (;;)
    {
        OS_Yield();
    }
}

Если программа пишется под mikroC PRO, то линкеру нужно указывать, что функция задача будет вызвана через указатель, напимер:

#pragma funcall main SimpleTask

Задача может находиться в одном из 5-и состояний:

не создана (не активна)
в ожидании
в готовности
выполняется
проиостановлена

Кроме того, задача может иметь приоритет от 0 (высший) до 7 (низший). Приоритет можно изменять в ходе выполнения программы. Подробнее о приоритетах и состояниях.

Для работы с задачами OSA резервирует память под дескрипторы задач. В файле OSAcfg.h задается константа OS_TASKS, которая показывает, сколько одновременно активных задач может работать в программе.

Указатель на TCB

Большинство операций по управлению задачей осуществляется через указатель на ее дескриптор или tcb (Task Control Block). Дескрипторы задач недоступны напрямую, поэтому нужно создавать глобальную переменную типа OST_TASK_POINTER, и все опреации производить через нее:

OST_TASK_POINTER tp_MyTask;

Для работы с указателем он должен быть проинициализирован сервисом OS_Task_GetCur. Этот сервис желательно вызывать в самом начале функции-задачи:

void MtTask (void)
{
    tp_MyTask = OS_GetCurTask();
    for (;;) {
        /*....*/
    }
}

Для управления задачей из самой задачи в качестве параметра сервисов управления может применяться системный макрос this_task (или сам сервис OS_Task_GetCur):

void MyTask (void)
{
    for (;;) {
        /*...*/
        OS_Task_SetPriority(this_task, 0);    // Установить высший приоритет текущей задаче
        /*...*/
    }
}

Создание задачи

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

Например:

#include <osa.h>
 
void Task1 (void)
{
    for (;;)
    {
        OS_Yield()
    }
}
 
...
 
void main (void)
{
    OS_Init();
    OS_Task_Create(7, Task1);
    ...
    for (;;) OS_Sched();
}

В данном примере создается задача Task1 с низшим приоритетом. Теперь ОС будет знать, что есть такая активная задача и будет принимать ее в расчет, когда будет выбирать готовую задачу для выполнения. Сервис OS_Task_Create может вызываться в любом месте программы.

Если приоритетный режим не включен (OS_DISABLE_PRIORITY определена в файле OSAcfg.h), то параметр priority все равно нужно передавать, просто он будет игнорироваться. Это сделано для того, чтобы включать/отключать приоритетный режим было проще.

Ошибка при создании задачи

Если в памяти, отведенной системой под задачи, есть свободный дескриптор, то он будет выделен под новую задачу. Если свободных дескрипторов нет, то задача не будет создана, а после выполнения OS_Task_Create будет установлен флаг ошибки (его можно проверить сервисом OS_IsError).

    OS_Task_Create(7, Task1);
    if (OS_IsError()) ...	;	// Обрабатываем ошибку

Если такая ошибка возникает, то нужно либо увеличить значение константы OS_TASKS в файле OSAcfg.h и пересобрать проект, либо если предполагалось, что свободный дескриптор должен быть, искать ошибку в программе (например, предполагалось, что какая-то задача выполнит остановку, но по каким-то причинам ее не выполнила).

По завершению работы этого сервиса можно получить указатель на дескриптор вновь созданной задачи сервисом OS_Task_GetCreated() (бывает нужно, когда одна задача будет приостанавливаться или удаляться из другой):

    OST_TASK_POINTER  tp;
 
    OS_Task_Create(0, MyTask);
    if (!OS_IsError()) tp = OS_Task_GetCreated();

Если программа пишется под CCS, то в функции main для всех функций-задач нужно вызвать сервис OS_Task_Define

Удаление задачи

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

Рекомендуется удалять задачу из самой себя.

При удалении задачи дескриптор освобождается и, если удаление производилось из самой задачи (с параметром this_task), то сразу же происходит передача управления планировщику. В случае удаления задачи самой себя после вызова OS_Task_Delete(this_task) уже ничего не будет выполняться. Например:

    ...
    OS_Task_Delete(this_task);
    Counter ++;
    ...

В этом примере переменная Counter не увеличится.

Если нужно остановить задачу, но при этом сразу же запустить другую, то нужно сначала запустить другую, а затем остановить текущую.

    . . .
    OS_Task_Create(1, Task_NewTask);
    OS_Task_Delete(this_task);
    . . .

При таком подходе есть недостаток: нужно резервировать память под большее количество задач, чем требуется. Например, в диктофоне есть несколько задач: обработка кнопок, индикация, воспроизведение, запись, проверка заряженности батареек. Здесь есть две задачи, которые не могут выполняться одновременно: запись и воспроизведение. Таким образом, активных задач в один момент времени может быть только 4. Переходя в запись из воспроизведения, нам нужно создавать новую задачу до завершения старой, а это требует наличия свободного дескриптора задач. Т.е. должно быть зарезервировано место под 5 задач (OS_TASKS = 5).

void Task_Play (void)
{
    . . .
    OS_Task_Create(1, Task_Record);
    OS_Task_Delete(this_task);
    . . .
}

Фактически получается, что несколько байт (один дескриптор задачи) будут просто заняты под ничто. Чтобы этого избежать, есть системный сервис OS_Task_Replace. Этот сервис удаляет текущую задачу, а на освободившееся место формирует новую. В нашем примере для диктофона это будет выглядеть так:

    . . .
    OS_Task_Replace(1, Task_Record);
    . . .

Изменение приоритета задачи

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

Сервис	Описание	Свойства
char OS_Task_GetPriority (tp)	Возвращает приоритет задачи
OS_Task_SetPriority (tp, priority)	Изменить приоритет задачи на priority

Локальные переменные в задачах

Все активные (созданные) задачи могут выполняться параллельно, поэтому следует помнить, что их локальные переменные могут пересекаться, следовательно, их значения могут быть потеряны после передачи управления системе. Если нужно, чтобы переменная помнила свое значение, то ее нужно определять как static. Например:

void Task1 (void)
{
  static char s_cCounter;  // Эта переменная будет сохраняться
                           // при переключении контекста.
  char i, j;               // Эти переменные врЕменные, и их можно
                           // использовать только в пределах одного
                           // вызова задачи.
  . . .
}

Все сервисы для работы с задачами

Сервис	Аргументы	Описание	Свойства
Создание/удаление
OS_Task_Define	`(TaskName)`	Для CCS: сообщает компилятору, что функция вызывается по указателю.	main()
OS_Task_Create	`(priority, TaskName)`	Инициализируем конкретную задачу.
OS_Task_Replace	`(priority, TaskName)`	Заменить текущую задачу на новую.
OS_Task_Delete	`(tp)`	Удалить задачу
Управление состоянием
`OST_TASK_POINTER` OS_Task_GetCur		Получить указатель на дескриптор текущей задачи
`OST_TASK_POINTER` OS_Task_GetCreated		Получить указатель на дескриптор только что созданной задачи
OS_Task_Pause	`(tp)`	Приостановить задачу
OS_Task_Continue	`(tp)`	Продолжить выполнение ранее приостановленной задачи
`char` OS_Task_GetPriority	`(tp)`	Возвращает приоритет текущей задачи
OS_Task_SetPriority	`(tp, priority)`	Изменить приоритет текущей задачи
OS_Task_IsPaused	`(tp)`	Проверить, приостановлена ли задача

OSA : Таймеры

2011-01-22T14:49:54+03:00

OSA : Таймеры

Введение

Таймеры служат для упрощения организации время-зависимых процессов. С их помощью можно выделять кванты времени работы задач или просто функций, не являющихся задачами, выдавать указания по времени работы другим задачам, наконец, просто для отсчета временных интервалов. Таймеры в OSA привязаны к системным тикам (периодам вызова OS_Timer). При вызове OS_Timer все активные таймеры увеличиваются на 1, а при переполнении какого-либо из них устанавливается соответствующий флаг переполнения.

Типы таймеров

OSA предоставляет возможность использования четырех типов таймеров:

TTIMERS - таймеры задач
STIMERS - статические таймеры
QTIMERS - очередь таймеров
DTIMERS - динамические таймеры (устаревшие)

Почему так много и какой из них лучше? Читайте Рекомендации по выбору таймера.

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

Таймеры задач

Описание

Таймеры задач - это те счетчики, которые хранятся в дескрипторах задач и используются для формирования задержек (OS_Delay) и ожидания событий с выходом по таймауту (OS_xxx_Wait_TO). Раньше их функциональность этим ограничивалась. Начиная с версии 100210, появилась возможность использовать эти таймеры для второстепенных целей. Например, теперь можно инициализировать таймер и вызвать функцию, которая будет работать до тех пор, пока таймер не закончит счет.

Преимущества

Когда выполняется задержка с использованием этих таймеров (OS_Delay() или OS_Ttimer_Delay()), планировщик не рассматривает задачу, выполняющую задержку, что ускоряет его работу (при использовании других типов таймеров планировщик проверяет готовность задач);
Сервисы OS_xxx_Wait_TO используют только эти таймеры

Недостатки

Жесткая привязка: одна задача - один таймер;
С таймерами можно работать только внутри функции-задачи или внутри функций, вызываемых задачей. Т.е. нельзя с ними работать из прерывания.

Использование

Определения в файле OSAcfg.h:

OS_ENABLE_TTIMERS	Для использования таймеров задач в файле osacfg.h должна быть определена эта константа.
OS_TTIMER_SIZE	Задает размерность таймеров: 1, 2 или 4 (по умолчанию 2).
OS_TTIMERS_OPTIMIZE_SIZE	Включает оптимизацию кода OS_Timer() по размеру (по умолчанию код оптимизирован по скорости)
OS_BANK_TASKS	Определяет банк памяти для хранения дескрипторов задач: 0, 1, 2 или 3 (по умолчанию 0)

Статические таймеры

Описание

Статические таймеры - это массив из OS_STIMERS счетчиков размерностью OS_STIMER_SIZE (обе константы задаются в файле osacfg.h). Для работы с ними сервисам нужно указывать ID - номер таймера (в виде целого числа). Старший бит счетчика используется для индикации его состояния: установлен - таймер считает, сброшен - таймер остановлен. Таким образом, сам счетчик таймера на 1 бит меньше разрядности переменной, в которой он содержится. Т.е., если OS_STIMER_SIZE = 2 байта, то под счетчик выделяются только 15 бит. Статические таймеры самые компактные из всех.

Раньше назначение каждого статического таймера было предопределено с начала программы. Т.е. цель, с которой использовался таймер, должна была быть известна заранее, а следовательно - за каждым таймером закреплялся свой номер. Это было неудобно, т.к. возникали сложности с переносом модулей, использующих статические таймеры, в другие проекты. Начиная с версии 100210 появилась возможность назначать таймеры в ходе программы (см. ниже)

Преимущества

компактные
быстрые

Недостатки

на этапе компиляции нужно знать, сколько таймеров может использоваться одновременно
максимально может быть использовано 64 таймера

Использование

Определения в файле OSAcfg.h:

OS_STIMERS	Этой константой задается количество используемых в программе статических таймеров
OS_STIMER_SIZE	Задает размерность таймеров: 1, 2 или 4 (по умолчанию 2)
OS_STIMERS_OPTIMIZE_SIZE	Включает оптимизацию кода OS_Timer() по размеру (по умолчанию код оптимизирован по скорости)
OS_STIMERS_ENABLE_ALLOCATION	Включает дополнительный код для назначения таймеров, а также доболнительный массив битов, отвечающих за занятость таймеров. Становятся доступны сервисы OS_Stimer_Alloc, OS_Stimer_Free, OS_Stimer_Found
OS_BANK_STIMERS	Определяет банк памяти для хранения массива таймеров: 0, 1, 2 или 3 (по умолчанию 0)

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

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

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

Очередь таймеров

Описание

Этот тип таймеров введен с версии 100210. Все запускаемые таймеры выстраиваются в очередь так, что первым в ней стоит тот, которому считать меньше всех. Далее - в порядке возрастания оставшегося времени счета. Это позволяет очень быстро обрабатывать большое количество таймеров сервисом OS_Timer(). При большом количество таймеров это существенно ускоряет работу OS_Timer, что может оказаться незаменимым качеством при обработке таймеров в прерывании.

1. Для PICC16 эти таймеры могут располагаться только в банках 0 и 1.
2. Очередь таймеров не поддерживается в 12-разрядных контроллерах

Преимущества

может быть использовано столько таймеров, сколько влезает в память
высокая скорость обработки большого количества таймеров сервисом OS_Timer()

Недостатки

Каждый таймер помимо счетчика содержит еще два байта (или два слова для C30): флаги и указатель на следующий таймер
Громоздкая функция, занимающаяся добавлением/удалением таймеров в очередь
В зависимости от того, в какое место очереди добавляется таймер, время его добавления при большом количестве активных таймеров в очереди может затянуться на тысячи тактов.

Использование

Определения в файле OSAcfg.h:

OS_ENABLE_QTIMERS	Для использования очереди таймеров должна быть определена эта константа
OS_QTIMER_SIZE	Задает размерность таймеров: 1, 2 или 4 (по умолчанию 2)

Таймеры определяются в программе как обычные переменные:

OST_QTIMER qt_1, qt_2;

Перед работой с таймером он должен быть создан сервисом OS_Qtimer_Create. При запуске таймер добавляется в очередь, занимая в ней место в соответствии с длительностью счета. При каждом вызове OS_Timer() происходит уменьшение на 1 только первого в очереди таймера (чем и объясняется высокая скорость обработки большого количества таймеров). Когда таймер досчитывает до 0, он удаляется из очереди и устанавливается его бит переполнения.

Например в очередь помещаются два таймера с временами счета 30 и 10 тиков:

    OS_Qtimer_Run(qt_1, 30);
    OS_Qtimer_Run(qt_2, 10);

Сначала в начало пустой очереди поместится таймер qt_1 со временем счета = 30. Затем его потеснит новый таймер qt_2, он встанет в начало очереди, т.к. ему считать меньше. При этом время счета таймера qt_1 изменится с 30 на 20. Так происходит потому, что первые 10 тиков будет считать таймер qt_2, а qt_1 будет дожидаться своей очереди. Как только qt_2 досчитает и удалится из очереди, начнет уменьшаться qt_1, вставший на этот момент в начало очереди. 10 тиков уже отсчитаны и ему останется только 20. Если теперь будет запущен еще один таймер qt_3 со временем счета 100:

    OS_Qtimer_Run(qt_3, 100);

то он поместится в конец очереди, а значение его счетчика будет уменьшено на значение первого в очереди, т.е. на 20. Т.е. реально в счетчик запишется значение 80.

Динамические таймеры

Описание

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

Важным свойством динамического таймера является то, что после переполнения он продолжает счет (в отличие от всех остальных, которые после переполнения останавливается). Это позволяет отсчитывать равные интервалы времени вне зависимости от того, в какой момент таймер обработан задачей. Например, таймер был запущен на отсчет интервала в 1 секунду. Секунда прошла (произошло переполнение таймера), а задача, ожидающая этот таймер, не смогла начать выполняться из-за того, что сейчас выполняется или готова к выполнению более приоритетная задача. В результате этого задача сможет обработать таймер только через некоторое время после его переполнения (например, через 100 мс). Но, обработав его, она вновь задает интервал счета в 1 секунду, и при этом учитывается, что уже прошло 100 мс. Поэтому следующее переполнение произойдет через 900 мс. Все остальные таймеры (и таймеры задач, и статические таймеры, и очередь таймеров) останавливают счет после переполнения.

Для PICC16 эти таймеры могут располагаться только в банках 0 и 1.

Преимущества

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

Недостатки

Очень медленно обрабатываются в OS_Timer
Каждый таймер помимо счетчика содержит еще два байта (или два слова для C30): флаги и указатель на следующий таймер
Требуются две дополнительные функции для добавления и удаления таймера из очереди

Использование

Определения в файле OSAcfg.h:

OS_ENABLE_DTIMERS	Для использования динамических таймеров должна быть определена эта константа
OS_DTIMER_SIZE	Задает размерность таймеров: 1, 2 или 4 (по умолчанию 2)

Таймеры определяются в программе как обычные переменные:

OST_DTIMER dt_1, dt_2;

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

Максимальные задержки

Здесь для удобства сведены максимально допустимые задержки (округлены в меньшую сторону) для наиболее часто используемых значений системного тика:

Интервал вызова OS_Timer	1-байтовые	2-байтовые	4-байтовые
Диапазон значений	0-255	0-65535	0-4294967295
1 ms	255 мс	64 сек	48 суток
10 ms	2.4 сек	10 мин	490 суток
18.2 ms	9.2 сек	18 мин	900 суток
256 us	130 мс	16 сек	12 суток
1024 us	520 мс	65 сек	50 суток
8192 us	4 с	8 мин	400 суток

Как уже было сказано, старший бит статического таймера используется для индикации счета (если он =1, значит, таймер считает, если =0, - таймер остановлен или произошел таймаут), следовательно для статических таймеров все значения из таблицы должны быть поделены на 2.

Сервисы для работы с таймерами

Назначение	TTIMERS	STIMERS	DTIMERS	QTIMERS
Создание/удаление
Создание		OS_Stimer_Alloc	OS_Dtimer_Create	OS_Qtimer_Create
Удаление		OS_Stimer_Free	OS_Dtimer_Delete	OS_Qtimer_Delete
Поиск свободного		OS_Stimer_Found
Работа
Запуск	OS_Ttimer_Run	OS_Stimer_Run	OS_Dtimer_Run	OS_Qtimer_Run
Остановка	OS_Ttimer_Break	OS_Stimer_Break	OS_Dtimer_Break	OS_Qtimer_Break
Задержка	OS_Ttimer_Delay	OS_Stimer_Delay	OS_Dtimer_Delay	OS_Qtimer_Delay
Ожидание	OS_Ttimer_Wait	OS_Stimer_Wait	OS_Dtimer_Wait	OS_Qtimer_Wait
Проверка состояния
Был ли таймаут	OS_Ttimer_Check	OS_Stimer_Check	OS_Dtimer_Check	OS_Qtimer_Check
Считает ли	OS_Ttimer_IsRun	OS_Stimer_IsRun	OS_Dtimer_IsRun	OS_Qtimer_IsRun
Текущее значение	OS_Ttimer_Get	OS_Stimer_Get	OS_Dtimer_Get	OS_Qtimer_Get
Дополнительно
Приостановить	OS_Ttimer_Pause	OS_Stimer_Pause	OS_Dtimer_Pause
Продолжить	OS_Ttimer_Continue	OS_Stimer_Continue	OS_Dtimer_Continue
+
Активен ли			OS_Dtimer_IsActive
Увеличить время счета			OS_Dtimer_Add
Приостановлен ли			OS_Dtimer_IsStopped
Обновить время счета			OS_Dtimer_Update

	TTIMERS		STIMERS		DTIMERS	QTIMERS
	(speed)*	(size)*	(speed)*	(size)*
ROM, words	t*6+30	57	t4 (+60) *	14 (+60)* *	74	482
RAM, bytes	t*2		t2 (+t/8) *		t*4+2
OS_Timer, cycles	t4+To1	t15+Ta6+To*2+4	t3+Ta1	t8+Ta3+3	t9+Ta13+5	17+To*22

	TTIMERS		STIMERS		DTIMERS	QTIMERS
	(Speed)	(size)	(speed)	(size)
ROM, words	60	57	80	74	74	482
RAM, bytes	10		11		22
OS_Timer, cycles min/cycles max*	20 (25)	109 (119)	20 (20)	58 (58)	50 (115)	17 (127)

	TTIMERS		STIMERS		DTIMERS	QTIMERS
	(Speed)	(size)	(speed)	(size)
ROM, words	330	57	260	74	74	482
RAM, bytes	100		107		202
OS_Timer, cycles min/cycles max*	200 (250)	1054 (1154)	200 (200)	553 (553)	1105	17 (1122)