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

Интеграция C кода в модели Engee с использованием блока C Function

В данном примере представлены различные способы интеграции C кода в модели Engee с использованием блока C Function.

Перед началом работы подключим библиотеку для сравнения с MATLAB:

In [ ]: 
using MATLAB

Используем макрос @__DIR__ для того, чтобы узнать папку, в которой лежит интерактивный скрипт:

In [ ]: 
demoroot = @__DIR__
Out[0]:
"/user/demo_renew/ccodeintegration"

Основы использования блока C Function

Рассмотрим простые примеры использования блока C Function, иллюстрирующие основы интеграции C кода в модель Engee.

1. Работа с многомерными сигналами, передача параметров и использование директивы #define

В модель cCodeIntegration_basics.engee добавлен блок C Function, на вход которого поступает синусоидальный сигнал in:

basics_1.PNG

Предположим, что мы хотим увеличить амплитуду синусоиды in в gain раз и сдвинуть её на величину bias. То есть выходной сигнал должен определяться по формуле out = gain * in + bias.

Перейдём в настройки блока C Function, где во вкладке Ports мы ознакомимся с определением входа и выхода блока. Здесь связываются переменные исходного кода с портами блока C Function:

  1. Скалярная переменная x типа double связывается с первым входным портом in;
  2. Векторная (3 элемента) переменная y типа double связывается с первым выходным портом out.
image_2.png

Массив gain также определяется в настройках блока C Function (вкладка Parameters):

image.png

Стоит отметить, что после передачи переменной в качестве параметра она становится:

  1. Глобальной - к gain можно обратиться из любой вкладки редактора исходного кода;
  2. С квалификатором const - при попытке изменения значения gain будет получена ошибка.

Величина смещения bias определяется идентификатором #define bias, который задается во вкладке Build options:

image.png

В данном примере смещение равно 5.

Перейдём во владку Main настроек блока C Function и нажмём кнопку "Редактировать исходный код". В открывшемся редакторе исходного кода на вкладке OutputCode приведён код, исполняемый на каждом шаге расчёта модели:

image.png

В цикле for (для каждого из трёх выходных сигналов) на каждом шаге расчёта модели определяется значение переменной y.

Промоделируем систему:

In [ ]: 
cCodeIntegration_basics = engee.load("$demoroot/models/cCodeIntegration_basics.engee", force = true)
simulationResults_basics = engee.run(cCodeIntegration_basics)
Out[0]:
SimulationResult(
    "out" => WorkspaceArray{Vector{Float64}}("cCodeIntegration_basics/out")

)

Закроем модель:

In [ ]: 
engee.close(cCodeIntegration_basics, force = true);

Импортируем результаты моделирования:

In [ ]: 
cCodeIntegration_basics_t = simulationResults_basics["out"].time;

cCodeIntegration_basics_y1 = [y[1] for y in simulationResults_basics["out"].value];
cCodeIntegration_basics_y2 = [y[2] for y in simulationResults_basics["out"].value];
cCodeIntegration_basics_y3 = [y[3] for y in simulationResults_basics["out"].value];

Построим график:

In [ ]: 
plot(cCodeIntegration_basics_t, cCodeIntegration_basics_y1)
plot!(cCodeIntegration_basics_t, cCodeIntegration_basics_y2)
plot!(cCodeIntegration_basics_t, cCodeIntegration_basics_y3)

title!("Выходной сигнал блока C Function <br> (Многомерные сигналы, параметры и #define)")
xlabel!("Время, [с]")
ylabel!("Амплитуда")
Out[0]:

2. Использование целочисленных типов данных и статических переменных

В модели cCodeIntegration_integers.engee реализуем при помощи блока C Function простой счётчик, выходом которого будет положительное целое число, обозначающее номер текущей итерации:

cCodeIntegration_integers_1.PNG

Проанализируем содержимое вкладок Ports и Build Options в настройках блока C Function:

image.png
image.png

Названия целочисленных типов данных в блоке C Function задаются в соответствии с заголовочным файлом <stdint.h> стандартной библиотеки языка C. Этот файл подключается в строке Headers вкладки Build options.

Во вкладке Ports связывается 64-битовая переменная без знака out (тип задаётся как uint64_t, а не long, см. предыдущий абзац про <stdint.h>) исходного кода с первым выходным портом блока C Function.

