ГОСТ Р МЭК 61131-3-2016. Национальный стандарт Российской Федерации. Контроллеры программируемые. Часть 3. Языки программирования

6.6 Программные компоненты (POU)

6.6.1 Общие свойства программных компонентов

6.6.1.1 Общие положения

Программными компонентами (POU), установленными в настоящем стандарте, являются функция, функциональный блок, класс и программа. Функциональные блоки и классы могут содержать методы.

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

Примечание - Упомянутый выше параметрический интерфейс не совпадает с интерфейсом, определенным в рамках объектно-ориентированного подхода.

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

Ранее объявленный программный компонент может использоваться в объявлении других программных компонентов, как показано на рисунке 3.

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

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

6.6.1.2 Присваивание и выражение

6.6.1.2.1 Общие положения

Языковые конструкции присваивания и выражения используются в текстовых и (частично) графических языках.

6.6.1.2.2 Присваивание

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

Переменные одного типа всегда могут присваиваться. Дополнительно применяются следующие правила:

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

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

- переменная производного типа может использоваться везде, где может использоваться переменная ее базового типа.

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

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

a) в текстовой форме (частично применимой и к графическим языкам) оператор присваивания может быть следующим:

":= " который означает, что значение выражения в правой стороне оператора записывается в переменную в левой стороне оператора; или

" => " который означает, что значение в левой стороне оператора записывается в переменную в правой стороне оператора.

Оператор "=>" используется только для списка параметров вызова функций, методов, функциональных блоков и т.п. и только для передачи параметра VAR_OUTPUT назад вызывающему объекту.

Пример -

A:= B + C/2;

Func (in1:= A, out2 => x); A_struct1:= B_Struct1;

Примечание - Присваивание определенных пользователем типов данных (STUCTURE, ARRAY) рассматривается в таблице 72;

b) в графической форме:

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

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

6.6.1.2.3 Выражение

Выражение - это языковая конструкция, которая состоит из определенной конфигурации операндов (таких как литералы, переменные, вызовы функций) и операторов, (таких как +, -, *, /) и которая производит одно значение, которое может быть многозначным.

Для адаптации типов данных операции в выражении может использоваться неявное или явное преобразование типа:

a) в текстовой форме (а также частично в графических языках), выражение вычисляется в определенном порядке, зависящем от приоритетов, заложенных в языке.

Пример - ... B + C/2 * SIN(x) ...;

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

6.6.1.2.4 Константное выражение

Константное выражение - это языковая конструкция, состоящая из определенной комбинации операндов (таких как +, -, *) и производит одно значение, которое может быть многозначным.

6.6.1.3 Частичный доступ к переменным типа ANY_BIT

Для переменных типа данных ANY_BIT (BYTE, WORD, DWORD, LWORD), частичный доступ к биту, байту, слову и двойному слову переменной определен в таблице 17.

Таблица 17

Частичный доступ к переменным типа ANY_BIT

Номер	Описание	Тип данных	Пример и синтаксис (примечание 2)
	Тип данных - доступ к		myVAR_12.%X1; yourVAR1.%W3;
1a	BYTE - бит VB2.%X0	BOOL	от <имя_переменной>.%X0 до <имя_переменной>.%X7
1b	WORD - бит VW3.%X15	BOOL	от <имя_переменной>.%X0 до <имя_переменной>.%X15
1c	DWORD - бит	BOOL	от <имя переменной>.%X0 до <имя_переменной>.%X31
1d	LWORD - бит	BOOL	от <имя_переменной>.%X0 до <имя_переменной>.%X63
2a	WORD - байт VW4.%B0	BYTE	от <имя_переменной>.%B0 до <имя_переменной>.%B1
2b	DWORD - байт	BYTE	от <имя_переменной>.%B0 до <имя_переменной>.%B3
2c	LWORD - байт	BYTE	от <имя_переменной>.%B0 до <имя_переменной>.%B7
3a	DWORD - слово	WORD	от <имя_переменной>.%W0 до <имя_переменной>.%W1
3b	LWORD - слово	WORD	от <имя_переменной>.%W0 до <имя_переменной>.%W3
4	LWORD - двойное слово VL5.%D1	DWORD	от <имя_переменной>.%D0 до <имя_переменной>.%D1
Префикс доступа к биту %X может быть опущен в соответствии с таблицей 16, например, By1.%X7 эквивалентно By1.7. Частичный доступ не должен использоваться с прямо представленными переменными, например, %IB10.

Для адресации части переменной используются символ "%" и префикс размера, определенный как и для прямо представленных переменных в таблице 16 (X, B, W, D, L) используются в сочетании с целым литералом (со значением от 0 до max) для адреса внутри переменной. Литерал 0 указывает на самую младшую часть, max - на самую старшую часть. Префикс "%X" может факультативно использоваться при доступе к битам.

Пример - Частичный доступ к переменным ANY_BIT

VAR

Bo: BOOL;

By: BYTE;

Wo: WORD;

Do: DWORD;

Lo: LWORD;

END_VAR;

Bo:= By.%X0; // бит 0 переменной By

Bo:= By.7; // бит 7 переменной By; %X используется по умолчанию и может быть опущен.

Bo:= Lo.63 // бит 63 переменной Lo;

By:= Wo.%B1; // байт 1 переменной Wo;

By:= Do.%B3; // байт 3 переменной Do.

6.6.1.4 Представление и правила вызова

6.6.1.4.1 Общие положения

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

1 Там, где не заданы входные переменные стандартных функций, применяются неявные имена IN1, IN2, ... в порядке сверху вниз. Если стандартная функция имеет один вход без имени, применяется неявное имя IN.

2 Если какая-либо переменная VAR_IN_OUT какого-либо вызова в программном компоненте "неправильно отображается", возникает ошибка.

Переменная VAR_IN_OUT "отображена правильно", если:

- она графически соединена в левой части; или

- она присваивается оператором ":=" в текстовом вызове, переменной, объявленной (без квалификатора CONSTANT) в блоке VAR_IN_OUT, VAR, VAR_TEMP, VAR_OUTPUT или VAR_EXTERNAL содержащего программного компонента или "правильно отображенной" в блоке VAR_IN_OUT другого содержащегося вызова.

3 "Правильно отображенная" (как показано в правиле выше) переменная VAR_IN_OUT вызова может

- графически соединяться в правой части; или

- присваиваться, используя оператор ":=" в текстовом операторе присваивания переменной, объявленной в блоке VAR, VAR_OUTPUT или VAR_EXTERNAL содержащего программного компонента.

Если такое соединение будет приводить к неопределенному значения переменной, соединенной таким образом, то возникает ошибка.

4 Имя экземпляра функционального блока может использоваться как вход, если оно объявлено как VAR_INPUT, или как VAR_IN_OUT.

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

- если он объявлен как VAR_INPUT, переменные функционального блока могут только читаться;

- если он объявлен как VAR_IN_OUT, переменные функционального блока могут читаться и записываться, и функциональный блок может вызываться.

6.6.1.4.2 Текстовые языки

Свойства текстового вызова определяются в таблице 20. Текстовый вызов состоит из имени вызываемого объекта и последующего списка параметров.

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

Перечень параметров вызова предоставляет фактические значения и может присваивать их соответствующим именам формальных параметров (если они имеются):

- Формальный вызов

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

a) присваивание значений входным и входным-выходным переменным, используя оператор ":="; и

b) присваивание значений выходным переменным, используя оператор "=>".

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

Порядок параметров в перечне не имеет значения. Могут использоваться параметры управления выполнением EN и ENO.

Пример 1

A:= LIMIT(EN:= COND, IN:= B, MN:= 0, MX:= 5, ENO => TEMPL); // полный перечень параметров

A:= LIMIT(IN:= B, MX:= 5); // неполный перечень параметров

- Неформальный вызов

Перечень параметров содержит точно такое число параметров, и точно в том порядке и тех же типов данных, как задано в определении функции, исключая параметры управления выполнением EN и ENO.

Пример 2

A:= LIMIT(B, 0, 5)

Данный вызов эквивалентен полному вызову в примере 1, но без параметров EN и ENO.

6.6.1.4.3 Графические языки

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

1 Все блоки - прямоугольные.

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

3 Направление обработки блока - слева направо (входные параметры в левой стороне и выходные параметры - в правой).

4 Имя или символ вызываемого объекта, как описано ниже, расположено внутри блока.

5 Предусмотрено место для входных и выходных переменных, появляющихся на левой и правой сторонах блока, соответственно.

6 Могут использоваться дополнительные входная EN и выходная ENO переменные. Если они присутствуют, то показываются в самой верхней позиции слева и справа от блока, соответственно.

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

8 Соединения параметров (включая результат функции) показываются линиями передачи сигналов.

9 Отрицание логического сигнала показывается помещением светлого кружка вблизи от пересечения входной и выходной линии с блоком. В наборе символов это может быть представлено буквой "O" верхнего регистра, как показано в таблице 20. Отрицание выполняется за пределами программного компонента.

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

Результаты и выходы (VAR_OUTPUT) могут соединяться с переменной, используемой как входная переменная к другим вызовам, или могут оставаться без соединения.

Графический пример (язык FBD)

Текстовый пример (язык ST)

Объяснение

"ГОСТ Р МЭК 61131-3-2016. Национальный стандарт Российской Федерации. Контроллеры программируемые. Часть 3. Языки программирования"

A:= ADD(B,C,D); // функция или

A:= B + C + D; // операторы

Неформальный перечень параметров

(B, C, D)

A:= SHL(IN:= B, N:= C);

Имена формальных параметров

IN, N

A:= SHL(

EN:= ENABLE,

IN:= B,

N := C,

NOT ENO => NO_ERR);

Имена формальных параметров

Использование входного параметра EN и отрицания выходного параметра ENO

A:= INC(V:= X);

Определенная пользователем функция INC

Имена формальных параметров V для VAR_IN_OUT

В примере показывается графическое и текстовое представление вызова, включая вызов стандартной функции (ADD) без определенных имен формальных параметров; вызов стандартной функции (SHL) с определенными именами формальных параметров; вызов этой же функции с использованием входного параметра EN и выходного параметра ENO с отрицанием; и вызов определенной пользователем функции (INC) с определенными именами формальных параметров.

Рисунок 10 - Формальное и неформальное представление вызова

(примеры)

6.6.1.5 Управление выполнением (EN, ENO)

Как показано в таблице 18, дополнительная логическая входная переменная EN (Разрешить) и дополнительная логическая выходная переменная ENO (Разрешить выход) могут предоставляться разработчиком или пользователем в соответствии с объявлением.

VAR_INPUT	EN:	BOOL:= 1;	END_VAR
VAR_OUTPUT	ENO:	BOOL;	END_VAR

Когда используются эти переменные, выполнение операций, определенных программным компонентом, контролируется в соответствии со следующими правилами:

1 Если значение EN равно FALSE, то программный компонент не будет выполняться. Кроме того, значение ENO будет установлено в FALSE. Разработчик подробно определяет поведение в этом случае, см. примеры ниже.

2 В противном случае, если значение EN равно TRUE, значение ENO устанавливается в TRUE, и реализация программного компонента будет выполняться. Программный компонент может устанавливать ENO в логическое значение в соответствии с результатами выполнения.

3 Если во время выполнения одного из программных компонентов возникает ошибка, выходная переменная ENO этого программного компонента устанавливается в FALSE (0) системой программированного контроллера.

4 Если выходная переменная ENO установлена FALSE (0), значения всех других выходных переменных (VAR_OUTPUT, VAR_IN_OUT и результат функции) определяются разработчиком.

5 Входная переменная EN устанавливается в фактическое значение только во время вызова программного компонента.

6 Выходная переменная ENO передается только как во время вызова программного компонента.

7 Выходная переменная ENO устанавливается только внутри программного компонента.

8 Использование параметров EN или ENO в функции REF() для получения указателя на EN или ENO является ошибкой.

В случае, когда EN равно FALSE, можно выполнять другие действия вместо нормального выполнения программного компонента. Данные действия определяются разработчиком. См. примеры ниже.

Пример 1 - Внутренняя реализация

Входная переменная EN оценивается внутри программного компонента.

Если EN равно FALSE, то ENO устанавливается в False, и программный компонент немедленно завершает выполнение или выполняет подмножество операций в зависимости от ситуации.

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

Пример 2 - Внешняя реализация

Входная переменная EN оценивается вне программного компонента. Если EN равно False, то только происходит установка ENO в значение False, и программный компонент не вызывается.

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

Входной параметр EN не устанавливается вне программного компонента отдельно от вызова.

На следующем рисунке и в примерах иллюстрируется использование программного компонента с параметрами EN и ENO и без них:

Пример 3 - Внутренняя реализация

myInst (EN:= cond, A:= v1, C:= v3, B=> v2, ENO=> X);

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

IF NOT EN THEN... // выполняет подмножество операций

// в зависимости от ситуации

ENO:= 0; RETURN; END_IF;

Пример 4 - Внешняя реализация

IF cond THEN myInst (A:= v1, C:= v3, B=> v2, ENO=> X)

ELSE X:= 0; END_IF;

В таблице 18 приведены свойства при вызове программного компонента с параметрами EN и ENO и без них.

Таблица 18

Управление выполнением графически с использованием EN и ENO

Номер	Описание <a>	Пример <b>
1	Использование без EN и ENO	Показано для функции в языках FBD и ST C:= ADD(IN1:= A, IN2:= B);
2	Использование только EN (без ENO)	Показано для функции в языках FBD и ST C:= ADD(EN:= ADD_EN. IN1:= A, IN2:= B);
3	Использование только ENO (без EN)	Показано для функции в языках FBD и ST C:= ADD(IN1:= A, IN2:= B, ENO => ADD_OK);
4	Использование EN и ENO	Показано для функции в языках FBD и ST C:= ADD(EN:= ADD_EN, IN1 := a, IN2:= IN2, EN => ADD_OK);
<a> Разработчик указывает в каком из языков поддерживается свойство, то есть в реализации может быть запрещено использование EN и/или ENO. <b> Языки, выбранные для демонстрации свойств выше, даны только для примера.

6.6.1.6 Преобразование типов данных

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

Представление и интерпретация информации, хранящейся в переменной зависит от объявленного типа данных переменной. Имеется два случая, где используется преобразование типов данных.

- В присваивании значения переменной другой переменной с другим типом данных.

Это применимо к операторам присваивания ":=" и "=>" и присваивании переменным, объявленным как параметры, то входным и выходным переменным функций, функциональных блоков, методов и программ. На рисунке 11 показаны правила преобразования исходного типа данных в целевой тип данных;

Пример 1

A:= B; // Присваивание переменной

FB1 (x:= z, v => W); // Присваивание параметрам

- В выражении (см. 7.3.2 для языка ST), состоящем из операторов, таких как "+", и операндов, таких как литералы и переменные такого же типа данных или других типов данных.

Пример 2

... SQRT(B + (C * 1.5)); // Выражение

- Явное преобразование типа данных выполняется использованием функции преобразования.

- Неявное преобразование типа данных имеет следующие правила применения:

1) должно сохранять значение и точность типов данных;

2) может применяться для типизированных функций;

3) может применяться к присваиваниям выражений переменным;

Пример 3

myUDInt:= myUInt1 * myUInt2;

/* Умножение имеет результат типа UINT

который затем неявно преобразуется в тип UDINT при присваивании */

4) может применяться к присваиванию входного параметра;

5) может применяться к присваиванию входного параметра;

6) не применяется к присваиванию входного-выходного параметра;

7) может применяться так, что операнды и результаты операции или перегруженной функции получает одинаковый тип данных;

Пример 4

myUDInt:= myUInt1 * myUDInt2;

// myUInt1 неявно конвертируется в тип данных UDINT, умножение имеет результат типа данных UDINT

8) правила для нетипизированных литералов определяются разработчиком.

Примечание - Для предотвращения неопределенностей, пользователь может использовать типизированные литералы.

Пример 5

IF myWord = NOT (0) THEN ...; // Неопределенное сравнение с 16#FFF, 16#0001, 16#00FF и т.д.

IF myWord = NOT (WORD#0) THEN ...; // Неопределенное сравнение c 16#FFFF

На рисунке 11 показаны два альтернативных "явных" и "неявных" преобразования исходного типа данных к целевому типу данных.

Исходный тип данных

Целевой тип данных

действительный

целый

без знака

битовый

дата и время

символьный

LREAL

REAL

LINT

DINT

INT

SINT

ULINT

UDINT

UINT

USINT

LWORD

DWORD

WORD

BYTE

BOOL

LTIME

TIME

LDT

LDATE

DATE

LTOD

TOD

WSTRING

STRING

WCHAR

CHAR

действительный

LREAL

REAL

целый

LINT

DINT

INT

SINT

без знака

ULINT

UDINT

UINT

USINT

битовый

LWORD

DWORD

WORD

BYTE

BOOL

дата и время

LTIME

TIME

LDT

LDATE

DATE

LTOD

TOD

символьный

WSTRING

& X

STRING (Примечание)

WCHAR

CHAR (Примечание)

Обозначения:

- преобразование типа данных не требуется;

- - данным стандартом не определены явные или неявные преобразования типов данных. Реализация может поддерживать дополнительные преобразования типов данных, специфичные для разработчика;

i - неявное преобразование типов данных; однако дополнительно разрешено явное преобразование типов;

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

Примечание - Преобразование STRING в WSTRING и CHAR в WCHAR не являются неявными, во избежание конфликтов с используемыми наборами символов.

Рисунок 11 - Правила преобразования типов данных -

явные и неявные (сводка)

На рисунке 12 показаны преобразования типов данных, поддерживаемые неявным преобразованием типов данных. Стрелки представляют возможные пути преобразования. Например, BOOL может быть преобразована в BYTE, BYTE может быть преобразована в WORD и т.д.

Рисунок 12 - Поддерживаемые неявные преобразования типов

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

Пример 6 - Сравнение явных и неявных преобразований типов

1) Объявление типа

VAR

PartsRatePerHr: REAL;

PartsDone: INT;

HoursElapsed: REAL;

PartsPerShift: INT;

ShiftLength: SINT;

END_VAR

2) Использование в языке ST

a) Явное преобразование типа данных

PartsRatePerHr:= INT_TO_REAL(PartsDone) / HoursElapsed;

PartsPerShift := REAL_TO_INT(SINT_TO_REAL(ShiftLength)*PartsRatePerHr);

b) Явное преобразование перегруженного типа

PartsRatePerHr:= TO_REAL(PartsDone)/HoursElapsed; PartsPerShift := TO_INT(TO_REAL(ShiftLength)* PartsRatePerHr);

c) Неявное преобразование типа данных

PartsRatePerHr:= PartsDone / HoursElapsed;

PartsPerShift := TO_INT(ShiftLength * PartsRatePerHr);

3) Использование в языке FBD

a) Явное преобразование типа данных

$"ГОСТ Р МЭК 61131-3-2016. Национальный стандарт Российской Федерации. Контроллеры программируемые. Часть 3. Языки программирования"$

b) Явное преобразование перегруженного типа

c) Неявное преобразование типов типизированными функциями

6.6.1.7 Перегрузка

6.6.1.7.1 Общие положения

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

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

- стандартные функции

Это - перегруженные стандартные функции (например, ADD, MUL) и перегруженные стандартные функции преобразования (например, TO_REAL, TO_INT);

- стандартные методы

Настоящий стандарт не определяет стандартные методы в пределах стандартных классов и типов функциональных блоков. Однако они могут быть предоставлены разработчиком;

- функциональные блоки

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

Однако они могут быть определены другими частями МЭК 61131, и могут предоставляться разработчиком;

- стандартные классы

Настоящий стандарт не определяет стандартных классов. Однако они могут быть определены в других частях МЭК 61131, и могут предоставляться разработчиком;

- операции

Это, например, "+" и "*" в языке ST; ADD, MUL в языке IL.

6.6.1.7.2 Преобразование типов данных

Когда система программированного контроллера поддерживает перегруженные элементы языка, данный элемент языка применяется ко всем подходящим типам данных этого родового типа, которые поддерживаются системой.

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

Пример 1

Настоящий стандарт определяет для функции ADD родовой тип данных ANY_NUM для многих входных переменных одного вида и одного выходного результата.

Разработчик определяет для этого родовой тип данных ANY_NUM для связанных элементарных типов данных REAL и INT системы PLC.

Пример 2

Настоящий стандарт определяет функцию битового сдвига LEFT для родового типа данных ANY_BIT для одной входной переменной и выходного результата и родового типа данных ANY_INT для другой входной переменной.

Разработчик определяет следующие два родовых типа данных для системы PLC:

ANY_BIT представляет, например, элементарные типы данных BYTE и WORD;

ANY_INT представляет, например, элементарные типы данных INT и LINT.

Перегруженный элемент языка оперирует с определенными элементарными типами данных в соответствии со следующими правилами:

- типы данных входных переменных и результата имеют одинаковый тип, это применимо к входным переменным и результату одинакового вида.

"Одинаковый вид" означает, что параметры, операнды и результат одинаково используются при сложении и умножении.

Более сложные комбинации определяются разработчиком;

- если типы данных входных и выходных данных одинакового вида имеют разный тип, то преобразование типов в элементе языка определяется разработчиком;

- неявное преобразование типов выражения и присваивания следует за последовательностью вычисления выражения. См. примеры ниже;

- тип данных переменной для хранения результата перегруженной функции не влияет на тип данных результата функции или результата.

Примечание - Пользователь может явно задать тип результата операции, используя типизированные функции.

