Документация

Обзор операции

Следующий псевдокод показывает выполнение основной программы.

main()
{
  Initialization (including installation of rt_OneStep as an 
    interrupt service routine for a real-time clock)
  Initialize and start timer hardware
  Enable interrupts
  While(not Error) and (time < final time)
    Background task
  EndWhile
  Disable interrupts (Disable rt_OneStep from executing)
  Complete any background tasks
  Shutdown
}

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

Инструкции по изменению основной программы

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

Обзор операции

Область операции rt_OneStep зависит от

Разрешенные режимы решателя для Embedded Real-Time System Target Files суммирует разрешенные режимы решателя для односкоростных и многоскоростных моделей. Обратите внимание, что для модели с одной скоростью только SingleTasking разрешен режим решателя.

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

Односкоростная однозадачная операция

Единственным допустимым режимом решателя для модели с одной скоростью является SingleTasking. Такие модели выполняются в «односкоростной» операции.

Следующий псевдокод показывает проект rt_OneStep в односкоростной программе.

rt_OneStep()
{
  Check for interrupt overflow or other error
  Enable "rt_OneStep" (timer) interrupt
  Model_Step()  -- Time step combines output,logging,update
}

Для случая с одной скоростью сгенерированные model_step функция есть

void model_step(void)

Односкоростной rt_OneStep предназначен для выполнения model_step в течение одного такта. Чтобы применить это ограничение времени, rt_OneStep поддерживает и проверяет флаг переполнения таймера. При вводе прерывания таймера отключаются до тех пор, пока не будет проверен флаг переполнения и другие условия ошибки. Если флаг переполнения снят, rt_OneStep устанавливает флаг и продолжает с включенными прерываниями таймера.

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

Повторное преобразование rt_OneStep по таймеру является условием ошибки. Если это условие обнаружено rt_OneStep сигнализирует об ошибке и немедленно возвращается. (Обратите внимание, что вы можете изменить это поведение, если хотите обрабатывать условие по-другому.)

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

Многоразовая операция многозадачности

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

Следующий псевдокод показывает проект rt_OneStep в многозадачной программе.

rt_OneStep()
{
  Check for base-rate interrupt overrun
  Enable "rt_OneStep" interrupt
  Determine which rates need to run this time step

  Model_Step0()        -- run base-rate time step code

  For N=1:NumTasks-1   -- iterate over sub-rate tasks
    If (sub-rate task N is scheduled)
    Check for sub-rate interrupt overrun
      Model_StepN()    -- run sub-rate time step code
    EndIf
  EndFor
}

Идентификаторы задач.  Выполнение блоков, имеющих различные частоты дискретизации, разбивается на задачи. Каждому блоку, который выполняется с заданной частотой дискретизации, присваивается идентификатор задачи (tid), который связывает его с задачей, которая выполняется с такой скоростью. Где есть NumTasks задачи в системе, область значений идентификаторов задач 0.. NumTasks-1.

Определение приоритетности задач базовой скорости и субрейта.  Приоритеты задач определяются в порядке убывания по скорости. Задача базовой скорости является задачей, которая запускается с самой высокой скоростью в системе (оборудование тактовая частота). Задача базовой скорости имеет самый высокий приоритет (tid 0). Следующая самая быстрая задача (tid 1) имеет следующий наивысший приоритет, и так далее до самой медленной, самой низкой приоритетной задачи (tid NumTasks-1).

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

Группировка скоростей и специфичные для скорости функции model_step.  В модели с одной скоростью выходные блоки расчетов выполняются в рамках одной функции model_step. Для многозадачных моделей генератор кода пытается использовать другую стратегию. Эта стратегия называется группировкой скоростей. Группировка скоростей генерирует отдельные model_step функции для задачи базовой скорости и каждой задачи подрейса в модели. Соглашение об именовании функций для этих функций является

model_stepN

где N является идентификатором задачи. Для примера, для модели с именем my_model который имеет три скорости, генерируются следующие функции:

void my_model_step0 (void);
void my_model_step1 (void);
void my_model_step2 (void);

Каждый model_step<reservedrangesplaceholder0 > функция выполняет блоки, разделяющие tid N; другими словами, блочный код, который выполняется в N задач сгруппирован в связанный model_step<reservedrangesplaceholder0 > функция.