Во вкладке Output code редактора исходного кода блока C Function приведён код, исполняемый на каждом шаге моделирования:

image.png

Статическая переменная counter инициализируется в 0 на первом шаге симуляции, после чего на каждой итерации её значение увеличивается на 1 и присваивается переменной out.

Промоделируем систему:

In [ ]: 
cCodeIntegration_integers = engee.load("$demoroot/models/cCodeIntegration_integers.engee", force = true)
simulationResults_integers = engee.run(cCodeIntegration_integers)
Out[0]:
SimulationResult(
    "counter" => WorkspaceArray{UInt64}("cCodeIntegration_integers/counter")

)

Закроем модель:

In [ ]: 
engee.close(cCodeIntegration_integers, force = true);

Импортируем результаты моделирования:

In [ ]: 
cCodeIntegration_integers_t = simulationResults_integers["counter"].time;
cCodeIntegration_integers_y = simulationResults_integers["counter"].value;

Построим график:

In [ ]: 
plot(cCodeIntegration_integers_t, cCodeIntegration_integers_y, legend = false)

title!("Выходной сигнал блока C Function <br> (Целочисленные типы и статические переменные)")
xlabel!("Время, [с]")
ylabel!("Номер итерации")
Out[0]:

Более подробная информация о назначении вкладок редактора исходного кода, возможностях построения и доступных типах данных представлена в документации Engee.

Интеграция внешнего исходного кода

Постановка задачи

Рассмотрим более интересную инженерную задачу.

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

В файлах alphabetafilter.c и alphabetafilter.h предложена реализация альфа-бета фильтра на языке C.

Содержимое файла alphabetafilter.c:

#include "alphabetafilter.h"
#include <math.h>

double dt = 0.01;
static double xk_1, vk_1;

Parameters determineAlphaBeta(double processNoiseVariance, double measurementNoiseVariance)
{
    double lambda, r;
    Parameters p;

    lambda = (processNoiseVariance * pow(dt, 2)) / measurementNoiseVariance;
    r = (4 + lambda - sqrt(8 * lambda + pow(lambda, 2))) / 4;

    p.alpha = 1 - pow(r, 2);
    p.beta = 2 * (2 - p.alpha) - 4 * sqrt(1 - p.alpha);

    return p;
}

double alphaBetaFilter(double value, Parameters p)
{
    double xk, vk, rk;

    xk = xk_1 + (vk_1 * dt);
    vk = vk_1;

    rk = value - xk;

    xk += p.alpha * rk;
    vk += (p.beta * rk) / dt;

    xk_1 = xk;
    vk_1 = vk;

    return xk;
}

void initializeStaticVariables()
{
    xk_1 = 0;
    vk_1 = 0;
}

Содержимое файла alphabetafilter.h:

typedef struct {
    double alpha;
    double beta;
} Parameters;

Parameters determineAlphaBeta(double, double);
double alphaBetaFilter(double, Parameters);
void initializeStaticVariables();

Интегрируем данный исходный код в нашу модель Engee.

Анализ модели

Модель cCodeIntegration_source.engee:

source_1.PNG

Данная модель состоит из:

  1. Объекта управления Plant;
  2. Подсистемы, реализующей ПИД-регулятор второго порядка Controller;
  3. Блоков Band-Limited White Noise ProcessNoise и MeasurementNoise, моделирующих внешнее воздействие и шум измерений;
  4. Блока C Function Filter, реализующего альфа-бета фильтр.

Параметр Sample Time блока Filter равен шагу решателя модели Ts:

image.png

Проанализируем содержимое вкладки Build options настроек блока Filter:

image.png

В строках этой вкладки:

  • Source files - подключен файл исходного кода alphabetafilter.c;
  • Iinclude directories - задан путь до папки, содержащей заголовочный файл;
  • Headers - подключен заголовочный файл alphabetafilter.h.

Во вкладке Ports настроек блока связываются переменные исходного кода с входными и выходными портами блока Filter.

В исходном коде блока Filter на вкладке OutputCode приведён циклически исполняемый код:

image.png

На каждом шаге расчёта модели последовательно вызываются функции determineAlphaBeta() и alphabetafilter(), после чего отфильтрованное значение сохраняется в переменную out, соответствующую выходному порту x блока Filter.