Пример 3

int3 := int1 + int2 (* Сложение выполняется как целочисленная операция *)

dint1:= int1 + int2; (* Сложение выполняется как целочисленная операция, когда результат преобразуется в тип DINT и присваивается переменной dint1 *)

dint1:= dint2 + int3; (* int3 преобразуется в тип DINT, сложение выполняется как сложение DINT *)

6.6.2 Функции

6.6.2.1 Общие положения

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

Если не оговорено иное, к функциям применяются общие свойства программных компонентов.

Выполнение функции:

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

- возможно предоставляет выходные переменные, которые могут быть многоэлементными;

- может изменять значение входных-выходных переменных и переменных VAR_EXTERNAL.

Функция с результатом может вызываться в выражении или как оператор. Функция без результата не должна вызываться внутри выражения.

6.6.2.2 Объявление функции

Объявление функции состоит из следующих элементов, как определено в таблице 19. Данные свойства объявляются так же, как описано для функциональных блоков.

При объявления функции применяются следующие правила, заданные в таблице 19:

1 Объявление начинается с ключевого слова FUNCTION, за которым следует идентификатор, указывающий имя функции.

2 Если функция предоставляет результат, то далее следует символ ":" и тип данных значения, возвращаемого функцией. Если функция не предоставляет результата, двоеточие и тип данных опускаются.

3 Конструкции с VAR_INPUT, VAR_OUTPUT и VAR_IN_OUT, если требуются, указывающие имена и типы данных параметров функции.

4 Значения переменных, которые передаются функции через конструкцию VAR_EXTERNAL, могут изменяться из функции.

5 Значения констант, которые передаются функции через конструкцию VAR_EXTERNAL CONSTANT, не могут изменяться из функции.

6 Значения переменных, которые передаются функции через конструкцию VAR_EXTERNAL, могут изменяться из функции.

7 Массивы переменной длины могут использоваться как VAR_INPUT, VAR_OUTPUT и VAR_IN_OUT.

8 Входные-выходные и временные переменные могут инициализироваться.

9 Могут использоваться входная переменная EN и выходная переменная ENO как описано.

10 Если требуется, конструкция VAR...END_VAR, а также последовательность VAR_TEMP...END_VAR используются для определения имен и типов внутренних временных переменных.

В отличие от функциональных блоков, переменные, объявленные в секции VAR, не сохраняются.

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

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

13 Ключевое слово END_FUNCTION завершает объявление.

Таблица 19

Объявление функции

Номер	Описание	Пример
1a	Без результата FUNCTION ... END_FUNCTION	FUNCTION myFC ... END_FUNCTION
1b	С результатом FUNCTION <name>: <data type> END_FUNCTION	FUNCTION myFC: INT ... END_FUNCTION
2a	Входные параметры VAR_INPUT...END_VAR	VAR_INPUT IN:
2b	Выходные параметры VAR_OUTPUT...END_VAR	VAR_OUTPUT OUT: BOOL; ET_OFF: TIME; END_VAR
2c	Входные-выходные параметры VAR_IN_OUT...END_VAR	VAR_IN_OUT A: INT; END_VAR
2d	Временные переменные VAR_TEMP...END_VAR	VAR_TEMP I: INT; END_VAR
2e	Временные переменные VAR...END_VAR	VAR B: REAL; END_VAR Различие с функциональными блоками из-за проблем совместимости в функциональных блоках VAR являются статическими (сохраняются)!
2f	Внешние переменные VAR_EXTERNAL...END_VAR	VAR_EXTERNAL B: REAL; END_VAR Соответствует следующему: VAR_GLOBAL B: REAL...
2g	Внешние константы VAR_EXTERNAL CONSTANT...END_VAR	VAR_EXTERNAL CONSTANT B: REAL; END_VAR Соответствует следующему: VAR_GLOBAL B: REAL
3a	Инициализация входных параметров	VAR_INPUT MN: INT:= 0;
3b	Инициализация выходных параметров	VAR_OUTPUT RES: INT:= 1;
3c	Инициализация временных переменных	VAR I: INT:= 1;
--	Входной параметр EN и выходной параметр ENO	Определено в таблице 18

Пример -

// Спецификация интерфейсов параметра

FUNCTION SIMPLE_FUN: REAL

VAR_INPUT

A, B: REAL;

C: REAL:= 1.0; END_VAR

VAR_IN_OUT COUNT: INT;

END_VAR

// Спецификация интерфейсов параметра

// Спецификация тела функции

VAR COUNTP1: INT; END_VAR COUNTP1:=

ADD(COUNT, 1);

COUNT := COUNTP1

SIMPLE_FUN:= A*B/C; // результат

END_FUNCTION

// Спецификация тела функции

a) Объявление и тело функции (языки ST и FBD) - (см. Примечание)

*VAR_GLOBAL DataArray: ARRAY [0..100] OF INT;* *END_VAR* *FUNCTION SPECIAL_FUN*	*// Внешний интерфейс*
*VAR_INPUT* *FirstIndex: INT;* *LastIndex: INT;*	*// функция без результата, но есть выходная переменная Sum*
*END_VAR* *VAR_OUTPUT Sum:* *INT;* *END_VAR* *VAR_EXTERNAL DataArray:* *ARRAY [0..100] OF INT;* *END_VAR*
*VAR I: INT; Sum: INT:= 0; END_VAR* *FOR i:= FirstIndex TO LastIndex DO Sum:=* *Sum* + *DataArray[i];* *END_FOR* *END_FUNCTION*	*// Тело функции - графически не показано*

b) Объявление и тело функции (функция без результата - с выходом Var)

Примечание - В примере a) входной переменной дано определенное неявное значение 1.0, чтобы предотвратить ошибку "деление на ноль", если вход не указан при вызове функции, например, если графический вход в функцию слева не соединен.

6.6.2.3 Вызов функции

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

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

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

Функция не содержит информацию о внутреннем состоянии, то есть она не сохраняет никакие входные, внутренние (временные) и выходные элементы от одного вызова до другого:

- вызов функции с одинаковыми параметрами (VAR_INPUT и VAR_IN_OUT) и одинаковыми значениями переменных VAR_EXTERNAL всегда будет изготавливать одинаковые значения выходных переменных, входных-выходных переменных, внешних переменных и результат функции, если он имеется.

Примечание - Некоторые функции, обычно предоставляемые как системные функции от разработчика могут производить различные значения, например, функции TIME(), RANDOM().

Таблица 20

Вызов функции

Номер	Описание	Пример
1a	Полный формальный вызов (только текстовый) Примечание 1 - Такой вызов используется, если указание параметров EN и ENO в вызове является обязательным.	A:= LIMIT(EN: = COND, IN:= B, MN:= 0, MX:= 5, ENO => TEMPL);
1b	Неполный формальный вызов (только текстовый) Примечание 2 - Используется, если использование параметров EN и ENO в вызове не является обязательным.	A:= LIMIT(IN:= B, MX:= 5); Примечание 3 - Переменная MN будет иметь неявное значение 0 (ноль).
2	Неформальный вызов (только текстовый) (с фиксированным порядком параметров и полный) Примечание 4 - Используется для вызова стандартных функций без формальных имен.	A:= LIMIT(B, 0, 5); Примечание 4 - Данный вызов эквивалентен вызову в примере 1a, но без параметров EN и ENO.
3	Функция без результата функции	FUNCTION myFun // нет объявления типа VAR_INPUT x: INT; END_VAR; VAR_OUTPUT y: REAL; END_VAR; myFun(150, var); // Вызов
4	Графическое представление
5	Использование логического входа с отрицанием и логического выхода с отрицанием в графическом представлении	Примечание 6 - Использование таких конструкций запрещено для входных-выходных переменных.
6	Графическое использование VAR_IN_OUT

Пример - Вызов функции

Вызов

VAR

X, Y, Z, Res1, Res2: REAL;

En1, V: BOOL;

END_VAR

Res1:= DIV(In1:= COS(X), In2:= SIN(Y), ENO => EN1);

Res2:= MUL(SIN(X), COS(Y));

Z := ADD(EN:= EN1, IN1:= Res1, IN2:= Res2, ENO => V);

a) Вызов стандартных функций с результатом и параметрами EN и ENO

Объявление

FUNCTION My_function // нет типа, нет результата

VAR_INPUT In1: REAL; END_VAR

VAR_OUTPUT Out1, Out2: REAL; END_VAR

VAR_TEMP Tmp1: REAL; END_VAR // разрешено использование VAR_TEMP

VAR_EXTERNAL Ext: BOOL; END_VAR

// Тело функции

END_FUNCTION

Текстовый и графический вызов

My_Function (In1:= a, Out1 => b; Out2 => c);

// без результата

// с двумя выходными переменными

b) Объявление и вызов функции без результата, но с двумя выходными переменными

Текстовый и графический вызов

myFC1 (In1:= a, Inout:= b, Out1 => Tmp1); // использование временной переменной

d:= myFC2 (In1:= Tmp1, Inout:= b); // переменная b сохраняется в входной-выходной

переменной inout; Присваивание переменной

c:= b; // значение переменной b присвоено переменной c

// результат

// присваивание переменной

c) Вызов функции с графическим представлением входных-выходных переменных

Текстовый и графический вызов

// не разрешен в языке ST

My_Function (In1:= a, Out1 => Tmp1, Out2 => Tmp2);

d:= Tmp1 + Tmp2;

d) Вызов функции без результата, но с выражением из выходных переменных

Примечание 2 - Данные примеры представляют различные представления одной и той же функциональности. Не требуется поддерживать какое-либо автоматическое преобразование между двумя формами представления.

6.6.2.4 Типизированные и перегруженные функции

Функция, которая нормально представляет перегруженный оператор, должна быть типизированной. Это можно сделать добавлением символа подчеркивания "_" с последующим требуемым типом, как показано в таблице 21. Типизированная функции выполняется, используя тип данных для своих входных и выходных переменных. Может применяться неявное или явное преобразование типов.

Таблица 21

Типизированные и перегруженные функции

Номер	Описание	Пример
1a	Перегруженная функция ADD (ANY_Num to ANY_Num)
1b	Преобразование входных переменных ANY_ELEMENT TO_INT
2a <a>	Типизированные функции: ADD_INT
2b <a>	Преобразование типов: WORD_TO_INT
Примечание - Перегрузка нестандартных функций или типов функциональных блоков не входит в задачу настоящего стандарта.
<a> Если поддерживается свойство 2, разработчик предоставляет дополнительную таблицу, показывающую, какие функции являются перегруженными и какие являются типизированными в реализации.

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

Пример 1 - Типизированные и перегруженные функции

VAR

A: INT;

B: INT;

C: INT;

END_VAR

C:= A+B

Примечание 1 - Преобразование типов в показанном выше примере не требуется.

VAR

A: INT;

B: REAL;

C: REAL;

END_VAR

C:= INT_TO_REAL(A)+B;

C:= TO_REAL(A) + B;

VAR

A: INT;

B: INT;

C: REAL;

END_VAR

C:= INT_TO_REAL(A+B);

C:= TO_REAL(A+B);

a) Объявление типа (язык ST)

b) Использование (языки FBD и ST)

Пример 2 - Явное и неявное преобразование типов типизированными функциями

VAR

A: INT;

B: INT;

C: INT;

END_VAR

C:= ADD_INT(A, B);

Примечание 2 - Преобразование типов в показанном выше примере не требуется.

Явное преобразование типа данных

VAR

A: INT;

B: REAL;

C: REAL;

END_VAR

C:= ADD_REAL(INT_TO_REAL(A), B);

Неявное преобразование типа данных

VAR

A: INT;

B: REAL;

C: REAL;

END_VAR

C:= ADD_REAL (A, B);

Явное преобразование типа данных

VAR

A: INT;

B: INT;

C: REAL;

END_VAR

C:= INT_TO_REAL(ADD_INT(A, B));

Неявное преобразование типа данных

VAR

A: INT;

B: INT;

C: REAL;

END_VAR

C:= ADD_INT(A, B);

a) Объявление типов (язык ST)

b) Использование (языки FBD и ST)

6.6.2.5 Стандартные функции

6.6.2.5.1 Общие положения

Стандартная функция, определенная в этом подпункте расширяемой, может иметь две или более входных переменных, к которым может быть применена указанная операция. Например, расширяемое сложение дает в качестве выхода сумму всех ее входов. Максимальное число входных переменных расширяемой функции определяется разработчиком. Фактическое число входных переменных в формальном вызове расширяемой функции определяется именем формальной входной переменной с самым большим индексом в последовательности имен переменной.

Пример 1 -

Оператор X:= ADD (Y1, Y2, Y3);

эквивалентен оператору X:= ADD (IN1:= Y1, IN2:= Y2, IN3:= Y3);

Пример 2 -

Оператор I:= MUX_INT (K:=3, IN0:= 1, IN2:= 2, IN4:= 3);

эквивалентен оператору I:= 0;

6.6.2.5.2 Функции преобразования типов данных

Как показано в таблице 22, функции преобразования типов *_TO_**, где "*" - тип входной переменной IN, а "**" - тип выходной переменной OUT, например, INT_TO_REAL. Влияние преобразований типов на точность и типы ошибок, которые могут возникать во время выполнения операций преобразования типов, определяется разработчиком.

Таблица 22

Функция преобразования типов данных

Номер	Описание	Графическая форма	Пример использования
1a	Типизированное преобразование вход_TO_выход	() - Входной тип данных, например, INT (*) - Выходной тип данных, например, REAL	A:= INT_TO_REAL(B);
1b <a>, <b>, <e>	Перегруженное преобразование TO_выход	- Входной тип данных, например, INT (**) - Выходной тип данных, например, REAL	A:= TO_REAL(B);
2a <c>	"Старое" перегруженное усечение данных TRUNC		Не рекомендуется
2b <c>	Типизированное усечение данных вход_TRUNC_выход		A:= REAL_TRUNC_INT(B);
2c <c>	Перегруженное усечение данных TRUNC_выход		A:= TRUNC_INT(B);
3a <d>	Типизированная функция вход_BCD_TO_выход		A:= WORD_BCD_TO_INT(B);
3b <d>	Перегруженная функция BCD_TO_выход		A:= BCD_TO_INT(B);
4a <d>	Типизированная функция вход_TO_BCD_выход		A:= INT_TO_BCD_WORD(B);
4b <d>	Перегруженная функция TO_BCD_выход		A:= TO_BCD_WORD(B);
Примечание - Примеры использования даны на языке ST. -------------------------------- <a> Декларация соответствия на свойство 1 этой таблицы должна включать перечень поддерживаемых специфических преобразований типов и описание эффектов выполнения каждого преобразования. <b> Преобразования типа REAL или LREAL в тип SINT, INT, DINT или LINT производить, округлять в соответствии с МЭК 60559, согласно которому, если два ближайших целых значения одинаково близки, результатом является ближайшее целое число, например: REAL_TO_INT ( 1.6) эквивалентно 2; REAL_TO_INT ( -1.6) эквивалентно -2; REAL_TO_INT ( 1.5) эквивалентно 2; REAL_TO_INT (-1.5) эквивалентно -2; REAL_TO_INT ( 1.4) эквивалентно 1; REAL_TO_INT (-1.4) эквивалентно -1; REAL_TO_INT ( 2.5) эквивалентно 2; REAL_TO_INT ( -2.5) эквивалентно -2. <c> Функция TRUNC_* используется для усечения по направлению к нулю типов REAL или LREAL, выдавая один из целых типов, например: TRUNC_INT ( 1.6) эквивалентно INT#1; TRUNC_INT (-1.6) эквивалентно INT#-1; TRUNC_SINT ( 1.4) эквивалентно SINT#1; TRUNC_SINT (-1.4) эквивалентно SINT#-1. <d> Функции преобразования _BCD_TO_* и *_TO_BCD_ выполняют преобразования между переменными типа BYTE, WORD, DWORD и LWORD и переменными типа USINT, UINT, UDINT и ULINT (представленными "" и "*", соответственно), когда соответствующие переменные типа битовой строки закодированы в формате BCD. Например, значением USINT_TO_BCD_BYTE(25) будет 2#0010_0101, а значением WORD_BCD_TO_UINT (2#0011_0110_1001) будет 396. <e> Когда входом или выходом функции преобразования типов является тип STRING или WSTRING, данные символьной строки соответствуют внешнему представлению соответствующих данных, как указано в 6.3.3, в наборе символов, определенном в 6.1.1.

6.6.2.5.3 Преобразование числовых типов данных

В преобразовании числовых типов данных используются следующие правила:

1 Тип данных источника расширяется до самого большого типа данных этой категории типов данных.

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

3 Затем этот результат преобразуется в целевой тип данных.

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

Примечание - Реализация функции преобразования может использовать более эффективную процедуру.

Пример - X:= REAL_TO_INT (70_000.4)

1 Значение (70_000.4) типа REAL преобразуется в значение (70_000.400_000..) типа LREAL.

2 Значение (70_000.4000_000..) типа LREAL преобразуется в значение (70_000) типа LINT. Здесь значение округлено до целого.

3 Значение (70_000) типа LINT преобразуется в значение типа INT. Здесь окончательное значение определяется разработчиком, поскольку максимальное значение, которое может хранить тип INT равно 65536.

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

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

Тип данных BOOL, используемый в качестве исходного типа данных, рассматривается как тип данных целого без знака, который может хранить значения 0 и 1.

В таблице 23 описаны функции преобразования с деталями, вытекающими из применения описанных выше правил.

Таблица 23

Преобразование числовых типов данных

Номер	Функция преобразования типов данных			Детали преобразования
1	LREAL	_TO_	REAL	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
2	LREAL	_TO_	LINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
3	LREAL	_TO_	DINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
4	LREAL	_TO_	INT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
5	LREAL	_TO_	SINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
6	LREAL	_TO_	ULINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
7	LREAL	_TO_	UDINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
8	LREAL	_TO_	UINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
9	LREAL	_TO_	USINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
10	REAL	_TO_	LREAL	Преобразование, сохраняющее значение
11	REAL	_TO_	LINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
12	REAL	_TO_	DINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
13	REAL	_TO_	INT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
14	REAL	_TO_	SINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
15	REAL	_TO_	ULINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
16	REAL	_TO_	UDINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
17	REAL	_TO_	UINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
18	REAL	_TO_	USINT	Преобразование с округлением, ошибки дают результат, определяемый разработчиком
19	LINT	_TO_	LREAL	Преобразование с потенциальной потерей точности
20	LINT	_TO_	REAL	Преобразование с потенциальной потерей точности
21	LINT	_TO_	DINT	Ошибки диапазона значений дают результат, определяемый разработчиком
22	LINT	_TO_	INT	Ошибки диапазона значений дают результат, определяемый разработчиком
23	LINT	_TO_	SINT	Ошибки диапазона значений дают результат, определяемый разработчиком
24	LINT	_TO_	ULINT	Ошибки диапазона значений дают результат, определяемый разработчиком
25	LINT	_TO_	UDINT	Ошибки диапазона значений дают результат, определяемый разработчиком
26	LINT	_TO_	UINT	Ошибки диапазона значений дают результат, определяемый разработчиком
27	LINT	_TO_	USINT	Ошибки диапазона значений дают результат, определяемый разработчиком
28	DINT	_TO_	LREAL	Преобразование, сохраняющее значение
29	DINT	_TO_	REAL	Преобразование с потенциальной потерей точности
30	DINT	_TO_	LINT	Преобразование, сохраняющее значение
31	DINT	_TO_	INT	Ошибки диапазона значений дают результат, определяемый разработчиком
32	DINT	_TO_	SINT	Ошибки диапазона значений дают результат, определяемый разработчиком
33	DINT	_TO_	ULINT	Ошибки диапазона значений дают результат, определяемый разработчиком
34	DINT	_TO_	UDINT	Ошибки диапазона значений дают результат, определяемый разработчиком
35	DINT	_TO_	UINT	Ошибки диапазона значений дают результат, определяемый разработчиком
36	DINT	_TO_	USINT	Ошибки диапазона значений дают результат, определяемый разработчиком
37	INT	_TO_	LREAL	Преобразование, сохраняющее значение
38	INT	_TO_	REAL	Преобразование, сохраняющее значение
39	INT	_TO_	LINT	Преобразование, сохраняющее значение
40	INT	_TO_	DINT	Преобразование, сохраняющее значение
41	INT	_TO_	SINT	Ошибки диапазона значений дают результат, определяемый разработчиком
42	INT	_TO_	ULINT	Ошибки диапазона значений дают результат, определяемый разработчиком
43	INT	_TO_	UDINT	Ошибки диапазона значений дают результат, определяемый разработчиком
44	INT	_TO_	UINT	Ошибки диапазона значений дают результат, определяемый разработчиком
45	INT	_TO_	USINT	Ошибки диапазона значений дают результат, определяемый разработчиком
46	SINT	_TO_	LREAL	Преобразование, сохраняющее значение
47	SINT	_TO_	REAL	Преобразование, сохраняющее значение
48	SINT	_TO_	LINT	Преобразование, сохраняющее значение
49	SINT	_TO_	DINT	Преобразование, сохраняющее значение
50	SINT	_TO_	INT	Преобразование, сохраняющее значение
51	SINT	_TO_	ULINT	Ошибки диапазона значений дают результат, определяемый разработчиком
52	SINT	_TO_	UDINT	Ошибки диапазона значений дают результат, определяемый разработчиком
53	SINT	_TO_	UINT	Ошибки диапазона значений дают результат, определяемый разработчиком
54	SINT	_TO_	USINT	Ошибки диапазона значений дают результат, определяемый разработчиком
55	ULINT	_TO_	LREAL	Преобразование с потенциальной потерей точности
56	ULINT	_TO_	REAL	Преобразование с потенциальной потерей точности
57	ULINT	_TO_	LINT	Ошибки диапазона значений дают результат, определяемый разработчиком
58	ULINT	_TO_	DINT	Ошибки диапазона значений дают результат, определяемый разработчиком
59	ULINT	_TO_	INT	Ошибки диапазона значений дают результат, определяемый разработчиком
60	ULINT	_TO_	SINT	Ошибки диапазона значений дают результат, определяемый разработчиком
61	ULINT	_TO_	UDINT	Ошибки диапазона значений дают результат, определяемый разработчиком
62	ULINT	_TO_	UINT	Ошибки диапазона значений дают результат, определяемый разработчиком
63	ULINT	_TO_	USINT	Ошибки диапазона значений дают результат, определяемый разработчиком
64	UDINT	_TO_	LREAL	Преобразование, сохраняющее значение
65	UDINT	_TO_	REAL	Преобразование с потенциальной потерей точности
66	UDINT	_TO_	LINT	Преобразование, сохраняющее значение
67	UDINT	_TO_	DINT	Ошибки диапазона значений дают результат, определяемый разработчиком
68	UDINT	_TO_	INT	Ошибки диапазона значений дают результат, определяемый разработчиком
69	UDINT	_TO_	SINT	Ошибки диапазона значений дают результат, определяемый разработчиком
70	UDINT	_TO_	ULINT	Преобразование, сохраняющее значение
71	UDINT	_TO_	UINT	Ошибки диапазона значений дают результат, определяемый разработчиком
72	UDINT	_TO_	USINT	Ошибки диапазона значений дают результат, определяемый разработчиком
73	UINT	_TO_	LREAL	Преобразование, сохраняющее значение
74	UINT	_TO_	REAL	Преобразование, сохраняющее значение
75	UINT	_TO_	LINT	Преобразование, сохраняющее значение
76	UINT	_TO_	DINT	Преобразование, сохраняющее значение
77	UINT	_TO_	INT	Ошибки диапазона значений дают результат, определяемый разработчиком
78	UINT	_TO_	SINT	Ошибки диапазона значений дают результат, определяемый разработчиком
79	UINT	_TO_	ULINT	Преобразование, сохраняющее значение
80	UINT	_TO_	UDINT	Преобразование, сохраняющее значение
81	UINT	_TO_	USINT	Ошибки диапазона значений дают результат, определяемый разработчиком
82	USINT	_TO_	LREAL	Преобразование, сохраняющее значение
83	USINT	_TO_	REAL	Преобразование, сохраняющее значение
84	USINT	_TO_	LINT	Преобразование, сохраняющее значение
85	USINT	_TO_	DINT	Преобразование, сохраняющее значение
86	USINT	_TO_	INT	Преобразование, сохраняющее значение
87	USINT	_TO_	SINT	Ошибки диапазона значений дают результат, определяемый разработчиком
88	USINT	_TO_	ULINT	Преобразование, сохраняющее значение
89	USINT	_TO_	UDINT	Преобразование, сохраняющее значение
90	USINT	_TO_	UINT	Преобразование, сохраняющее значение

