Логические модули > Руководство пользователя

BCDC_TO_INT

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	BYTE	Двухзначное число в формате BCD
Выходы	BCDC_TO_INT	INT	Двухзначное число в формате DEC

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

Пример

VAR
    bcdInput  : BYTE := 2#01000010; 
    decOutput : INT;
END_VAR

decOutput := OSCAT_BASIC.BCDC_TO_INT(bcdInput); // результат 42

END_PROGRAM

BIT_COUNT

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	DWORD	Строка бит
Выходы	BIT_COUNT	INT	Число бит со значением TRUE

Функция BIT_COUNT возвращает число бит со значением TRUE в переменной IN типа DWORD.

Пример

VAR
    InputVal  : DWORD := 2#0011_0001; 
    result    : INT;
END_VAR

result := OSCAT_BASIC.BIT_COUNT(InputVal); // результат 3

END_PROGRAM

BIT_LOAD_B

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	BYTE	Строка бит
	VAL	BOOL	Значение бита
	POS	INT	Номер бита (0…7)
Выходы	BIT_LOAD_B	BYTE	Строка бит с записанным битом

Функция BIT_LOAD_B устанавливает бит номер POS переменной IN типа BYTE в значение VAL.

Пример

VAR
    InputVal  : BYTE := 2#0011_0001; 
    NewVal    : BOOL := TRUE;
    PosVal    : INT := 1;
    result    : BYTE;
END_VAR

result := OSCAT_BASIC.BIT_LOAD_B(IN:=InputVal, VAL := NewVal, POS := PosVal); 
// результат 2#00110011

END_PROGRAM

BIT_LOAD_B2

Тип модуля: функция	Переменная	Тип	Описание
Входы	I	BYTE	Строка бит
	D	BOOL	Значение бита
	P	INT	Номер начального бита для записи (0…7)
	N	INT	Число записываемых бит
Выходы	BIT_LOAD_B2	BYTE	Строка бит с записанными битами

Функция BIT_LOAD_B2 устанавливает N бит переменной I типа BYTE, начиная с P-го, в значение D.

Пример

VAR
    InputVal  : BYTE := 2#0011_0001; 
    NewVal    : BOOL := TRUE;
    PosVal    : INT := 1;
    AmVal     : INT := 3;
    result    : BYTE;
END_VAR

result := OSCAT_BASIC.BIT_LOAD_B2(I:=InputVal, D := NewVal, P := PosVal, N := AmVal);
// результат 2#00111111

END_PROGRAM

BIT_LOAD_DW

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	DWORD	Строка бит
	VAL	BOOL	Значение бита
	POS	INT	Номер бита (0…31)
Выходы	BIT_LOAD_DW	DWORD	Строка бит с записанным битом

Функция BIT_LOAD_DW устанавливает бит номер POS переменной IN типа DWORD в значение VAL.

Пример

VAR
    InputVal : DWORD := 2#0000_0000_0000_0000_0000_0000_0000_0000; 
    NewVal   : BOOL  := TRUE;
    PosVal   : INT   := 2;
    result   : DWORD;
END_VAR