Запуск симуляции

Промоделируем систему:

In [ ]: 
cCodeIntegration_source = engee.load("$demoroot/models/cCodeIntegration_source.engee", force = true)
simulationResults_source = engee.run(cCodeIntegration_source)
Out[0]:
SimulationResult(
    "filtered" => WorkspaceArray{Float64}("cCodeIntegration_source/filtered")
,
    "noisy" => WorkspaceArray{Float64}("cCodeIntegration_source/noisy")

)

Закроем модель:

In [ ]: 
engee.close(cCodeIntegration_source, force = true);

Результаты моделирования

Импортируем результаты моделирования:

In [ ]: 
cCodeIntegration_source_noisy_t = simulationResults_source["noisy"].time;
cCodeIntegration_source_noisy_y = simulationResults_source["noisy"].value;
In [ ]: 
cCodeIntegration_source_filtered_t = simulationResults_source["filtered"].time;
cCodeIntegration_source_filtered_y = simulationResults_source["filtered"].value;

Построим график:

In [ ]: 
plot(cCodeIntegration_source_noisy_t, cCodeIntegration_source_noisy_y, label = "Исходный сигнал")
plot!(cCodeIntegration_source_filtered_t, cCodeIntegration_source_filtered_y, label = "Отфильтрованный сигнал")
plot!(legend = :bottomright)

title!("Альфа-бета фильтр <br> (Интеграция внешнего исходного кода)")
xlabel!("Время, [с]")
ylabel!("Амплитуда")
Out[0]:

Интеграция статических и динамических библиотек

Постановка задачи

Зачастую исходный код поставляется не в явном виде, а в составе статических или динамических библиотек. Библиотеки с интерфейсом C API интегрируются в модели Engee также легко, как и внешний исходный код!

Скомпилируем статическую (alphabetafilter.a) и динамическую (alphabetafilter.so) библиотеку из файлов alphabetafilter.c и alphabetafilter.h с использованием MakeFile.

Содержимое файла Makefile:

all: alphabetafilter.a alphabetafilter.so

alphabetafilter.o: alphabetafilter.c
	$(CC) -c -fPIC $^ -o $@

alphabetafilter.a: alphabetafilter.o
	ar rcs $@ $^

alphabetafilter.so: alphabetafilter.o
	$(CC) -shared $^ -o $@
    
clean:
	rm -f *.o *.a *.so

Запустим компиляцию библиотек:

In [ ]: 
run(`make -C $demoroot/source`)

make: Entering directory '/user/demo_renew/ccodeintegration/source'
cc -c -fPIC alphabetafilter.c -o alphabetafilter.o
ar rcs alphabetafilter.a alphabetafilter.o
cc -shared alphabetafilter.o -o alphabetafilter.so
make: Leaving directory '/user/demo_renew/ccodeintegration/source'
Out[0]:
Process(`make -C /user/demo_renew/ccodeintegration/source`, ProcessExited(0))

Интегрируем статическую и динамическую библиотеку в нашу модель Engee.

Статическая библиотека: Анализ модели

По своей структуре модель cCodeIntegration_library_static.engee не отличается от рассмотренной ранее cCodeIntegration_source.engee; отличаются лишь директивы на вкладке Build options настроек блока Filter. Проанализируем её содержимое:

image.png

Здесь определены следующие опции построения:

  • Include directories - задан путь до папки, содержащей заголовочный файл;
  • Library directories - задан путь до папки, содержащей статическую библиотеку;
  • Headers - подключен заголовочный файл alphabetafilter.h;
  • Libraries - подключена статическая библиотека alphabetafilter.a.

Статическая библиотека: Запуск симуляции

Промоделируем систему:

In [ ]: 
cCodeIntegration_library_static = engee.load("$demoroot/models/cCodeIntegration_library_static.engee", force = true)
simulationResults_library_static = engee.run(cCodeIntegration_library_static)
Out[0]:
SimulationResult(
    "filtered" => WorkspaceArray{Float64}("cCodeIntegration_library_static/filtered")
,
    "noisy" => WorkspaceArray{Float64}("cCodeIntegration_library_static/noisy")

)

Закроем модель:

In [ ]: 
engee.close(cCodeIntegration_library_static, force = true);

