Один шаблон.
Десять датчиков.

1. Создайте проект

Откройте MetaPlatform. В окне «Рабочая область» введите имя QuickStart и нажмите «Создать».

Нажмите «…» справа от строки «Проект» и выберите MetaCore.

MetaCore — софт-ПЛК для тестирования и отладки на компьютере. Он выполняет сгенерированный ST-код до его переноса в TIA Portal или CODESYS. Для этого примера не нужны физический ПЛК, настройка оборудования или виртуальный контроллер сторонней среды.

В дальнейшем выберете другую платформу в том же меню и повторите генерацию: MetaPlatform подготовит программу для выбранной среды. Алгоритм нашего примера останется тем же; подключение реальных каналов выполняется отдельно.

2. Объявите логический вход датчика

В меню «…» рядом с MetaGen выберите «Добавить Global Variable List». Назовите документ MyGlobals. При генерации будет создана глобальная таблица с этим именем.

Чтобы задать имя, откройте меню «…» у созданного документа → «Переименовать». Этим же способом далее назовём функциональный блок и компонент.

В редактор вставьте только следующую строку. Обрамление VAR_GLOBAL … END_VAR MetaPlatform добавляет сама.

Sensor1_fInput : REAL := 10.0; // Датчик 1. Входное значение

Sensor1_fInput — логическая переменная аналогового входа. С ней будет работать программа. Слово «логическая» здесь означает назначение переменной в программе, а не тип BOOL: наше значение имеет тип REAL.

Пока задаём начальное значение 10.0. Для первого запуска этого достаточно.

Как этот вход будет связан с оборудованием

В проекте CODESYS или TIA Portal вы объявляете сырые теги каналов, связанные с физическими адресами ПЛК. Маппинг переносит значения между этими тегами и логическими переменными программы. При необходимости он также преобразует тип или масштаб значения.

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

Маппинг входов выполняют перед обработкой сигналов, а маппинг выходов — после расчёта команд. Если поменяется модуль или адрес канала, вы измените привязку, а код обработки продолжит работать с прежним логическим именем.

3. Напишите функциональный блок

В меню MetaGen выберите «Добавить функциональный блок». Назовите его CSensorLinear. Вставьте тело блока:

VAR_INPUT
    in_fValue : REAL;
    in_fK : REAL;
    in_fB : REAL;
END_VAR

VAR_OUTPUT
    out_fValue : REAL;
END_VAR

out_fValue := in_fK * in_fValue + in_fB;

Блок рассчитывает k × x + b. Например, при входе 10, коэффициенте 2 и смещении 5 результат равен 25.

Такой блок можно написать и в целевой среде разработки. Здесь мы включили его в проект MetaPlatform, поэтому его код попадёт в результат генерации вместе с остальной программой.

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

4. Соберите проектный компонент Sensors

В меню MetaGen выберите «Добавить компонент» и назовите его Sensors.

Проектный компонент MetaGen объединяет вызовы блоков, настройки и данные для отображения. Сейчас он обработает один датчик. Позже тот же компонент будет создавать обработку десяти датчиков по таблице параметров.

Нажатие на заголовок области разворачивает её; повторное нажатие возвращает прежнюю раскладку. Это удобно при заполнении таблиц.

Экземпляры / Instances

Заполните одну строку:

CSensorLinear — тип блока, а Sensor1_Inst — его экземпляр для конкретного датчика. При генерации экземпляр будет объявлен в глобальной таблице Inst. У каждого следующего датчика появится свой экземпляр с собственными значениями.

Sensor1_Inst	CSensorLinear	Датчик 1

Данные / Data

Добавьте две настройки и один результат для отображения:

Остальные столбцы оставьте пустыми. 1 в столбце публикации включает передачу тега в таблицы для внешнего доступа и HMI.

REAL	conf		Sensor1_fK	2.0	Датчик 1. Коэффициент	1
REAL	conf		Sensor1_fB	5.0	Датчик 1. Смещение	1
REAL	val	Sensor1_Inst	out_fValue		Датчик 1. Результат	1

conf создаёт настройку в Conf. Это данные, которые в рабочем проекте задаёт оператор или наладчик. Здесь будут Conf.Sensor1_fK и Conf.Sensor1_fB с начальными значениями 2.0 и 5.0.

