В этой статье приведен перевод документации [1] с описанием части библиотек системных служб (system services library, SSL), касающейся аппаратных часов реального времени (real-time clock, RTC). Такие часы встроены в большинство моделей процессоров Blackfin (в настоящий момент кроме двухядерных процессоров семейства Teton [2]). Интерфейс программирования (API) библиотеки службы RTC позволяет генерировать и обслуживать события RTC стандартным, универсальным способом - так же, как обслуживаются события и ресурсы других системных служб.

Служба RTC предоставляет простой для использования API. В дополнение к чтению и записи данных и времени, служба позволяет приложению стандартным способом координировать 8 разных событий RTC, независимо от модели процессора Blackfin. Можно разрешить 5 периодических событий, возникающих каждую секунду, каждую минуту, каждый час, каждые сутки (в полночь), и каждые сутки в определенное время. Есть событие будильника, возникающее в определенную дату и время. Также есть события обратного отсчета секунд (stopwatch), которое происходит по истечении заданного промежутка времени. И еще есть событие, которое сигнализирует о завершении всех ожидающих записей в регистры RTC (об этом подробнее далее, также см. [3]).

В этой документации описаны базовые операции со службой RTC, интерфейс программирования (API) и инструкции для инициализации и использования службы RTC в клиентском приложении.

Отладочная версия библиотеки SSL (она компилируется с заданным макроопределением ADI_SSL_DEBUG) предоставляет проверку параметров функций API и другие возможные условия возникновения ошибок. Analog Devices настоятельно рекомендует использовать при разработке ПО отладочные версии библиотеки, и после процедуры тестирования библиотека может быть скомпилирована в версии релиза (без макроопределения ADI_SSL_DEBUG).

[Работа службы RTC]

Инициализация службы RTC. Перед использованием службы RTC приложение должно инициализировать эту службу вызовом функции adi_rtc_Init(). В отличие от некоторых системных служб, которые требуют от приложения предоставления памяти для службы на этапе инициализации, служба RTC не требует для этого дополнительной памяти. Единственный параметр, передаваемый в функцию adi_rtc_Init(), это параметр критического региона кода, который может использоваться позже, если Менеджер Прерываний [4] вызывался с настройкой защиты критических областей кода. В текущей реализации системных служб для этого параметра используется нулевой указатель NULL (в большинстве примеров в качестве параметра передается макрос ADI_SSL_ENTER_CRITICAL, определенный в заголовке adi_ssl_Init.h как NULL). Для дополнительной информации см. "Protecting Critical Code Regions" [1]. Также см. [5].

Перед инициализацией службы RTC приложение также должна инициализировать Менеджер Прерываний с помощью функции adi_int_Init(). Если используется отложенный вызов callback-функций (вместо немедленного, в контексте прерывания), то также необходимо инициализировать Менеджер Отложенных Вызовов (deferred callback, DCB) путем запуска функции adi_dcb_Init() (см. [6]).

Некоторые регистры аппаратуры RTC (memory-mapped registers, MMR) имеют определенные ограничения, связанные с тем, что запись в них должна осуществляться только 1 раз в течение одного цикла 1 Гц. Значение, записанное в такой MMR, не войдет в действие до наступления следующего тика 1 Гц, и последующее значение, записанное в тот же самый регистр до наступления этого следующего тика, будет отброшено. Служба RTC реализует механизм кэширования таких регистров, решающий эту проблему, чем гарантируется отсутствие потери необходимого функционала. При этом приложение не должно напрямую обращаться к регистрам MMR RTC, полностью полагаясь только на вызовы API-функций службы RTC.

Как только приложение вызвало adi_rtc_Init(), кэши регистров RTC очищаются. Устанавливается бит прескалера, чтобы счетчик часов срабатывал с дискретностью 1 Гц (подразумевается, что к выводам RTXI и RTXO подключен кварц на 32.768 кГц [3]), как происходит у обычных часов. Инициализируется среда callback-вызовов RTC, и регистр флагов событий RTC очищается, тем самым сбрасываются все события RTC, ожидающие обработки. Обработчик прерываний RTC (ISR) подцепляется к цепочке приоритета IVG, и служба RTC становится готовой к работе. Прерывания RTC в этот момент инициализированы для пробуждения процессора (вывода его из режимов пониженного энергопотребления). Если такое поведение не нужно, то приложение может вызвать API-функцию adi_rtc_DisableWakeup().