6.6.2.5.4 Преобразование типов битовых типов данных

При преобразовании этого типа данных используются следующие правила:

1 Преобразование типов данных осуществляется как передача двоичных данных.

2 Если исходный тип данных меньше, чем целевой тип данных, исходное значение хранится в самых правых битах целевой переменной, а самые левые биты устанавливаются в ноль.

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

В таблице 24 описаны функции преобразования с деталями, вытекающими из применения описанных выше правил.

Таблица 24

Преобразование битовых типов данных

Номер	Функция преобразования типов данных			Детали преобразования
1	LWORD	_TO_	DWORD	Двоичная передача самых правых байтов в адресат
2	LWORD	_TO_	WORD	Двоичная передача самых правых байтов в адресат
3	LWORD	_TO_	BYTE	Двоичная передача самых правых байтов в адресат
4	LWORD	_TO_	BOOL	Двоичная передача самого правого бита в адресат
5	DWORD	_TO_	LWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
6	DWORD	_TO_	WORD	Двоичная передача самых правых байтов в адресат
7	DWORD	_TO_	BYTE	Двоичная передача самых правых байтов в адресат
8	DWORD	_TO_	BOOL	Двоичная передача самого правого бита в адресат
9	WORD	_TO_	LWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
10	WORD	_TO_	DWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
11	WORD	_TO_	BYTE	Двоичная передача самых правых байтов в адресат
12	WORD	_TO_	BOOL	Двоичная передача самого правого бита в адресат
13	BYTE	_TO_	LWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
14	BYTE	_TO_	DWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
15	BYTE	_TO_	WORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
16	BYTE	_TO_	BOOL	Двоичная передача самого правого бита в адресат
17	BYTE	_TO_	CHAR	Передача двоичных данных
18	BOOL	_TO_	LWORD	Дает результат 16#0 или 16#1
19	BOOL	_TO_	DWORD	Дает результат 16#0 или 16#1
20	BOOL	_TO_	WORD	Дает результат 16#0 или 16#1
21	BOOL	_TO_	BYTE	Дает результат 16#0 или 16#1
22	CHAR	_TO_	BYTE	Передача двоичных данных
23	CHAR	_TO_	WORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
24	CHAR	_TO_	DWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
25	CHAR	_TO_	LWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
26	WCHAR	_TO_	WORD	Передача двоичных данных
27	WCHAR	_TO_	DWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль
28	WCHAR	_TO_	LWORD	Двоичная передача самых правых байтов в адресат, самые левые байты устанавливаются в нуль

6.6.2.5.5 Преобразование битовых типов данных в числовые типы данных

При преобразовании этого типа данных используются следующие правила:

1 Преобразование типов данных осуществляется как передача двоичных данных.

Пример 1

X: SINT:= 18; W: WORD; W:= SINT_TO_WORD(X); и W получает значение 16#0012.

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

Пример 2

W: WORD: = 16#1234; X: SINT; X:= W; и X получает значение 54 (=16#34).

В таблице 25 описаны функции преобразования с деталями, вытекающими из применения описанных выше правил.

Таблица 25

Преобразование битовых и числовых типов данных

Номер	Функция преобразования типов данных			Детали преобразования
1	LWORD	_TO_	LREAL	Передача двоичных данных
2	DWORD	_TO_	REAL	Передача двоичных данных
3	LWORD	_TO_	LINT	Передача двоичных данных
4	LWORD	_TO_	DINT	Двоичная передача самых правых байтов в адресат
5	LWORD	_TO_	INT	Двоичная передача самых правых байтов в адресат
6	LWORD	_TO_	SINT	Двоичная передача самого правого байта в адресат
7	LWORD	_TO_	ULINT	Передача двоичных данных
8	LWORD	_TO_	UDINT	Двоичная передача самых правых байтов в адресат
9	LWORD	_TO_	UINT	Двоичная передача самых правых байтов в адресат
10	LWORD	_TO_	USINT	Двоичная передача самого правого байта в адресат
11	DWORD	_TO_	LINT	Двоичная передача в самые правые байты адресата
12	DWORD	_TO_	DINT	Передача двоичных данных
13	DWORD	_TO_	INT	Двоичная передача самых правых байтов в адресат
14	DWORD	_TO_	SINT	Двоичная передача самого правого байта в адресат
15	DWORD	_TO_	ULINT	Двоичная передача в самые правые байты адресата
16	DWORD	_TO_	UDINT	Передача двоичных данных
17	DWORD	_TO_	UINT	Двоичная передача самых правых байтов в адресат
18	DWORD	_TO_	USINT	Двоичная передача самого правого байта в адресат
19	WORD	_TO_	LINT	Двоичная передача в самые правые байты адресата
20	WORD	_TO_	DINT	Двоичная передача в самые правые байты адресата
21	WORD	_TO_	INT	Передача двоичных данных
22	WORD	_TO_	SINT	Двоичная передача самого правого байта в адресат
23	WORD	_TO_	ULINT	Двоичная передача в самые правые байты адресата
24	WORD	_TO_	UDINT	Двоичная передача в самые правые байты адресата
25	WORD	_TO_	UINT	Передача двоичных данных
26	WORD	_TO_	USINT	Двоичная передача самого правого байта в адресат
27	BYTE	_TO_	LINT	Двоичная передача в самые правые байты адресата
28	BYTE	_TO_	DINT	Двоичная передача в самые правые байты адресата
29	BYTE	_TO_	INT	Двоичная передача в самые правые байты адресата
30	BYTE	_TO_	SINT	Передача двоичных данных
31	BYTE	_TO_	ULINT	Двоичная передача в самые правые байты адресата
32	BYTE	_TO_	UDINT	Двоичная передача в самые правые байты адресата
33	BYTE	_TO_	UINT	Двоичная передача в самые правые байты адресата
34	BYTE	_TO_	USINT	Передача двоичных данных
35	BOOL	_TO_	LINT	Дает результат 0 или 1
36	BOOL	_TO_	DINT	Дает результат 0 или 1
37	BOOL	_TO_	INT	Дает результат 0 или 1
38	BOOL	_TO_	SINT	Дает результат 0 или 1
39	BOOL	_TO_	ULINT	Дает результат 0 или 1
40	BOOL	_TO_	UDINT	Дает результат 0 или 1
41	BOOL	_TO_	UINT	Дает результат 0 или 1
42	BOOL	_TO_	USINT	Дает результат 0 или 1
43	LREAL	_TO_	LWORD	Передача двоичных данных
44	REAL	_TO_	DWORD	Передача двоичных данных
45	LINT	_TO_	LWORD	Передача двоичных данных
46	LINT	_TO_	DWORD	Двоичная передача самых правых байтов в адресат
47	LINT	_TO_	WORD	Двоичная передача самых правых байтов в адресат
48	LINT	_TO_	BYTE	Двоичная передача самого правого байта в адресат
49	DINT	_TO_	LWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
50	DINT	_TO_	DWORD	Передача двоичных данных
51	DINT	_TO_	WORD	Двоичная передача самых правых байтов в адресат
52	DINT	_TO_	BYTE	Двоичная передача самого правого байта в адресат
53	INT	_TO_	LWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
54	INT	_TO_	DWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
55	INT	_TO_	WORD	Передача двоичных данных
56	INT	_TO_	BYTE	Двоичная передача самого правого байта в адресат
57	SINT	_TO_	LWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
58	SINT	_TO_	DWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
59	SINT	_TO_	WORD	Передача двоичных данных
60	SINT	_TO_	BYTE	Передача двоичных данных
61	ULINT	_TO_	LWORD	Передача двоичных данных
62	ULINT	_TO_	DWORD	Двоичная передача самых правых байтов в адресат
63	ULINT	_TO_	WORD	Двоичная передача самых правых байтов в адресат
64	ULINT	_TO_	BYTE	Двоичная передача самого правого байта в адресат
65	UDINT	_TO_	LWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
66	UDINT	_TO_	DWORD	Передача двоичных данных
67	UDINT	_TO_	WORD	Двоичная передача самых правых байтов в адресат
68	UDINT	_TO_	BYTE	Двоичная передача самого правого байта в адресат
69	UINT	_TO_	LWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
70	UINT	_TO_	DWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
71	UINT	_TO_	WORD	Передача двоичных данных
72	UINT	_TO_	BYTE	Двоичная передача самого правого байта в адресат
73	USINT	_TO_	LWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
74	USINT	_TO_	DWORD	Двоичная передача в самые правые байты адресата, остальные байты = 0
75	USINT	_TO_	WORD	Передача двоичных данных
76	USINT	_TO_	BYTE	Передача двоичных данных

6.6.2.5.6 Преобразование типов данных даты и времени

В таблице 26 показывается преобразование типов данных даты и времени.

Таблица 26

Преобразование типов данных даты и времени

Номер	Функция преобразования типов данных			Детали преобразования
1	LTIME	_TO_	TIME	Ошибки диапазона значений дают результат, определяемый разработчиком, и может происходить потеря точности
2	TIME	_TO_	LTIME	Ошибки диапазона значений дают результат, определяемый разработчиком, и может происходить потеря точности
3	LDT	_TO_	DT	Ошибки диапазона значений дают результат, определяемый разработчиком, и может происходить потеря точности
4	LDT	_TO_	DATE	Преобразует только содержащуюся дату, ошибки диапазона значений дают результат, определяемый разработчиком
5	LDT	_TO_	LTOD	Преобразует только содержащееся время суток
6	LDT	_TO_	TOD	Преобразует только содержащееся время суток, может происходить потеря точности
7	DT	_TO_	LDT	Ошибки диапазона значений дают результат, определяемый разработчиком, и может происходить потеря точности
8	DT	_TO_	DATE	Преобразует только содержащуюся дату, ошибки диапазона значений дают результат, определяемый разработчиком
9	DT	_TO_	LTOD	Преобразует только содержащееся время суток, ошибки диапазона значений дают результат, определяемый разработчиком
10	DT	_TO_	TOD	Преобразует только содержащееся время суток, ошибки диапазона значений дают результат, определяемый разработчиком
11	LTOD	_TO_	TOD	Преобразование, сохраняющее значение
12	TOD	_TO_	LTOD	Ошибки диапазона значений дают результат, определяемый разработчиком, и может происходить потеря точности

6.6.2.5.7 Преобразование символьных типов данных

В таблице 27 показывается преобразование символьных типов данных.

Таблица 27

Преобразование символьных типов данных

Номер	Функция преобразования типов данных			Детали преобразования
1	WSTRING	_TO_	STRING	Преобразуются только символы, поддерживаемые разработчиком в типе данных STRING, преобразование остальных символов определяется разработчиком
2	WSTRING	_TO_	WCHAR	Передается первый символ строки, если строка пустая, целевая переменная имеет неопределенное значение
3	STRING	_TO_	WSTRING	Преобразует символы строки как определено разработчиком в соответствующие символы набора символов ИСО/МЭК 10646 (UTF-16)
4	STRING	_TO_	CHAR	Передается первый символ строки, если строка пустая, целевая переменная имеет неопределенное значение
5	WCHAR	_TO_	WSTRING	Дает строку с фактической длиной в один символ
6	WCHAR	_TO_	CHAR	Преобразуются только символы, поддерживаемые разработчиком в типе данных CHAR, преобразование остальных символов определяется разработчиком
7	CHAR	_TO_	STRING	Дает строку с фактической длиной в один символ
8	CHAR	_TO_	WCHAR	Преобразует символ как определено разработчиком в соответствующий символ набора символов UTF-16

6.6.2.5.8 Числовые и арифметические функции

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

Таблица 28

Числовые и арифметические функции

Номер	Описание (имя функции)	Тип входной/выходной переменной	Объяснение
	Графическая форма () - Тип входной/выходной переменной (*) - Имя функции		Пример использования в языке ST A:= SIN(B); (язык ST)
	Общие функции
1	ABS(x)	ANY_NUM	Абсолютная величина
2	SQRT(x)	ANY_REAL	Квадратный корень
	Логарифмические функции
3	LN(x)	ANY_REAL	Натуральный логарифм
4	LOG(x)	ANY_REAL	Десятичный логарифм
5	EXP(x)	ANY_REAL	Экспонента
	Тригонометрические функции
6	SIN(x)	ANY_REAL	Синус от входного значения в радианах
7	COS(x)	ANY_REAL	Косинус от входного значения в радианах
8	TAN(x)	ANY_REAL	Тангенс от входного значения в радианах
9	ASIN(x)	ANY_REAL	Главное значение арксинуса
10	ACOS(x)	ANY_REAL	Главное значение арккосинуса
11	ATAN(x)	ANY_REAL	Главное значение арктангенса
12	ATAN2(yx)	ANY_REAL	Угол между положительным направлением оси x плоскости и точкой, заданной координатами (x, y). Значение угла является положительным для углов против часовой стрелки (верхняя полуплоскость, y > 0), и отрицательным для углов по часовой стрелке (нижняя полуплоскость, y < 0).

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

Таблица 29

Арифметические функции

Номер	Описание	Название	Символ (оператор)	Объяснение
	Графическая форма			Пример использования в языке
	(***) - Название или символ			как вызов функции: A:= ADD(B, C, D); или как оператор (символ) A:= B + C + D;
	Расширяемые арифметические функции
1 <c>	Сложение	ADD	+	OUT:= IN1 + IN2 +... + INn
2	Умножение	MUL	*	OUT:= IN1 * IN2 ... INn
	Нерасширяемые арифметические функции
3 <c>	Вычитание	SUB	-	OUT:= IN1 * IN2 ... INn
4 <d>	Деление	DIV	/	OUT:= IN1 / IN2
5 <e>	Остаток по модулю	MOD		OUT:= IN1 modulo IN2
6 <f>	Экспонента	EXPT	**	OUT:= IN1IN2
7 <g>	Пересылка	MOVE	:=	OUT:= IN
Примечание 1 - Непустые значения в графе "Символ" могут использоваться как операторы в текстовых языках. Примечание 2 - Запись IN1, IN2, ..., INn ссылается на входные переменные в нисходящем порядке; OUT ссылается на выходную переменную. Примечание 3 - Примеры использования и объявления даны на языке ST.
<a> Когда представление функции поддерживается именем, это отмечается суффиксом "n" в декларации соответствия. Например, "1n" представляет запись "ADD". <b> Когда представление функции поддерживается символом, это отмечается суффиксом "s" в декларации соответствия. Например, "1s" представляет запись "+". <c> Входные и выходные переменные для этих функций имеют тип ANY_MAGNITUDE. <d> Результатом деления целых чисел является целое число того же типа с усечением значения по направлению к нулю, например, 7/3 = 2 и (-7)/3 = -2. <e> Для этой функции, IN1 и IN2 имеют родовой тип ANY_INT. Результат выполнения этой функции MOD эквивалентен вычислению следующих операторов языка ST: IF (IN2 = 0) THEN OUT:=0; ELSE OUT:=IN1 - (IN1/IN2)*IN2; END_IF <f> Для функции EXPT, IN1 имеет тип ANY_REAL, a IN2 - тип ANY_NUM. Тип выходной переменной - такой же, как тип переменной IN1. <g> Функция MOVE имеет ровно одну входную переменную (IN) типа ANY и одну входную переменную (OUT) типа ANY.

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

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

6.6.2.5.9 Битовые строки и поразрядные логические функции

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

Таблица 30

Функции битового сдвига

Номер	Описание	Название	Объяснение
	Графическая форма		Пример использования a
	(***) - Имя функции		A:= SHL(IN:=B, N:=5); (язык ST)
1	Сдвиг влево	SHL	OUT:= IN, сдвинутому влево на N бит, биты справа заполняются нулями
2	Сдвиг вправо	SHR	OUT:= IN, сдвинутому вправо на N бит, биты слева заполняются нулями
3	Циклический сдвиг влево	ROL	OUT:= IN, циклически сдвинутому влево на N бит
4	Циклический сдвиг вправо	ROR	OUT:= IN, циклически сдвинутому вправо на N бит
Примечание 1 - Запись OUT ссылается на результат функции. *Пример -* *IN:= 2#0001_1001 of type BYTE, N* = 3 *SHL(IN, 3)* = *2#1100_1000* *SHR(IN, 3)* = *2#0000_0011* *ROL(IN, 3)* = *2#1100_1000* *ROR(IN, 3)* = *2#0010_0011* Примечание 2 - IN типа BOOL (один бит) не имеет смысла.
<a> Если входная переменная N меньше нуля, возникает ошибка.

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

Таблица 31

Поразрядные логические функции

Номер	Описание	Название	Символ	Объяснение (см. примечание 3)
	Графическая форма (***) - Название или символ			Примеры использования (см. примечание 5) A:= AND(B, C, D); или A:= B & C & D;
1	И	AND	& (см. примечание 1)	OUT:= IN1 & IN2 &... & INn
2	Или	OR	> = 1 (см. примечание 2)	OUT:= IN1 OR IN2 OR... OR INn
3	Исключающее или	XOR	= 2k+1 (см. примечание 2)	OUT:= IN1 XOR IN2 XOR... XOR INn
4	Отрицание	NOT		OUT:= NOT IN1 (см. примечание 4)
Примечание 1 - Данный символ подходит для использования в качестве оператора в текстовых языках, как показано в таблицах 68 и 71. Примечание 2 - Данный символ не подходит для использования в качестве оператора в текстовых языках. Примечание 3 - Запись IN1, IN2, ..., INn ссылается на входные переменные в нисходящем порядке; OUT ссылается на выходную переменную. Примечание 4 - Графическое отрицание сигналов типа BOOL также может быть осуществлено. Примечание 5 - Примеры использования и объявления даны на языке ST.
<a> Когда представление функции поддерживается именем, это отмечается суффиксом "n" в декларации соответствия. Например, "1n" представляет запись "AND". <b> Когда представление функции поддерживается символом, это отмечается суффиксом "s" в декларации соответствия. Например, "1s" представляет запись "&".

6.6.2.5.10 Функции выбора и сравнения

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

Таблица 32

Функции выбора <d>