val описывает уже существующий параметр блока: область Sensor1_Inst, параметр out_fValue. При публикации генератор создаст его копию в View.Sensor1_Inst_out_fValue. Это значение затем можно показывать на панели оператора.

Сам вход Sensor1_fInput здесь повторно описывать не нужно: он уже объявлен в MyGlobals и доступен программе.

Шаблон ST / ST Template

Вставьте вызов блока:

Sensor1_Inst(
    in_fValue := Sensor1_fInput,
    in_fK := Conf.Sensor1_fK,
    in_fB := Conf.Sensor1_fB
);

На вход блока поступает глобальная переменная, а коэффициент и смещение читаются из Conf. Результат остаётся в Sensor1_Inst.out_fValue.

Параметры / Params, Экспорт MetaLab и Экспорт MetaView пока оставьте пустыми. Для выполнения этого примера сценарии и экраны не нужны.

5. Сгенерируйте и запустите

1. В меню «Проект» выполните «Сохранить проект».
2. Убедитесь, что выбрана MetaCore, затем нажмите «Сгенерировать». Дождитесь окончания генерации; сообщения доступны внизу в области «Логи».
3. Через «Проект» → «Скачать» сохраните результаты генерации.

4. Откройте MetaPlatform Runtime. Нажмите «+ Импорт файлов» и выберите скачанный MetaPlatformArtifacts.zip. RT извлечёт из него артефакты модулей.
5. В разделе MetaCore выберите артефакт MetaGen, нажмите «Загрузить», затем «Запустить». Дополнительные библиотеки для нашего примера не требуются.

Можно импортировать и отдельно MetaGenArtifact.zip. Архив исходного проекта, который вы получаете командой «Экспортировать проект», предназначен для открытия в MetaPlatform; для запуска в RT нужен именно результат генерации.

Посмотрите результат

Откройте MetaCore → Онлайн и выберите Inst.Sensor1_Inst. Возле формулы видны вход 10.0, коэффициент 2.0, смещение 5.0 и результат 25.0.

Выберите Inst.Sensors_Inst: это экземпляр созданного проектного компонента Sensors. Здесь виден вызов датчика и фактические значения переданных параметров.

В том же списке выберите MetaGen → Conf, чтобы увидеть настройки, затем через «Назад» откройте View, чтобы увидеть опубликованный результат.

Менять значения во время этого упражнения не требуется. Мы задали их в проекте и проверяем полученный результат.

Что появилось в сгенерированной программе

MetaGen сформировал объявления автоматически. В пакете MetaGenArtifact.zip → MetaCore/MetaCore.zip найдите GVL/Inst.st:

VAR_GLOBAL
    Sensor1_Inst : CSensorLinear;
    Sensors_Inst : Sensors;
    // Далее — служебные экземпляры генератора
END_VAR

В Types/_Conf.st описаны настройки, а в Types/_View.st — опубликованные значения. Сами структуры Conf и View объявлены в GVL/MetaGen.st:

VAR_GLOBAL
    Conf : _Conf;
    View : _View;
END_VAR

После выполнения алгоритма сгенерированная функция makeView обновляет результат для отображения:

FUNCTION makeView : BOOL
View.Sensor1_Inst_out_fValue := Sensor1_Inst.out_fValue;
END_FUNCTION

Этот вызов уже включён в основную программу. Дописывать перенос в View вручную не нужно.

6. Превратите один датчик в десять

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

Добавьте входы

В MyGlobals замените прежнюю строку этим списком:

Sensor1_fInput : REAL := 10.0; // Датчик 1. Входное значение
Sensor2_fInput : REAL := 20.0; // Датчик 2. Входное значение
Sensor3_fInput : REAL := 30.0; // Датчик 3. Входное значение
Sensor4_fInput : REAL := 40.0; // Датчик 4. Входное значение
Sensor5_fInput : REAL := 50.0; // Датчик 5. Входное значение
Sensor6_fInput : REAL := 60.0; // Датчик 6. Входное значение
Sensor7_fInput : REAL := 70.0; // Датчик 7. Входное значение
Sensor8_fInput : REAL := 80.0; // Датчик 8. Входное значение
Sensor9_fInput : REAL := 90.0; // Датчик 9. Входное значение
Sensor10_fInput : REAL := 100.0; // Датчик 10. Входное значение