Завершение работы службы RTC. Когда приложению больше не нужен функционал службы RTC, оно вызывает функцию завершения adi_rtc_Terminate(). Эта функция удаляет все установленные callback-вызовы с очисткой всех определенных статически структур данных.

Установка и чтение даты и времени. Для установки даты и времени служба RTC предоставляет API-функцию adi_rtc_SetDateTime(). Для использования этой функции приложение декларирует структуру типа tm (определена в заголовочном файле time.h).

struct tm {
   int tm_sec;
   int tm_min;
   int tm_hour;
   int tm_mday;
   int tm_mon;
   int tm_year;
   int tm_wday;
   int tm_yday;
   int tm_isdst;
};

Приложение устанавливает поля этой структуры значениями месяца, дня, года, часа, минуты и секунды, и передает указатель на эту структуру в функцию adi_rtc_SetDateTime(). Функция преобразует предоставленные в структуре tm данные в 32-битный целочисленный формат, и загружает полученные данные в регистр RTC_STAT, где аппаратура RTC отсчитывает реальные время и дату. Ниже на картинке показана структура регистра RTC_STAT [3]. Каждое поле в структуре tm представлено диапазоном бит в регистре RTC_STAT.

Функцию adi_rtc_SetDateTime() нужно вызвать только 1 раз, однако возможны и последующие повторные вызовы. Установленные дата и время вступят в действие на следующем тике 1 Гц, и время будет автоматически увеличиваться на 1 секунду с каждым тиком 1 Гц, пока предоставляется питание VDDRTC (обычно это маломощная литиевая батарейка на 3V [3]). Приложение может обращаться к API-функциям RTC для получения текущей даты и времени, или может установить callback-вызовы для обслуживания событий RTC.

Служба RTC предоставляет API-функцию adi_rtc_GetDateTime(), которая позволяет приложению получить текущие дату и время из MMR-регистра RTC_STAT. Для использования этой функции приложение декларирует структуру типа tm, и передает указатель на неё в функцию adi_rtc_GetDateTime. Функция adi_rtc_GetDateTime считывает дату и время из регистра RTC_STAT, и преобразует прочитанные данные, возвращая их в структуре tm.

Служба RTC поддерживает часы реального времени только в тех рамках, которые предоставляет аппаратура RTC. Служба не делает подстройку часов на летнее время, также не делается учет зон времени. Приложение может само довольно просто осуществить такие коррекции времени, поскольку дата и время сохраняется в структуре tm для совместимости со стандартными функциями времени, которые можно найти в VisualDSP C/C++ Compiler Run-Time Library.

[События RTC]

Служба RTC предоставляет механизм для обработки заранее определенных событий, обслуживаемых на уровне прерываний во время обычного выполнения кода программы. Каждое событие (event) идентифицируется уникальным числом (Event ID), эти числа определены в заголовочном файле adi_rtc.h. Приложение предоставляет callback-функцию для обработки события. Служба RTC также предоставляет механизм для установки и удаления callback-функций, и запуск callback-функций, когда наступают соответствующие этой функции события аппаратуры RTC. Всего поддерживается 8 разных событий RTC. Приложение разрешает обработку нужного события путем вызова функции adi_rtc_InstallCallback(), в которую передается значение Event ID.

Периодическое событие секунды. Приложение может разрешить возникновение прерывания, когда изменяется счетчик секунд в регистре RTC_STAT. Это событие прерывания разрешается, когда приложение вызывает функцию adi_rtc_InstallCallback() передавая в неё значение аргумента ADI_RTC_EVENT_SECONDS. Это событие становится разрешенным, и прерывания будут периодически возникать каждую секунду, пока приложение не запретит это событие передачей аргумента ADI_RTC_EVENT_SECONDS в функцию adi_rtc_RemoveCallback().

Периодическое событие минуты. Приложение может разрешить возникновение прерывания, когда изменяется счетчик минут в регистре RTC_STAT. Это событие прерывания разрешается, когда приложение вызывает функцию adi_rtc_InstallCallback() передавая в неё значение аргумента ADI_RTC_EVENT_MINUTES. Это событие становится разрешенным, и прерывания будут периодически возникать каждую минуту, пока приложение не запретит это событие передачей аргумента ADI_RTC_EVENT_MINUTES в функцию adi_rtc_RemoveCallback().