Номер	Описание	Имя	Графическая форма	Объяснение/Пример
1	Пересылка <a>, <d> (присваивание)	MOVE		OUT:= IN
2	Двоичный выбор <d>	SEL		OUT:= IN0 if G = 0 OUT:= IN1 if G = 1 *Пример 1 -* A:= *SEL (G:= 0, IN0:= X, IN1:= 5);*
3	Расширяемая функция максимума	MAX		OUT:= MAX(IN1, IN2, ..., INn); *Пример 2 -* A:= *MAX(B, C, D);*
4	Расширяемая функция минимума	MIN		OUT:= MIN (IN1, IN2,..., Nn) *Пример 3 -* A:= *MIN(B, C, D);*
5	Ограничитель	LIMIT		OUT:= MIN (MAX(IN, MN),MX); *Пример 4 -* A:= *LIMIT(IN:= B, MN:= 0, MX:= 5);*
6	Расширенный мультиплексор <b>, <c>, <d>, <e>	MUX		a, b, c: Выбирает одну из N входных переменных в зависимости от входной переменной K *Пример 5 -* A:= *MUX(0, B, C, D);* *имеет такой же эффект как* A:= B;
Примечание 1 - Запись IN1, IN2, ..., INn ссылается на входные переменные в нисходящем порядке; OUT ссылается на выходную переменную. Примечание 2 - Примеры использования и объявления даны на языке ST.
<a> Функция MOVE имеет ровно одну входную переменную IN типа ANY и одну входную переменную OUT типа ANY. <b> Неименованные входные переменные функции MUX имеют неявные имена IN0, IN1,..., INn-1 в нисходящем порядке, где n из общего числа входных переменных. Данные имена могут (но необязательно) быть показаны в графическом представлении. <c> Функция MUX может быть типизирована в форме MUX__, где - тип входной переменной K и ** - тип других входных переменных и выхода. <d> Разработчику разрешается (но необязательно) поддерживать выбор среди переменных определенных пользователем типов данных, чтобы подтвердить соответствие этому свойству. <e> Если фактическое значение входной переменной K функции MUX находится вне диапазона {0 ... n-1}, возникает ошибка.

Стандартное графическое представление, имена функций и символов и описания функций сравнения показываются в таблице 33. Все функции сравнения (за исключением функции NE) являются расширяемыми.

Таблица 33

Функции сравнения

Номер	Описание	Имя <a>	Символ <b>	Объяснение (расширяемая: 2 или большее число операндов)
	Графическая форма			Пример использования
	(***) Имя или символ			A:= GT(B, C, D); // Имя функции или A:= (B>C) & (C>D); // Символ
1	Убывающая последовательность	GT	>	OUT:= (IN1>IN2)& (IN2>IN3) &.. & (INn-1 > INn)
2	Монотонная последовательность	GE	>=	OUT:= (IN1>=IN2)&(IN2>=IN3)&.. & (INn-1 >= INn)
3	Equality	EQ	=	OUT:= (IN1=IN2)&(IN2=IN3) &.. & (INn-1 = INn)
4	Монотонная последовательность	LE	<=	OUT:= (IN1<=IN2)&(IN2<=IN3)&.. & (INn-1 <= INn)
5	Increasing sequence	LT	<	OUT:= (IN1<IN2)& (IN2<IN3) &.. & (INn-1 < INn)
6	Inequality	NE	<>	OUT:= (IN1<>IN2) (нерасширяемая)
Примечание 1 - Запись IN1, IN2, ..., INn ссылается на входные переменные в нисходящем порядке; OUT ссылается на выходную переменную. Примечание 2 - Все символы, показанные в данной таблице, могут использоваться как операторы в текстовых языках. Примечание 3 - Примеры использования и объявления даны на языке ST. Примечание 4 - Стандартные функции сравнения могут также определяться зависящими от языка, например, на языке релейно-контактных схем.
<a> Когда представление функции поддерживается именем, это отмечается суффиксом "n" в декларации соответствия. Например, "1n" представляет запись "GT". <b> Когда представление функции поддерживается символом, это отмечается суффиксом "s" в декларации соответствия. Например, "1s" представляет запись ">".

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

К строкам символов применяется таблица 33. Вместо однобайтовой строки может использоваться переменная типа CHAR или WCHAR, соответственно.

При сравнении двух строк разной длины более короткая строка рассматривается расширенной справа символами с нулевым значением до длины более длинной строки. Сравнение осуществляется слева направо на базе числовых значений кодов символа в наборе символов.

Пример - Строка символов 'Z' больше строки символов 'AZ' ('Z' > 'A') и строка символов 'AZ' больше чем строка 'ABC' ('A' = 'A' и 'Z' > 'B').

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

Ошибка возникает, если:

- фактическое значение какой-либо входной переменной типа ANY_INT в таблице 34 меньше нуля;

- вычисление функции приводит к попытке (1) получить доступ к несуществующей позиции в строке, или (2) получить строку длиннее определенной разработчиком максимальной длины строки;

- аргументы типа данных STRING или CHAR и аргументы типа данных WSTRING или WCHAR смешаны в одной функции.

Таблица 34

Строковые функции

Номер	Описание	Графическая форма	Пример
1	Длина строки		Длина строки A:= LEN('ASTRING'); ... эквивалентно A:= 7;
2	Левая подстрока		L самых левых символов из IN A:= LEFT(IN:='ASTR', L:=3); эквивалентно A:= 'AST';
3	Правая подстрока		L самых правых символов из IN A:= LEFT(IN:='ASTR', L:=3); эквивалентно A:= 'STR';
4	Средняя подстрока		L символов из IN, начиная с P-й позиции символа A:= MID(IN:='ASTR', L:=2, P:=2); эквивалентно A:= 'ST';
5	Расширяемая конкатенация		Расширяемая конкатенация A:= CONCAT('AB','CD','E'); эквивалентно A:= 'ABCDE';
6	Вставить		Вставить строку IN2 в строку IN1 после P-й позиции символа A:= INSERT(IN1:='ABC', IN2:='XY', P=2); эквивалентно A:= 'ABXYC';
7	Удалить		Удалить L символов из строки IN, начиная с P-й позиции символа A:= DELETE(IN:='ABXYC', L:=2, P:=3); эквивалентно A:= 'ABC';
8	Заменить		Заменить L символов строки IN1 строкой IN2, начиная в P-й позиции символа A:= REPLACE(IN1:='ABCDE', IN2:='X', L:=2, P:=3); эквивалентно A:= 'ABXE';
9	Найти		Найти позицию символа в начала первого вхождения строки IN2 в строку IN1. Если вхождения строки IN2 не обнаружены, то OUT:= 0. A:= FIND(IN1:='ABCBC', IN2:='BC'); ... эквивалентно A:= 2;
Примечание 1 - Примеры в этой таблице даются на языке ST. Примечание 2 - Все входные переменные функции CONCAT имеют тип ANY_CHARS, то есть могут быть также типа CHAR или типа WCHAR. Примечание 3 - Входная переменная IN2 функций INSERT, REPLACE, FIND имеет тип ANY_CHARS, то есть может также иметь тип CHAR или WCHAR.

6.6.2.5.11 Функции даты и продолжительности времени

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

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

Таблица 35

Числовые функции типов данных времени и продолжительности

времени

Номер	Описание (имя функции)	Символ	IN1	IN2	OUT
1a	ADD	+	TIME, LTIME	TIME, LTIME	TIME, LTIME
1b	ADD_TIME	+	TIME	TIME	TIME
1c	ADD_LTIME	+	LTIME	LTIME	LTIME
2a	ADD	+	TOD, LTOD	LTIME	TOD, LTOD
2b	ADD_TOD_TIME	+	TOD	TIME	TOD
2c	ADD_LTOD_LTIME	+	LTOD	LTIME	LTOD
3a	ADD	+	DT, LDT	TIME, LTIME	DT, LDT
3b	ADD_DT_TIME	+	DT	TIME	DT
3c	ADD_LDT_LTIME	+	LDT	LTIME	LDT
4a	SUB	-	TIME, LTIME	TIME, LTIME	TIME, LTIME
4b	SUB_TIME	-	TIME	TIME	TIME
4c	SUB_LTIME	-	LTIME	LTIME	LTIME
5a	SUB	-	DATE	DATE	TIME
5b	SUB_DATE_DATE	-	DATE	DATE	TIME
5c	SUB_LDATE_LDATE	-	LDATE	LDATE	LTIME
6a	SUB	-	TOD, LTOD	TIME, LTIME	TOD, LTOD
6b	SUB_TOD_TIME	-	TOD	TIME	TOD
6c	SUB_LTOD_LTIME	-	LTOD	LTIME	LTOD
7a	SUB	-	TOD, LTOD	TOD, LTOD	TIME, LTIME
7b	SUB_TOD_TOD	-	TOD	TOD	TIME
7c	SUB_TOD_TOD	-	LTOD	LTOD	LTIME
8a	SUB	-	DT, LDT	TIME, LTIME	DT, LDT
8b	SUB_DT_TIME	-	DT	TIME	DT
8c	SUB_LDT_LTIME	-	LDT	LTIME	LDT
9a	SUB	-	DT, LDT	DT, LDT	TIME, LTIME
9b	SUB_DT_DT	-	DT	DT	TIME
9c	SUB_LDT_LDT	-	LDT	LDT	LTIME
10a	MUL	*	TIME, LTIME	ANY_NUM	TIME, LTIME
10b	MUL_TIME	*	TIME	ANY_NUM	TIME
10c	MUL_LTIME	*	LTIME	ANY_NUM	LTIME
11a	DIV	/	TIME, LTIME	ANY_NUM	TIME, LTIME
11b	DIV_TIME	/	TIME	ANY_NUM	TIME
11c	DIV_LTIME	/	LTIME	ANY_NUM	LTIME
Примечание - Данные стандартные функции поддерживают перегрузку, но только в пределах обоих наборов типов данных (TIME, DT, DATE, TOD) и (LTIME, LDT, DATE, LTOD).

Пример -

Операторы языка ST

X:= DT#1986-04-28-08:40:00;

Y:= DT_TO_TOD(X);

W:= DT_TO_DATE(X);

имеют такой же результат, как и операторы с "извлеченными" данными.

X:= DT#1986-04-28-08:40:00;

Y:= TIME_OF_DAY#08:40:00;

W:= DATE#1986-04-28;

Функции конкатенации и расщепления данных, показанные в таблице 36, определены и для обработки данных даты и времени. Дополнительно определена функция получения дня недели.

Таблица 36

Дополнительные CONCAT и SPLIT функции для типов данных даты

и времени

Номер	Описание	Графическая форма	Пример
	Конкатенация типов данных даты и времени
1a	CONCAT_DATE_TOD		Соединить дату и время VAR myD: DATE; END_VAR myD:= CONCAT_DATE_TOD (D#2010-03-12, TOD#12:30:00);
1b	CONCAT_DATE_LTOD		Соединить дату и время суток VAR myD: DATE; END_VAR myD:= CONCAT_DATE_LTOD (D#2010-03-12, TOD#12:30:12.1223452);
2	CONCAT_DATE		Соединить дату и время суток VAR myD: DATE; END_VAR myD:= CONCAT_DATE (2010,3,12);
3a	CONCAT_TOD		Соединить время суток VAR myTOD: TOD; END_VAR myTD:= CONCAT_TOD (16,33,12,0);
3b	CONCAT_LTOD		Соединить время суток VAR myTOD: LTOD; END_VAR myTD:= CONCAT_TOD (16,33,12,0);
4a	CONCAT_DT		Соединить время суток VAR myDT: DT; Day: USINT; END_VAR Day:= 17; myDT:= CONCAT_DT (2010,3,Day,12,33,12,0);
4b	CONCAT_LDT		Соединить время суток VAR myDT: LDT; Day: USINT; END_VAR Day := 17; myDT:= CONCAT_LDT (2010,3,Day,12,33,12,0);
	Расщепление типов даты и времени
5	SPLIT_DATE	См. примечание 2	Расщепить дату VAR myD: DATE:= DATE#2010-03-10; myYear: UINT; myMonth, myDay: USINT; END_VAR SPLIT_DATE (myD, myYear, myMonth, myDay);
6a	SPLIT_TOD	См. примечание 2	Расщепить время суток VAR myTOD: TOD:= TOD#14:12:03; myHour, myMin, mySec: USINT; myMilliSec: UINT; END_VAR SPLIT_TOD(myTOD, myHour, myMin, mySec, myMilliSec);
6b	SPLIT_LTOD	См. примечание 2	Расщепить время суток VAR myTOD: LTOD:=TOD#14:12:03; myHour, myMin, mySec: USINT; myMilliSec: UINT; END_VAR SPLIT_TOD(myTOD, myHour, myMin, mySec, myMilliSec);
7a	SPLIT_DT	См. примечание 2	Расщепить дату VAR myDT: DT := DT#2010-03-10-14:12:03:00; myYear, myMilliSec: UINT; myMonth, myDay, myHour, myMin, mySec: USINT; END_VAR SPLIT_DT(myDT, myYear, myMonth, myDay, myHour, myMin, mySec, myMilliSec);
7b	SPLIT_LDT	См. примечание 2	Расщепить дату VAR myDT: LDT := DT#2010-03-10-14:12:03:00; myYear, myMilliSec: UINT; UINT; myMonth, myDay, myHour, myMin, mySec: USINT; END_VAR SPLIT_DT(myDT, myYear, myMonth, myDay, myHour, myMin, mySec, myMilliSec);
	Получить день недели
8	DAY_OF_WEEK	См. примечание 2	Получить день недели: VAR myD: DATE:= DATE#2010-03-10; myDoW: USINT; END_VAR myDoW: = DAY_OF_WEEK(myD);
8	Функция DAY_OF_WEEK возвращает 0 для воскресенья, 1 для понедельника, ..., 6 для субботы
Примечание 1 - Тип данных входной переменной YEAR должен быть, по меньшей мере, 16-битовым типом для поддержки допустимого значения года. Примечание 2 - Типы данных для типов данных выходных переменных ANY_INT определяет разработчик. Примечание 3 - Разработчик может определять дополнительные входные и выходные переменные в соответствии с поддерживаемой точностью, например, микросекунды и наносекунды.

6.6.2.5.12 Функции преобразования порядка следования байтов

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

Порядок следования байтов определяет упорядочение байтов в длинных типах данных и переменных.

Значения данных в порядке big endian (от старшего к младшему) помещаются в байтах памяти, начиная с левого байта и оканчивая правым.

Значения данных в порядке little endian (от младшего к старшему) помещаются в байтах памяти, начиная с правого байта и оканчивая левым.

Независимо от порядка следования байтов, битовое смещение 0 адресует самый правый бит типа данных.

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

Пример 1 - Порядок следования байтов

TYPE D: DWORD:= 16#1234_5678; END_TYPE;

Расположение в памяти

для порядка big endian: 16#12, 16#34, 16#56, 16#78

для порядка little endian: 16#78, 16#56, 16#34, 16#12.

Пример 2 - Порядок следования байтов

TYPE L: ULINT:= 16#1234_5678_9ABC_DEF0; END_TYPE;

Расположение в памяти

для порядка big endian: 16#12, 16#34, 16#56, 16#78, 16#9A, 16#BC, 16#DE, 16#F0

для порядка little endian: 16#F0, 16#DE, 16#BC, 16#9A, 16#78, 16#56, 16#34, 16#12

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

- ANY_INT с размером больше или равным 16 бит.

- ANY_BIT с размером больше или равным 16 бит.

- ANY_REAL;

- WCHAR;

- TIME;

- массивы этих типов данных;

- структуры, содержащие компоненты этих типов данных.

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

Таблица 37

Функции преобразования порядка следования байтов

Номер	Описание	Графическая форма	Текстовая форма
1	TO_BIG_ENDIAN		Преобразование в формат данных big endian A:= TO_BIG_ENDIAN(B);
2	TO_LITTLE_ENDIAN		Преобразование в формат данных little endian B:= TO_LITTLE_ENDIAN(A);
3	BIG_ENDIAN_TO		Преобразование из формата данных big endian A:= FROM_BIG_ENDIAN(B);
4	LITTLE_ENDIAN_TO		Преобразование из формата данных little endian A:= FROM_LITTLE_ENDIAN(B);
Типы данных на входной и выходной стороне должны иметь одинаковый тип данных. Примечание - В случае, если переменная уже находится в требуемом формате, функция не изменяет представления данных.

6.6.2.5.13 Функции перечислимых типов данных

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

Таблица 38

Функции перечислимых типов данных

Номер	Описание/имя функции	Символ	Номер свойства "x" в таблице "y"
1	SEL		Свойство 2, таблица 32
2	MUX		Свойство 6, таблица 32
3 <a>	EQ	=	Свойство 3, таблица 33
4 <a>	NE	<>	Свойство 6, таблица 33
Примечание - К данной таблице применяются положения примечаний 1 и 2 таблицы 33.
Примечание - К данной таблице применяются положения подстрочных примечаний <a> и <b> таблицы 33.

6.6.2.5.14 Функции подтверждения

Функции подтверждения проверяют, содержит ли заданный входной параметр допустимое значение.

Для типов данных REAL и LREAL определена перегруженная функция IS_VALID. Функции подтверждения возвращает результат FALSE, если действительное число не является числом (NaN) или равно бесконечности (+Inf, -Inf).

Разработчик может поддерживать дополнительные типы данных посредством функции подтверждения IS_VALID. Результат таких расширений определяется разработчиком.

Перегруженная функция IS_VALID_BCD определена для типов данных BYTE, WORD, DWORD и LWORD. Функции подтверждения возвращает результат FALSE, если значение не удовлетворяет определению BCD.

Перечень свойств функций подтверждения приведен в таблице 39.

Таблица 39

Функции подтверждения

Номер

Функция

Графическая форма

Пример

IS_VALID

Подтверждение значения типа REAL

VAR R: REAL; END_VAR

IF IS_VALID(R) THEN ...

IS_VALID_BCD

Тест подтверждения слова BCD

VAR W: WORD; END_VAR

IF IS_VALID_BCD(W) THEN ...

6.6.3 Функциональные блоки

6.6.3.1 Общие положения

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

Концепция функционального блока реализуется типом функционального блока и экземпляром функционального блока:

- тип функционального блока состоит из следующих частей:

- определение структуры данных, разделенной на входные, выходные и

внутренние переменные;

- набор операций, выполняемых с элементами структуры данных при

вызове экземпляра типа функционального блока;

- экземпляр функционального блока:

- это многократное, именованное применение (экземпляры) типа

функционального блока;

- каждый экземпляр имеет связанный идентификатор (имя экземпляра),

и структуру данных, содержащую статические входные, выходные и внутренние

переменные.

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

Если не оговорено иное, к функциональным блокам применяются общие свойства программных компонентов;

- объектно-ориентированный функциональный блок.

Функциональный блок может быть расширен набором объектно-ориентированных свойств.

Объектно-ориентированный функциональный блок является также расширенным множеством классов.

6.6.3.2 Объявление типа функционального блока

Тип функционального блока объявляется таким же образом, как и функции.

Свойства объявления типа функционального блока определены в таблице 40:

1) ключевое слово FUNCTION_BLOCK, за которым следует имя объявляемого функционального блока;

2) множество операций, составляющее тело функционального блока;

3) завершающее ключевое слово END_FUNCTION_BLOCK после тела функционального блока;

4) конструкции VAR_INPUT, VAR_OUTPUT и VAR_IN_OUT, при необходимости, определяющие имена и типы переменных;

5) значения переменных, которые объявляются через конструкцию VAR_EXTERNAL, могут изменяться из функционального блока;

6) значения констант, которые объявляются через конструкцию VAR_EXTERNAL CONSTANT и не могут изменяться из функционального блока;

7) массивы переменной длины могут использоваться как VAR_IN_OUT;

8) выходные и статические переменные могут инициализироваться;

9) переменные EN и ENO объявляются так же, как и входные и выходные переменные. Имеются специфические свойства функциональных блоков (отличные от свойств функций);

10) конструкция VAR...END_VAR и также конструкция VAR_TEMP...END_VAR, при необходимости, определяющие имена и типы внутренних переменных функциональных блоков. В отличие от функций, переменные, объявленные в секции VAR, являются статическими;

11) переменные секции VAR (статические) могут быть объявлены как PUBLIC или PRIVATE. По умолчанию используется спецификатор доступ PRIVATE. Переменные PUBLIC могут использоваться вне функционального блока, используя такой же синтаксис, как при доступе к выходным переменным функционального блока;

12) для входных, выходных и внутренних переменных функционального блока могут использоваться квалификаторы RETAIN или NON_RETAIN, как показано в таблице 40;

13) в текстовых объявлениях квалификаторы R_EDGE и F_EDGE используются для обозначения функции детектирования фронта сигнала логических входных переменных. Это приводит к неявному объявлению в данном функциональном блоке функционального блока типа R_TRIG или F_TRIG, соответственно, для выполнения обнаружения требуемого фронта. Пример такой конструкции приведен в таблице 40;

14) в графических объявлениях для детектирования задних и передних фронтов сигнала применяется конструкция, показанная в таблице. При использовании набора символов в графических объявлениях, символы ">" и "<" показываются на границе функционального блока;

15) в объявлении внутренних переменных функционального блока может использоваться символ "*", как определено в таблице 16;

16) если в объявлениях типов стандартных входных и выходных переменных функционального блока используются родовые типы данных, то правила определения фактических типов выходных параметров таких типов функциональных блоков являются частью определения типа функционального блока;

17) экземпляры других функциональных блоков, классов, объектно-ориентированных функциональных блоков могут объявляться во всех секциях переменных, за исключением секции VAR_TEMP;

