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

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

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

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^® включение:

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

Статическая основная программа содержит:

Для односкоростных моделей, операции rt_OneStep и main функция в статической основной программе эквивалентна, они находятся в автоматически сгенерированной версии, описанной в, Развертывают Сгенерированные Программы Независимого исполняемого файла В Целевой компьютер. Для многоскоростных, многозадачных моделей статическая основная программа и сгенерированный код отличаются как описано в следующем разделе.

Разрабатывать приложение при помощи статической основной программы:

Если ваше существующее приложение зависит от статического ert_main.c разработанный в релизах перед R2012b, rt_main.c, rt_malloc_main.c, или rt_cppclass_main.cpp, вы можете должны быть продолжить использовать ту статическую основную программу.

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

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

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

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

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

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

Сделайте немного модификаций к основному циклу и 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 определение данных или во время выполнения.

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

Когда вы, параметр конфигурации модели clear Генерирует пример основная программа, генератор кода, производите немного отличающийся код группировки уровня для совместимости с более старым статическим 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