result := OSCAT_BASIC.BIT_LOAD_DW(IN := InputVal, VAL := NewVal, POS := PosVal); 
(* результат 2#00000000000000000000000000000100*)

END_PROGRAM

BIT_LOAD_DW2

Тип модуля: функция	Переменная	Тип	Описание
Входы	I	DWORD	Строка бит
	D	BOOL	Значение бита
	P	INT	Номер начального бита для записи (0…31)
	N	INT	Число записываемых бит
Выходы	BIT_LOAD_DW2	DWORD	Строка бит с записанными битами

Функция BIT_LOAD_DW2 устанавливает N бит переменной I типа DWORD, начиная с P-го, в значение D.

Пример

VAR
    InputVal  : DWORD := 2#0000_0000_0000_0000_0000_0000_0000_0000; 
    NewVal    : BOOL := TRUE;
    PosVal    : INT := 1;
    AmVal     : INT := 3;
    result    : DWORD;
END_VAR

result := OSCAT_BASIC.BIT_LOAD_DW2(I:=InputVal, 
                     D := NewVal, P := PosVal, N := AmVal); 
(* результат 2#00000000000000000000000000001110 *)

END_PROGRAM

BIT_LOAD_W

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	WORD	Строка бит
	VAL	BOOL	Значение бита
	POS	INT	Номер бита (0…15)
Выходы	BIT_LOAD_W	WORD	Строка бит с записанным битом

Функция BIT_LOAD_W устанавливает бит номер POS переменной IN типа WORD в значение VAL.

Пример

VAR
    InputVal : WORD := 2#0000_0000_0000_0000; 
    NewVal   : BOOL  := TRUE;
    PosVal   : INT   := 2;
    result   : WORD;
END_VAR

result := OSCAT_BASIC.BIT_LOAD_W(IN := InputVal, VAL := NewVal, POS := PosVal); 
(* результат 2#0000000000000100*)

END_PROGRAM

BIT_LOAD_W2

Тип модуля: функция	Переменная	Тип	Описание
Входы	I	WORD	Строка бит
	D	BOOL	Значение бита
	P	INT	Номер начального бита для записи (0…15)
	N	INT	Число записываемых бит
Выходы	BIT_LOAD_W2	WORD	Строка бит с записанными битами

Функция BIT_LOAD_W2 устанавливает N бит переменной I типа WORD, начиная с P-го, в значение D.

Пример

VAR
    InputVal  : WORD := 2#0000_0000_0000_0000; 
    NewVal    : BOOL := TRUE;
    PosVal    : INT := 1;
    AmVal     : INT := 3;
    result    : WORD;
END_VAR

result := OSCAT_BASIC.BIT_LOAD_W2(I:=InputVal, 
                     D := NewVal, P := PosVal, N := AmVal); 
// результат 2#0000000000001110

END_PROGRAM

BIT_OF_DWORD

Тип модуля: функция	Переменная	Тип	Описание
Входы	in	DWORD	Строка бит
Входы	N	INT	Номер бита (0…31)
Выходы	BIT_OF_DWORD	BOOL	Значение бита

Функция BIT_OF_DWORD возвращает значение бита номер N переменной in.

Пример

VAR
    InputVal   : DWORD := 2#0000_1111_0000_1100_0011_1001_1111_0000; 
    NumberVal  : INT := 4;
     result    : BOOL;
END_VAR

result := OSCAT_BASIC.BIT_OF_DWORD(in :=InputVal, N := NumberVal); // результат TRUE

END_PROGRAM

BIT_TOGGLE_B

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	BYTE	Строка бит
Входы	POS	INT	Номер бита (0…7)
Выходы	BIT_TOGGLE_B	BYTE	Строка бит с инвертированным битом

Функция BIT_TOGGLE_B инвертирует бит номер POS переменной in.

Пример

VAR
    InputVal  : BYTE := 2#111_0000; 
    PosVal    : INT := 3;
    result    : BYTE;
END_VAR

result := OSCAT_BASIC.BIT_TOGGLE_B(IN:=InputVal,  POS := PosVal); 
// результат 2#11111000

END_PROGRAM

BIT_TOGGLE_DW

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	DWORD	Строка бит
Входы	POS	INT	Номер бита (0…31)
Выходы	BIT_TOGGLE_DW	DWORD	Строка бит с инвертированным битом

Функция BIT_TOGGLE_DW инвертирует бит номер POS переменной in.

Пример

VAR
    InputVal  : DWORD := 2#0000_0000_0000_0000_0000_0000_1111_0000; 
    PosVal    : INT := 3;
    result    : DWORD;
END_VAR

result := OSCAT_BASIC.BIT_TOGGLE_DW(IN:=InputVal,  POS := PosVal); 
// результат 2#00000000000000000000000011111000

END_PROGRAM

BIT_TOGGLE_W

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	WORD	Строка бит
Входы	POS	INT	Номер бита (0…15)
Выходы	BIT_TOGGLE_W	WORD	Строка бит с инвертированным битом

Функция BIT_TOGGLE_W инвертирует бит номер POS переменной in.

Пример

VAR
    InputVal  : WORD := 2#0000_0000_1111_0000; 
    PosVal    : INT := 3;
    result    : WORD;
END_VAR

result := OSCAT_BASIC.BIT_TOGGLE_W(IN:=InputVal,  POS := PosVal); 
// результат 2#0000000011111000

END_PROGRAM

BYTE_OF_BIT

Тип модуля: функция	Переменная	Тип	Описание
Входы	B0…B7	BOOL	Отдельные биты (B0 – младший)
Выходы	BYTE_OF_BIT	BYTE	Байт, собранный из отдельных бит

Функция BYTE_OF_BIT собирает 8 BOOL переменных в переменную типа BYTE.

Пример

VAR
    bit0 : BOOL := TRUE;   // младший бит
    bit1 : BOOL := FALSE;
    bit2 : BOOL := TRUE;
    bit3 : BOOL := FALSE;
    bit4 : BOOL := TRUE;
    bit5 : BOOL := FALSE;
    bit6 : BOOL := FALSE;
    bit7 : BOOL := TRUE;   // старший бит
    
    resultByte : BYTE;
END_VAR

resultByte := OSCAT_BASIC.BYTE_OF_BIT( 
           B0 := bit0, B1 := bit1, B2 := bit2, B3 := bit3, 
           B4 := bit4, B5 := bit5, B6 := bit6, B7 := bit7);
// результат 10010101 (старший бит слева)

END_PROGRAM

BYTE_OF_DWORD

Тип модуля: функция	Переменная	Тип	Описание
Входы	in	DWORD	Исходная переменная
Входы	N	BYTE	Номер считываемого байта (0…3)
Выходы	BYTE_OF_DWORD	BYTE	Выделенный байт

Функция BYTE_OF_DWORD свыделяет из переменной in типа DWORD байт с номер N. См. также обратную функцию DWORD_OF_BYTE.

Пример

VAR
    InputVar   : DWORD := 16#AABBCCDD;
    NumberVar  : BYTE := 1;
    resultByte : BYTE;
END_VAR

resultByte := OSCAT_BASIC.BYTE_OF_DWORD(in := InputVar, N := NumberVar);
// результат 16#CC

END_PROGRAM

BYTE_TO_BITS

Тип модуля: ФБ	Переменная	Тип	Описание
Входы	in	BYTE	Исходная переменная
Выходы	B0...B7	BOOL	Выделенные биты (B0 – младший)

ФБ BYTE_TO_BITS извлекает отдельные биты из переменной in типа BYTE.

Пример

VAR
    inputByte : BYTE := 16#95;                  // 2#1001_0101
    ByteToBitsInst : OSCAT_BASIC.BYTE_TO_BITS;  // экземпляр ФБ
    
    bit0, bit1, bit2, bit3 : BOOL;              // выходные биты
    bit4, bit5, bit6, bit7 : BOOL;              // выходные биты
END_VAR

ByteToBitsInst(
    in := inputByte, 
    B0 => bit0,     // bit0 = TRUE
    B1 => bit1,     // bit1 = FALSE
    B2 => bit2,     // bit2 = TRUE 
    B3 => bit3,     // bit3 = FALSE
    B4 => bit4,     // bit4 = TRUE
    B5 => bit5,     // bit5 = FALSE    
    B6 => bit6,     // bit6 = FALSE
    B7 => bit7      // bit7 = TRUE
);

END_PROGRAM

BYTE_TO_GRAY

Тип модуля: функция	Переменная	Тип	Описание
Входы	in	BYTE	Число в двоичном коде
Выходы	BYTE_TO_GRAY	BYTE	Число в коде Грея

Функция BYTE_TO_GRAY преобразует число в двоичном коде in в число в коде Грея. См. также обратную функцию GRAY_TO_BYTE.

Пример

VAR
    InputVal  : BYTE := 2#0001_0110; 
    result    : BYTE;
END_VAR

result := OSCAT_BASIC.BYTE_TO_GRAY(InputVal); // результат 2#0001_1101

END_PROGRAM

CHECK_PARITY

Тип модуля: функция	Переменная	Тип	Описание
Входы	in	DWORD	Проверяемая переменная
Входы	p	BOOL	Бит четности
Выходы	CHECK_PARITY	BOOL	Результат проверки

Функция CHECK_PARITY проверяет переменную in типа DWORD с битом четности p на четность и возвращает TRUE в случае, есть общее число битов со значением TRUE (включая значение бита четности) является четным числом. См. также функцию PARITY.

Пример

VAR
    InputVar   : DWORD := 16#1110_0000; 
    ParityVar  : BOOL := TRUE; 
    result     : BOOL;
END_VAR

result := OSCAT_BASIC.CHECK_PARITY(in := InputVar, p := ParityVar); // результат TRUE

END_PROGRAM

CHK_REAL

Тип модуля: функция	Переменная	Тип	Описание
Входы	X	REAL	Проверяемое число с плавающей точкой
Выходы	CHK_REAL	BYTE	Код состояния числа

Функция CHK_REAL проверяет состояние числа с плавающей точкой X и возвращает код состояния согласно стандарту IEEE 754-2008:

16#00 – число с плавающей точкой;
16#20 – +∞;
16#40 – −∞;
16#80 – NaN*.
* — не число.

Пример

VAR
    InputVal  : REAL := 11.22; 
    result    : BYTE;
END_VAR

result := OSCAT_BASIC.CHK_REAL(InputVal); // результат 16#00

END_PROGRAM

CRC_GEN

Тип модуля: функция	Переменная	Тип	Описание
Входы	PT	POINTER TO ARRAY [0..32000] OF BYTE	Пакет данных, для которого будет сгенерирована контрольная сумма
	SIZE	INT	Размер пакета данных (в байтах)
	PL	INT	Степень порождающего полинома
	PN	DWORD	Порождающий полином
	INIT	DWORD	Стартовые данные
	REV_IN	BOOL	Направление вычислений
	REV_OUT	BOOL	Инверсия порядка битов
	XOR_OUT	DWORD	Значение для XOR
Выходы	CRG_GEN	DWORD	Сгенерированная контрольная сумма
Используемые модули	REVERSE, REFLECT

Функция CRC_GEN генерирует контрольную сумму (по алгоритму CRC) для пакета данных размером SIZE байт, расположенных по указателю PT. В большинстве случаев при вызове функции используются операторы ADR() и SIZEOF() – первый возвращает указатель на заданную переменную (массив байт), а второй – ее размер в байтах.

Входная переменная PN определяет производящий полином для функции, PL – его степень. Максимально допустимая степень полинома, используемого в функции – 32. Вход INIT определяет стартовые данные для генерации (обычно 0x0000 или 0xFFFF). Вход REV_IN определяет порядок вычислений: FALSE – со старшего значащего бита, TRUE – с младшего. Вход REV_OUT определяет порядок бит при входе на элемент XOR: FALSE – прямой, TRUE – инвертированный. Вход XOR_OUT определяет число, которое используется при операции XOR.

Функция способна работать с пакетами данных с длиной не менее 4 байта.

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

http://reveng.sourceforge.net/crc-catalogue/ (каталог алгоритмов CRC)

http://zorc.breitbandkatze.de/crc.html (онлайн-генератор контрольных сумм)

http://www.tahapaksu.com/crc/ (еще один онлайн-генератор, удобен при работе с Modbus)

Таблица аргументов функции для некоторых алгоритмов CRC

CRC	PL (DEC)	PN (HEX)	INIT (HEX)	REV_IN	REV_OUT	XOR_OUT (HEX)
CRC-3/ROHC	3	0x3	0x7	TRUE	TRUE	0x0
CRC-4/ITU	4	0x3	0x0	TRUE	TRUE	0x0
CRC5/EPC	5	0x9	0x9	FALSE	FALSE	0x0
CRC-5/ITU	5	0x15	0x0	TRUE	TRUE	0x0
CRC-5/USB	5	0x5	0x1F	TRUE	TRUE	0x1F
CRC-6/DARC	6	0x19	0x0	TRUE	FALSE	0x0
CRC-6/ITU	6	0x3	0x0	TRUE	TRUE	0x0
CRC-7	7	0x9	0x0	FALSE	FALSE	0x0
CRC-7/ROHC	7	0x4F	0x7F	TRUE	TRUE	0x0
CRC-8	8	0x7	0x0	FALSE	FALSE	0x0
CRC-8/DARC	8	0x39	0x0	TRUE	TRUE	0x0
CRC-8/I-CODE	8	0x1D	0xFD	FALSE	FALSE	0x0
CRC-8/ITU	8	0x7	0x0	FALSE	FALSE	0x55
CRC-8/MAXIM	8	0x31	0x0	TRUE	TRUE	0x0
CRC-8/ROHC	8	0x7	0xFF	TRUE	TRUE	0x0
CRC-8/WCDNA	8	0x9B	0x0	TRUE	TRUE	0x0
CRC-10	10	0x233	0x0	FALSE	FALSE	0x0
CRC-11	11	0x385	0x1A	FALSE	FALSE	0x0
CRC-12/3GPP	12	0x80F	0x0	FALSE	TRUE	0x0
CRC-12/DECT	12	0x80F	0x0	FALSE	FALSE	0x0
CRC-14/DARC	14	0x805	0x0	TRUE	TRUE	0x0
CRC-15	15	0x4599	0x0	FALSE	FALSE	0x0
CRC-16/LHA	16	0x8005	0x0	TRUE	TRUE	0x0
CRC-16/CCITT-AUG	16	0x1021	0x1D0F	FALSE	FALSE	0x0
CRC-16/BUYPASS	16	0x8005	0x0	FALSE	FALSE	0x0
CRC-16/CCITT-FALSE	16	0x1021	0xFFFF	FALSE	FALSE	0x0
CRC-16/DDS	16	0x8005	0x800D	FALSE	FALSE	0x0
CRC-16/DECT-R	16	0x589	0x0	FALSE	FALSE	0x1
CRC	PL (DEC)	PN (HEX)	INIT (HEX)	REV_IN	REV_OUT	XOR_OUT (HEX)
CRC-16/DECT-X	16	0x589	0x0	FALSE	FALSE	0x0
CRC-16/DNP	16	0x3D65	0x0	TRUE	TRUE	0xFFFF
CRC-16/EN13757	16	0x3D65	0x0	FALSE	FALSE	0xFFFF
CRC-16/GENIBUS	16	0x1021	0xFFFF	FALSE	FALSE	0xFFFF
CRC-16/MAXIM	16	0x8005	0x0	TRUE	TRUE	0xFFFF
CRC-16/MCRF4XX	16	0x1021	0xFFFF	TRUE	TRUE	0x0
CRC-16/RIELLO	16	0x1021	0xB2AA	TRUE	TRUE	0x0
CRC-16/T10-DIF	16	0x8BB7	0x0	FALSE	FALSE	0x0
CRC-16/TELEDISK	16	0xA097	0x0	FALSE	FALSE	0x0
CRC-16/USB	16	0x8005	0xFFFF	TRUE	TRUE	0xFFFF
CRC-16/CCITT-TRUE	16	0x1021	0x0	TRUE	TRUE	0x0
CRC-16/MODBUS	16	0x8005	0x0	TRUE	TRUE	0x0
CRC-16/X-25	16	0x1021	0xFFFF	TRUE	TRUE	0xFFFF
CRC-16/XMODEM	16	0x1021	0x0	FALSE	FALSE	0x0
CRC-24/OPENPGP	24	0x864CFB	0xB704CE	FALSE	FALSE	0x0
CRC-24/FLEXRAY-A	24	0x5D6DCB	0xFEDCBA	FALSE	FALSE	0x0
CRC-24/FLEXRAY-B	24	0x5D6DCB	0xABCDEF	FALSE	FALSE	0x0
CRC-32/PKZIP	32	0x04C11DB7	0xFFFFFFFF	TRUE	TRUE	0xFFFFFFFF
CRC-32/BZIP2	32	0x04C11DB7	0xFFFFFFFF	FALSE	FALSE	0xFFFFFFFF
CRC-32/CASTAGNOLI	32	0x1EDC6F41	0xFFFFFFFF	TRUE	TRUE	0xFFFFFFFF
CRC-32/D	32	0xA833982B	0xFFFFFFFF	TRUE	TRUE	0xFFFFFFFF
CRC-32/MPEG2	32	0x04C11DB7	0xFFFFFFFF	FALSE	FALSE	0x0
CRC-32/POSIX	32	0x04C11DB7	0x0	FALSE	FALSE	0xFFFFFFFF
CRC-32/Q	32	0x814141AB	0x0	FALSE	FALSE	0x0
CRC-32/JAM	32	0x04C11DB7	0xFFFFFFFF	TRUE	TRUE	0x0
CRC-32/XFER	32	0xAF	0x0	FALSE	FALSE	0x0

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

Примечание

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

Пример

DEC_2

Тип модуля: ФБ	Переменная	Тип	Описание
Входы	D	BOOL	Вход декодера
Входы	A	BOOL	Бит разрешения
Выходы	Q0	BOOL	Выход 0
Выходы	Q1	BOOL	Выход 1

Функциональный блок DEC_2 представляет собой двухбитный декодер. Принцип работы блока:

если A=FALSE, тоQ0:=D;
если A=TRUE, тоQ1:=D.

DEC_4

Тип модуля: ФБ	Переменная	Тип	Описание
Входы	D	BOOL	Вход декодера
	A0	BOOL	Бит разрешения 0
	A1	BOOL	Бит разрешения 1
Выходы	Q0	BOOL	Выход 0
	Q1	BOOL	Выход 1
	Q2	BOOL	Выход 2
	Q3	BOOL	Выход 3

Функциональный блок DEC_4 представляет собой четырехбитный декодер. Принцип работы блока:

если A0=FALSE и A1=FALSE, тоQ0:=D;
если A0=TRUE и A1=FALSE , то Q1:=D;
если A0=FALSE и A1=TRUE, то Q2:=D;
если A0=TRUE и A1=TRUE , то Q3:=D.

DEC_8

Тип модуля: ФБ	Переменная	Тип	Описание
Входы	D	BOOL	Вход декодера
	A0	BOOL	Бит разрешения 0
	A1	BOOL	Бит разрешения 1
	A2	BOOL	Бит разрешения 2
Выходы	Q0	BOOL	Выход 0
	Q1	BOOL	Выход 1
	Q2	BOOL	Выход 2
	Q3	BOOL	Выход 3
	Q4	BOOL	Выход 4
	Q5	BOOL	Выход 5
	Q6	BOOL	Выход 6
	Q7	BOOL	Выход 7

Функциональный блок DEC_8 представляет собой восьмибитный декодер. Принцип работы блока:

если A0=FALSE и A1=FALSE и A2=FALSE, то Q0:=D;
если A0=TRUE и A1=FALSE и A2=FALSE, то Q1:=D;
если A0=FALSE и A1=TRUE и A2=FALSE, то Q2:=D;
если A0=TRUE и A1=TRUE и A2=FALSE, то Q3:=D;
если A0=FALSE и A1=FALSE и A2=TRUE, то Q4:=D;
если A0=TRUE и A1=FALSE и A2=TRUE, то Q5:=D;
если A0=FALSE и A1=TRUE и A2=TRUE, то Q6:=D;
если A0=TRUE и A1=TRUE и A2=TRUE, то Q7:=D.

DW_TO_REAL

Тип модуля: функция	Переменная	Тип	Описание
Входы	X	DWORD	Входное значение
Выходы	DW_TO_REAL	REAL	Представление входного значения как REAL

Функция DW_TO_ REAL интерпретирует входную переменную X типа DWORD как значение с плавающей точкой, представленное в формате IEEE 754. В отличие от стандартного оператора конверсии DWORD_TO_REAL, который преобразует десятичное представление переменной типа DWORD в соответствующее число c плавающей точкой (например, 5->5.0), данная функция не меняет исходное значение, а только представляет его в другом формате. В частности, это необходимо при передаче переменных типа REAL по протоколу Modbus, который не стандартизирует передаваемые типы данных.

См. также обратную функцию REAL_TO_DW.

Пример

VAR
    InputVar  : DWORD := 16#4133851F; 
    result    : REAL;
END_VAR

result := OSCAT_BASIC.DW_TO_REAL(X := InputVar); // результат 11.22

END_PROGRAM

DWORD_OF_BYTE

Тип модуля: функция	Переменная	Тип	Описание
Входы	B3…B0	BYTE	Исходные байты (B0 – младший)
Выходы	DWORD_OF_BYTE	DWORD	Собранное значение

Функция DWORD_OF_BYTE возвращает значение типа DWORD, собранное из отдельных байтов B3…B0, где B0 является младшим байтом.

См. также обратную функцию BYTE_OF_DWORD.

Пример

VAR
    bt0 : BYTE := 16#AA;   // младший байт
    bt1 : BYTE := 16#BB;
    bt2 : BYTE := 16#CC;
    bt3 : BYTE := 16#DD;
    resultDW : DWORD;
END_VAR

resultDW := OSCAT_BASIC.DWORD_OF_BYTE( 
           B0 := bt0, B1 := bt1, B2 := bt2, B3 := bt3
           );
// результат 16#DDCCBBAA

END_PROGRAM

DWORD_OF_WORD

Тип модуля: функция	Переменная	Тип	Описание
Входы	W1…W0	WORD	Исходные слова (W0 – младшее)
Выходы	DWORD_OF_WORD	DWORD	Собранное значение

Функция DWORD_OF_WORD возвращает значение типа DWORD, собранное из отдельных слов W1 и W0, где W0 является младшим cловом.

См. также обратную функцию WORD_OF_DWORD.

Пример

VAR
    word0 : WORD := 16#BBAA;   //младшее слово
    word1 : WORD := 16#DDCC;
    resultDW : DWORD;
END_VAR

resultDW := OSCAT_BASIC.DWORD_OF_WORD( 
           W0 := word0, W1 := word1);
// результат 16#DDCCBBAA

END_PROGRAM

GRAY_TO_BYTE

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	BYTE	Число в коде Грея
Выходы	GRAY_TO_BYTE	BYTE	Число в двоичном коде

Функция GRAY_TO_BYTE преобразует число в коде Грея IN в число в двоичном коде.

См. также обратную функцию BYTE_TO_GRAY.

Пример

VAR
    inVar  : BYTE := 2#0001_1101;
    resVar : BYTE;
END_VAR

resVar := OSCAT_BASIC.GRAY_TO_BYTE(IN := inVar); (* результат 2#0001_0110 *)

END_PROGRAM

INT_TO_BCDC

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	INT	Двухзначное число в формате DEC
Выходы	INT_TO_BCDC	BYTE	Двухзначное число в формате BCD

Функция INT_TO_BCDC конвертирует двухзначное число из десятичного формата в двоично-десятичный.

См. также обратную функцию BCDC_TO_INT.

Пример

VAR
    inVar  : INT := 31;
    resVar : BYTE;
END_VAR

resVar := OSCAT_BASIC.INT_TO_BCDC(IN := inVar); (* результат 2#0011_0001 *)

END_PROGRAM

MATRIX

Тип модуля: ФБ	Переменная	Тип	Описание
Входы	x1…x5	BOOL	Сигналы строк
Выходы	code	BYTE	Код нажатия
	TP	BOOL	Флаг «произошло нажатие»
	y1…y4	BOOL	Сигналы опроса столбцов
Параметры	Release	BOOL	Обработка отпускания кнопки

Функциональный блок MATRIX используется для опроса матричной клавиатуры размером 5x4. На входы x1…5 заводятся сигналы от строк. ФБ последовательно генерирует импульсы на выходах y1…y4, которые должны использоваться для опроса соответствующих столбцов. Если один из входов имеет значение TRUE, то на выход code поступает код нажатой кнопки, содержащий номер ее строки и столбца, а на выходе TP генерируется единичный импульс. Если параметр Release имеет значение TRUE, то отрабатывается также отпускание кнопки.

Расшифровка битов кода
Бит 7	TRUE – кнопка нажата, FALSE – кнопка отпущена
Бит 6	Номер столбца (бит 2)	От 0 до 3
Бит 5	Номер столбца (бит 1)
Бит 4	Номер столбца (бит 0)
Бит 3	Всегда FALSE
Бит 2	Номер строки (бит 2)	От 1 до 5
Бит 1	Номер строки (бит 1)
Бит 0	Номер строки (бит 0)

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

MUX_2

Тип модуля: функция	Переменная	Тип	Описание
Входы	D0	BOOL	Информационный вход 0
	D1	BOOL	Информационный вход 1
	A0	BOOL	Адресный вход
Выходы	MUX_2	BOOL	Выход мультиплексора

Функция MUX_2 реализует двухбитный мультиплексор. Принцип работы функции:

если A0=FALSE, то MUX_2:=D0;
если A0=TRUE, то MUX_2:=D1.

MUX_4

Тип модуля: функция	Переменная	Тип	Описание
Входы	D0	BOOL	Информационный вход 0
	D1	BOOL	Информационный вход 1
	D2	BOOL	Информационный вход 2
	D3	BOOL	Информационный вход 3
	A0	BOOL	Адресный вход 0
	A1	BOOL	Адресный вход 1
Выходы	MUX_4	BOOL	Выход мультиплексора

Функция MUX_4 реализует четырехбитный мультиплексор. Принцип работы функции:

если A0=FALSE и A1=FALSE, то MUX_4:=D0;
если A0=TRUE и A1=FALSE, то MUX_4:=D1;
если A0=FALSE и A1=TRUE, то MUX_4:=D2;
если A0=TRUE и A1=TRUE, то MUX_4:=D3.

PARITY

Тип модуля: функция	Переменная	Тип	Описание
Входы	in	BYTE	Исходный байт
Выходы	PARITY	BOOL	Бит четности

Функция PARITY вычисляет бит четности для байта in. Соответственно, если число битов в состоянии TRUE в байте является нечетным, то бит четности = TRUE. В противном случает бит четности = FALSE.

См. также функцию CHECK_PARITY.

Пример

VAR
    InputVar   : BYTE := 2#1111_1000; 
    result     : BOOL;
END_VAR

result := OSCAT_BASIC.PARITY(in := InputVar); // результат TRUE

END_PROGRAM

REAL_TO_DW

Тип модуля: функция	Переменная	Тип	Описание
Входы	X	REAL	Входное значение
Выходы	REAL_TO_DW	DWORD	Представление входного значения как DWORD

Функция REAL_TO_DW интерпретирует входную переменную X типа REAL как значение в шестнадцатеричной системе. В отличие от стандартного оператора конверсии REAL_TO_DWORD, который округляет значение с плавающей точкой до ближайшего меньшего целого (например, 5.7->5), данная функция не меняет исходное значение, а только представляет его в другом формате. В частности, это необходимо при передаче переменных типа REAL по протоколу Modbus, который не стандартизирует передаваемые типы данных.

См. также обратную функцию DW_TO_REAL.

Пример

VAR
    inVar  : REAL := 11.22;
    resVar : DWORD;
END_VAR

resVar := OSCAT_BASIC.REAL_TO_DW(X := inVar); (* результат 16#4133851F *)

END_PROGRAM

REFLECT

Тип модуля: функция	Переменная	Тип	Описание
Входы	D	DWORD	Строка бит
Входы	L	INT	Длина отражаемой части
Выходы	REFLECT	DWORD	Строка бит с обратным порядком бит

Функция REFLECT меняет порядок L младших бит переменной D на обратный.

Пример

VAR
    inVar  : DWORD := 2#1100_0001;
    LVar   : INT := 4;
    resVar : DWORD;
END_VAR

resVar := OSCAT_BASIC.REFLECT(D := inVar, L := LVar);
 (* результат 2#0000_0000_0000_0000_0000_0000_1100_1000 *)

END_PROGRAM

REVERSE

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	BYTE	Строка бит
Выходы	REVERSE	BYTE	Строка бит с обратным порядком бит

Функция REVERSE меняет порядок бит переменной IN на обратный.

Пример

VAR
    inVar  : BYTE := 2#1100_0001;
    resVar : BYTE;
END_VAR

resVar := OSCAT_BASIC.REVERSE(IN := inVar); (* результат 2#1000_0011 *)

END_PROGRAM

SHL1

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	DWORD	Строка бит
Входы	N	INT	Кол-во сдвигаемых бит
Выходы	SHL1	DWORD	Строка бит, сдвинутая влево

Функция SHL1 выполняет побитный сдвиг переменной IN влево на N бит с дополнением единицами справа (в отличие от стандартного оператора SHL, который производит дополнение нулями).

Пример

VAR
    inVar  : DWORD := 2#0000_0000_1100_0001;
    NVar   : INT := 8;
    resVar : DWORD;
END_VAR

resVar := OSCAT_BASIC.SHL1(IN := inVar, N := NVar);
 (* результат 2#0000_0000_0000_0000__1100_0001_1111_1111 *)

END_PROGRAM

SHR1

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	DWORD	Строка бит
Входы	N	INT	Кол-во сдвигаемых бит
Выходы	SHR1	DWORD	Строка бит, сдвинутая вправо

Функция SHR1 выполняет побитный сдвиг переменной IN вправо на N бит с дополнением единицами слева (в отличие от стандартного оператора SHR, который производит дополнение нулями).

Пример

VAR
    inVar  : DWORD := 2#0000_0000_0000_0000_0000_0000_1100_0001;
    NVar   : INT := 4;
    resVar : DWORD;
END_VAR

resVar := OSCAT_BASIC.SHR1(IN := inVar, N := NVar);
 (* результат 2#1111_0000_0000_0000_0000_0000_0000_1100 *)

END_PROGRAM

SWAP_BYTE

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	WORD	Исходная переменная
Выходы	SWAP_BYTE	WORD	Переменная с переставленными байтами

Функция SWAP_BYTE меняет порядок байт переменной IN.

Пример

VAR
    inVar  : WORD := 16#ADDE;
    resVar : WORD;
END_VAR

resVar := OSCAT_BASIC.SWAP_BYTE(IN := inVar); (* результат 16#DEAD *)

END_PROGRAM

SWAP_BYTE2

Тип модуля: функция	Переменная	Тип	Описание
Входы	IN	DWORD	Исходная переменная
Выходы	SWAP_BYTE	DWORD	Переменная с обратным порядком байт

Функция SWAP_BYTE2 меняет порядок байт переменной IN на обратный.

Пример

VAR
    inVar  : DWORD := 16#AABBCCDD;
    resVar : DWORD;
END_VAR

resVar := OSCAT_BASIC.SWAP_BYTE2(IN := inVar); (* результат 16#DDCCBBAA *)

END_PROGRAM

WORD_OF_BYTE

Тип модуля: функция	Переменная	Тип	Описание
Входы	B1…B0	BYTE	Исходные байты (B0 – младший)
Выходы	WORD_OF_BYTE	WORD	Собранное значение

Функция WORD_OF_BYTE возвращает значение типа DWORD, собранное из отдельных байтов B1…B0, где B0 является младшим байтом.

Пример

VAR
    bt0 : BYTE := 16#AD;   // младший байт
    bt1 : BYTE := 16#DE;
    resW : WORD;
END_VAR

resW := OSCAT_BASIC.WORD_OF_BYTE(B0 := bt0, B1 := bt1);
// результат 16#DEAD

END_PROGRAM

WORD_OF_DWORD

Тип модуля: функция	Переменная	Тип	Описание
Входы	in	DWORD	Исходная переменная
Входы	N	BYTE	Номер считываемого слова (0…1)
Выходы	WORD_OF_DWORD	WORD	Выделенное слово

Функция WORD_OF_DWORD выделяет из переменной in типа DWORD слово с номером N.

См. также обратную функцию DWORD_OF_WORD.

Пример

VAR
    dwVar : DWORD := 16#AABBCCDD;   //младшее слово
    num   : BYTE := 0;
    resultW : WORD;
END_VAR

resultW := OSCAT_BASIC.WORD_OF_DWORD(in := dwVar, N := num);
// результат 16#CCDD

END_PROGRAM