18) экземпляр функционального блока, объявленный внутри типа функционального блока, не должен иметь, во избежание неопределенностей, такое же имя, как функция из той же области имен.

Таблица 40

Объявление типа функционального блока

Номер	Описание	Пример
1	Объявление типа функционального блока FUNCTION_BLOCK ... END_FUNCTION_BLOCK	FUNCTION_BLOCK myFB ... END_FUNCTION_BLOCK
2a	Объявление входных переменных VAR_INPUT ...END_VAR	VAR_INPUT IN: BOOL; T1: TIME; END_VAR
2b	Объявление входных переменных VAR_OUTPUT ... END_VAR	VAR_OUTPUT OUT: BOOL; ET_OFF: TIME; END_VAR
2c	Объявление входных-выходных переменных VAR_IN_OUT ... END_VAR	VAR_IN_OUT A: INT; END_VAR
2d	Объявление временных переменных VAR_TEMP ... END_VAR	VAR_TEMP I: INT; END_VAR2e
	Объявление статических переменных VAR ... END_VAR	VAR B: REAL; END_VAR
2f	Объявление внешних переменных VAR_EXTERNAL ... END_VAR	VAR_EXTERNAL B: REAL; END_VAR Соответствует следующему: VAR_GLOBAL B: REAL
2g	Объявление внешних переменных VAR_EXTERNAL CONSTANT ... END_VAR	VAR_EXTERNAL CONSTANT B: REAL; END_VAR Соответствует следующему: VAR_GLOBAL B: REAL
3a	Инициализация входных параметров	VAR_INPUT MN: INT:= 0;
3b	Инициализация выходных параметров	VAR_OUTPUT RES: INT:= 1;
3c	Инициализация статических переменных	VAR B: REAL:= 12.1;
3d	Инициализация временных переменных	VAR_TEMP I: INT:= 1;
-	Входной параметр EN и выходной параметр ENO	Определено в таблице 18
4a	Объявление квалификатора RETAIN для входных переменных	VAR_INPUT RETAIN X: REAL; END_VAR
4b	Объявление квалификатора RETAIN для выходных переменных	REAL; END_VAR
4c	Объявление квалификатора RETAIN для выходных переменных	VAR_INPUT NON_RETAIN X: REAL; END_VAR
4d	Объявление квалификатора NON_RETAIN для выходных переменных	VAR_OUTPUT NON_RETAIN X: REAL; END_VAR
4e	Объявление квалификатора NON_RETAIN для статических переменных	VAR RETAIN X: REAL; END_VAR
4f	Объявление квалификатора NON_RETAIN для статических переменных	VAR NON_RETAIN X: REAL; END_VAR
5a	Объявление квалификатора RETAIN для локальных экземпляров функционального блока	VAR RETAIN TMR1: TON; END_VAR
5b	Объявление квалификатора NON_RETAIN для локальных экземпляров функционального блока	VAR NON_RETAIN TMR1: TON; END_VAR
6a	Текстовое объявление: - входных переменных переднего фронта	FUNCTION_BLOCK AND_EDGE VAR_INPUT X: BOOL R_EDGE; Y: BOOL F_EDGE; END_VAR VAR_OUTPUT Z: BOOL; END_VAR Z:= X AND Y; (пример на языке ST ) END_FUNCTION_BLOCK
6b	- входных переменных заднего фронта (текстовое)	См. выше
7a	Графическое объявление:
	- входных переменных переднего фронта (>)	FUNCTION_BLOCK (* Внешний интерфейс *)
		(* тело функционального блока *)
		END_FUNCTION_BLOCK
7b	Графическое объявление: - входных переменных заднего фронта (<)	См. выше
Примечание - Свойства 1 - 3 этой таблицы эквивалентны функциям, см. таблицу 19.

Ниже приведены примеры объявления типа FB.

Пример 1 - Объявление типа функционального блока

FUNCTION_BLOCK DEBOUNCE

(*** Внешний интерфейс ***)

VAR_INPUT

IN: BOOL; (* Неявно = 0 *)

DB_TIME: TIME:= t#10ms; (* Неявно = t#10ms *)

END_VAR

VAR_OUTPUT

OUT: BOOL; (* Неявно = 0 *)

ET_OFF: TIME; (* Неявно = t#0s *)

END_VAR

VAR DB_ON: TON; (** Внутренние переменные **)

DB_OFF: TON; (**и экземпляры FB **)

DB_FF: SR;

END_VAR

(*** Тело функционального блока ***)

DB_ON (IN:= IN, PT:= DB_TIME);

DB_OFF(IN:= NOT IN, PT:= DB_TIME);

DB_FF (S1:= DB_ON.Q, R:= DB_OFF.Q);

OUT:= DB_FF.Q1;

ET_OFF:= DB_OFF.ET;

END_FUNCTION_BLOCK

a) Текстовое объявление (язык ST)

FUNCTION_BLOCK

(* Интерфейс внешних параметров *)

(* Тело типа функционального блока *)

END_FUNCTION_BLOCK

b) Графическое объявление (язык FBD)

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

Пример 2 -

FUNCTION_BLOCK ACCUM

VAR_IN_OUT A: INT; END_VAR

VAR_INPUT X: INT; END_VAR

A:=A+X;

END_FUNCTION_BLOCK

a) Графическое и текстовое объявление типа функционального блока и функции

VAR

ACC: INT;

X1: INT;

X2: INT;

END_VAR

Это объявление предположительное:

эффект выполнения:

ACC:= ACC+X1*X2;

b) Допустимое использование экземпляра функционального блока и функции

Объявления как в примере b) предполагаются для

ACC, X1, X2, X3 и X4;

эффект выполнения следующий:

ACC:= ACC+X1*X2+X3*X4;

c) Допустимое использование экземпляра функционального блока

VAR

X1: INT;

X2: INT;

X3: INT;

X4: INT;

END_VAR

Объявление предположительное:

эффект выполнения:

X3:= X3+X1*X2;

X4:= X3;

d) Допустимое использование экземпляра функционального блока

НЕДОПУСТИМО!

Соединение к входной-выходной переменной A не является переменной или именем функционального блока (см. предыдущий текст)

e) Неразрешенное использование экземпляра FB

Следующий пример показывает функциональный блок AND_EDGE, используемый в таблице 40.

Пример 3 - Объявление типа функционального блока AND_EDGE

Объявление функционального блока AND_EDGE на примере выше в таблице 40 эквивалентно следующему объявлению:

FUNCTION_BLOCK AND_EDGE

VAR_INPUT

X: BOOL;

Y: BOOL;

END_VAR

VAR

X_TRIG: R_TRIG;

Y_TRIG: F_TRIG;

END_VAR VAR_

OUTPUT

Z: BOOL;

END_VAR

X_TRIG(CLK:= X);

Y_TRIG(CLK:= Y);

Z:= X_TRIG.Q AND Y_TRIG.Q;

END_FUNCTION_BLOCK

Определение функциональных блоков обнаружения фронта R_TRIG и F_TRIG см. в таблице 44.

6.6.3.3 Объявление экземпляра функционального блока

Экземпляр функционального блока объявляется таким же образом, как и описанные структурные переменные.

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

Таблица 41

Объявление экземпляра функционального блока

Номер

Описание

Пример

Объявление экземпляра функционального блока

VAR

FB_instance_1, FB_instance_2: my FB_Type;

T1, T2, T3: TON;

END_VAR

Объявление экземпляра FB с инициализацией его переменных

VAR

TempLoop: PID:=(PropBand:= 2.5,

Integral:= T#5s);

END_VAR

Распределяет начальные значения входным и выходным переменным экземпляра функционального блока

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

6.6.3.4 Вызов функционального блока

6.6.3.4.1 Общие положения

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

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

1) текстуальный вызов функционального блока состоит из имени экземпляра с последующим перечнем параметров;

2) в графическом представлении имя экземпляра функционального блока располагается над блоком;

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

a) немедленно во время вызова функционального блока (типовой способ); или

b) отдельно от вызова. Такие отдельные присваивания становятся эффективными во время следующего вызова функционального блока;

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

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

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

4) Если экземпляр функционального блока вызывается с входным параметром EN=0, разработчик определяет установлены ли в экземпляре входные и входные-выходные переменные.

5) Имя экземпляра функционального блока может использоваться в качестве входного параметра экземпляра функционального блока, если оно объявлено как входная переменная в секции VAR_INPUT или как входная-выходная переменная экземпляра функционального блока в секции VAR_IN_OUT.

6) Выходные значения экземпляра другого функционального блока, чье имя передается в функциональный блок через конструкцию VAR_INPUT, VAR_IN_OUT или VAR_EXTERNAL могут использоваться для доступа, но не могут изменяться из функционального блока.

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

8) Через конструкцию VAR_IN_OUT в функциональный блок могут передаваться только переменные или имена экземпляров функциональных блоков.

Это делается для предотвращения непреднамеренных изменений таких выходных переменных. Тем не менее, "каскадное" использование конструкций VAR_IN_OUT разрешено.

Свойства вызова функционального блока приведены в следующей таблице 42.

Таблица 42

Вызов функционального блока

Номер	Описание	Пример
1	Полный формальный вызов (только текстовый) Используется, если указание параметров EN и ENO в вызове является обязательным	YourCTU( EN:= not B, CU:= r, PV:= c1, ENO=> next, Q => out, CV => c2);
2	Неполный формальный вызов (только текстовый)	YourCTU (Q => out, CV => c2); Переменные EN, CU, PV будут иметь значение последнего вызов или начальное значение, если FB не вызывался раньше
3	Графический вызов
4	Графический вызов с отрицаниями логических входных и выходных переменных	Использование этих конструкций запрещено для входных-выходных переменных
5a	Графический вызов с использованием конструкции VAR_IN_OUT
5b	Графический вызов с присваиванием переменной из конструкции VAR_IN_OUT
6a	Текстовый вызов с отдельным присваиванием входной переменной FB_Instance.Input:= x;	YourTon.IN:= r; YourTon.PT:= t; YourTon(not Q => out);
6b	Графический вызов с отдельным присваиванием входной переменной
7	Чтение выходной переменной после вызова FB (текстовая форма) x:= FB_Instance.Output;	-
8a	Выходная переменная, присвоенная в вызове FB (текстовая форма)	-
8b	Выходная переменная, присвоенная в вызове FB с отрицанием (текстовая форма)	-
9a	Текстовый вызов с именем экземпляра функционального блока как входной переменной	VAR_INPUT I_TMR: TON; END_VAR EXPIRED:= I_TMR.Q; В данном и следующих примерах предполагается, что переменные EXPIRED и A_VAR были объявлены с типом BOOL
9b	Графический вызов с именем экземпляра функционального блока как входной переменной	См. a)
10a	Текстовый вызов с именем экземпляра функционального блока как переменной из VAR_IN_OUT	VAR_IN_OUT IO_TMR: TOF; END_VAR IO_TMR (IN:=A_VAR, PT:= T#10S); EXPIRED:= IO_TMR.Q;
10b	Графический вызов с именем экземпляра функционального блока как переменной из VAR_IN_OUT	-
11a	Текстовый вызов с именем экземпляра функционального блока как внешней переменной	VAR_EXTERNAL EX_TMR: TOF; END_VAR EX_TMR(IN:= A_VAR, PT:= T#10S); EXPIRED:= EX_TMR.Q;
11b	Графический вызов с именем экземпляра функционального блока как внешней переменной	-

Пример - Вызов функционального блока с

YourCTU (EN:= not b,

CU:= r,

PV:= c,

not Q => out);

a) Вызов FB с немедленным присваиванием входных переменных (типичное использование)

YourCTU.CU:= r;

YourCTU.PV:= V;

YourCTU(not Q => out);

b) Вызов FB с отдельным присваиванием входной переменной

VAR a, b, r, out: BOOL;

YourCTU: CTU; END_VAR

YourCTU (EN:= NOT (a <> b),

CU:= r,

NOT Q => out);

c) Вызов FB с немедленным доступом к выходной переменной (типовое использование)

В вызове также разрешено использование отрицания

VAR FF75: SR; END_VAR (* Объявление *) FF75(S1:=

bIn1, (* вызов *)

R:= bIn2);

bOut3:= FF75.Q1;

d) Вызов FB с текстовым отдельным присваиванием выходной переменной (после вызова)

VAR

TONs: array [0..100] OF TON;

i: INT;

END_VAR

TON[12](IN:= bIn1, PT:= T#10ms);

TON[i](IN:= bIn1, PT:= T#20ms);

e) Вызов FB, используя массив экземпляров

TYPE

Cooler: STRUCT

Temp:Temp: INT;

Cooling: TOF;

END_STRUCT;

END_TYPE

VAR

myCooler: Cooler;

END_VAR

myCooler.Cooling(IN:= bIn1, PT:= T#30s);

f) Вызов FB с использованием экземпляра как элемента структуры

6.6.3.4.2 Использование входных и выходных параметров

На рисунках 13 и 14 приведена сводка правил использования входных и выходных параметров функционального блока в контексте вызова этого функционального блока. Присваивание входных и входных-выходных параметров становится эффективным при следующем вызове FB.

FUNCTION_BLOCK FB_TYPE;
VAR_INPUT In:		REAL; END_VAR
VAR_OUTPUT Out:		REAL; END_VAR
VAR_IN_OUT In_out:		REAL; END_VAR
VAR M:		REAL; END_VAR
END_FUNCTION-BLOCK VAR FB_INST: FB_TYPE; A, B, C: REAL; END_VAR
Использование	a) Внутри функционального блока		b) Outside function block
1 Чтение входной переменной	M:= In;		Не разрешено (см. примечания 1 и 2)
2 Присваивание входной переменной	Не разрешено (см. примечание 1)		// Вызов с немедленным присваиванием параметра FB_INST(In:= A); // Отдельное присваивание (см. примечание 4) FB_INST.In:= A;
3 Чтение выходной переменной	M:= Out;		// Вызов с немедленным присваиванием параметра FB_INST(Out => B); // Отдельное присваивание B:= FB_INST.Out;
4 Присваивание выходной переменной	Out:= M;		Не разрешено (см. примечание 1)
5 Чтение входной-выходной переменной	M:= In_out;		Не разрешено Не разрешено
6 Присваивание входной-выходной переменной	In_out:= M; (см. примечание 3)		// Вызов с немедленным присваиванием параметра Не разрешено
Примечание 1 - Использования, перечисленные в данной таблице с пометкой "Не разрешено", могут приводить к непредсказуемым побочным эффектам, определяемым разработчиком. Примечание 2 - Чтение и запись (присваивание) входных и выходных параметров и внутренних переменных функционального блока могут выполняться "функцией взаимодействия", "функцией интерфейса оператора" или "функциями программирования, тестирования и мониторинга", определенными в МЭК 61131-1. Примечание 3 - Изменение в функциональном блоке переменной, объявленной в секции VAR_IN_OUT, разрешено.

Рисунок 13 - Использование входных и выходных параметров

функционального блока (правила)

Использование входных и выходных параметров, определенных правилами на рисунке 13, иллюстрируется на рисунке 14.

Разрешено!

Не разрешено!

Метки 1a, 1b,... соответствуют правилам из рисунка 13.

Рисунок 14 - Использование входных и выходных параметров

функционального блока (иллюстрация правил)

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

Примеры - Графическое использование имен функциональных блоков в качестве параметров и внешних переменных.

FUNCTION_BLOCK

(* Внешний интерфейс *)

(* Тело функционального блока *)

END_FUNCTION_BLOCK

FUNCTION_BLOCK

(* Внешний интерфейс *)

(* Тело функционального блока *)

END_FUNCTION_BLOCK

a) Имя функционального блока как входная переменная (см. примечание)

FUNCTION_BLOCK

(* Внешний интерфейс *)

(* Тело функционального блока *)

END_FUNCTION_BLOCK

FUNCTION_BLOCK

(* Внешний интерфейс *)

(* Тело функционального блока *)

END_FUNCTION_BLOCK

b) Имя функционального блока как входная-выходная переменная

FUNCTION_BLOCK

(* Внешний интерфейс *)

VAR_EXTERNAL X_TMR: TON; END_VAR

(* Тело функционального блока *)

END_FUNCTION_BLOCK

PROGRAM

(* Внешний интерфейс *)

VAR_GLOBAL X_TMR: TON; END_VAR

(* Тело программы *)

END_PROGRAM

c) Имя функционального блока как внешняя переменная

Примечание - I_TMR здесь не представлена графически, так как это будет предполагать вызов I_TMR внутри INSIDE_A, что запрещено правилами 3) и 4) на рисунке 13.

6.6.3.5 Стандартные функциональные блоки

6.6.3.5.1 Общие положения

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

Там, где в данном разделе показываются стандартные функциональные блоки, могут быть также написаны эквивалентные текстовые объявления, как для примера в таблице 44.

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

6.6.3.5.2 Бистабильные элементы

Графическая форма и тело функционального блока стандартных бистабильных элементов показаны в таблице 43.

Таблица 43

Стандартные функциональные блоки с двумя устойчивыми

состояниями <a>

Номер	Описание/графическая форма	Тело функционального блока
1a	Бистабильный функциональный блок (доминанта включения): SR (S1, R, Q1)

1b	Бистабильный функциональный блок (доминанта включения) с длинными именами входных параметров: SR (SET1, RESET, Q1)

2a	Бистабильный функциональный блока (доминанта выключения): RS (S, R1, Q1)

2b	Бистабильный функциональный блок (доминанта выключения) с длинными именами входных параметров: RS (SET, RESET1, Q1)

<a> Начальным состоянием выходной переменной Q1 является нормальное неявное значение 0 для логических переменных.

6.6.3.5.3 Определение фронта (R_TRIG и F_TRIG)

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

1 Выходная переменная Q функционального блока R_TRIG остается в значении BOOL#1 от одного вычисления вычислениями функционального блока до другого, отслеживая переход 0 к 1 входной переменной CLK, и возвращается в 0 при следующем выполнении.

Выходная переменная Q функционального блока F_TRIG остается в значении BOOL#1 от одного вычисления вычислениями функционального блока до другого, отслеживая переход 1 к 0 входной переменной CLK, и возвращается в 0 при следующем выполнении.

Таблица 44

Стандартный функциональный блок обнаружения фронта

Номер	Описание/графическая форма	Определение (на языке ST)
1	Детектор переднего фронта: R_TRIG(CLK, Q)
		FUNCTION_BLOCK R_TRIG VAR_INPUT CLK: BOOL; END_VAR VAR_OUTPUT Q: BOOL; END_VAR VAR M: BOOL; END_VAR Q:= CLK AND NOT M; M:= CLK; END_FUNCTION_BLOCK
2	Детектор заднего фронта: F_TRIG(CLK, Q)
		FUNCTION_BLOCK F_TRIG VAR_INPUT CLK: BOOL; END_VAR VAR_OUTPUT Q: BOOL; END_VAR VAR M: BOOL; END_VAR Q:= NOT CLK AND NOT M; M:= NOT CLK; END_FUNCTION_BLOCK
Примечание - Когда входная переменная CLK экземпляра типа R_TRIG соединяется со значением BOOL#1, его выходная переменная Q сохраняет значение BOOL#1 после первого выполнения, следующего за "холодным рестартом". Выходная переменная Q сохраняет значение BOOL#0 после всех следующих выполнений. Это же применимо к экземпляру F_TRIG, входная переменная CLK которого отсоединяется или соединяется к значению FALSE.

6.6.3.5.4 Счетчики

Графическое представление стандартных функциональных блоков счетчика с типами связанных входных и выходных переменных представлено в таблице 45. Функционирование этих функциональных блоков определяется в телах соответствующих функциональных блоков.

Таблица 45

Стандартные функциональные блоки счетчиков

Номер	Описание/графическая форма		Тело функционального блока (язык ST)
	Возрастающий счетчик
1a	CTU_INT(CU, R, PV, Q, CV) or CTU(..)
			VAR_INPUT CU: BOOL R_EDGE; ... /* Фронт вычисляется внутри, используя тип данных R_EDGE */

	а также:		IF R THEN CV:= 0; ELSIF CU AND (CV < PVmax) THEN CV:= CV+1; END_IF; Q:= (CV >= PV);
1b	CTU_DINT	PV, CV: DINT	см. 1a
1c	CTU_LINT	PV, CV: LINT	см. 1a
1d	CTU_UDINT	PV, CV: UDINT	см. 1a
1e	CTU_ULINT(CD, LD, PV, CV) PV, CV: ULINT		см. 1a
	Убывающие счетчики
2a	CTD_INT(CD, LD, PV, Q, CV) or CTD
			VAR_INPUT CU: BOOL R_EDGE; ... // Фронт вычисляется внутри типом данных R_EDGE

	а также:		IF LD THEN CV:= PV; ELSIF CD AND (CV > PVmin) THEN CV:= CV-1; END_IF; Q:= (CV <= 0);
2b	CTD_DINT	PV, CV: DINT	См. 2a
2c	CTD_LINT	PV, CV: LINT
2d	CTD_UDINT	PV, CV: UDINT	См. 2a
2e	CTD_ULINT	PV, CV: UDINT	См. 2a
	Реверсивные счетчики
3a	CTUD_INT(CD, LD, PV, Q, CV) or CTUD(..)
	а также:		VAR_INPUT CU, CD: BOOL R_EDGE; ... // Фронт вычисляется внутри типом данных R_EDGE IF R THEN CV:= 0; ELSIF LD THEN CV:= PV; ELSE IF NOT (CU AND CD) THEN IF CU AND (CV < PVmax) THEN CV:= CV+1; ELSIF CD AND (CV > PVmin) THEN CV:= CV-1; END_IF; END_IF; END_IF; QU:= (CV >= PV); QD:= (CV <= 0);