Планирование model_stepN выполнение.  На каждом такте деления, rt_OneStep поддерживает счетчики расписания и флаги событий для каждой задачи подрейса. Счетчики реализованы следующим taskCounter массивы, индексированные на tid. Флаги событий реализованы как массивы, индексированные на tid.

Ведение счетчиков планирования и флагов задач для субскоростей осуществляется по rt_OneStep. Счетчики планирования являются в основном делителями тактовой частоты, которые подсчитывают период дискретизации, сопоставленный с каждой задачей субскорости. Пара задач, которая обменивается данными, поддерживает флаг взаимодействия на более высокой скорости. Флаги взаимодействия задач указывают, что запланировано выполнение как быстрых, так и медленных задач.

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

На каждом вызове rt_OneStep обновляет свои структуры данных планирования и шагает задачу базовой скорости (rt_OneStep вызывает model_step0 поскольку задача базовой скорости должна выполняться на каждом шаге синхроимпульса). Затем, rt_OneStep итерация флагов планирования в tid порядок, безоговорочно вызывающий model_step<reservedrangesplaceholder0 > для любой задачи, флаг которой установлен. Задачи выполняются в порядке приоритета.

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

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

Обнаружение переполнения.  Многоразовые rt_OneStep также поддерживает массив флагов переполнения таймера. rt_OneStep обнаруживает переполнение таймера для каждой задачи той же логикой, что и односкоростной rt_OneStep.

Многократная однозадачная операция

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

В многократной однозадачной программе блоки выполняются с различными скоростями, но под одним и тем же идентификатором задачи. Область операции rt_OneStepв этом случае является упрощенным вариантом многозадачной операции многозадачности. Группировка скоростей не используется. Единственная задача - это задача базовой скорости. Поэтому только один model_step функция сгенерирована:

void model_step(void)

На каждом такте деления, rt_OneStep проверяет флаг переполнения и вызывает model_step. Функция планирования для многократной однозадачной программы rate_scheduler (а не rate_monotonic_scheduler). Планировщик поддерживает счетчики планирования на каждом такте. Существует один счетчик для каждой частоты дискретизации в модели. Счетчики реализованы в массиве (индексируется на tid) в Timing структура внутри rtModel.

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

Инструкции по изменению rt_OneStep

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

Комментарии в rt_OneStep указать место для добавления кода.

В многоразовых rt_OneStep, можно улучшить эффективность путем разворачивания for и while циклы.

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

Также соблюдайте следующие осторожные рекомендации:

Обзор

В большинстве случаев самой легкой стратегией развертывания сгенерированного кода является использование опции Generate a example main program для генерации ert_main.c или .cpp модуль (см. «Генерация автономной программы»).

Однако, если выключить опцию Generate a example main program, можно использовать статический основной модуль в качестве примера или шаблона для разработки встраиваемых приложений. Статические основные модули, предоставляемые MathWorks^® включают:

Статический основной модуль не является частью сгенерированного кода; он предоставляется как базис для пользовательских модификаций и для использования в симуляции. Если существующие приложения зависят от статического ert_main.c (разработан в релизах до R2012b), rt_main.c, rt_malloc_main.c, или rt_cppclass_main.cppможет потребоваться продолжить использование статического основного программного модуля.

При разработке приложений с помощью статического основного модуля следует скопировать модуль в рабочую папку и переименовать его перед внесением изменений. Например, можно переименовать rt_main.c на model_rt_main.c. Кроме того, необходимо изменить настройки шаблона make-файла или набора инструментальных средств таким образом, чтобы процесс сборки создавал соответствующий файл объекта, такой как model_rt_main.obj (в UNIX^®, model_rt_main.o), в папке сборки.

Статический основной модуль содержит

Для односкоростных моделей операция rt_OneStep и основная функция по существу совпадает в статическом основном модуле, так же как и в автоматически сгенерированной версии, описанной в Deploy Generated Независимый Исполняемый Файл Programs To Target Hardware. Однако для многозадачных моделей с многозадачностью статический и сгенерированный код немного отличаются. В следующем разделе описывается этот случай.