Периодическое событие часа. Приложение может разрешить возникновение прерывания, когда изменяется счетчик часов в регистре RTC_STAT. Это событие прерывания разрешается, когда приложение вызывает функцию adi_rtc_InstallCallback() передавая в неё значение аргумента ADI_RTC_EVENT_HOURS. Это событие становится разрешенным, и прерывания будут периодически возникать каждый час, пока приложение не запретит это событие передачей аргумента ADI_RTC_EVENT_HOURS в функцию adi_rtc_RemoveCallback().

Периодическое событие дня (суток). Приложение может разрешить возникновение прерывания, когда наступает полночь при изменении счетчика суток в регистре RTC_STAT. Это событие прерывания разрешается, когда приложение вызывает функцию adi_rtc_InstallCallback() передавая в неё значение аргумента ADI_RTC_EVENT_DAYS. Это событие становится разрешенным, и прерывания будут периодически возникать каждые сутки, пока приложение не запретит это событие передачей аргумента ADI_RTC_EVENT_DAYS в функцию adi_rtc_RemoveCallback().

Периодические или однократные события обратного отсчета времени. Приложение может настроить событие stopwatch на возникновение прерывания, когда истечет заданный период времени (заданный в секундах). Одно и то же событие stopwatch может быть либо периодическим, либо однократным. Событие становится разрешенным, когда приложение передает аргумент ADI_RTC_EVENT_STOPWATCH в функцию adi_rtc_InstallCallback(), также передавая при этом количество секунд для заданной длительности времениn. По умолчанию событие stopwatch происходит только однократно (one-shot stopwatch event). Callback-функция может тогда либо запретить это событие передачей аргумента ADI_RTC_EVENT_STOPWATCH в функцию adi_rtc_RemoveCallback(), или может повторно разрешить событие stopwatch путем вызова функции adi_rtc_ResetStopwatch(). Если событие stopwatch заново разрешено таким образом, то оно становится периодическим.

Однократное событие будильника. Приложение может разрешить событие будильника (alarm event), которое однократно вызовет прерывание в указанный день и указанное время. Это событие прерывания разрешается, когда приложение передает аргумент ADI_RTC_EVENT_ONCE_ALM в функцию adi_rtc_InstallCallback(), передавая при этом также и структуру tm, содержащую дату и время срабатывания будильника. После того, как произойдет событие будильника, callback может быть удален передачей аргумента ADI_RTC_EVENT_ONCE_ALM в функцию adi_rtc_RemoveCallback(). Тогда может быть запланировано другое такое же событие путем повторной установки callback. После установки планирования этого события можно путем удаления callback отменить его до того, как событие сработает.

Периодическое событие будильника. Приложение может разрешить прерывания будильника, которое будет срабатывать каждый день (сутки) в указанное время, пока будильник не будет запрещен. Это событие прерывания становится разрешенным, когда приложение передает аргумент ADI_RTC_EVENT_EACH_DAY_ALM в функцию adi_rtc_InstallCallback(), передавая также структуру tm, где содержится время дня, на которое настраивается будильник. Это событие остается разрешенным, и прерывание будет происходить каждые сутки в указанное время, пока приложение не вызовет функцию adi_rtc_RemoveCallback(), передав в неё аргумент ADI_RTC_EVENT_EACH_DAY_ALM.

Событие завершения записи в MMR RTC. Все операции записи в MMR-регистры RTC_STAT, RTC_ALARM, RTC_SWCNT и RTC_ICTL синхронизируются с тиками 1 Гц. Приложению иногда необходимо оповещение, что такая запись завершилась. Для этой цели можно разрешить прерывание, когда завершились все ожидающие синхронизации записи в регистры RTC. Это событие становится разрешенным, когда приложение передает аргумент ADI_RTC_EVENT_WRITES_COMPLETE в функцию adi_rtc_InstallCallback(). Событие остается разрешенным до тех пор, пока приложение не запретит это событие путем вызова функции adi_rtc_RemoveCallback() с аргументом ADI_RTC_EVENT_WRITES_COMPLETE.

[Callback-функции]