3b	CTUD_DINT	PV, CV: DINT	См. 3a
3c	CTUD_LINT	PV, CV: LINT	См. 3a
3d	CTUD_UDINT	PV, CV: UDINT	См. 3a
3e	CTUD_ULINT	PV, CV: ULINT	См. 3a
Примечание - Числовые значения переменных предела PVmin и PVmax определяются разработчиком.

6.6.3.5.5 Таймеры

Графическая форма стандартных функциональных блоков таймера показана в таблице 46. Функционирование этих функциональных блоков определено на временной диаграмме, приведенной на рисунке 15.

Таблица 46

Стандартные функциональные блоки таймера

Номер	Описание		Символ	Графическая форма
1a	Импульсный таймер, перегруженный	TP	*** эквивалентно: TP
1b	Импульсный таймер с типом данных TIME		TP_TIME
1c	Импульсный таймер с типом данных LTIME		TP_LTIME
2a	Таймер с задержкой включения, перегруженный	TON	TON
				PT см. примечание
2b	Таймер с задержкой включения с типом данных TIME		TON_TIME
2c	Таймер с задержкой включения с типом данных LTIME		TON_LTIME	IN: Input (Start)
2d <a>	Таймер с задержкой включения, перегруженный	(графическая форма)	T---0	PT: Установленное время
3a	Таймер с задержкой отключения, перегруженный	TOF	TOF	Q: Выходная переменная
3b	Таймер с задержкой отключения с типом данных TIME		TOF_TIME	ET: Истекшее время
3c	Таймер с задержкой отключения с типом данных LTIME		TOF_LTIME
3d <a>	Таймер с задержкой отключения, перегруженный	(графическая форма)	0---T
Примечание - Воздействие изменения значения входной переменной PT во время работы таймера, например, установка PT в t#0s при возобновлении функционирования экземпляра TP определяется параметром, задаваемым разработчиком.
<a> В текстовых языках свойства 2b и 3b не используются.

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

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

a) Импульсный отсчет времени (PT)

b) Времени с задержкой включения (TON)

c) Расчет времени с задержкой отключения (TOF)

Рисунок 15 - Стандартные функциональные блока

таймера - временные диаграммы (правила)

6.6.3.5.6 Функциональные блоки взаимодействия

Стандартные функциональные блоки взаимодействия для программируемых контроллеров определены в МЭК 61131-5. Данные функциональные блоки предоставляют функциональность взаимодействия, такую как средства проверки устройств, сбор данных опроса, запрограммированный сбор данных, управление параметрами, управление с взаимоблокировкой, запрограммированное аварийное оповещение, управление и защита соединений.

6.6.4 Программы

В МЭК 61131-1 программа определяется как "логический набор всех элементов и конструкций языка программирования, необходимый для запланированной обработки сигналов, требуемой для управления оборудованием или процессом системой PLC".

Объявление и использование программ идентично объявлению и использованию функциональных блоков с дополнительными свойствами, показанными в таблице 47, и со следующими отличиями:

1) ограничивающими ключевыми словами для программы являются PROGRAM...END_PROGRAM;

2) программа содержит конструкцию VAR_ACCESS...END_VAR, которые предоставляют средства определения именованных переменных, к которым может осуществляться доступ некоторыми службами связи, указанными в МЭК 61131-5. Путь доступа связывает каждую такую переменную с входными, выходными или внутренними переменными программы;

3) программы могут устанавливаться только в ресурсах, в то время как функциональные блоки могут устанавливаться в программах или других функциональных блоках;

4) программа может содержать назначение своего расположения в объявлениях своих глобальных и внутренних переменных. Назначение расположения с частично определенным прямым представлением может использоваться только в объявлениях внутренних переменных программы;

5) объектно-ориентированные свойства программ не входят в задачу настоящего стандарта.

Таблица 47

Объявление программы

Номер	Описание	Пример
1	Объявление программы PROGRAM ... END_PROGRAM	PROGRAM myPrg ... END_PROGRAM
2a	Объявление входных переменных VAR_INPUT ... END_VAR	VAR_INPUT IN: BOOL; T1: TIME; END_VAR
2b	Объявление выходных переменных VAR_OUTPUT ... END_VAR	VAR_OUTPUT OUT: BOOL; ET_OFF: TIME; END_VAR
2c	Объявление входных-выходных переменных VAR_IN_OUT ... END_VAR	VAR_IN_OUT A: INT; END_VAR
2d	Объявление временных переменных VAR_TEMP ... END_VAR	VAR_TEMP I: INT; END_VAR
2e	Определение статических переменных VAR ... END_VAR	VAR B: REAL; END_VAR
2f	Объявление внешних переменных END_VAR	VAR_EXTERNAL B: REAL; END_VAR Соответствует следующему: VAR_GLOBAL B: REAL
2g	Объявление внешних переменных VAR_EXTERNAL CONSTANT ... END_VAR	VAR_EXTERNAL CONSTANT B: REAL; END_VAR Соответствует следующему: VAR_GLOBAL B: REAL
3a	Инициализация входных параметров	VAR_INPUT MN: INT:= 0;
3b	Инициализация выходных параметров	VAR_OUTPUT RES: INT:= 1;
3c	Инициализация статических переменных	VAR B: REAL:= 12.1;
3d	Инициализация временных переменных	VAR_TEMP I: INT:= 1;
4a	Объявление квалификатора RETAIN для входных переменных	VAR_INPUT RETAIN X: REAL; END_VAR
4b	Объявление квалификатора RETAIN для выходных переменных	VAR_OUTPUT RETAIN X: REAL; END_VAR
4c	Объявление квалификатора NON_RETAIN для входных переменных	VAR_INPUT NON_RETAIN X: REAL; END_VAR
4d	Объявление квалификатора NON_RETAIN для выходных переменных	VAR_OUTPUT NON_RETAIN X: REAL; END_VAR
4e	Объявление квалификатора NON_RETAIN для статических переменных	REAL; END_VAR
4f	Объявление квалификатора NON_RETAIN для статических переменных	VAR NON_RETAIN X: REAL; END_VAR
5a	Объявление квалификатора RETAIN для локальных экземпляров функционального блока	VAR RETAIN TMR1: TON; END_VAR
5b	Объявление квалификатора NON_RETAIN для локальных экземпляров FB	VAR NON_RETAIN TMR1: TON; END_VAR
6a	Текстовое объявление - входных переменных переднего фронта	PROGRAM AND_EDGE VAR_INPUT X: BOOL R_EDGE; Y: BOOL F_EDGE; END_VAR VAR_OUTPUT Z: BOOL; END_VAR Z:= X AND Y; (* Пример на языке ST *) END_PROGRAM
6b	Текстовое объявление - входных переменных заднего фронта (текстовое)	См. выше
7a	Графическое объявление - входных переменных переднего фронта (>)	ПРОГРАММА (* Внешний интерфейс ) ( тело функционального блока *) END_PROGRAM
7b	Графическое объявление - входных переменных заднего фронта (<)	См. выше
8a	Объявление VAR_GLOBAL...END_VAR в программе PROGRAM	VAR_GLOBAL z1: BYTE; END_VAR
8b	VAR_GLOBAL CONSTANT объявления в объявлениях типов программы ПРОГРАММЫ	VAR_GLOBAL CONSTANT z2: BYTE; END_VAR
9	Объявление VAR_ACCESS...END_VAR в программе PROGRAM	VAR_ACCESS ABLE: STATION_1.%IX1.1: BOOL READ_ONLY; BAKER: STATION_1.P1.x2: UINT READ_WRITE; END_VAR
Примечание - Свойства от 2a до 7b эквивалентны соответствующим свойствам таблицы 40 для функциональных блоков.

6.6.5 Классы

6.6.5.1 Общие положения

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

- определение структуры данных, разделенной на общие и внутренние переменные;

- выполняемые над элементами структуры данных;

- классы, состоящие из методов (алгоритмов) и структур данных;

- интерфейс с прототипами метода и реализация интерфейсов;

- наследование интерфейсов и классов.

Инстанцирование классов.

Примечание. термины "класс" и "объект", используемые в языках C#, C++, Java, UML и т.д., соответствуют терминам "тип" и "экземпляр" языков программирования PLC изданного стандарта. Это показано ниже.

Языки программирования ИТ: C#, C++, Java, UML	Языки PLC из стандарта
Class (= тип класса)	Type (тип функционального блока или класса)
Object (= экземпляр класса)	Instance (экземпляр функционального блока или класса)

Наследование интерфейса и классов с использованием механизмов реализации и расширения показано на рисунке 16. Это определено в 6.6.5.

Рисунок 16 - Обзор наследования и реализации интерфейса

Класс - это программный компонент, разработанный для объектно-ориентированного программирования. По существу, класс содержит переменные и методы. Класс должен инстанцироваться до того, как его методы смогут вызываться и как можно осуществлять доступ к его переменным.

6.6.5.2 Объявление класса

Свойства объявления класса определены в таблице 48:

1) ключевое слово CLASS с последующим идентификатором, указывающим имя определяемого класса;

2) завершающее ключевое слово END_CLASS;

3) значения переменных, которые объявлены через конструкцию VAR_EXTERNAL, могут изменяться из класса;

4) Значения констант, которые объявлены через конструкцию VAR_EXTERNAL CONSTANT, не могут изменяться из класса;

5) конструкция VAR...END_VAR, при необходимости, указывающая имена и типы переменных класса;

6) переменные могут быть инициализированы;

7) переменные секции VAR (статические) могут быть объявлены как PUBLIC (общие). К общим переменным можно получать доступ извне класса, используя такой же синтаксис, как для доступа к выходным переменным функционального блока;

8) для внутренних переменных класса могут использоваться квалификаторы RETAIN и NON_RETAIN;

9) для объявления внутренних переменных класса может использоваться символ "*", как определено в таблице 16;

10) переменные могут быть общими PUBLIC, индивидуальными PRIVATE, внутренними INTERNAL или защищенными PROTECTED. По умолчанию используется спецификатор доступа PROTECTED;

11) класс может поддерживать наследование других классов для расширения базового класса;

12) класс может реализовывать один или более интерфейсов;

13) экземпляры других функциональных блоков, классы и блоки объектно-ориентированных функций могут быть объявлены в секциях переменных VAR и VAR_EXTERNAL;

14) экземпляр класса, объявленный внутри класса, не обязан использовать то же имя, как функция (той же области видимости) для предотвращения неопределенностей.

Класс имеет следующие различия от функционального блока:

- ключевые слова FUNCTION_BLOCK и END_FUNCTION_BLOCK заменены ключевыми словами CLASS и END_CLASS, соответственно;

- переменные объявляются только в секции VAR. Не разрешены секции VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT и VAR_TEMP. У класса нет тела;

- класс может определять только методы;

- вызов экземпляра класса невозможен. Могут вызываться только методы класса.

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

Таблица 48

Класс

Номер	Описание Ключевое слово	Объяснение
1	CLASS ... END_CLASS	Определение класса
1a	Спецификатор FINAL	Класс не может использоваться в базовом классе
	Основанные на функциональном блоке
2a	Определение переменных VAR ... END_VAR	VAR B: REAL; END_VAR
2b	Инициализация переменных	VAR B: REAL:= 12.1; END_VAR
3a	Квалификатор RETAIN для внутренних переменных	VAR RETAIN X: REAL; END_VAR
3b	Квалификатор RETAIN для внутренних переменных	VAR NON_RETAIN X: REAL; END_VAR
4a	Объявления VAR_EXTERNAL внутри объявлений типа класса	См. эквивалентный пример в таблице 40
4b	Объявления VAR_EXTERNAL CONSTANT в объявлениях типа класса	См. эквивалентный пример в таблице 40
	Методы и спецификаторы
5	METHOD...END_METHOD	Определение метода
5a	Спецификатор PUBLIC	Метод может вызываться откуда угодно
5b	Спецификатор PRIVATE	Метод может вызываться только внутри определяющего программного компонента
5c	Спецификатор INTERNAL	Метод может вызываться из одного пространства имен
5d	Спецификатор PROTECTED	Метод может вызываться только из определяющего программного компонента и его наследников (неявно)
5e	Спецификатор FINAL	Метод не может быть перегружен
	Наследование	- данные свойства - такие же как в таблице 53 свойств наследования
6	EXTENDS	Класс является наследником класса Примечание - Наследование функциональных блоков отсутствует
7	OVERRIDE	Метод переопределяет базовый метод - см. динамическое связывание имен
8	ABSTRACT	Абстрактный класс - по меньшей мере, один метод является абстрактным Абстрактный метод - шаблон метода
	Ссылка на доступ
9a	THIS	Ссылка на собственные методы
9b	SUPER	Ссылка на метод базового класса
	Спецификаторы доступа переменной
10a	Спецификатор PUBLIC	Доступ к переменной возможен из любого места
10b	Спецификатор PRIVATE	Доступ к переменной осуществляется только внутри определяющего программного компонента
10c	Спецификатор INTERNAL	Доступ к переменной осуществляется только внутри одного пространства имен
10d	Спецификатор PROTECTED	Доступ к переменной осуществляется только из определяющего программного компонента и его наследников (неявно)
	Полиморфизм
11a	с секцией переменных VAR_IN_OUT	Переменным из секции VAR_IN_OUT может быть присвоен экземпляр производного класса
11b	со ссылкой	Ссылке на (базовый) класс может быть присвоен адрес экземпляра производного класса

Пример ниже иллюстрирует свойства объявления класса и его использование.

Пример - Определение класса

Class CCounter

VAR

m_iCurrentValue: INT; (* Default = 0 *)

m_bCountUp: BOOL:=TRUE;

END_VAR

VAR PUBLIC

m_iUpperLimit: INT:=+10000;

m_iLowerLimit: INT:=-10000;

END_VAR

METHOD Count (* Только тело *)

IF (m_bCountUp AND m_iCurrentValue<m_iUpperLimit) THEN

m_iCurrentValue:= m_iCurrentValue+1;

END_IF;

IF (NOT m_bCountUp AND m_iCurrentValue>m_iLowerLimit) THEN

m_iCurrentValue:= m_iCurrentValue-1;

END_IF;

END_METHOD

METHOD SetDirection

VAR_INPUT

bCountUp: BOOL;

END_VAR

m_bCountUp:=bCountUp;

END_METHOD

END_CLASS

6.6.5.3 Декларация экземпляра класса

Экземпляр класса объявляется подобно определению структурной переменной.

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

Таблица 49

Декларация экземпляра класса

Номер

Описание

Пример

Объявление экземпляра класса с неявной инициализацией

VAR

MyCounter1: CCounter;

END_VAR

Декларация экземпляра класса с инициализацией его общих переменных

VAR

MyCounter2: CCounter:=

(m_iUpperLimit: =20000;

m_iLowerLimit: =-20000);

END_VAR

Элементы, которым не присвоено значение в перечне инициализации, получают начальные значения из объявления класса.

6.6.5.4 Методы класса

6.6.5.4.1 Общие положения

Применительно к задачам языков программируемых контроллеров, концепция методов, хорошо известных в объектно-ориентированном программировании, принимается как набор факультативных элементов языка, используемых при определении класса.

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

6.6.5.4.2 Сигнатура

В целях данного стандарта, термин сигнатура определен в разделе 3 как набор информации, однозначно определяющий идентичность параметров МЕТОДА.

Сигнатура включает:

- имя метода;

- тип результата;

- имена переменных, типы данных и порядок всех параметров, то есть входных, выходных и входных-выходных переменных.

Локальные переменные не являются частью сигнатуры. Переменные, объявленные в секции VAR_EXTERNAL и постоянные переменные не существенны для сигнатуры.

Спецификаторы доступа, такие как PUBLIC или PRIVATE не существенны для сигнатуры.

6.6.5.4.3 Объявление и выполнение метода

Класс может иметь набор методов.

Объявление метода должно подчиняться следующим правилам:

1 Методы объявляются в области действия класса.

2 Метод может объявляться на любом из языков, указанных в этом стандарте.

3 В текстовом объявлении методы перечисляются после объявления переменных класса.

4 Метод может объявлять свои собственные VAR_INPUT, внутренние временные переменные VAR и VAR_TEMP, VAR_OUTPUT, VAR_IN_OUT и результат метода.

Ключевые слова VAR_TEMP и VAR имеют то же самое значение и оба являются разрешенными для внутренних переменных.

(Ключевое слово VAR используется в функциях).

5 Объявление метода содержит один из следующих спецификаторов доступа: PUBLIC, PRIVATE, INTERNAL или PROTECTED. Если спецификатор доступа не задан, метод будет PROTECTED по умолчанию.

6 Объявление метода может содержать дополнительные ключевые слова OVERRIDE или ABSTRACT.

Примечание 1 - Перегрузка методов не входит в задачу настоящего стандарта.

Объявление метода должно подчиняться следующим правилам:

7 Во время выполнения метод может читать свои входные переменные и вычисляет выходные переменные и результат, используя временные переменные.

8 Результат метода присваивается его имени.

9 Все переменные метода и его результат являются временными (как переменные функции), то есть переменные не сохраняются от одного вычисления метода до другого.

Поэтому, вычисление выходных переменных метода возможно только в непосредственном контексте вызова метода.

10 Имена переменных каждого метода класса должны быть различными (уникальными). Имена локальных переменных различных методов могут быть одинаковыми.

11 Все методы класса имеют доступ для чтения/записи к статическим и внешним переменным, объявленным в классе.

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

13 Во время выполнения метод может использовать другие методы, определенные в этом классе. Методы экземпляра данного класса вызываются, используя ключевое слово THIS.

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

Пример 1

Объект (экземпляр)

Примечание 2 - Алгоритм методов имеет доступ к их собственным данным и к данным класса.

(Временные параметры заключены в скобки)

Определение класса (типа) с методами:

CLASS name

VAR vars; END_VAR

VAR_EXTERNAL externals;

END_VAR

METHOD name_1

VAR_INPUT inputs;

END_VAR

VAR_OUTPUT outputs;

END_VAR

END_METHOD

METHOD name_i

VAR_INPUT inputs;

END_VAR

VAR_OUTPUT outputs;

END_VAR

END_METHOD END_CLASS

Примечание 3 - Данное графическое представление метода служит только для иллюстрации

Вызов метода:

a) Использование результата (результат является необязательным)

R1 := I.method1(inm1 := A, outm1 => Y);

b) Использование вызова (результат не объявлен)

I.method1(inm1 := A, outm1 => Y); Присваивание переменным метода за пределами метода

;

Чтение выходных переменных метода за пределами метода

Пример 2

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

*CLASS COUNTER* *VAR* *CV: UINT;* *Max: UINT:= 1000;* *END_VAR*	*// Текущее значение счетчика*
*METHOD PUBLIC UP: UINT* *VAR_INPUT INC: UINT; END_VAR* *VAR_OUTPUT QU: BOOL; END_VAR* *IF CV* <= *Max - INC*	*/ Метод прямого счета, используя inc* *// Приращение* *// Обнаружение верхнего предела*
*THEN CV:= CV + INC;* *QU:= FALSE;*	*// Увеличение текущего значения*
*ELSE QU:= TRUE;* *END_IF* *UP:= CV;*	*// Достигнут верхний предел*
*END_METHOD*	*// Результат метода*
*METHOD PUBLIC UP5: UINT* *VAR_OUTPUT QU: BOOL; END_VAR*
*UP5:= THIS. UP(INC:= 5, QU* => *QU);*	*// Count up by 5*
*END_METHOD*	*// Достигнут верхний предел*
*END_CLASS*	*// Вызов внутреннего метода*

6.6.5.4.4 Представление вызова метода

Методы могут вызываться в текстовых языках (таблица 50) и в графических языках.

Таблица 50

Текстовый вызов методов -

Формальный и неформальный перечень параметров

Номер	Описание	Пример
1a	Полный формальный вызов (только текстовый) Используется, если указание параметров EN и ENO в вызове является обязательным	A:= COUNTER.UP(EN:= TRUE, INC:= B, START:= 1, ENO=> %MX1, QU => C);
1b	Неполный формальный вызов (только текстовый)	A:= COUNTER.UP(INC:= B, QU => C);
1b	Используется, если указание параметров EN и ENO в вызове не является обязательным	Переменная START будет иметь неявное значение 0 (ноль)
2	Неформальный вызов (только текстовый) (с фиксированным порядком параметров и полный)	A:= COUNTER.UP(B, 1, C); Данный т вызов эквивалентен вызову в примере 1a, но без параметров EN и ENO

В представлениях всех языков имеется два разных случая вызова метода:

a) внутренний вызов метода из экземпляра собственного класса Имя метода предваряется ключевым словом "THIS". Данный вызов может выдаваться другим методом;

b) внешний вызов метода экземпляра другого класса. Имени метода предшествует имя экземпляра и ".".

Этот вызов может выдаваться методом или телом функционального блока, где объявлен экземпляр класса.

Примечание - Используются следующие синтаксисы:

- синтаксис A() используется для вызова глобальной функции A;

- синтаксис THIS.A() используется для вызова метода из собственного экземпляра класса;

- синтаксис THIS.A() используется для вызова метода A из другого экземпляра класса.

6.6.5.4.5 Текстовое представление вызова

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

Метод может вызываться формально или неформально.

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

Пример 1 - ... class_instance_name.method_name(parameters).