У каждого датчика своё начальное значение: 10, 20, …, 100. Так мы сразу увидим, что экземпляры работают независимо.

Заполните Параметры / Params

Откройте Sensors. В области параметров создайте два столбца: SensorId и Comment. Вставьте блок начиная с A1, вместе с первой строкой заголовков:

SensorId	Comment
Sensor1	Датчик 1
Sensor2	Датчик 2
Sensor3	Датчик 3
Sensor4	Датчик 4
Sensor5	Датчик 5
Sensor6	Датчик 6
Sensor7	Датчик 7
Sensor8	Датчик 8
Sensor9	Датчик 9
Sensor10	Датчик 10

Замените конкретное имя подстановкой

|SensorId| — шаблонная подстановка: имя столбца между двумя вертикальными чертами |. Для каждой строки генератор подставляет вместо неё значение из таблицы параметров. Аналогично работает |Comment|.

В таблице Экземпляры замените прежнюю строку:

|SensorId|_Inst	CSensorLinear	|Comment|

В таблице Данные замените прежние три строки следующими. Не добавляйте их под старыми: это новое содержимое тех же строк.

REAL	conf		|SensorId|_fK	2.0	|Comment|. Коэффициент	1
REAL	conf		|SensorId|_fB	5.0	|Comment|. Смещение	1
REAL	val	|SensorId|_Inst	out_fValue		|Comment|. Результат	1

В области Шаблон ST замените вызов:

|SensorId|_Inst(
    in_fValue := |SensorId|_fInput,
    in_fK := Conf.|SensorId|_fK,
    in_fB := Conf.|SensorId|_fB
);

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

7. Посмотрите десять работающих датчиков

Сохраните проект и снова выполните генерацию. Импортируйте новый результат в RT. Остановите первый запуск, выберите новый артефакт, нажмите «Загрузить» → «Запустить».

В MetaCore → Онлайн откройте Inst.Sensors_Inst. Вместо одного вызова вы увидите десять. Код создан по тому самому короткому шаблону.

FUNCTION_BLOCK Sensors
Sensor1_Inst(
    in_fValue := Sensor1_fInput,
    in_fK := Conf.Sensor1_fK,
    in_fB := Conf.Sensor1_fB
);

Sensor2_Inst(
    in_fValue := Sensor2_fInput,
    in_fK := Conf.Sensor2_fK,
    in_fB := Conf.Sensor2_fB
);

Sensor3_Inst(
    in_fValue := Sensor3_fInput,
    in_fK := Conf.Sensor3_fK,
    in_fB := Conf.Sensor3_fB
);

Sensor4_Inst(
    in_fValue := Sensor4_fInput,
    in_fK := Conf.Sensor4_fK,
    in_fB := Conf.Sensor4_fB
);

Sensor5_Inst(
    in_fValue := Sensor5_fInput,
    in_fK := Conf.Sensor5_fK,
    in_fB := Conf.Sensor5_fB
);

Sensor6_Inst(
    in_fValue := Sensor6_fInput,
    in_fK := Conf.Sensor6_fK,
    in_fB := Conf.Sensor6_fB
);

Sensor7_Inst(
    in_fValue := Sensor7_fInput,
    in_fK := Conf.Sensor7_fK,
    in_fB := Conf.Sensor7_fB
);

Sensor8_Inst(
    in_fValue := Sensor8_fInput,
    in_fK := Conf.Sensor8_fK,
    in_fB := Conf.Sensor8_fB
);

Sensor9_Inst(
    in_fValue := Sensor9_fInput,
    in_fK := Conf.Sensor9_fK,
    in_fB := Conf.Sensor9_fB
);

Sensor10_Inst(
    in_fValue := Sensor10_fInput,
    in_fK := Conf.Sensor10_fK,
    in_fB := Conf.Sensor10_fB
);
END_FUNCTION_BLOCK

Откройте MetaGen → View и сравните результаты. У всех датчиков k = 2 и b = 5, а входы различаются:

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

Что дальше с этими данными