Группировка скоростей и статическая основная программа

Цели, основанные на цели ERT, иногда используют статический основной модуль и запрещают использование опции Generate a example main program. Это делается, потому что к статическому основному модулю были добавлены специфичные для цели модификации, и эти модификации не будут сохранены, если основная программа была регенерирована.

Ваш статический основной модуль может использовать или не использовать совместимую группировку скоростей model_step<reservedrangesplaceholder0 > функций. Если ваш основной модуль основан на статическом rt_main.c, rt_malloc_main.c, или rt_cppclass_main.cpp модуль, он не использует специфичные для скорости model_step<reservedrangesplaceholder0 > вызовы функций. В нем используется старый стиль model_step функция, передающая идентификатор задачи:

void model_step(int_T tid);

По умолчанию, когда опция Сгенерировать пример основной программы отключена, цель ERT генерирует model_step «обертка» для многозадачных, многозадачных моделей. Цель оболочки состоит в том, чтобы взаимодействовать со специфичным для скорости model_step<reservedrangesplaceholder0 > функций к вызову старого стиля. Код обертки отправляется в model_step<reservedrangesplaceholder0 > вызов с помощью switch оператор, как в следующем примере:

void mymodel_step(int_T tid) /* Sample time:  */
{

  switch(tid) {
   case 0 :
    mymodel_step0();
    break;
   case 1 :
    mymodel_step1();
    break;
   case 2 :
    mymodel_step2();
    break;
   default :
    break;
  }
}

Следующий псевдокод показывает, как rt_OneStep вызывает model_step от статической основной программы в многозадачной, многозадачной модели.

rt_OneStep()
{
  Check for base-rate interrupt overflow
  Enable "rt_OneStep" interrupt
  Determine which rates need to run this time step

  ModelStep(tid=0)     --base-rate time step

  For N=1:NumTasks-1  -- iterate over sub-rate tasks
    Check for sub-rate interrupt overflow
    If (sub-rate task N is scheduled)
      ModelStep(tid=N)    --sub-rate time step
    EndIf
  EndFor
}

Можно использовать переменную TLC RateBasedStepFcn чтобы указать, что генерируются только основанные на скорости функции шага, без функции оболочки. Если ваш целевой объект вызывает совместимую группировку скоростей model_step<reservedrangesplaceholder0 > function непосредственно, set RateBasedStepFcn на 1. В этом случае функция обертки не генерируется.

Вам следует задать RateBasedStepFcn до %include "codegenentry.tlc" оператор в целевом файле системы. Также можно задать RateBasedStepFcn в вашем target_settings.tlc файл.

Изменение статической основной программы

Как и с сгенерированным ert_main.c или .cpp, вы должны сделать несколько изменений в основной цикл и rt_OneStep. Смотрите Инструкции по изменению основной программы и Инструкции по изменению rt_OneStep.

Кроме того, вы должны заменить rt_OneStep вызов в основном цикле с фоновым вызовом задачи или оператором null.

Другие изменения, которые вы, возможно, должны сделать,

Изменение статического основного для выделения и доступа к данным образца модели

Если вы используете статический основной программный модуль, и ваша модель сконфигурирована для Reusable function упаковка интерфейса кода, но параметр конфигурации модели Use dynamic memory allocation for model initialization очищен, данные образца модели должны быть выделены статически или динамически вызывающим основным кодом. Указатели на отдельные структуры данных моделей (такие как Блоки IO, DWork и Параметры) должны быть настроены в структуре модели реального времени данных верхнего уровня.

Чтобы поддержать основные изменения, процесс сборки генерирует подмножество следующих моделей реального времени макросов (RTM), основанных на требованиях к данным вашей модели, в model.h.

Используйте эти макросы в своей статической основной программе для доступа к отдельным структурам данных моделей в структуре данных RTM. Например, предположим, что пример модели rtwdemo_reusable сконфигурирован с Reusable function упаковка интерфейса кода, Use dynamic memory allocation for model initialization очищенная Pass root-level I/O as установленная на Individual argumentsи Optimization панель опции Remove root level I/O zero initialization удалена. Создание модели генерирует следующие структуры данных моделей и точки входа модели в rtwdemo_reusable.h:

/* Block states (auto storage) for system '<Root>' */
typedef struct {
  real_T Delay_DSTATE;                 /* '<Root>/Delay' */
} D_Work;

/* Parameters (auto storage) */
struct Parameters_ {
  real_T k1;                           /* Variable: k1
                                        * Referenced by: '<Root>/Gain'
                                        */
};

/* Model entry point functions */
extern void rtwdemo_reusable_initialize(RT_MODEL *const rtM, real_T *rtU_In1,
  real_T *rtU_In2, real_T *rtY_Out1);
extern void rtwdemo_reusable_step(RT_MODEL *const rtM, real_T rtU_In1, real_T
  rtU_In2, real_T *rtY_Out1);

Кроме того, если Generate an example main program параметра конфигурации модели не выбран для модели, rtwdemo_reusable.h содержит определения для макросов RTM rtmGetDefaultParam, rtmsetDefaultParam, rtmGetRootDWork, и rtmSetRootDWork.

Кроме того, для ссылки сгенерированные rtmodel.h файл содержит пример определения параметра с начальными значениями (неисполняющий код):

#if 0

/* Example parameter data definition with initial values */
static Parameters rtP = {
  2.0                                  /* Variable: k1
                                        * Referenced by: '<Root>/Gain'
                                        */
};                                     /* Modifiable parameters */

#endif

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

static RT_MODEL rtM_;
static RT_MODEL *const rtM = &rtM_;    /* Real-time model */
static Parameters rtP = {
  2.0                                  /* Variable: k1
                                        * Referenced by: '<Root>/Gain'
                                        */
};                                     /* Modifiable parameters */

static D_Work rtDWork;                 /* Observable states */

/* '<Root>/In1' */
static real_T rtU_In1;

/* '<Root>/In2' */
static real_T rtU_In2;

/* '<Root>/Out1' */
static real_T rtY_Out1;

В теле вашей основной функции можно использовать следующие вызовы макросов RTM, чтобы настроить параметры модели и данные DWork в структуре данных модели реального времени:

int_T main(int_T argc, const char *argv[])
{
...
/* Pack model data into RTM */

rtmSetDefaultParam(rtM, &rtP);
rtmSetRootDWork(rtM, &rtDWork);

/* Initialize model */
rtwdemo_reusable_initialize(rtM, &rtU_In1, &rtU_In2, &rtY_Out1);
...
}

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

Совместимость основной программы

Когда опция Generate a example main program отключена, генерация кода производит немного другой код группировки скоростей для совместимости со старым статическим ert_main.c модуль. Для получения дополнительной информации см. разделы «Группировка ставок» и «Статическая основная программа».

Сделайте группировку частот S-функций совместимой

Встроенный Simulink^® блоки, а также блоки DSP System Toolbox™ соответствуют требованиям для генерации кода группировки скоростей. Однако записанные пользователем многоразовые встроенные S-функции могут не быть совместимыми с группировкой скоростей. Несовместимые блоки генерируют менее эффективный код, но в противном случае совместимы с группировкой скоростей. Чтобы в полной мере использовать преимущества эффективности группировки скоростей, ваши многоуровневые встроенные S-функции должны быть обновлены, чтобы быть полностью совместимыми с группировкой скоростей. Необходимо обновить реализации TLC S-функций, как описано в этом разделе.

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

Чтобы сделать группировку скорости S-функций совместимой, можно использовать следующие функции TLC для генерации ModelOutputs и ModelUpdate код, соответственно:

OutputsForTID(block, system, tid)
UpdateForTID(block, system, tid)

Приведенные ниже перечни кодов иллюстрируют генерацию выхода расчетов без группировки ставок (листинг 1) и с группировкой ставок (листинг 2). Обратите внимание на следующее:

Список 1: Выводит генерацию кода без группировки скоростей

%% multirate_blk.tlc

%implements "multirate_blk" "C"