Статическая библиотека: Результаты моделирования

Импортируем результаты моделирования:

In [ ]: 
cCodeIntegration_library_static_noisy_t = simulationResults_library_static["noisy"].time;
cCodeIntegration_library_static_noisy_y = simulationResults_library_static["noisy"].value;
In [ ]: 
cCodeIntegration_library_static_filtered_t = simulationResults_library_static["filtered"].time;
cCodeIntegration_library_static_filtered_y = simulationResults_library_static["filtered"].value;

Построим график:

In [ ]: 
plot(cCodeIntegration_library_static_noisy_t, cCodeIntegration_library_static_noisy_y, label = "Исходный сигнал")
plot!(cCodeIntegration_library_static_filtered_t, cCodeIntegration_library_static_filtered_y, label = "Отфильтрованный сигнал")
plot!(legend = :bottomright)

title!("Альфа-бета фильтр <br> (Интеграция статической библиотеки)")
xlabel!("Время, [с]")
ylabel!("Амплитуда")
Out[0]:

Динамическая библиотека: Анализ модели

По своей структуре модель cCodeIntegration_library_dynamic.engee не отличается от рассмотренной ранее cCodeIntegration_source.engee; отличаются лишь директивы на вкладке Build options настроек блока Filter. Проанализируем её содержимое:

image.png

Здесь определены следующие опции построения:

  • Include directories - задан путь до папки, содержащей заголовочный файл;
  • Library directories - задан путь до папки, содержащей динамическую библиотеку;
  • Headers - подключен заголовочный файл alphabetafilter.h;
  • Libraries - подключена динамическая библиотека alphabetafilter.so.

Во вкладке Start code редактора исходного кода блока Filter выполняется вызов функции initializeStaticVariables():

dynamic_2.PNG

Функция initializeStaticVariables() объявлена в файле alphabetafilter.h и предназначена для инициализации статических переменных xk_1 и vk_1, использующихся в динамической библиотеке. Это необходимо для того, чтобы при повторном запуске симуляции, переменные не сохраняли своё последнее рассчитанное значение, а сбрасывались к исходному (в данном случае в 0).

Динамическая библиотека: Запуск симуляции

Промоделируем систему:

In [ ]: 
cCodeIntegration_library_dynamic = engee.load("$demoroot/models/cCodeIntegration_library_dynamic.engee", force = true)
simulationResults_library_dynamic = engee.run(cCodeIntegration_library_dynamic)
Out[0]:
SimulationResult(
    "filtered" => WorkspaceArray{Float64}("cCodeIntegration_library_dynamic/filtered")
,
    "noisy" => WorkspaceArray{Float64}("cCodeIntegration_library_dynamic/noisy")

)

Закроем модель:

In [ ]: 
engee.close(cCodeIntegration_library_dynamic, force = true);

Динамическая библиотека: Результаты моделирования

Импортируем результаты моделирования:

In [ ]: 
cCodeIntegration_library_dynamic_noisy_t = simulationResults_library_dynamic["noisy"].time;
cCodeIntegration_library_dynamic_noisy_y = simulationResults_library_dynamic["noisy"].value;
In [ ]: 
cCodeIntegration_library_dynamic_filtered_t = simulationResults_library_dynamic["filtered"].time;
cCodeIntegration_library_dynamic_filtered_y = simulationResults_library_dynamic["filtered"].value;

Построим график:

In [ ]: 
plot(cCodeIntegration_library_dynamic_noisy_t, cCodeIntegration_library_dynamic_noisy_y, label = "Исходный сигнал")
plot!(cCodeIntegration_library_dynamic_filtered_t, cCodeIntegration_library_dynamic_filtered_y, label = "Отфильтрованный сигнал")
plot!(legend = :bottomright)

title!("Альфа-бета фильтр <br> (Интеграция динамической библиотеки)")
xlabel!("Время, [с]")
ylabel!("Амплитуда")
Out[0]:

Интеграция кода, сгенерированного из модели Simulink

Постановка задачи

Сгенерируем C код из Simulink модели alphabetafilter.slx и интегрируем его в нашу модель Engee cCodeIntegration_cg_simulink.engee.

Модель alphabetafilter.slx, реализующая альфа-бета фильтр, собрана в Simulink из простых блоков и состоит из подсистем determineAlphaBeta и filterInputSignal.