По отмеченным строкам Data MetaPlatform автоматически формирует теги для HMI: настройки находятся в Conf, результаты — в View. Эти имена можно использовать при подключении панели или SCADA. Передача живых значений начинается после настройки связи с запущенным ПЛК.

Основная цепочка уже работает: один шаблон → десять датчиков → генерация → исполнение в MetaCore. Дальше посмотрим на перенос программы в CODESYS и добавим визуализацию результатов.

8. Перенесите программу в CODESYS 3.5

Теперь покажем ту же программу в среде разработки ПЛК. В меню проекта MetaPlatform выберите CoDeSys 3.5, повторите генерацию и скачайте результат. Менять компонент Sensors, таблицу параметров или функциональный блок не нужно.

1. Распакуйте результат генерации. Внутри артефактов MetaGen откройте папку CoDeSys35: в ней находится файл MetaGen.export.
2. Откройте проект в CODESYS 3.5 и выделите Application в дереве устройств.
3. Выберите Проект → Импорт…, укажите MetaGen.export и импортируйте объекты.

В программе PLC_PRG, которая вызывается циклической задачей, добавьте вызов основной программы MetaGen:

_MetaGen_Main_Inst();

Выполните компиляцию. В дереве Application → MetaGen появились наши блоки, глобальные таблицы, типы данных и служебные функции. Откройте Sensors: здесь те же десять вызовов, которые мы рассматривали в MetaCore.

Мы продемонстрировали перенос программы в среду разработки CODESYS 3.5. Аналогично проект переносится в Siemens TIA Portal и CODESYS 2.3: выбираете целевую платформу, генерируете и импортируете подготовленные для неё файлы. Код и весь функционал созданного проекта поддерживаются этими платформами; вручную переписывать алгоритм под каждую среду не требуется.

Дальше продолжим работу в MetaPlatform и MetaCore. К особенностям импорта, настройке оборудования и загрузке в контроллер вернёмся в отдельных главах — повторять перенос для каждого следующего примера не будем.

9. Покажите значения на экране

Десять датчиков уже работают. Теперь покажем их результаты в MetaView — визуализации внутри MetaPlatform Runtime. Создадим одну простую карточку, а генератор подготовит по ней карточки всех датчиков из Params.

Продолжайте проект с десятью датчиками. Если в предыдущем разделе выбрали CODESYS, верните в меню проекта платформу MetaCore. Для этого упражнения нужны версии MetaPlatform и Runtime с поддержкой HTML-экранов MetaView.

Создайте карточку

В меню «…» рядом с MetaView выберите «Добавить экран» и назовите его SensorCard.

Замените содержимое редактора следующим блоком:

<div style="width:280px;padding:20px">
  <h3>{comment}</h3>
  <p>Результат обработки</p>
  <p style="font-size:36px;font-weight:600" mv:text="{valueTag}">—</p>
</div>

Это вся карточка: название датчика, подпись и крупное число. Для упражнения достаточно скопировать её целиком. Размер и отступы задаются в style; оформление можно будет изменить позже.

В шаблоне MetaGen мы использовали |SensorId|. В карточке MetaView подстановки записываются в фигурных скобках: {comment} и {valueTag}. MetaPlatform находит их в тексте автоматически. Свяжем эти два шаблона таблицей экспорта.

Свяжите карточку с датчиками

Откройте проектный компонент Sensors. В области «Экспорт MetaView» заполните три строки:

SensorCard.id	|SensorId|	Идентификатор карточки
SensorCard.comment	|Comment|	Название датчика
SensorCard.valueTag	View.|SensorId|_Inst_out_fValue	Результат обработки

SensorCard перед точкой — имя нашего базового экрана. id задаёт уникальное имя создаваемой карточки, comment — её название, а valueTag — тег результата. id нужен для идентификации карточки и передаётся через экспорт, даже если не используется в её тексте.

Для первой строки Params получится карточка Sensor1 с названием «Датчик 1» и тегом View.Sensor1_Inst_out_fValue. Для второй — Sensor2 и её собственный тег. Так будут обработаны все десять строк.

Таблицу Data менять не нужно: результат out_fValue уже отмечен для публикации и попадает во View. Алгоритм по-прежнему вычисляет значение в CSensorLinear; карточка только показывает его.

Сгенерируйте и откройте в Runtime

