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

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

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

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 зависит от

Разрешенные Режимы Решателя для Встроенных Конечных файлов Системы реального времени обобщают разрешенные режимы решателя для односкоростного и многоскоростных моделей. Обратите внимание на то, что для односкоростной модели, только 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шаг функция

void model_step(void)

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

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

Перепрерывание 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шаг. Для многоскоростных, многозадачных моделей генератор кода пытается использовать различную стратегию. Эта стратегия называется группировкой уровня. Группировка уровня генерирует отдельный modelшаг функции для задачи базовой ставки и каждой задачи подуровня в модели. Функциональное соглашение о присвоении имен для этих функций

model_stepN

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

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

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

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

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

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

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

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

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

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

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

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

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

void model_step(void)

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

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

Инструкции для Изменения rt_OneStep

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

Комментарии в rt_OneStep укажите на место, чтобы добавить ваш код.

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

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

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

Панорама

В большинстве случаев самая легкая стратегия развертывания сгенерированного кода состоит в том, чтобы использовать Генерировать пример основная опция программы, чтобы сгенерировать ert_main.c или .cpp модуль (см., Генерирует Автономную Программу).

Однако, если вы поворачиваете Генерировать пример основная опция программы прочь, можно использовать статический основной модуль в качестве примера или шаблона для разработки встраиваемых приложений. Статические основные модули, обеспеченные 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 и основная функция является по существу тем же самым в статическом основном модуле, как они находятся в автоматически сгенерированной версии, описанной в, Развертывают Сгенерированные Программы Независимого исполняемого файла В Целевой компьютер. Для многоскоростных, многозадачных моделей, однако, статический и сгенерированный код немного отличается. Следующий раздел описывает этот случай.

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

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

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

void model_step(int_T tid);

По умолчанию, когда Генерировать пример, основная опция программы выключена, цель ERT, генерирует modelшаг “обертка” для многоскоростных, многозадачных моделей. Цель обертки состоит в том, чтобы соединить интерфейсом со специфичным для уровня model_stepN функции к вызову старого стиля. Код обертки отправляет model_stepN вызовите с 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шаг из статической основной программы в многоскоростной, многозадачной модели.

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_stepN функционируйте непосредственно, установите RateBasedStepFcn к 1. В этом случае функция обертки не сгенерирована.

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

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

Как со сгенерированным ert_main.c или .cpp, необходимо сделать несколько модификаций к основному циклу и rt_OneStep. См. Инструкции для Изменения Основной Программы и Инструкций для Изменения rt_OneStep.

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

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

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

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

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

Используйте их макросы в вашей статической основной программе, чтобы получить доступ к отдельным структурам данных модели в структуре данных 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 определение данных или во время выполнения.

Основная программная совместимость

Когда Генерировать пример, основная опция программы выключена, генерация кода, производит немного отличающийся код группировки уровня для совместимости с более старым статическим ert_main.c модуль. Смотрите, что Уровень Группируется и Статическая Основная Программа для деталей.

Сделайте свой уровень S-функций, группирующийся совместимый

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

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

Чтобы сделать ваш уровень 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