Приложение может разрешить события RTC и обрабатывать их путем определения и установки callback для этого события. Callback это просто функция (так называемая функция обратного вызова), связанная с определенным событием или группой событий, и которая вызывается всякий раз, когда происходит связанное событие. Для каждого события можно написать отдельную callback-функцию, или можно написать одну callback-функцию, которая будет обрабатывать все события RTC, фильтруя события с помощью оператора case. Если callback-функция не является "отложенного" типа (deferred), то она выполняется в контексте подпрограммы обработки прерывания (ISR). Этот ISR работает как часть службы RTC, и вызывается из Менеджера Прерываний всякий раз, когда возникло одно из возможных событий RTC. Служба RTC предоставляет функцию для установки callback-ов, функцию для удаления callback-ов, и обработчик, который запускает callback-функции. Приложение, в свою очередь, предоставляет callback-функцию (или несколько callback-функций), которая управляет обработкой каждого события, и также не обязательную структуру данных, состоящую из специфической для события информации, которая передается в callback-функцию из обработчика службы RTC. На первый взгляд все это кажется запутанным и непонятным, однако позже будет приведен поясняющий пример кода, где демонстрируется, как используется эта структура.

Список callback-функций. Для обработки callback-ов служба RTC хранит таблицу (список) с записями по каждому из 8 событий. Каждая запись хранит указатель на callback-функцию, или NULL, если соответствующий callback не был установлен. Когда приложение вызывает функцию adi_rtc_InstallCallback, передавая в неё Event ID, служба RTC вставляет указатель на callback-функцию в запись списка событий. Когда происходит это событие, обработчик RTC использует запись для нахождения и выполнения callback-функции, привязанной к этому событию. Когда приложение вызывает adi_rtc_RemoveCallback для запрета события, указатель на callback-функцию удаляется из списка callback для этого события.

Установка callback. Чтобы установить callback для одного из событий RTC, приложение просто вызывает API-функцию adi_rtc_InstallCallback, передавая в неё Event ID. Для некоторых событий, таких как будильники и события stopwatch, в эту функцию передается еще и другая информация (время срабатывания будильника или длительность периода stopwatch). Функция adi_rtc_InstallCallback использует эту информацию для конфигурирования аппаратных регистров RTC, чтобы в заданное время генерировалось прерывание. Опциональная структура данных ClientHandle также передается в функцию adi_rtc_InstallCallback, где содержится информация, сохраняемая в callback-списке, и передаваемая в callback-функцию при её вызове.

Удаление callback. Приложение может запретить обработку события путем передачи Event ID в качестве параметра в функцию adi_rtc_RemoveCallback. Эта функция удаляет callback из callback-списка для этого события, и также конфигурирует аппаратные регистры RTC, чтобы для этого события больше не происходило прерывание.

Обработчик прерывания RTC. У службы RTC есть обработчик прерывания, который "подцеплен в цепочку" группы вектора прерываний (interrupt vector group, IVG). Обработка таких цепочек осуществляется Менеджером Прерываний. Обратите внимание на разницу между обработчиком прерывания, определенном в службе RTC, и обработчиком прерывания (interrupt service routine, ISR), который определен в Менеджере Прерываний для обработки события определенного уровня IVG. ISR Менеджера Прерываний выполнит обработчик прерывания RTC, когда произойдет необходимое событие аппаратуры RTC. Обработчик прерывания читает флаги событий в регистре RTC_ISTAT, чтобы определить источник, который вызвал прерывание. Затем этот обработчик просматривает callback-список на предмет поиска записи для этого события (см. выше "Список callback-функций"). Эта запись укажет на callback-функцию, и на её параметр ClientHandle (см. далее "Использование в callback-функции параметра ClientHandle"). Этот обработчик выполнит callback с передачей ей параметра ClientHandle. Когда callback завершится, управление перейдет в обработчик прерывания RTC, который в свою очередь вернет управление Менеджеру Прерываний.

Использование в callback-функции параметра ClientHandle. В функцию adi_rtc_InstallCallback также передается как аргумент структура опциональных данных, которая называется ClientHandle. Это определяемая пользователем структура, где содержится специфическая для события информация, которая сохраняется в записи callback-списка вместе с указателем на callback-функцию. Когда происходит событие, Менеджер Прерываний выполнит обработчик прерывания RTC. Этот обработчик прерывания использует callback-список для поиска адреса callback-функции и информации ClientHandle, которая должна быть передана в эту callback-функцию.

[Пример]