1. Сохраните проект и выполните полную генерацию через меню «Проект» → «Сгенерировать». В MetaView появится коллекция MetaGen Screens с созданными карточками.
2. Скачайте новый MetaPlatformArtifacts.zip и импортируйте его в Runtime. Теперь архив содержит и программу MetaGen, и экраны MetaView.
3. В разделе MetaCore остановите прежний запуск, если он работает. Выберите новый артефакт MetaGen, нажмите «Загрузить» → «Запустить».
4. Перейдите в MetaView, выберите артефакт MetaView из этого же импорта и нажмите «Загрузить».
5. Нажмите «Из MetaCore» → «Подключить». В списке экранов выберите «Датчик 1».

На карточке появится 25 — результат 2 × 10 + 5. Выберите другой датчик: значения будут такими же, как в онлайн-просмотре View.

До подключения вместо значения показывается тире. В этом примере адреса тегов формируются при генерации для MetaCore — вводить их вручную не нужно. Кнопка «Из MetaCore» подставляет адрес запущенного контроллера.

Мы описали одну карточку и три строки экспорта — получили десять экранов с правильными названиями и привязками. Для нового датчика генератор создаст карточку по той же строке Params, по которой создаёт его экземпляр и настройки.

Соберите датчики на одном экране

Отдельные карточки уже работают. Чтобы видеть их рядом, в меню MetaView выберите «Добавить сцену» и назовите её Overview. Замените содержимое редактора следующим блоком:

<div>
  <mv:screen id="AllSensors" comment="Все датчики" style="width:920px">
    <h2>Десять датчиков</h2>
    <div style="display:flex;flex-wrap:wrap;gap:12px">
      <mv:screen ref="Sensor1"></mv:screen>
      <mv:screen ref="Sensor2"></mv:screen>
      <mv:screen ref="Sensor3"></mv:screen>
      <mv:screen ref="Sensor4"></mv:screen>
      <mv:screen ref="Sensor5"></mv:screen>
      <mv:screen ref="Sensor6"></mv:screen>
      <mv:screen ref="Sensor7"></mv:screen>
      <mv:screen ref="Sensor8"></mv:screen>
      <mv:screen ref="Sensor9"></mv:screen>
      <mv:screen ref="Sensor10"></mv:screen>
    </div>
  </mv:screen>
</div>

ref="Sensor1" вставляет уже созданную карточку с этим id. Здесь мы перечисляем расположенные на общем экране датчики; повторять их оформление и привязки не нужно. Строка с display:flex располагает карточки рядом и переносит их на следующую строку.

Сохраните проект, повторите полную генерацию и импортируйте новый архив в RT. В разделе MetaView загрузите новый артефакт, подключитесь и выберите «Все датчики». Код ПЛК на этом шаге не изменился, поэтому работающий MetaCore перезапускать не требуется.

Если экран не помещается, используйте прокрутку или кнопку «В отдельном окне ↗»: визуализацию можно развернуть отдельно от рабочего окна RT.

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

10. Подайте синус и измените настройку

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

MetaLab выполняет сценарии виртуальной наладки: вместо физического датчика задаёт входное значение программе. MetaCore обрабатывает его нашим блоком, а MetaView показывает результат и позволяет менять настройки.

Продолжайте проект из главы 9. Все десять датчиков остаются в проекте; синус подключим только к Sensor1. Остальные показания останутся постоянными.

Откройте вход для сценария

В Sensors → Данные / Data добавьте четвёртую строку. Первые три строки сохраните:

REAL	global		|SensorId|_fInput		|Comment|. Входное значение	1

global здесь ссылается на уже объявленную переменную из MyGlobals. Второго объявления не будет. Publish = 1 делает её доступной для MetaLab. Подстановка |SensorId| подготовит входы всех десяти датчиков, но сценарий будет записывать только Sensor1_fInput.

При генерации Sensor1_fInput появится в MetaLab → OPC UA Tags с адресом для MetaCore. Сценарий пишет именно во вход программы; опубликованный результат View.Sensor1_Inst_out_fValue по-прежнему вычисляет функциональный блок.

Создайте один сценарий

В меню MetaLab добавьте пользовательский сценарий и назовите его SensorSine. Вставьте следующий блок в A1 таблицы, без заголовков:

factory	create	SimSensor1	sensor	
SimSensor1	set_tag	Sensor1_fInput		
SimSensor1	set_min		0	
SimSensor1	set_max		20	
SimSensor1	set_period		20	
SimSensor1	sin			
h	confirm			Синус работает. Откройте MetaView и измените коэффициент датчика. Нажмите «Продолжить» только после проверки.

Первые строки создают имитатор SimSensor1, связывают его с Sensor1_fInput и задают синус от 0 до 20 с периодом 20 с. Метод sin запускает изменение сигнала.

h.confirm оставляет сценарий на ожидании оператора. Пока это ожидание открыто, синус продолжает работать — можно перейти в MetaView и спокойно проверить показания. После «Продолжить» сценарий завершится и перестанет обновлять вход.

Оставьте комментарии обычных строк пустыми: непустой комментарий запрашивает дополнительное подтверждение. Сообщение в этом примере нужно только у h.confirm.

Таблицу Экспорт MetaLab в Sensors оставьте пустой. Здесь один пользовательский сценарий с конкретным именем тега, поэтому автоматическое создание сценариев пока не требуется.

Добавьте настройку на карточку

В SensorCard замените HTML следующим блоком. К знакомому показанию добавилось одно поле — коэффициент k:

<div style="width:280px;padding:20px">
  <h3>{comment}</h3>
  <p>Результат обработки</p>
  <p style="font-size:36px;font-weight:600" mv:text="{valueTag}">—</p>
  <label>Коэффициент k
    <input type="number" step="any" mv:value="{kTag}" mv:editable="true">
  </label>
  <p>Введите значение и нажмите Enter.</p>
</div>

mv:value связывает поле с настройкой, а mv:editable="true" разрешает её изменять. Новое значение отправляется только по Enter. Если передумали, нажмите Escape; уход из поля без Enter также отменяет ввод.

В Sensors → Экспорт MetaView добавьте четвёртую строку:

SensorCard.kTag	Conf.|SensorId|_fK	Коэффициент

Для первого датчика {kTag} станет Conf.Sensor1_fK, для второго — Conf.Sensor2_fK, и так далее. Одно поле в шаблоне добавит индивидуальную настройку на все десять карточек. Сам коэффициент уже объявлен и опубликован в Data — второй раз создавать его не нужно. Смещение b оставляем равным 5.

Сгенерируйте и запустите

1. Сохраните проект, выполните полную генерацию для MetaCore и скачайте MetaPlatformArtifacts.zip.
2. В Runtime импортируйте новый архив через «+ Импорт файлов».
3. В разделе MetaCore остановите предыдущую программу, выберите новый артефакт MetaGen, нажмите «Загрузить» → «Запустить». На этом шаге программу нужно загрузить заново: мы добавили публикацию входов.
4. В разделе MetaView выберите новый артефакт MetaView, нажмите «Загрузить», затем «Из MetaCore» → «Подключить». Откройте «Датчик 1».
5. Перейдите в MetaLab, выберите артефакт MetaLab из того же импорта и нажмите «Загрузить». Нажмите «Из MetaCore», выберите SensorSine и нажмите «Запустить». Режим «Автоматически» оставьте выключенным.

В списке также могут быть MetaGen Init Objects и MetaGen Scenario. В этом примере они пустые; достаточно запустить только SensorSine.

Дождитесь сообщения «Синус работает». Пока не нажимайте «Продолжить»: перейдите в MetaView. Ожидание подтверждения не останавливает имитатор.

Посмотрите, как меняется результат

На карточке «Датчик 1» показание плавно увеличивается и уменьшается. При k = 2 и b = 5 вход 0…20 превращается в результат 5…45. Полный цикл занимает около 20 с.

В поле «Коэффициент k» замените 2 на 1 и нажмите Enter. Теперь показание меняется в пределах 5…25. Синус на входе остался прежним — изменился результат обработки в ПЛК.

Мы изменили настройку работающей программы без повторной генерации и загрузки. На экране «Все датчики» меняется только первый датчик; остальные продолжают показывать 45, 65, …, 205. Их коэффициенты также остались равны 2.