%% Function: mdlOutputs =====================================================
%% Abstract:
%%
%%  Compute the two outputs (input signal decimated by the
%%  specified parameter). The decimation is handled by sample times.
%%  The decimation is only performed if the block is enabled.
%%  Each port has a different rate.
%%
%%  Note, the usage of the enable should really be protected such that
%%  each task has its own enable state. In this example, the enable
%% occurs immediately which may or may not be the expected behavior.
%%
  %function Outputs(block, system) Output
  /* %<Type> Block: %<Name> */
  %assign enable = LibBlockInputSignal(0, "", "", 0)
  {
    int_T *enabled = &%<LibBlockIWork(0, "", "", 0)>;

    %if LibGetSFcnTIDType("InputPortIdx0") == "continuous"
      %% Only check the enable signal on a major time step.
      if (%<LibIsMajorTimeStep()> && ...
                           %<LibIsSFcnSampleHit("InputPortIdx0")>) {
        *enabled = (%<enable> > 0.0);
      }
    %else
      if (%<LibIsSFcnSampleHit("InputPortIdx0")>) {
        *enabled = (%<enable> > 0.0);
      }
    %endif

    if (*enabled) {
      %assign signal = LibBlockInputSignal(1, "", "", 0)
      if (%<LibIsSFcnSampleHit("OutputPortIdx0")>) {
        %assign y = LibBlockOutputSignal(0, "", "", 0)   
        %<y> = %<signal>;
      }
      if (%<LibIsSFcnSampleHit("OutputPortIdx1")>) {
        %assign y = LibBlockOutputSignal(1, "", "", 0)
        %<y> = %<signal>;
      }
    }
  }

  %endfunction
%% [EOF] sfun_multirate.tlc

Список 2: Выводит генерацию кода с группировкой скоростей

%% example_multirateblk.tlc

%implements "example_multirateblk" "C"


  %% Function: mdlOutputs =====================================================
  %% Abstract:
  %%
  %% Compute the two outputs (the input signal decimated by the
  %% specified parameter). The decimation is handled by sample times.
  %% The decimation is only performed if the block is enabled.  
  %% All ports have different sample rate.
  %%
  %% Note: the usage of the enable should really be protected such that
  %% each task has its own enable state. In this example, the enable
  %% occurs immediately which may or may not be the expected behavior.
  %%
  %function Outputs(block, system) Output



  %assign portIdxName = ["InputPortIdx0","OutputPortIdx0","OutputPortIdx1"]
  %assign portTID     = [%<LibGetGlobalTIDFromLocalSFcnTID("InputPortIdx0")>, ...
                        %<LibGetGlobalTIDFromLocalSFcnTID("OutputPortIdx0")>, ...
                        %<LibGetGlobalTIDFromLocalSFcnTID("OutputPortIdx1")>]
  %foreach i = 3
    %assign portName = portIdxName[i]
    %assign tid      = portTID[i]
    if (%<LibIsSFcnSampleHit(portName)>) {
                       %<OutputsForTID(block,system,tid)>
    }
  %endforeach

  %endfunction

  %function OutputsForTID(block, system, tid) Output
  /* %<Type> Block: %<Name> */
  %assign enable = LibBlockInputSignal(0, "", "", 0)  
  %assign enabled = LibBlockIWork(0, "", "", 0)  
  %assign signal = LibBlockInputSignal(1, "", "", 0)

  %switch(tid)
    %case LibGetGlobalTIDFromLocalSFcnTID("InputPortIdx0") 
                         %if LibGetSFcnTIDType("InputPortIdx0") == "continuous"
                           %% Only check the enable signal on a major time step.
                           if (%<LibIsMajorTimeStep()>) {  
                             %<enabled> = (%<enable> > 0.0);
                           }
                         %else
                           %<enabled> = (%<enable> > 0.0);
                         %endif
                         %break
    %case LibGetGlobalTIDFromLocalSFcnTID("OutputPortIdx0") 
                         if (%<enabled>) {
                           %assign y = LibBlockOutputSignal(0, "", "", 0)
                           %<y> = %<signal>;
                         }
                         %break
    %case LibGetGlobalTIDFromLocalSFcnTID("OutputPortIdx1") 
                         if (%<enabled>) {
                           %assign y = LibBlockOutputSignal(1, "", "", 0)
                           %<y> = %<signal>;
                         }
                         %break
    %default 
                         %% error it out
  %endswitch

  %endfunction

%% [EOF] sfun_multirate.tlc