Вместе с установкой VisualDSP++ 5.0 предоставляется проект примера PeriodicStopwatch (также есть и другие примеры использования службы RTC: EachDayAlarm, OnceAlarm, OneShotStopwatch, RTCPeriodicDays, RTCPeriodicHours, RTCPeriodicMinutes, RTCPeriodicSeconds, SetGetDateTime). Пример PeriodicStopwatch демонстрирует использование функций adi_rtc_InstallCallback и adi_rtc_RemoveCallback для установки события stopwatch и его обработки в callback-функции. Также демонстрируется использование функции adi_rtc_ResetStopwatch для повторного разрешения события stopwatch, и использование ClientHandle для удобного управления обработкой события, чтобы периодическое событие stopwatch происходило каждые 5 секунд в течение 20 секунд, и затем все останавливалось.

В следующем примере кода определена структура данных STOPWATCH_INFO, у которой есть 3 информационных поля, по указателю на структуру вся эта информация передается в callback. Первое поле показывает, что это событие периодическое. Второе поле показывает количество секунд, которое callback-функция использует, когда заново разрешает stopwatch-событие (в этом примере 5). Третье поле говорит, сколько раз нужно повторно разрешать stopwatch-событие (в этом примере 3). Если это поле установлено в 0, то событие повторяется непрерывно. Аргумент ClientHandle используется, чтобы передать эту структуру данных в функцию adi_rtc_InstallCallback.

typedef struct
{
   // Должны ли эти callback-вызовы быть периодическими,
   // или вызов должен быть однократным:
   u32 PeriodicFlag;
   // Значение для записи в регистр обратного отсчета stopwatch,
   // когда stopwatch-событие повторно разрешается:
   u32 SecondsCounter;
   // Сколько раз нужно повторно разрешить stopwatch-событие:
   u32 NumRepetitions;
} STOPWATCH_INFO;

В этом примере предоставляется callback-функция RTCCallback, в которой есть оператор switch, обрабатывающий все события RTC (здесь показана только обработка события STOPWATCH). Callback-функция принимает 3 аргумента:

void *ClientHandle
u32 EventID
void *pArg

ClientHandle содержит указатель на структуру, который передается как параметр в функцию adi_rtc_InstallCallback, когда устанавливается callback. Обработчик прерывание передает этот аргумент в callback-функцию, когда происходит прерывание. EventID задает, какое из 8 возможных событий сгенерировало вызов callback, в этом примере событие stopwatch. Аргумент pArg гибкий, указанный как тип void*, и он зарезервирован для передачи любой уместной информации, которая нужна для callback-функции, чтобы обработать событие. Callback выполняет оператор switch по значению EventID, и выполняет ту ветвь case, который соответствует нужному EventID. Для события stopwatch callback-функция видит, что установлен флаг PeriodicFlag, поэтому вызывается функция adi_rtc_ResetStopwatch, чтобы повторно разрешить событие, используя значение количества секунд NumSeconds для установки счетчика stopwatch. Ниже показан код примера из callback-функции, где обрабатывается событие stopwatch.