Внутренний вызов метода требует использования THIS вместо имени экземпляра.

Пример 2 - ... THIS.method_name (parameters).

6.6.5.4.6 Графическое представление

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

Вызовы метода могут поддерживать параметры EN и ENO, как определено в таблице 18.

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

Ключевое слово THIS размещают над блоком;

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

Над блоком размещают имя экземпляра класса.

6.6.5.4.7 Ошибка

Использование выхода метода независимо от вызова метода рассматривается как ошибка. См. пример ниже.

Пример - Внутренний и внешний вызов метода

VAR

CT: COUNTER;

LIMIT: BOOL;

VALUE: UINT;

END_VAR

1) В структурированном тексте (язык ST).

a) Внутренний вызов метода:

VALUE:= THIS.UP (INC:= 5, QU => LIMIT);

b) Внешний вызов модуля:

VALUE:= CT.UP (INC:= 5, QU => LIMIT);

2) На функциональных блоковых диаграммах (язык FBD)

Вызван в классе другого метода

Ключевое слово THIS обязательно

a) Внутренний вызов метода:

Метод UP возвращает результат

Графическое представление служит только для иллюстрации

Переменная On разрешает вызов метода

CT - экземпляр класса, объявленный в другом классе или функциональном блоке

Вызывается методом или в теле функционального блока

b) Внешний вызов модуля:

Метод UP возвращает результат

Графическое представление служит только для иллюстрации

Переменная On разрешает вызов метода;

3) Ошибка Использование выхода метода без графического или текстового вызова

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

6.6.5.5 Наследование класса (EXTENDS, SUPER, OVERRIDE, FINAL)

6.6.5.5.1 Общие положения

Применительно к языкам программирования PLC, концепция наследования, определенная в объектно-ориентированном программировании применяется как способ создания новых элементов.

Наследование классов показано на рисунке 17. На базе существующего класса может быть порожден один или более классов. Данный процесс может повторяться многократно.

Примечание - "Множественное наследование" не поддерживается.

Порожденный (дочерний) класс обычно расширяет базовый (родительский) класс дополнительными методами.

Термин "базовый" класс означает всех "предков", то есть родительский класс и его родительские классы и т.д.

Наследование классов с использованием EXTENDS

Рисунок 17 - Наследование классов (иллюстрация)

6.6.5.5.2 Ключевое слово EXTENDS для классов

Класс может порождаться из уже существующего класса (базового класса), используя ключевое слово EXTENDS.

Пример - CLASS X1 EXTENDS X;

Применяются следующие правила:

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

- не наследуются методы PRIVATE;

- за пределами пространства имен не наследуются методы INTERNAL.

2 Порожденный класс наследует все переменные (если таковые имеются) из базового класса.

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

Примечание - Класс может реализовывать (используя ключевое слово IMPLEMENTS) один или более интерфейсов.

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

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

Это может повторяться несколько раз.

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

6.6.5.5.3 OVERRIDE метод

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

1 Метод, переопределяющий унаследованный метод, имеет такую же сигнатуру (имя метода и переменные) в пределах области действия класса.

2 Метод, переопределяющий унаследованный класс, должен иметь следующие свойства:

- ключевое слово OVERRIDE следует за ключевым словом METHOD;

- порожденный класс имеет доступ к базовым методам, которые определены как PUBLIC or PROTECTED или NTERNAL в том же пространстве имен;

- новый метод будет иметь те же спецификаторы доступа. Но спецификатор FINAL может быть использован для переопределенного метода.

Пример - METHOD OVERRIDE mb;

6.6.5.5.4 FINAL для классов и методов

Метод со спецификатором FINAL не будет переопределяться. Класс со спецификатором FINAL не может быть базовым классом.

Пример 1 - METHOD FINAL mb;

Пример 2 - CLASS FINAL c1.

6.6.5.5.5 Ошибки при использовании ключевых слов (EXTENDS, SUPER, OVERRIDE, FINAL)

Следующие ситуации рассматриваются как ошибка:

1 Порожденный класс определяет переменную с именем переменной (определенной или унаследованной), уже содержащейся в базовом классе. Данное правило не применяется к переменным, объявленным как PRIVATE.

2 Порожденный класс определяет метод с именем, уже содержащемся в базовом классе.

3 Порожденный класс порождается из его собственного базового класса (прямо или косвенно), то есть рекурсия не разрешена.

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

Пример - Наследование и переопределение

Класс, расширяющий класс LIGHTROOM.

CLASS LIGHTROOM

VAR LIGHT: BOOL; END_VAR

METHOD PUBLIC DAYTIME

LIGHT:= FALSE;

END_METHOD

METHOD PUBLIC NIGHTTIME

LIGHT:= TRUE;

END_METHOD

END_CLASS

CLASS LIGHT2ROOM EXTENDS LIGHTROOM

VAR LIGHT2: BOOL; END_VAR // Second light

METHOD PUBLIC OVERRIDE DAYTIME

LIGHT:= FALSE; // Доступ к переменным родительского класса

LIGHT:= FALSE; // конкретная реализация END_METHOD

METHOD PUBLIC OVERRIDE NIGHTTIME

LIGHT:= TRUE; // Доступ к переменным родительского класса

LIGHT:= TRUE; // конкретная реализация

END_METHOD

END_CLASS

6.6.5.6 Динамическое связывание имен (OVERRIDE)

Связывание имен - это ассоциация имени метода с именем реализации. Привязка имени (например, компилятором) до выполнения программы называется статической или "ранней" привязкой. Привязка, выполняемая во время выполнения программы, называется динамической или "поздней" привязкой.

В случае вызова внутреннего метода, свойство переопределения с ключевым словом OVERRIDE приводит к различию между статической и динамической формой связывания имен:

- статическое связывание: ассоциирует имя метода с реализацией метода класса с вызовом внутреннего метода, или содержит метод, выполняющий вызов внутреннего метода;

- динамическое связывание: ассоциирует имя метода с реализацией метода фактического типа экземпляра класса.

Пример 1 - Динамическое связывание имен

Переопределение с воздействием на связывание

// Объявление

CLASS CIRCLE

METHOD PUBLIC PI: LREAL // Метод дает менее точное определение

PI PI:= 3.1415;

END_METHOD

METHOD PUBLIC CF: LREAL // Метод вычисляет длину окружности

VAR_INPUT DIAMETER: LREAL; END_VAR

CF:= THIS.PI() * DIAMETER; // Внутренний вызов метода:

END_METHOD // используя динамические связывания PI

END_CLASS

CLASS CIRCLE 2 EXTENDS CIRCLE // Класс с методом, переопределяющим PI

METHOD PUBLIC OVERRIDE PI: LREAL // Метод выдает более точное значение PI

PI:= 3.1415926535897;

END_METHOD

END_CLASS

PROGRAM TEST VAR

CIR1: CIRCLE; // Экземпляр CIRCLE

CIR2: CIRCLE2; // Экземпляр CIRCLE2

CUMF1: LREAL;

CUMF2: LREAL;

DYNAMIC: BOOL;

END_VAR

CUMF1:= CIR1.CF(1.0); // Вызов метода CIR1

CUMF2:= CIR2.CF(1.0); // Вызов метода CIR2

DYNAMIC:= CUMF1 <> CUMF2; // Динамическое связывание приводит к значению True

END_PROGRAM

В данном примере класс CIRCLE содержит внутренний вызов своего метода PI с низкой точностью для вычисления длины окружности (CF).

Порожденный класс CIRCLE2 переопределяет этот метод более точным определением PI.

Вызов метода PI() ссылается либо на CIRCLE.PI, либо на CIRCLE2.PI, в соответствии с типом экземпляра, в котором выполнялся вызов метода CF. Здесь значение CUMF2 точнее значения CUMF1.

Пример 2 - Графическая иллюстрация приведенного выше текстового примера (упрощенная)

6.6.5.7 Вызов метода собственного или базового класса (THIS, SUPER)

6.6.5.7.1 Общие положения

Для доступа к методу, определенному внутри или вне собственного класса, используются ключевые слова THIS и SUPER.

6.6.5.7.2 THIS

THIS обеспечивает ссылку на экземпляр собственного класса.

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

THIS может быть передан переменной типа INTERFACE.

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

Пример - Использование ключевого слова THIS

Для удобства данные примеры копируются из приведенных выше примеров.

INTERFACE ROOM

METHOD DAYTIME END_METHOD // Вызывается в дневное время METHOD NIGHTTIME END_METHOD

// Вызывается в ночное время

END_INTERFACE

FUNCTION_BLOCK ROOM_CTRL //

VAR_INPUT

RM: ROOM; // Интерфейс ROOM как типа входной переменной

END_VAR

VAR_EXTERNAL

Actual_TOD: TOD; // Глобальное определение времени

END_VAR

IF (RM = NULL) // ВАЖНО: проверить законность ссылки!

THEN RETURN;

END_IF;

IF Actual_TOD >= TOD#20:15 OR Actual_TOD <= TOD#6:00

THEN RM.NIGHTTIME(); // вызов метода из RM

ELSE RM.DAYTIME();

END_IF;

END_FUNCTION_BLOCK

// Применяет ключевое слово THIS для назначения собственного экземпляра

CLASS DARKROOM IMPLEMENTS ROOM// См. объявление ROOM выше VAR_EXTERNAL

Ext_Room_Ctrl: ROOM_CTRL; // См. объявление ROOM_CTRL выше END_VAR

METHOD PUBLIC DAYTIME; END_METHOD METHOD PUBLIC NIGHTTIME; END_METHOD

METHOD PUBLIC EXT_1

Ext_Room_Ctrl(RM:= THIS); // Вызвать Ext_Room_Ctrl с собственным экземпляром

END_METHOD

END_CLASS

6.6.5.7.3 Ключевое слово SUPER

Ключевое слово SUPER обеспечивает доступ к методам реализации базового класса.

С ключевым словом SUPER можно вызвать метод, который действителен в экземпляре базового (родительского) класса. Таким образом, имеет место статическое связывание.

Ключевое слово SUPER не может использоваться с экземплярами других программных элементов, например, выражение my- Room.SUPER.DAYTIME() не разрешено.

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

Пример - Использование ключевого слова SUPER и полиморфизм

LIGHT2ROOM с использованием SUPER как альтернативная реализация приведенного выше примера. Для удобства сюда скопированы некоторые предыдущие примеры.

INTERFACE ROOM

METHOD DAYTIME END_METHOD // Вызывается в дневное время

METHOD NIGHTTIME END_METHOD // Вызывается в ночное время

END_INTERFACE

CLASS LIGHTROOM IMPLEMENTS ROOM

VAR LIGHT: BOOL; END_VAR

METHOD PUBLIC DAYTIME

LIGHT:= FALSE;

END_METHOD

METHOD PUBLIC NIGHTTIME

LIGHT:= TRUE;

END_METHOD

END_CLASS

FUNCTION_BLOCK ROOM_CTRL

VAR_INPUT

RM: ROOM; // Интерфейс ROOM как тип переменной

END_VAR

VAR_EXTERNAL

Actual_TOD: TOD; // Глобальное определение времени

END_VAR

IF (RM = NULL) // ВАЖНО: проверить действительность ссылки!

THEN RETURN;

END_IF;

IF Actual_TOD >= TOD#20:15 OR

Actual_TOD <= TOD#06:00

THEN RM.NIGHT_TIME(); // Вызвать метод RM (динамическое связывание с

//либо LIGHTROOM.NIGHTTIME

// либо LIGHT2ROOM.NIGHTTIME)

ELSE RM.DAYTIME();

END_IF;

END_FUNCTION_BLOCK

// Применяет ключевое слово SUPER для вызова метода базового класса

CLASS LIGHT2ROOM EXTENDS LIGHTROOM // см. выше

VAR LIGHT2: BOOL; END_VAR // логическая переменная light

METHOD PUBLIC OVERRIDE DAYTIME

SUPER.DAYTIME(); // Вызов метода в LIGHTROOM

LIGHT2:= TRUE;

END_METHOD

METHOD PUBLIC OVERRIDE NIGHTTIME

SUPER.NIGHTTIME() // Вызов метода в LIGHTROOM

LIGHT2:= FALSE;

END_METHOD

END_CLASS

// Использование полиморфизма и динамическое связывание

PROGRAM C VAR

MyRoom1: LIGHTROOM; // См. выше

MyRoom2: LIGHT2ROOM; // См. выше

My_Room_Ctrl: ROOM_CTRL; // См. выше

END_VAR

My_Room_Ctrl(RM:= MyRoom1); // Вызовы в My_Room_Ctrl вызывают методы LIGHTROOM

My_Room_Ctrl(RM:= MyRoom2); // Вызовы в My_Room_Ctrl вызывают методы LIGHT2ROOM

END_PROGRAM

6.6.5.8 Абстрактный класс и абстрактный метод

6.6.5.8.1 Общие положения

Модификатор ABSTRACT может использоваться с классами или отдельными методами. Разработчик определяет реализацию этих свойств в соответствии с таблицей 48.

6.6.5.8.2 Абстрактный класс

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

Пример - CLASS ABSTRACT A1

Абстрактный класс имеет следующие свойства:

- абстрактный класс не может инстанцироваться;

- абстрактный класс содержит, по меньшей мере, один абстрактный метод.

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

Абстрактный класс может использоваться как тип входных и входных-выходных параметров.

6.6.5.8.3 Абстрактный метод

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

Методы класса, унаследованные из интерфейса, получают ключевое слово ABSTRACT, если они еще не реализованы.

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

Пример - METHOD PUBLIC ABSTRACT M1.

6.6.5.9 Спецификаторы доступа (PROTECTED, PUBLIC, PRIVATE, INTERNAL) к методу

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

- PROTECTED

Если реализовано наследование, применим спецификатор доступа PROTECTED. Он указывает, что метод доступен только внутри класса и из всех порожденных классов.

PROTECTED является умолчанием и может быть опущен.

Примечание - Если наследование не поддерживается, спецификатор доступа PROTECTED действует так же, как PRIVATE.

- PUBLIC

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

- PRIVATE

Спецификатор доступа PRIVATE указывает, что метод доступен только внутри самого класса.

INTERNAL

Если пространство имен реализовано, то может использоваться спецификатор доступа INTERNAL. Он указывает для методов, что они доступны только в пределах ПРОСТРАНСТВА ИМЕН, в котором класс объявлен.

Неявно доступ к прототипам методов всегда общий (PUBLIC), поэтому для прототипов методов не используется спецификатор доступа.

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

Пример - Спецификаторы доступа для методов.

Иллюстрация доступности (вызова) методов, определенных в классе C:

a) спецификаторы доступа: PUBLIC, PRIVATE, INTERNAL, PROTECTED

- PUBLIC Метод M1 доступен посредством вызова M1 из класса B (а также класса C);

- PRIVATE Метод M2 доступен посредством вызова M2 только из класса C;

- INTERNAL Метод M3 доступен посредством вызова M3 из ПРОСТРАНСТВА ИМЕН A (а также класса B и класса C);

- PROTECTED Метод M4 доступен посредством вызова M4 из класса порожденный_C (а также класса C);

b) вызовы методов изнутри и извне:

- метод M2 вызывается из класса C - с ключевым словом THIS;

- методы M1, M3 и M4 класса C вызываются из класса C - с ключевым словом SUPER для метода M4.

6.6.5.10 Спецификаторы доступа к переменной (PROTECTED, PUBLIC, PRIVATE, INTERNAL)

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

Примечание - Спецификаторы доступа могут комбинироваться с другими спецификаторами, такими как RETAIN или CONSTANT в любом порядке.

- PROTECTED

Если наследование реализовано, то спецификатор доступа PROTECTED является применимым. Для переменных он указывает, что они достижимы только изнутри класса и изнутри всех порожденных классов. Спецификатор доступа PROTECTED применяется по умолчанию, и может быть опущен.

Если наследование реализовано, но не используется, спецификатор PROTECTED имеет такой же эффект как спецификатор PRIVATE.

- PUBLIC

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

- PRIVATE

Спецификатор доступа PRIVATE для переменных указывает, что доступ к ним может осуществляться только из самого класса.

Если наследование не реализовано, спецификатор доступа PRIVATE используется по умолчанию и может быть опущен.

- INTERNAL

Если реализовано пространство имен, спецификатор доступа INTERNAL является применимым. Он указывает, что переменные доступны только из ПРОСТРАНСТВА ИМЕН, в котором объявлен класс.

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

6.6.6 Интерфейс

6.6.6.1 Общие положения

В объектно-ориентированном программировании концепция интерфейса вводится для обеспечения отделения спецификации интерфейса от его реализации как класса. Это позволяет использовать различные реализации общей спецификации интерфейса.

Определение интерфейса начинается с ключевого слова INTERFACE с последующим именем интерфейса и оканчивается ключевым словом END_INTERFACE (см. таблицу 51).

Таблица 51

Интерфейс

Номер	Описание Ключевое слово	Объяснение
1	INTERFACE ... END_INTERFACE	Определение интерфейса
	Методы и спецификаторы
2	METHOD...END_METHOD	Определение метода
	Наследование
3	EXTENDS	Интерфейс наследует из интерфейса
	Использование интерфейса
4a	IMPLEMENTS интерфейс	Реализует интерфейс как объявление класса
4b	IMPLEMENTS множественные интерфейсы	Реализует более одного интерфейса в объявлении класса
4c	Интерфейс как тип переменной	Ссылка на реализацию (экземпляр функционального блока) интерфейса

Интерфейс может содержать набор (неявно общих) прототипов методов.

6.6.6.2 Использование интерфейса

Спецификация интерфейса может использоваться двумя способами:

a) в объявлении класса

Она определяет, какие методы реализует класс, например, для повторного использования спецификации интерфейса, как показано на рисунке 18;

b) как тип переменной

Переменные, тип которых - интерфейс, являются ссылками на экземпляры классов и им может присваиваться значение до использования. Интерфейсы не используются как входные-выходные переменные.

Рисунок 18 - Интерфейс с порожденными классами (иллюстрация)

6.6.6.3 Прототип метода

Прототип метода - это сокращенное объявление метода для использования с интерфейсом. Он содержит имя метода, переменные VAR_INPUT, VAR_OUTPUT and VAR_IN_OUT и результат метода. Определение прототипа метода не содержит никакого алгоритма (кода) и временных переменных, то есть он еще не включает реализации.

Доступ к прототипам метода всегда PUBLIC; поэтому спецификатор доступа не используется в прототипе метода.

Ниже приведена иллюстрация интерфейса INTERFACE general_drive, включающая:

a) прототипы метода (без алгоритма);

b) класс drive_A и класс drive_B: IMPLEMENTS INTERFACE general_drive.

Данные классы имеют методы с разными алгоритмами.

6.6.6.4 Использование интерфейса в объявлении класса (IMPLEMENTS)

6.6.6.4.1 Общие положения

Класс может реализовывать один или более ИНТЕРФЕЙСОВ с использованием ключевого слова IMPLEMENTS.

Пример - CLASS B IMPLEMENTS A1, A2;

Класс реализует алгоритмы всех методов, указанных прототипами метода, которые содержатся в спецификациях ИНТЕРФЕЙСА.

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

Примечание - Реализация прототипа метода может иметь дополнительные временные переменные в методе.

6.6.6.4.2 Ошибки

Следующие ситуации рассматриваются как ошибка:

1 Если класс не реализует все методы, определенные в базовом (родительском) интерфейсе, и класс инстанцирован.

2 Если класс реализует метод с таким же именем, которое определено в интерфейсе, но с другой сигнатурой.

3 Если класс реализует метод с таким же именем, которое определено в интерфейсе, но не со спецификатором доступа PUBLIC или INTERNAL.

6.6.6.4.3 Пример

Приведенный ниже пример иллюстрирует объявление интерфейса в классе и использование посредством внешнего вызова метода

Пример - Класс реализует интерфейс.

// Объявление

INTERFACE ROOM

METHOD DAYTIME END_METHOD // Вызывается в дневное время

METHOD NIGHTTIME END_METHOD // Вызывается в ночное время

END_INTERFACE

CLASS LIGHTROOM IMPLEMENTS ROOM

VAR LIGHT: BOOL; END_VAR

METHOD PUBLIC DAYTIME

LIGHT:= FALSE;

END_METHOD

METHOD PUBLIC NIGHTTIME

LIGHT:= TRUE;

END_METHOD

END_CLASS

// Использование (посредством внешнего вызова метода)

PROGRAM A

VAR MyRoom: LIGHTROOM; END_VAR; // Инстанцирование класса

VAR_EXTERNAL Actual_TOD: TOD; END_VAR; // определение глобального времени

IF Actual_TOD >= TOD#20:15 OR Actual_TOD <= TOD#6:00

THEN MyRoom.NIGHTTIME();

ELSE MyRoom.DAYTIME();

END_IF;

END_PROGRAM

6.6.6.5 Использование интерфейса как типа переменной

6.6.6.5.1 Общие положения

Интерфейс может использоваться как тип переменной. Затем данная переменная становится указателем на экземпляр класса, реализующего интерфейс. Переменной должна быть назначена ссылка на экземпляр класса до того, как она может использоваться. Данное правило применяется во всех случаях, где может использоваться переменная.

Переменной типа INTERFACE могут быть назначены следующие значения:

1) экземпляр класса, реализующего интерфейс;

2) экземпляр класса, порожденного (посредством EXTENDS) из класса, реализующего интерфейс;

3) другая переменная того же порожденного типа INTERFACE;