Для завершения вернитесь в MetaLab и нажмите «Продолжить». Сценарий перестанет менять вход: в программе останется последнее переданное значение, а показание станет постоянным. MetaCore и MetaView продолжают работать. Чтобы снова запустить синус, выберите SensorSine и нажмите «Запустить».

Изменение через карточку записывает настройку в работающий MetaCore. Начальное значение 2.0 в проекте MetaPlatform само по себе не меняется. Чтобы сделать другое значение исходным для последующей генерации, измените его в Data.

11. Куда двигаться дальше

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

Перенесите программу на нужную платформу

Этот проект можно генерировать для Siemens TIA Portal, CODESYS 2.3 и CODESYS 3.5. Выберите платформу в меню проекта и повторите генерацию. MetaPlatform подготовит код для выбранной среды; переписывать формулу обработки и вручную создавать десять экземпляров не потребуется.

В главе 8 мы уже импортировали результат в CODESYS 3.5. Дальше вы можете собрать программу в соответствующей среде разработки и загрузить её в поддерживаемый контроллер или виртуальный ПЛК этой платформы. Для работы с оборудованием останется связать логические входы и выходы с реальными каналами через маппинг.

Выберите удобный способ проверки

MetaCore, MetaLab и визуализацию можно использовать в разных сочетаниях:

Так можно сначала проверить алгоритм в MetaCore, затем подключить к нему свою панель — например, Weintek с OPC UA — и проверить экраны ещё до готовности шкафа. Следующим шагом ту же программу можно проверить в виртуальном ПЛК выбранной платформы и подготовить к загрузке в оборудование.

Для связи MetaLab и MetaView с внешним ПЛК нужен доступный OPC UA сервер. Его наличие и настройка зависят от выбранного контроллера или симулятора. Для CODESYS 2.3 поддерживается генерация программы; подготовка сценариев MetaLab для этой платформы сейчас не поддерживается. Поэтому описанные варианты подключения через OPC UA относятся к MetaCore и подходящим средам Siemens и CODESYS 3.5.

Что рассмотрим в следующих руководствах

Быстрый старт показал весь путь на небольшом примере. Дальше разберём задачи, из которых складывается рабочий проект автоматизации:

• Перенос в TIA Portal и CODESYS. Импорт программы, её вызов, подключение библиотек, маппинг входов и выходов, запуск в виртуальном и реальном ПЛК.
• Обмен тегами с целевой платформой. Экспорт OPC UA адресов из TIA Portal и CODESYS 3.5, импорт в MetaPlatform и привязка к данным проекта. Для MetaCore адреса уже формируются при генерации; отдельно рассмотрим их экспорт для внешней визуализации.
• Подготовка HMI. Автоматическая генерация таблиц тегов, сообщений об авариях и трендов для поддерживаемых систем визуализации. Имена и назначение данных задаём в MetaPlatform, адреса берём из целевой платформы — затем импортируем подготовленные файлы в проект HMI.
• Стандартные компоненты MetaKit. Возьмём готовую обработку датчиков и узлы управления механизмами, такими как насосы, вентиляторы и клапаны. Разберём основные параметры, режимы, блокировки и настройки, чтобы собирать проект из готовых компонентов.
• Контуры управления. Свяжем датчик, регулятор и исполнительный механизм; зададим уставку и посмотрим, как контур реагирует на изменение измеряемой величины.
• Сценарии MetaLab и экраны MetaView. Перейдём от одного синуса к имитации работы механизмов, проверке команд и аварийных ситуаций. Научимся автоматически создавать сценарии и карточки по тем же строкам параметров, по которым генерируется программа.
• Собственные компоненты. Подробнее изучим режимы Data, подстановки, общие и индивидуальные настройки, чтобы переносить свои проверенные решения в повторно используемые шаблоны.

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

Готовые проекты

Если хотите сверить свой результат, импортируйте нужный архив в рабочей области MetaPlatform. Это четыре самостоятельных состояния примера; при последовательном прохождении руководства достаточно развивать один проект.

Примеры используют формат MetaGen v2; проекты с визуализацией также содержат HTML-экраны MetaView v3. В четвёртом примере добавлен пользовательский сценарий MetaLab; таблица экспорта MetaLab остаётся пустой. Скриншоты показывают русскоязычный интерфейс; рядом с названиями таблиц приведены английские обозначения.