static void RTCCallback ( void *ClientHandle, u32 Event, void *pArg )
{
   STOPWATCH_INFO CountdownStruct = *(STOPWATCH_INFO*)ClientHandle;
   switch ( (u32)Event )
   {
      /* Событие истечения таймаута stopwatch: */
   case ADI_RTC_EVENT_STOPWATCH:
      /* Инкремент счетчика срабатывания событий stopwatch */
      SWEventCounter++;
      /* Использование полей структуры данных, чтобы определить,

         что все действия завершены */
      /* Если должно быть однократное событие ...*/
      if ( ( CountdownStruct.PeriodicFlag == 0 )
      /* ... или если оно периодическое ... */
      || ( ( CountdownStruct.PeriodicFlag == 1 )
      /* ... но счетчик событий stopwatch достиг последнего повторения */
         && (SWEventCounter == CountdownStruct.NumRepetitions)
      /* Если NumRepetitions == 0, то повторения бесконечны. */
         && (CountdownStruct.NumRepetitions != 0 ) ) )
      {
         adi_rtc_RemoveCallback( ADI_RTC_EVENT_STOPWATCH );
         StopwatchCompleteFlag = 1;
         SWEventCounter = 0;
      }
      else
      {
         /* Ветка else подразумевает, что события периодические, и либо

            количество повторений бесконечное, либо счетчик пока не

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

            разрешим событие. */
         adi_rtc_ResetStopwatch( CountdownStruct.SecondsCounter );
      }
      break;
   case ...

В функции main примера callback устанавливается на событие stopwatch. Повторения событий происходят 20 секунд до завершения всех действий. Здесь показаны соответствующие секции функции main.

int main()
{
   int NumSeconds;
   int* pNumSeconds;
   /* Структура для передачи информации при установке stopwatch callback: */
   STOPWATCH_INFO StopwatchCallbackInfo;
   /* И указатель на неё: */
   STOPWATCH_INFO* pStopwatchCallbackInfo;
   /* Инициализация системных служб, включая службу RTC: */
   Result = adi_ssl_Init();
   /* Обнуление флага, сигнализирующего о завершении всех действий: */
   StopwatchCompleteFlag = 0;
   /* Инициализация статического счетчика количества прошедших событий: */
   SWEventCounter = 0;
   /* При повторном разрешении stopwatch будет установлен на 5 секунд: */
   StopwatchCallbackInfo.SecondsCounter = 5;
   /* События stopwatch будут происходить периодически: */
   StopwatchCallbackInfo.PeriodicFlag = 1;
   /* Срабатывания stopwatch будут повторно разрешены 3 раза: */
   StopwatchCallbackInfo.NumRepetitions = 3;
   /* Инициализация указателя на структуру, через которую передается

      информация в callback */
   pStopwatchCallbackInfo = &StopwatchCallbackInfo;
   /* Первый таймаут stopwatch произойдет через то же самое время,

      на которое сбрасывается значение stopwatch, т. е. 5 секунд: */
   NumSeconds = StopwatchCallbackInfo.SecondsCounter;
   /* Установка stopwatch callback: */
   adi_rtc_InstallCallback(ADI_RTC_EVENT_STOPWATCH,
                           (void*)pStopwatchCallbackInfo, NULL, RTCCallback,
                           (void*)NumSeconds);
   /* Ожидание срабатывания события stopwatch. После 5 секунд оно будет

      повторено три раза. */
   while( StopwatchCompleteFlag == 0 );
   /* Сюда код дойдет через 20 секунд. */
   ...
}

[Справочник по API RTC]

ADI_RTC_RESULT adi_rtc_Init(void *pCriticalRegionArg);

ADI_RTC_RESULT adi_rtc_Terminate(void);

ADI_RTC_RESULT adi_rtc_SetDateTime(struct tm *pDateTime);

ADI_RTC_RESULT adi_rtc_GetDateTime(struct tm *pDateTime);

ADI_RTC_RESULT adi_rtc_InstallCallback(ADI_RTC_EVENT_ID EventID,
                                       void *ClientHandle,
                                       ADI_DCB_HANDLE DCBHandle,
                                       ADI_DCB_CALLBACK_FN ClientCallback,
                                       void *Value);

ADI_RTC_RESULT adi_rtc_RemoveCallback(ADI_RTC_EVENT_ID EventID);

ADI_RTC_RESULT adi_rtc_SetEpoch(ADI_RTC_EPOCH *pEpoch);

ADI_RTC_RESULT adi_rtc_GetEpoch(ADI_RTC_EPOCH *pEpoch);

ADI_RTC_RESULT adi_rtc_EnableWakeup(void);

ADI_RTC_RESULT adi_rtc_DisableWakeup(void);

ADI_RTC_RESULT adi_rtc_ResetStopwatch(u32 NumSeconds);

[Ссылки]

1. VisualDSP++ 5.0 Device Drivers and System Services Manual for Blackfin® Processors site:analog.com.
2. Неофициальная классификация семейств процессоров Blackfin.
3. ADSP-BF538 RTC.
4. VDK: менеджер прерываний.
5. Специфика использования VDK для процессоров Blackfin.
6. VDK: менеджер отложенных функций обратного вызова.
7. VisualDSP++ 5.0 C/C++ Compiler and Library Manual for Blackfin Processors site:analog.com.
8. ADSP-BF538: обработка событий (прерывания, исключения).
9. ADSP-BF538: динамическое управление питанием.
10. 190211TestRTC.zip - исходный код проекта, где демонстрируется служба RTC с ежесекундной генерацией прерывания.