4) специальное значение NULL, указывающее на недопустимую ссылку. Данное значение также является начальным переменной, если она не инициализирована иным образом.

Переменная типа INTERFACE может сравниваться на равенство с другой переменной того же типа. Результат имеет значение TRUE, если переменные ссылаются на один и тот же экземпляр или если значения обоих переменных равны NULL.

6.6.6.5.2 Ошибка

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

Примечание - Для предотвращения ошибки времени выполнения, инструментальные программные средства должны предоставить неявный "пустой" метод. Другой способ состоит в предварительной проверке того, что назначен действительный экземпляр класса.

6.6.6.5.3 Пример

В примерах 1 и 2 показаны объявление и использование интерфейсов как типа переменной.

Пример 1 - Тип функционального блока с вызовом методов интерфейса

// Объявление

INTERFACE ROOM

METHOD DAYTIME END_METHOD // вызывается в дневное время

METHOD NIGHTTIME END_METHOD // вызывается в ночное время

END_INTERFACE

CLASS LIGHTROOM IMPLEMENTS ROOM

VAR LIGHT: BOOL; END_VAR

METHOD PUBLIC DAYTIME

LIGHT:= FALSE;

END_METHOD

METHOD PUBLIC NIGHTTIME

LIGHT:= TRUE;

END_METHOD

END_CLASS

FUNCTION_BLOCK ROOM_CTRL

VAR_INPUT RM: ROOM; END_VAR // Интерфейс ROOM как тип (входной) переменной

VAR_EXTERNAL

Actual_TOD: TOD; END_VAR // Определение глобального времени

IF (RM = NULL) // Важно: тест на действительную ссылку!

THEN RETURN;

END_IF;

IF Actual_TOD >= TOD#20:15 OR

Actual_TOD <= TOD#06:00

THEN RM.NIGHTTIME(); // Вызов метода RM ELSE RM.

DAYTIME();

END_IF;

END_FUNCTION_BLOCK

// Использование

PROGRAM B

VAR // Инстанцирование

My_Room: LIGHTROOM; // См. LIGHTROOM IMPLEMENTS ROOM

My_Room_Ctrl: ROOM_CTRL; // См. ROOM_CTRL выше

END_VAR

My_Room_Ctrl(RM:= My_Room);

// Вызов FB с передачей экземпляра класса в качестве

входной переменной

END_PROGRAM

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

Объявление:

Интерфейс ROOM с двумя методами и класс LIGHTROOM, реализующий интерфейс.

Функциональный блок ROOM_CTRL с входной переменной RM, которая имеет тип интерфейса ROOM. Функциональный блок ROOM_CTRL вызывает методы переданного класса, которые реализуют интерфейс.

Использование:

Программа B инстанцирует класс My_Room и функциональный блок My_Room_Ctrl и вызывает функциональный блок My_Room_Ctrl с передачей класса My_Room входной переменной RM типа интерфейс ROOM.

Пример 2 - Иллюстрация отношений из примера 1

Объявление:

Примечание - Функциональный блок не имеет реализованных методов, но вызывает методы переданного класса!

6.6.6.6 Наследование интерфейса (EXTENDS)

6.6.6.6.1 Общие положения

Применительно к языкам программирования PLC концепция наследования и реализации, определенная в объектно-ориентированном программировании применяется как способ создания новых элементов, как показано на рисунке 19 a), b), c) ниже.

a) Наследование интерфейса

Порожденный (дочерний) интерфейс расширяет (EXTENDS) базовый (родительский) интерфейс, который уже был определен, или

b) Реализация класса

Порожденный класс реализует (IMPLEMENTS) один или более интерфейсов, которые уже были определены, или

c) Наследование класса

Порожденный класс расширяет (EXTENDS) базовый класс, который уже был определен.

Иллюстрация иерархии наследования:

a) наследование интерфейса с использованием ключевого слова EXTENDS;

b) реализация интерфейса, используя ключевое слово IMPLEMENTS;

c) класса, используя ключевые слова EXTENDS и OVERRIDE.

Рисунок 19 - Наследование интерфейса и класса

Наследование интерфейса, как показано на рисунке 19 a) является первым из трех уровней наследование/реализация. На основе базового интерфейса можно породить один или более интерфейсов.

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

Пример - Интерфейс A1 расширяет интерфейс A.

Применяются следующие правила:

1 Порожденный (дочерний) интерфейс наследует без дополнительных объявлений все прототипы методов из его базового (родительского) интерфейса.

2 Порожденный интерфейс может наследовать из произвольного числа базовых интерфейсов.

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

4 Интерфейс, используемый как базовый интерфейс, может сам являться порожденным интерфейсом. Когда он передается своим порожденным интерфейсам, наследуются также прототипы метода.

Данный процесс может повторяться многократно.

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

6.6.6.6.2 Ошибка

Следующие ситуации будут рассматриваться как ошибка:

1) интерфейс определяет дополнительный прототип метода (в соответствии с правилом 3) с таким же именем прототипа метода, как и один из его базовых интерфейсов;

2) интерфейс является своим собственным базовым интерфейсом, явно или неявно, то есть рекурсия не разрешена.

Пример - Свойство OVERRIDE, как определено в 6.6.5.5 для классов, не применимо для интерфейсов.

6.6.6.7 Попытка присваивания

6.6.6.7.1 Общие положения

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

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

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

Результат попытки присваивания подтверждается отличием от значения NULL перед использованием.

6.6.6.6.7.2 Текстовое представление

В перечне инструкций (язык IL), оператор "ST" (Сохранить) используется как показано в следующем примере.

Пример 1

LD interface2 // в языке IL

ST? interface1

В структурированном тексте (язык ST), оператор "?=" используется как показано в следующем примере.

Пример 2

interface1 ?= interface2; // в языке ST

6.6.6.6.7.3 Графическое представление

В графических языках используется следующая конструкция:

Пример 1

Пример 2 - Попытка присваивания с ссылками интерфейса

Успешная и неудачная попытка присваивания с ссылками интерфейса

// Объявление

CLASS C IMPLEMENTS ITF1, ITF2

END_CLASS

// Использование

PROGRAM A

VAR

inst: C;

interf1: ITF1;

interf2: ITF2;

interf3: ITF3;

END_VAR

interf1:= inst; // теперь interf1 содержит действительную ссылку

interf2 ?= interf1; // interf2 будет содержать действительную ссылку

// равную interf2:= inst;

interf3 ?= interf1; // interf3 будет равно NULL

END_PROGRAM

Пример 3 - Попытка присваивания с указателями интерфейса

// Объявление

CLASS CIBase IMPLEMENTS ITF1, ITF2

END_CLASS

CLASS CIDerived EXTENDS CIBase

END_CLASS

// Использование

PROGRAM A

VAR

instbase: CIBase;

instderived: CIDerived;

rinstBase1, pinstBase2: REF_TO CIBase;

rinstDerived1, rinstDerived2: REF_TO CIDerived;

rinstDerived3, rinstDerived4: REF_TO CIDerived;

interf1: ITF1;

interf2: ITF2;

interf3: ITF3;

END_VAR

rinstBase1:= REF(instBase); // rinstbase1 ссылается на базовый класс

rinstBase2:= REF(instDerived); // rinstbase2 ссылается на порожденный класс

rinstDerived1 ?= rinstBase1; // rinstDerived1 == NULL

rinstDerived2 ?= rinstBase2; // rinstDerived2 будет содержать действительную

// ссылку на instDerived

interf1:= instbase; // interf1 является ссылкой на базовый класс

interf2:= instderived; // interf2 является ссылкой на порожденный класс

rinstDerived3 ?= interf1; // rinstDerived3 == NULL

rinstDerived4 ?= interf2; // rinstDerived4 будет содержать действительную

// ссылку на instDerived

END_PROGRAM

Результат попытки присваивания подтверждается отличием от значения NULL перед использованием.

Таблица 52

Попытка присваивания

Номер	Описание	Пример
1	Попытка присваивания интерфейсов, используя "?="	См. выше
2	Попытка присваивания интерфейсов, используя "?="	См. выше

6.6.7 Объектно-ориентированные свойства функциональных блоков

6.6.7.1 Общие положения

Концепция функциональных блоков МЭК 61131-3 расширена для поддержки объектно-ориентированной парадигмы в том объеме, как она определена для классов:

- в функциональных блоках дополнительно используются методы;

- функциональными блоками дополнительно реализуются интерфейсы;

- поддерживается наследование функциональных блоков.

В объектно-ориентированных функциональных блоках поддерживаются все свойства, определенные в таблице 40.

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

Таблица 53

Объектно-ориентированный функциональный блок

Номер	Описание Ключевое слово	Объяснение
1	Объектно-ориентированный функциональный блок	Объектно-ориентированное расширение концепции функциональных блоков
1a	Спецификатор FINAL	Функциональный блок не может использоваться как базовый функциональный блок
	Методы и спецификаторы
5	METHOD...END_METHOD	Определение метода
5a	Спецификатор PUBLIC	Метод может вызываться откуда угодно
5b	Спецификатор PRIVATE	Метод может вызываться только внутри определяющего программного компонента
5c	Спецификатор INTERNAL	Метод может вызываться из одного и того же пространства имен
5d	Спецификатор PROTECTED	Метод может вызываться только из определяющего программного компонента и его наследников (неявно)
5e	Спецификатор FINAL	Метод не может быть перегружен
	Использование интерфейса
6a	IMPLEMENTS интерфейс	Реализует интерфейс в объявлении функционального блока
6b	IMPLEMENTS множественные интерфейсы	Реализует более одного интерфейса в объявлении функционального блока
6c	Интерфейс как тип переменной	Поддержка ссылок на реализации (экземпляры функциональных блоков) интерфейса
	Наследование
7a	EXTENDS	Функциональный блок наследует из базового функционального блока
7b	EXTENDS	Функциональный блок наследует из базового функционального блока
8	OVERRIDE	Метод переопределяет базовый метод - см. динамическое связывание имен
9	ABSTRACT	Абстрактный функциональный блок - по меньшей мере, один метод является абстрактным Абстрактный метод - это шаблон метода
	Ссылка на доступ
10a	THIS	Ссылка на собственные методы
10b	Ключевое слово SUPER	Ссылка доступа на метод в базовом функциональном блоке
10c	SUPER()	Ссылка доступа на тело в базовом функциональном блоке
	Спецификаторы доступа переменной
11a	Спецификатор PUBLIC	Доступ к переменной возможен из любого места
11b	Спецификатор PRIVATE	Доступ к переменной осуществляется только внутри определяющего программного компонента
11c	Спецификатор INTERNAL	Доступ к переменной осуществляется только внутри одного и того же пространства имен
11d	Спецификатор PROTECTED	Доступ к переменной осуществляется только из определяющего программного компонента и его наследников (неявно)
	Полиморфизм
12a	с секцией переменных VAR_IN_OUT с одинаковой сигнатурой	Секции VAR_IN_OUT базового типа FB может присваиваться экземпляр порожденного типа FB без дополнительных переменных VAR_IN_OUT, VAR_INPUT и VAR_OUTPUT
12b	с секцией переменных VAR_IN_OUT с совместимой сигнатурой	Секции VAR_IN_OUT базового типа FB может присваиваться экземпляр порожденного типа FB без дополнительных переменных VAR_IN_OUT
12c	со ссылкой с одинаковой сигнатурой	Ссылке (базового) типа FB может присваиваться адрес экземпляра порожденного типа FB без дополнительных переменных VAR_IN_OUT, VAR_INPUT и VAR_OUTPUT
12d	со ссылкой с совместимой сигнатурой	Ссылке (базового) типа FB может присваиваться адрес экземпляра порожденного типа FB без дополнительных переменных VAR_IN_OUT

6.6.7.2 Методы для функциональных блоков

6.6.7.2.1 Общие положения

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

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

6.6.7.2.2 Варианты функциональных блоков

Функциональный блок может иметь тело функционального блока и дополнительно набор методов. Так как тело FB и/или методы могут быть опущены, существует три варианта функционального блока. Это показано в примере на рисунках 20 a), 20 b), 20 c).

Рисунок 20 - Функциональный блок с необязательным телом

и методами (иллюстрация)

a) Функциональный блок, имеющий только тело

Данный функциональный блок известен из МЭК 61131-3.

В данном случая у функционального блока нет реализованных методов. Элементы функционального блока (входные переменные, выходные переменные и т.п.) и вызовы функционального блока показаны на примере на рисунке 20 a).

b) Функциональный блок телом FB и методами

Методы поддерживают доступ к их собственным локально определенным переменным, а также к переменным, определенным в секциях VAR_INPUT, VAR_OUTPUT и VAR объявления функционального блока.

c) Функциональные блоки, имеющие только методы

В данном случае, функциональный блок имеет реализованное пустое тело функционального блока. Элементы функционального блока и вызов методов показан на рисунке 20 b).

В данном случае, функциональный блок может также быть объявлен как класс.

6.6.7.2.3 Объявление и выполнение метода

Функциональный блок может иметь набор методов, приведенных на рисунке 20 c).

Объявление метода подчиняется правилам метода класса, а также дополнительно следующим правилам:

1 Методы объявляются в области действия типа функционального блока.

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

Выполненные методы подчиняются правилам для методов класса и дополнительно следующим правилам:

3 Все методы имеют доступ для чтения-записи к статическим переменным, объявленным в функциональном блоке: Входные переменные (кроме тех, которые имеют тип данных BOOL R_EDGE или BOOL F_EDGE), входные, статические и внешние переменные.

4 Метод не имеет доступа к временным переменным VAR_TEMP и входным-выходным переменным VAR_IN_OUT функционального блока.

5 Переменные метода недоступны в теле (алгоритме) функционального блока.

6.6.7.2.4 Представление вызова метода

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

6.6.7.2.5 Спецификаторы доступа (PROTECTED, PUBLIC, PRIVATE, INTERNAL) к методу

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

6.6.7.2.6 Спецификаторы доступа к переменным (PROTECTED, PUBLIC, PRIVATE, INTERNAL)

Для секции VAR должно быть определено, откуда разрешен доступ к переменным этой секции.

Доступ к входным и выходным переменным неявно является общим (PUBLIC), поэтому в секциях входных и выходных переменных отсутствует спецификатор доступа. Входные-выходные переменные могут использоваться только в теле функционального блока и в операторе вызова. Доступ к переменным секции VAR_EXTERNAL всегда неявно является защищенным (PROTECTED); поэтому объявление этих переменных не использует спецификатора доступа.

6.6.7.2.7 Наследование функционального блока (EXTENDS, SUPER, OVERRIDE, FINAL)

6.6.7.2.8 Общие положения

Наследование функционального блока похоже на наследование классов. На основе существующего класса или типа функционального блока можно породить один или более функциональных блоков. Данный процесс может повторяться многократно.

6.6.7.2.9 SUPER() в теле порожденного функционального блока

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

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

1 Тело (если имеется) порожденного функционального блока будет вычисляться при вызове функционального блока.

2 Для того чтобы дополнительно выполнить тело базового функционального блока (если оно имеется) в порожденном функциональном блоке, используется вызов SUPER() Вызов SUPER() не имеет параметров.

Вызов SUPER() осуществляется только один раз в теле функционального блока и не используется в цикле.

3 Имена переменных в базовом и порожденном функциональных блоках должны быть уникальными.

4 Вызов функционального блока связывается динамически.

a) Тип порожденного функционального блока может использоваться везде, где может использоваться тип базового функционального блока.

b) Тип порожденного функционального блока может использоваться везде, где может использоваться тип базового функционального блока.

5 SUPER() может вызываться в теле функционального блока, но не в методе функционального блока.

На рисунке 21 показаны примеры использования SUPER():

Рисунок 21 - Наследование тела функционального блока

с SUPER() (пример)

6.6.7.2.10 OVERRIDE (переопределение метода)

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

6.6.7.2.11 FINAL для функционального блока и методов

Метод со спецификатором FINAL не может быть переопределен.

Функциональный блок со спецификатором FINAL не может быть базовым функциональным блоком.

6.6.7.3 Динамическое связывание имен (OVERRIDE)

Связывание имен - это ассоциация имени метода или имени функционального блока с реализацией метода или функционального блока. Оно используется как определено в 6.6.5.6 для методов и функциональных блоков.

6.6.7.4 Вызов метода из собственного и базового FB (THIS, SUPER) и полиморфизм

Для доступа к методу, определенному внутри и снаружи функционального блока используются ключевые слова THIS и SUPER.

6.6.7.5 Абстрактный функциональный блок и абстрактный метод

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

6.6.7.6 Спецификаторы доступа (PROTECTED, PUBLIC, PRIVATE, INTERNAL) к методу

Для каждого метода определяется, откуда разрешен вызов метода, как это определено для классов.

6.6.7.7 Спецификаторы доступа к переменной (PROTECTED, PUBLIC, PRIVATE, INTERNAL)

Для секции VAR определяется, откуда разрешен доступ к переменным секции, как определено это для классов.

Доступ к входным и выходным переменным неявно определен как общий (PUBLIC), поэтому спецификатор доступа в секциях входных и выходных переменных не используется. Выходные переменные неявно доступны только для чтения. Входные-выходные переменные могут использоваться только в теле функционального блока и в операторе вызова. Доступ к переменным секции VAR_EXTERNAL всегда неявно является защищенным (PROTECTED); поэтому объявление данных переменных не использует спецификатора доступа.

6.6.8 Полиморфизм

6.6.8.1 Общие положения

Существует четыре случая, где проявляется полиморфизм, они показаны в 6.6.8.2, 6.6.8.3, 6.6.8.4 и 6.6.8.5.

6.6.8.2 Полиморфизм в интерфейсе

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

6.6.8.3 Полиморфизм в секции VAR_IN_OUT

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

Таким образом, вызов функционального блока и вызов методов функционального блока через экземпляр секции VAR_IN_OUT является случаем динамического связывания.

Пример 1 - Динамическое связывание вызовов функционального блока

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

Пример 2

CLASS LIGHTROOM

VAR LIGHT: BOOL; END_VAR

METHOD PUBLIC SET_DAYTIME

VAR_INPUT: DAYTIME: BOOL; END_VAR

LIGHT:= NOT(DAYTIME);

END_METHOD

END_CLASS

CLASS LIGHT2ROOM EXTENDS LIGHTROOM

VAR LIGHT2: BOOL; END_VAR // Вторая переменная light

METHOD PUBLIC OVERRIDE SET_DAYTIME

VAR_INPUT: DAYTIME: BOOL; END_VAR

SUPER.SET_DAYTIME(DAYTIME); // Вызов LIGHTROOM.SET_DAYTIME LIGHT2:= NOT(DAYTIME);

END_METHOD

END_CLASS

FUNCTION_BLOCK ROOM_CTRL

VAR_IN_OUT RM: LIGHTROOM; END_VAR

VAR_EXTERNAL Actual_TOD: TOD; END_VAR // Определение глобального времени

// В этом случае функциональный блок для вызова динамически связан

// RM может ссылаться на порожденный класс!

RM.SET_DAYTIME(DAYTIME:= (Actual_TOD <= TOD#20:15) AND

(Actual_TOD >= TOD#6:00));

END_FUNCTION_BLOCK

// Использование полиморфизма и динамического связывания со ссылкой

PROGRAM D

VAR

MyRoom1: LIGHTROOM;

MyRoom2: LIGHT2ROOM;

My_Room_Ctrl: ROOM_CTRL;

END_VAR

My_Room_Ctrl(RM:= MyRoom1);

My_Room_Ctrl(RM:= MyRoom2);

END_PROGRAM;

6.6.8.4 Полиморфизм со ссылкой

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

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

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

Пример 1 - Альтернативная реализация примера lightroom

FUNCTION_BLOCK LIGHTROOM

VAR LIGHT: BOOL; END_VAR

VAR_INPUT: DAYTIME: BOOL; END_VAR

LIGHT:= NOT(DAYTIME);

END_FUNCTION_BLOCK

FUNCTION_BLOCK LIGHT2ROOM EXTENDS LIGHTROOM

VAR LIGHT2: BOOL; END_VAR // Дополнительное освещение

SUPER(); // Вызов LIGHTROOM

LIGHT2:= NOT(DAYTIME);

END_FUNCTION_BLOCK

FUNCTION_BLOCK ROOM_CTRL

VAR_INPUT RM: REF_TO LIGHTROOM; END_VAR

VAR_EXTERNAL Actual_TOD: TOD; END_VAR // Определение глобального времени

// в этом случае, функциональный блок для вызова динамически связанного

// RM может относиться к производному типу функционального блока!

IF RM <> NULL THEN

RM.DAYTIME:= (Actual_TOD <= TOD#20:15) AND (Actual_TOD >= TOD#6:00));

END_IF

END_FUNCTION_BLOCK

// Использование полиморфизма и динамического связывания со ссылкой

PROGRAM D

VAR

MyRoom1: LIGHTROOM; // см. выше

MyRoom2: LIGHT2ROOM; // см. выше

My_Room_Ctrl: ROOM_CTRL; // см. выше

END_VAR

My_Room_Ctrl(RM:= REF(MyRoom1));

My_Room_Ctrl(RM:= REF(MyRoom2));

END_PROGRAM;

6.6.8.5 Полиморфизм с THIS

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

Примечание - При особых обстоятельствах, например, если тип или метод функционального блока объявлен как FINAL, или отсутствуют производные типы функциональных блоков, то ссылка или THIS могут быть полностью определены в период компиляции. В данном случае нет необходимости в динамическом связывании.