Верхний уровень модели:

codegen_simulink_2.png

Подсистема determineAlphaBeta:

codegen_simulink_3.png

Подсистема filterInputSignal:

codegen_simulink_4.png

Сгенерируем код с использованием Simulink Embedded Coder:

In [ ]: 
cgPath = joinpath(demoroot,"cg/simulink")
cgModel = joinpath(demoroot,"cg/simulink/alphabetafilter")

mat"""
model = load_system($cgModel);
path = $cgPath;

set_param(0, 'CacheFolder', path)
set_param(0, 'CodeGenFolder', path)

slbuild(model)

set_param(0, 'CacheFolder', '')
set_param(0, 'CodeGenFolder', '')
"""

>> >> >> >> >> >> >> >> >> ### Starting build procedure for: alphabetafilter
### Generating code and artifacts to 'Model specific' folder structure
### Generating code into build folder: /user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw
### Invoking Target Language Compiler on alphabetafilter.rtw
### Using System Target File: /matlab/rtw/c/ert/ert.tlc
### Loading TLC function libraries
.......
### Generating TLC interface API for custom data
.
### Initial pass through model to cache user defined code
### Caching model source code
...................................
### Writing header file alphabetafilter_types.h
.
### Writing header file alphabetafilter.h
### Writing header file rtwtypes.h
### Writing source file alphabetafilter.c
### Writing header file alphabetafilter_private.h
### Writing source file alphabetafilter_data.c
.
### Writing source file ert_main.c
### TLC code generation complete (took 10.433s).
[Warning: P-code file /matlab/toolbox/coder/simulinkcoder_core/addStandardInfo.p
is older than source code file
/matlab/toolbox/coder/simulinkcoder_core/addStandardInfo.m.
/matlab/toolbox/coder/simulinkcoder_core/addStandardInfo.p may be obsolete and
may need to be regenerated.
Type "help pcode" for information about generating P-code.] 
### Saving binary information cache.
### Using toolchain: GNU gcc/g++ | gmake (64-bit Linux)
### Creating '/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw/alphabetafilter.mk' ...
### Building 'alphabetafilter': "/matlab/bin/glnxa64/gmake"  -f alphabetafilter.mk all
gcc -c -fwrapv -fPIC -O0 -msse2 -DCLASSIC_INTERFACE=0 -DALLOCATIONFCN=0 -DTERMFCN=1 -DONESTEPFCN=1 -DMAT_FILE=0 -DMULTI_INSTANCE_CODE=0 -DINTEGER_CODE=0 -DMT=0  -DTID01EQ=0 -DMODEL=alphabetafilter -DNUMST=1 -DNCSTATES=0 -DHAVESTDIO -DMODEL_HAS_DYNAMICALLY_LOADED_SFCNS=0 -I/user/demo_renew/ccodeintegration/cg/simulink -I/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw -I/matlab/extern/include -I/matlab/simulink/include -I/matlab/rtw/c/src -I/matlab/rtw/c/src/ext_mode/common -I/matlab/rtw/c/ert -o "alphabetafilter.o" "/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw/alphabetafilter.c"
gcc -c -fwrapv -fPIC -O0 -msse2 -DCLASSIC_INTERFACE=0 -DALLOCATIONFCN=0 -DTERMFCN=1 -DONESTEPFCN=1 -DMAT_FILE=0 -DMULTI_INSTANCE_CODE=0 -DINTEGER_CODE=0 -DMT=0  -DTID01EQ=0 -DMODEL=alphabetafilter -DNUMST=1 -DNCSTATES=0 -DHAVESTDIO -DMODEL_HAS_DYNAMICALLY_LOADED_SFCNS=0 -I/user/demo_renew/ccodeintegration/cg/simulink -I/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw -I/matlab/extern/include -I/matlab/simulink/include -I/matlab/rtw/c/src -I/matlab/rtw/c/src/ext_mode/common -I/matlab/rtw/c/ert -o "alphabetafilter_data.o" "/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw/alphabetafilter_data.c"
gcc -c -fwrapv -fPIC -O0 -msse2 -DCLASSIC_INTERFACE=0 -DALLOCATIONFCN=0 -DTERMFCN=1 -DONESTEPFCN=1 -DMAT_FILE=0 -DMULTI_INSTANCE_CODE=0 -DINTEGER_CODE=0 -DMT=0  -DTID01EQ=0 -DMODEL=alphabetafilter -DNUMST=1 -DNCSTATES=0 -DHAVESTDIO -DMODEL_HAS_DYNAMICALLY_LOADED_SFCNS=0 -I/user/demo_renew/ccodeintegration/cg/simulink -I/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw -I/matlab/extern/include -I/matlab/simulink/include -I/matlab/rtw/c/src -I/matlab/rtw/c/src/ext_mode/common -I/matlab/rtw/c/ert -o "ert_main.o" "/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter_ert_rtw/ert_main.c"
### Creating standalone executable ../alphabetafilter ...
g++  -o ../alphabetafilter alphabetafilter.o alphabetafilter_data.o ert_main.o  
### Created: ../alphabetafilter
### Successfully generated all binary outputs.
gmake: Nothing to be done for `all'.
### Successful completion of build procedure for: alphabetafilter
### Simulink cache artifacts for 'alphabetafilter' were created in '/user/demo_renew/ccodeintegration/cg/simulink/alphabetafilter.slxc'.

Build Summary

Top model targets built:

Model            Action                        Rebuild Reason                                    
=================================================================================================
alphabetafilter  Code generated and compiled.  Code generation information file does not exist.  

1 of 1 models built (0 models already up to date)
Build duration: 0h 0m 25.148s

Анализ модели

По своей структуре модель cCodeIntegration_cg_simulink.engee не отличается от рассмотренной ранее cCodeIntegration_source.engee; отличаются лишь директивы на вкладке Build options настроек блока Filter. Проанализируем её содержимое:

image.png

Здесь определены следующие опции построения:

  • Source files - подключены файлы исходного кода alphabetafilter.c и alphabetafilter_data.c;
  • Include directories - задан путь до папки, содержащей заголовочные файлы;
  • Headers - подключены заголовочные файлы alphabetafilter.h, alphabetafilter_types.h и rtwtypes.h.

Циклически исполняемый код приведён на вкладке Output code редактора исходного кода блока Filter:

image.png

На каждом шаге расчёта модели выполняется:

  • Инициализация структуры alphabetafilter_U переменными in, processNoiseVariance и measurementNoiseVariance (входные сигналы);

  • Вызов функции alphabetafilter_step();

  • Присваивание переменной out (выходной сигнал) результата x, сохранённого в структуре alphabetafilter_Y.

Во вкладке Start code редактора исходного кода блока Filter выполняется вызов функции alphabetafilter_initialize():

codegen_simulink_6.png

Во вкладке Terminate code редактора исходного кода блока Filter выполняется вызов функции alphabetafilter_terminate():

codegen_simulink_7.png

Запуск симуляции

Промоделируем систему:

In [ ]: 
cCodeIntegration_cg_simulink = engee.load("$demoroot/models/cCodeIntegration_cg_simulink.engee", force = true)
simulationResults_cg_simulink = engee.run(cCodeIntegration_cg_simulink)
Out[0]:
SimulationResult(
    "filtered" => WorkspaceArray{Float64}("cCodeIntegration_cg_simulink/filtered")
,
    "noisy" => WorkspaceArray{Float64}("cCodeIntegration_cg_simulink/noisy")

)

Закроем модель:

In [ ]: 
engee.close(cCodeIntegration_cg_simulink, force = true);

Результаты моделирования

Импортируем результаты моделирования:

In [ ]: 
cCodeIntegration_cg_simulink_noisy_t = simulationResults_cg_simulink["noisy"].time;
cCodeIntegration_cg_simulink_noisy_y = simulationResults_cg_simulink["noisy"].value;
In [ ]: 
cCodeIntegration_cg_simulink_filtered_t = simulationResults_cg_simulink["filtered"].time;
cCodeIntegration_cg_simulink_filtered_y = simulationResults_cg_simulink["filtered"].value;

Построим график:

In [ ]: 
plot(cCodeIntegration_cg_simulink_noisy_t, cCodeIntegration_cg_simulink_noisy_y, label = "Исходный сигнал")
plot!(cCodeIntegration_cg_simulink_filtered_t, cCodeIntegration_cg_simulink_filtered_y, label = "Отфильтрованный сигнал")
plot!(legend = :bottomright)

title!("Альфа-бета фильтр <br> (Интеграция кода, сгенерированного из модели Simulink)")
xlabel!("Время, [с]")
ylabel!("Амплитуда")
Out[0]:

Интеграция кода, сгенерированного из модели Engee

Постановка задачи

Сгенерируем C код из модели Engee alphabetafilter.engee, собранной из простых блоков и реализующей альфа-бета фильтр, и интегрируем его в нашу модель Engee cCodeIntegration_cg_engee.engee.

Верхний уровень модели:

codegen_engee_2.PNG

Подсистема determineAlphaBeta:

codegen_engee_3.PNG

Подсистема filterInputSignal:

codegen_engee_4.PNG

Сгенерируем код с использованием генератора кода Engee:

In [ ]: 
engee.generate_code("$demoroot/cg/engee/alphabetafilter.engee", "$demoroot/cg/engee/alphabetafilter_cg")

Анализ модели

По своей структуре модель cCodeIntegration_cg_engee.engee не отличается от рассмотренной ранее cCodeIntegration_source.engee; отличаются лишь директивы на вкладке Build options настроек блока Filter. Проанализируем её содержимое:

image.png

Здесь определены следующие опции построения:

  • Source files - подключен файл исходного кода alphabetafilter.c;
  • Include directories - задан путь до папки, содержащей заголовочные файлы;
  • Headers - подключен заголовочный файл alphabetafilter.h.

Циклически исполняемый код приведён на вкладке Output code редактора исходного кода блока Filter:

image.png

На каждом шаге расчёта модели выполняется:

  • Инициализация структуры alphabetafilter_U переменными in, processNoiseVariance и measurementNoiseVariance (входные сигналы);

  • Вызов функции alphabetafilter_step();

  • Присваивание переменной out (выходной сигнал) результата x, сохранённого в структуре alphabetafilter_Y.

Во вкладке Start code редактора исходного кода блока Filter выполняется вызов функции alphabetafilter_init():

codegen_engee_6.PNG

Во вкладке Terminate code редактора исходного кода блока Filter выполняется вызов функции alphabetafilter_term():

codegen_engee_7.PNG

Запуск симуляции

Промоделируем систему:

In [ ]: 
cCodeIntegration_cg_engee = engee.load("$demoroot/models/cCodeIntegration_cg_engee.engee", force = true)
simulationResults_cg_engee = engee.run(cCodeIntegration_cg_engee)
Out[0]:
SimulationResult(
    "filtered" => WorkspaceArray{Float64}("cCodeIntegration_cg_engee/filtered")
,
    "noisy" => WorkspaceArray{Float64}("cCodeIntegration_cg_engee/noisy")

)

Закроем модель:

In [ ]: 
engee.close(cCodeIntegration_cg_engee, force = true);

Результаты моделирования

Импортируем результаты моделирования:

In [ ]: 
cCodeIntegration_cg_engee_noisy_t = simulationResults_cg_engee["noisy"].time;
cCodeIntegration_cg_engee_noisy_y = simulationResults_cg_engee["noisy"].value;
In [ ]: 
cCodeIntegration_cg_engee_filtered_t = simulationResults_cg_engee["filtered"].time;
cCodeIntegration_cg_engee_filtered_y = simulationResults_cg_engee["filtered"].value;

Построим график:

In [ ]: 
plot(cCodeIntegration_cg_engee_noisy_t, cCodeIntegration_cg_engee_noisy_y, label = "Исходный сигнал")
plot!(cCodeIntegration_cg_engee_filtered_t, cCodeIntegration_cg_engee_filtered_y, label = "Отфильтрованный сигнал")
plot!(legend = :bottomright)

title!("Альфа-бета фильтр <br> (Интеграция кода, сгенерированного из модели Engee)")
xlabel!("Время, [с]")
ylabel!("Амплитуда")
Out[0]:

Выводы

Данный пример демонстрирует особенности использования блока C Function и различные способы интеграции C кода в модели Engee:

  1. Интеграцию внешнего исходного кода;
  2. Интеграцию статических и динамических библиотек;
  3. Интеграцию кода, сгенерированного из модели Simulink;
  4. Интеграцию кода, сгенерированного из модели Engee.

Блоки, использованные в примере