OSCAT_BASIC.SCHEDULER_0(T := tT1, T3 := T#200MS);
|
ALL_SAINTS: OSCAT_BASIC.HOLIDAY_DATA := (NAME := 'All Saints Day',
DAY := 1,
MONTH := 11,
USE := 1); |
ALL_SAINTS: OSCAT_BASIC.HOLIDAY_DATA := (NAME := 'Пасха',
DAY := 0,
MONTH := 0,
USE := 1); |
SAINT_TRINITY_DAY: OSCAT_BASIC.HOLIDAY_DATA := (NAME := 'Святая Троица',
DAY := 49,
MONTH := 0,
USE := 1); |
BUSS_UND_BETAG: OSCAT_BASIC.HOLIDAY_DATA := (NAME := 'Buss und Betag',
DAY := 27,
MONTH := 11,
USE := -3); |
HOLIDAYS_RU: OSCAT_BASIC.ARRAY [0..29] OF HOLIDAY_DATA; |
IF rst OR cnt < 0 THEN
pos := -1;
cnt := 0; //bug-fix |
VAR
xIn : BOOL;
dwVer : DWORD; (* версия библиотеки *)
dwRel : DWORD; (* дата релиза *)
END_VAR
xIn := FALSE;
dwVer := OSCAT_BASIC.OSCAT_VERSION(IN := xIn); (* вернёт версию библиотеки (DWORD),
зависит от установленной версии *)
xIn := TRUE;
dwRel := OSCAT_BASIC.OSCAT_VERSION(IN := xIn); (* вернёт дату релиза (DWORD),
зависит от установленной версии *)
END_PROGRAM |
VAR
bStatus : BYTE := 101; (* 100..199 — состояния ФБ *)
sAddr : STRING(10) := 'FB1.STATE'; (* описание/имя параметра *)
dtChange : DT := DT#2026-06-18-12:00:00; (* дата/время события *)
tStamp : TIME := T#1234ms; (* мс после старта *)
esr : OSCAT_BASIC.ESR_DATA; (* результат *)
typ : BYTE;
addrOut : STRING(10);
dsOut : DT;
tsOut : TIME;
b0 : BYTE;
END_VAR
esr := OSCAT_BASIC.STATUS_TO_ESR(
status := bStatus,
adress := sAddr,
DT_in := dtChange,
TS := tStamp
);
(* Пример чтения полей структуры ESR_DATA *)
typ := esr.TYP;
addrOut := esr.ADRESS;
dsOut := esr.DS;
tsOut := esr.TS;
b0 := esr.DATA[0];
END_PROGRAM |
VAR
x : REAL := 2.0; (* Аргумент, должен быть >= 1.0 *)
y : REAL; (* Результат ACOSH(x) *)
END_VAR
y := OSCAT_BASIC.ACOSH(x); (* y ≈ 1.3169579 *)
END_PROGRAM |
VAR
x : REAL := 2.0; (* |x| > 1 *)
y : REAL;
END_VAR
y := OSCAT_BASIC.ACOTH(X := x); (* y ≈ 0.5493061 *)
END_PROGRAM |
VAR
x : REAL := 0.5;
y : REAL;
END_VAR
y := OSCAT_BASIC.AGDF(X := x); (* у=0.5222381*)
END_PROGRAM |
VAR
x : REAL := 2;
y : REAL;
END_VAR
y := OSCAT_BASIC.ASINH(X := x); (* y=1.44363546*)
END_PROGRAM |
VAR
x : REAL := 1.0;
y : REAL := 1.0;
a1 : REAL;
x2 : REAL := 1.0;
y2 : REAL := 0.0;
a2 : REAL;
END_VAR
a1 := OSCAT_BASIC.ATAN2(Y := y, X := x); (* a1 ≈ 0.7853982 рад (π/4) *)
a2 := OSCAT_BASIC.ATAN2(Y := y2, X := x2); (* a2 = 0 рад *)
END_PROGRAM |
VAR
X : REAL := 0.5; (* Аргумент (в диапазоне -1..1, не включая ±1) *)
Y : REAL; (* Результат *)
END_VAR
Y := OSCAT_BASIC.ATANH(X); (* Y = ATANH(0.5) ≈ 0.549306 *)
END_PROGRAM |
VAR
x : REAL := 0.5;
y : REAL := 0.5;
b : REAL;
END_VAR
b := OSCAT_BASIC.BETA(X := x, Y := y); (* b = 3.10966635 *)
END_PROGRAM |
VAR
n : INT := 4;
k : INT := 2;
c : DINT;
END_VAR
c := OSCAT_BASIC.BINOM(N := n, K := k); (* c = 6 *)
END_PROGRAM |
VAR
x : REAL := 1.0; (* аргумент *)
t : REAL := 0.0; (* сдвиг *)
u : REAL := 0.5; (* масштаб, > 0 *)
p : REAL;
END_VAR
p := OSCAT_BASIC.CAUCHY(X := x, T := t, U := u); (* p ≈ 0.127323955 *)
END_PROGRAM |
VAR
x1 : REAL := 3.14;
x2 : REAL := -2.30;
r1 : INT;
r2 : INT;
END_VAR
r1 := OSCAT_BASIC.CEIL(X := x1); (* r1 = 4 *)
r2 := OSCAT_BASIC.CEIL(X := x2); (* r2 = -2 *)
END_PROGRAM |
VAR
x1 : REAL := 33000.22;
x2 : REAL := -33000.22;
r1 : DINT;
r2 : DINT;
END_VAR
r1 := OSCAT_BASIC.CEIL2(X := x1); (* r1 = 33001 *)
r2 := OSCAT_BASIC.CEIL2(X := x2); (* r2 = -33000 *)
END_PROGRAM |
VAR
x1 : REAL := 12.34567;
y1 : REAL := 12.34512;
n1 : INT := 5;
eq1 : BOOL;
x2 : REAL := 1.234567;
y2 : REAL := 1.229999;
n2 : INT := 4;
eq2 : BOOL;
END_VAR
eq1 := OSCAT_BASIC.CMP(X := x1, Y := y1, N := n1); (* eq1 = TRUE *)
eq2 := OSCAT_BASIC.CMP(X := x2, Y := y2, N := n2); (* eq2 = FALSE *)
END_PROGRAM |
VAR
x : REAL := 2.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.COSH(X := x); (* y ≈ 3.76219583 *)
END_PROGRAM |
VAR
x : REAL := 2.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.COTH(X := x); (* y ≈ 1.03731477 *)
END_PROGRAM |
VAR
x1 : REAL := 3.99;
x2 : REAL := -3.99;
r1 : DINT;
r2 : DINT;
END_VAR
r1 := OSCAT_BASIC.D_TRUNC(X := x1); (* r1 = 3 *)
r2 := OSCAT_BASIC.D_TRUNC(X := x2); (* r2 = -3 *)
END_PROGRAM |
VAR
x1 : INT := 5;
n1 : INT := 10;
r1 : INT;
x2 : INT := 0;
n2 : INT := 10;
r2 : INT;
END_VAR
r1 := OSCAT_BASIC.DEC1(X := x1, N := n1); (* r1 = 4 *)
r2 := OSCAT_BASIC.DEC1(X := x2, N := n2); (* r2 = 9 *)
END_PROGRAM |
VAR
r1 : REAL := 3.1415927; (* π *)
d1 : REAL;
END_VAR
d1 := OSCAT_BASIC.DEG(rad := r1); (* d1 ≈ 180.0 *)
END_PROGRAM |
VAR
a : REAL := 10.0;
b : REAL := 10.3;
x : REAL := 0.2;
r1 : BOOL;
c : REAL := 10.0;
d : REAL := 10.1;
r2 : BOOL;
END_VAR
r1 := OSCAT_BASIC.DIFFER(in1 := a, in2 := b, X := x); (* r1 = TRUE,
|10.0-10.3| = 0.3 > 0.2 *)
r2 := OSCAT_BASIC.DIFFER(in1 := c, in2 := d, X := x); (* r2 = FALSE,
|10.0-10.1| = 0.1 <= 0.2 *)
END_PROGRAM
|
VAR
x : REAL := 0.05;
y : REAL;
END_VAR
y := OSCAT_BASIC.ERF(X := x); (* y = 0.5637164 *)
END_PROGRAM |
VAR
x : REAL := 0.05;
y : REAL;
END_VAR
y := OSCAT_BASIC.ERFC(X := x); (* y = 0.9436284 *)
END_PROGRAM |
VAR
a : DINT := 10;
b : DINT := 11;
r1 : BOOL;
r2 : BOOL;
END_VAR
r1 := OSCAT_BASIC.EVEN(in := a); (* r1 = TRUE *)
r2 := OSCAT_BASIC.EVEN(in := b); (* r2 = FALSE *)
END_PROGRAM |
VAR
x1 : REAL := 2.0;
y1 : REAL;
x2 : REAL := -1.0;
y2 : REAL;
END_VAR
y1 := OSCAT_BASIC.EXP10(X := x1); (* y1 = 100.0 *)
y2 := OSCAT_BASIC.EXP10(X := x2); (* y2 = 0.1 *)
END_PROGRAM |
VAR
x1 : REAL := 2.0;
n1 : INT := 10;
y1 : REAL;
x2 : REAL := 5.0;
n2 : INT := 0;
y2 : REAL;
END_VAR
y1 := OSCAT_BASIC.EXPN(X := x1, N := n1); (* y1 = 1024.0 *)
y2 := OSCAT_BASIC.EXPN(X := x2, N := n2); (* y2 = 1.0 *)
END_PROGRAM |
VAR
x1 : INT := 5;
f1 : DINT;
x2 : INT := 13;
f2 : DINT;
END_VAR
f1 := OSCAT_BASIC.FACT(X := x1); (* f1 = 120 *)
f2 := OSCAT_BASIC.FACT(X := x2); (* f2 = -1 (вне диапазона 0..12) *)
END_PROGRAM |
VAR
x1 : INT := 10;
f1 : DINT;
x2 : INT := -1;
f2 : DINT;
END_VAR
f1 := OSCAT_BASIC.FIB(X := x1); (* f1 = 55 *)
f2 := OSCAT_BASIC.FIB(X := x2); (* f2 = -1 (вне допустимого диапазона) *)
END_PROGRAM |
VAR
x1 : REAL := 3.14;
x2 : REAL := -2.30;
r1 : INT;
r2 : INT;
END_VAR
r1 := OSCAT_BASIC.FLOOR(X := x1); (* r1 = 3 *)
r2 := OSCAT_BASIC.FLOOR(X := x2); (* r2 = -3 *)
END_PROGRAM |
VAR
x1 : REAL := 35000.25;
x2 : REAL := -35000.25;
r1 : DINT;
r2 : DINT;
END_VAR
r1 := OSCAT_BASIC.FLOOR2(X := x1); (* r1 = 35000 *)
r2 := OSCAT_BASIC.FLOOR2(X := x2); (* r2 = -35001 *)
END_PROGRAM |
VAR
x1 : REAL := 12.345;
f1 : REAL;
x2 : REAL := -12.345;
f2 : REAL;
END_VAR
f1 := OSCAT_BASIC.FRACT(X := x1); (* f1 ≈ 0.345 *)
f2 := OSCAT_BASIC.FRACT(X := x2); (* f2 ≈ -0.345 *)
END_PROGRAM |
VAR
x1 : REAL := 5.0;
g1 : REAL;
x2 : REAL := 6.0;
g2 : REAL;
END_VAR
g1 := OSCAT_BASIC.GAMMA(X := x1); (* g1 ≈ 24.0 (Γ(5) = 4! ) *)
g2 := OSCAT_BASIC.GAMMA(X := x2); (* g2 ≈ 120.0 (Γ(6) = 5! ) *)
END_PROGRAM |
VAR
x : REAL := 0.0; (* аргумент *)
u : REAL := 0.0; (* среднее (сдвиг) *)
si : REAL := 1.0; (* σ (масштаб), > 0 *)
p : REAL;
END_VAR
p := OSCAT_BASIC.GAUSS(X := x, U := u, SI := si); (* p ≈ 0.3989423 *)
END_PROGRAM |
VAR
x : REAL := 0.0; (* аргумент *)
u : REAL := 0.0; (* среднее (сдвиг) *)
si : REAL := 1.0; (* σ (масштаб), > 0 *)
f : REAL;
END_VAR
f := OSCAT_BASIC.GAUSSCD(X := x, U := u, SI := si); (* f = 0.5 *)
END_PROGRAM |
VAR
a : DINT := 48;
b : DINT := 18;
g : INT;
END_VAR
g := OSCAT_BASIC.GCD(A := a, B := b); (* g = 6 *)
END_PROGRAM |
VAR
x : REAL := 5.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.GDF(X := x); (* y = 1.55732048 *)
END_PROGRAM |
VAR
x : REAL := 1.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.GOLD(X := x); (* y ≈ 1.6180339 *)
END_PROGRAM |
VAR
x : REAL := 3.0;
y : REAL := 4.0;
h : REAL;
END_VAR
h := OSCAT_BASIC.HYPOT(X := x, Y := y); (* h = 5.0 *)
END_PROGRAM |
VAR
x1 : INT := 5;
d1 : INT := 3;
m : INT := 10;
r1 : INT;
x2 : INT := 9;
d2 : INT := 3;
r2 : INT;
x3 : INT := 1;
d3 : INT := -5;
r3 : INT;
END_VAR
r1 := OSCAT_BASIC.INC(X := x1, D := d1, M := m); (* r1 = 8 *)
r2 := OSCAT_BASIC.INC(X := x2, D := d2, M := m); (* r2 = 0 (12 > 10) *)
r3 := OSCAT_BASIC.INC(X := x3, D := d3, M := m); (* r3 = 10 (-4 < 0) *)
END_PROGRAM |
VAR
x1 : INT := 3;
n : INT := 5;
r1 : INT;
x2 : INT := 4;
r2 : INT;
END_VAR
r1 := OSCAT_BASIC.INC1(X := x1, N := n); (* r1 = 4 *)
r2 := OSCAT_BASIC.INC1(X := x2, N := n); (* r2 = 0 (т.к. 4 -> 0 при N=5) *)
END_PROGRAM |
VAR
x1 : INT := 5;
d1 : INT := 3;
l : INT := 0;
u : INT := 10;
r1 : INT;
x2 : INT := 9;
d2 : INT := 3;
r2 : INT;
x3 : INT := 1;
d3 : INT := -5;
r3 : INT;
END_VAR
r1 := OSCAT_BASIC.INC2(X := x1, D := d1, L := l, U := u); (*r1 = 8*)
r2 := OSCAT_BASIC.INC2(X := x2, D := d2, L := l, U := u); (*r2 = 0 (12 > 10 -> L)*)
r3 := OSCAT_BASIC.INC2(X := x3, D := d3, L := l, U := u); (*r3 = 10 (-4 < 0 -> U)*)
END_PROGRAM |
VAR
x : INT := 4;
y : REAL;
END_VAR
y := OSCAT_BASIC.INV(X := x); (* y = 0.25 *)
END_PROGRAM |
VAR
x : REAL := 3.0;
w : REAL;
END_VAR
w := OSCAT_BASIC.LAMBERT_W(X := x); (* w ≈ 1.04990888 *)
END_PROGRAM |
VAR
x : REAL := 5.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.LANGEVIN(X := x); (* y ≈ 0.800090849 *)
END_PROGRAM |
VAR
a : REAL := 1.2;
b : REAL := 5.6;
c : REAL := 3.4;
m : REAL;
END_VAR
m := OSCAT_BASIC.MAX3(in1 := a, in2 := b, in3 := c); (* m = 5.6 *)
END_PROGRAM |
VAR
a : REAL := 1.2;
b : REAL := 5.6;
c : REAL := 3.4;
m : REAL;
END_VAR
m := OSCAT_BASIC.MID3(in1 := a, in2 := b, in3 := c); (* m = 3.4 *)
END_PROGRAM |
VAR
a : REAL := 1.2;
b : REAL := 5.6;
c : REAL := 3.4;
m : REAL;
END_VAR
m := OSCAT_BASIC.MIN3(in1 := a, in2 := b, in3 := c); (* m = 1.2 *)
END_PROGRAM |
VAR
a1 : REAL := 5.5;
b1 : REAL := 2.0;
r1 : REAL;
a2 : REAL := 5.5;
b2 : REAL := 0.0;
r2 : REAL;
END_VAR
r1 := OSCAT_BASIC.MODR(IN := a1, DIVI := b1); (* r1 = 1.5 *)
r2 := OSCAT_BASIC.MODR(IN := a2, DIVI := b2); (* r2 = 0.0 (DIVI=0) *)
END_PROGRAM |
VAR
x : REAL := 10.0;
k : REAL := 2.5;
o : REAL := -3.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.MUL_ADD(X := x, K := k, O := o); (* y = 22.0 *)
END_PROGRAM |
VAR
x : REAL := 12.5;
y : REAL;
END_VAR
y := OSCAT_BASIC.NEGX(X := x); (* y = -12.5 *)
END_PROGRAM |
VAR
d1 : REAL := 180.0;
r1 : REAL;
d2 : REAL := 450.0; (* > 360°, будет приведено к диапазону 0..360° *)
r2 : REAL;
END_VAR
r1 := OSCAT_BASIC.RAD(DEG := d1); (* r1 ≈ 3.1415927 *)
r2 := OSCAT_BASIC.RAD(DEG := d2); (* r2 ≈ 1.5707963 (т.к. 450° -> 90°) *)
END_PROGRAM |
VAR
seed : REAL := 0.12345; (* зерно (last) *)
r1 : REAL;
r2 : REAL;
END_VAR
(* Первый вызов: получаем псевдослучайное число в диапазоне [0,1) *)
r1 := OSCAT_BASIC.RDM(last := seed); (* 0.0 <= r1 < 1.0 *)
(* Обновляем зерно значением предыдущего вызова *)
seed := r1;
(* Следующий вызов (в следующем цикле ПЛК): новое число, используя seed *)
r2 := OSCAT_BASIC.RDM(last := seed); (* 0.0 <= r2 < 1.0, обычно r2 <> r1 *)
END_PROGRAM |
VAR
seed : INT := 12345; (* зерно (last) *)
low : INT := 10;
high : INT := 20;
r1 : INT;
r2 : INT;
END_VAR
(* Первый вызов: целое число в диапазоне [10..20] *)
r1 := OSCAT_BASIC.RDM2(last := seed, low := low, high := high); (* 10 <= r1 <= 20 *)
(* Обновляем зерно значением предыдущего результата *)
seed := r1;
(* Следующий вызов (в следующем цикле ПЛК): новое число, используя seed *)
r2 := OSCAT_BASIC.RDM2(last := seed, low := low, high := high); (* 10 <= r2 <= 20,
обычно r2 <> r1 *)
END_PROGRAM |
VAR
seed : DWORD := 0.12345; (* зерно (last) *)
dw : DWORD;
END_VAR
(* Получаем псевдослучайный 32-битный набор *)
dw := OSCAT_BASIC.RDMDW(last := seed);
(* В качестве зерна для следующего цикла можно использовать предыдущее значение seed,
либо обновлять seed (например, значением OSCAT_BASIC.RDM(last := seed)) *)
END_PROGRAM |
VAR
x : REAL := 0.75;
n : INT := 100;
f : OSCAT_BASIC.FRACTION;
END_VAR
f := OSCAT_BASIC.REAL_TO_FRAC(X := x, N := n); (* ожидаемо: f = 3/4
(знаменатель <= 100) *)
END_PROGRAM |
VAR
x1 : REAL := 1234.56;
n1 : INT := 3;
y1 : REAL;
x2 : REAL := 0.012345;
n2 : INT := 2;
y2 : REAL;
END_VAR
y1 := OSCAT_BASIC.RND(X := x1, N := n1); (* y1 ≈ 1230.0 (3 значащие цифры) *)
y2 := OSCAT_BASIC.RND(X := x2, N := n2); (* y2 ≈ 0.012 (2 значащие цифры) *)
END_PROGRAM |
VAR
x1 : REAL := 12.3456;
n1 : INT := 2;
y1 : REAL;
x2 : REAL := 12.344;
n2 : INT := 2;
y2 : REAL;
END_VAR
y1 := OSCAT_BASIC.ROUND(in := x1, N := n1); (* y1 = 12.35 *)
y2 := OSCAT_BASIC.ROUND(in := x2, N := n2); (* y2 = 12.34 *)
END_PROGRAM |
VAR
x1 : REAL := 10.0;
x2 : REAL := 0.0;
x3 : REAL := -2.5;
s1 : INT;
s2 : INT;
s3 : INT;
END_VAR
s1 := OSCAT_BASIC.SGN(X := x1); (* s1 = 1 *)
s2 := OSCAT_BASIC.SGN(X := x2); (* s2 = 0 *)
s3 := OSCAT_BASIC.SGN(X := x3); (* s3 = -1 *)
END_PROGRAM |
VAR
x : REAL := 0.5;
y : REAL;
END_VAR
y := OSCAT_BASIC.SIGMOID(X := x); (* y = 0.622459352 *)
END_PROGRAM |
VAR
a : DINT := -10;
b : DINT := 10;
r1 : BOOL;
r2 : BOOL;
END_VAR
r1 := OSCAT_BASIC.SIGN_I(in := a); (* r1 = TRUE *)
r2 := OSCAT_BASIC.SIGN_I(in := b); (* r2 = FALSE *)
END_PROGRAM |
VAR
a : REAL := -10.0;
b : REAL := 10.0;
r1 : BOOL;
r2 : BOOL;
END_VAR
r1 := OSCAT_BASIC.SIGN_R(in := a); (* r1 = TRUE *)
r2 := OSCAT_BASIC.SIGN_R(in := b); (* r2 = FALSE *)
END_PROGRAM |
VAR
x : REAL := 0.5;
y : REAL;
END_VAR
y := OSCAT_BASIC.SINC(X := x); (* y = 0.9588511 *)
END_PROGRAM |
VAR
x : REAL := 0.5;
y : REAL;
END_VAR
y := OSCAT_BASIC.SINH(X := x); (* y ≈ 0.5210953 *)
END_PROGRAM |
VAR
x : REAL := 27.0;
n : REAL := 3.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.SQRTN(X := x, N := n); (* y = 3.0 *)
END_PROGRAM |
VAR
x : REAL := 0.5;
y : REAL;
END_VAR
y := OSCAT_BASIC.TANC(X := x); (* y = 1.092605 *)
END_PROGRAM |
VAR
x : REAL := 0.5;
y : REAL;
END_VAR
y := OSCAT_BASIC.TANH(X := x); (* y = 0.462117136 *)
END_PROGRAM |
VAR
low : REAL := 0.5;
high : REAL := 10.0;
x1 : REAL := 5.0;
x2 : REAL := 0.0;
r1 : BOOL;
r2 : BOOL;
END_VAR
r1 := OSCAT_BASIC.WINDOW(low := low, in := x1, high := high); (* r1 = TRUE *)
r2 := OSCAT_BASIC.WINDOW(low := low, in := x2, high := high); (* r2 = FALSE *)
END_PROGRAM |
VAR
low : REAL := 0.0;
high : REAL := 10.0;
x1 : REAL := 0.0;
x2 : REAL := 10.0;
x3 : REAL := 10.1;
r1 : BOOL;
r2 : BOOL;
r3 : BOOL;
END_VAR
r1 := OSCAT_BASIC.WINDOW2(low := low, in := x1, high := high); (* r1 = TRUE *)
r2 := OSCAT_BASIC.WINDOW2(low := low, in := x2, high := high); (* r2 = TRUE *)
r3 := OSCAT_BASIC.WINDOW2(low := low, in := x3, high := high); (* r3 = FALSE *)
END_PROGRAM |
VAR
aArr : ARRAY[0..9] OF REAL; (* обрабатываемый массив *)
rRes : REAL; (* результат функции, если она возвращает REAL *)
END_VAR
(* Пример вызова: имя функции условное *)
rRes := OSCAT_BASIC.MyArrayFunc(
pt := ADR(aArr), (* указатель на массив *)
size := SIZEOF(aArr) (* размер массива в байтах *)
);
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
done: BOOL;
END_VAR
done := OSCAT_BASIC._ARRAY_ABS(
pt := ADR(a),
size := SIZEOF(a)
); (* после обработки: a = [2.0, 12.0, 4.0, 8.0, 6.0], done = TRUE *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
xAdd : REAL := 10.0;
done : BOOL;
END_VAR
done := OSCAT_BASIC._ARRAY_ADD(
pt := ADR(a),
size := SIZEOF(a),
X := xAdd
); (* после обработки: a = [8.0, 22.0, 6.0, 18.0, 16.0], done = TRUE *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
init : REAL := 0.0;
done : BOOL;
END_VAR
done := OSCAT_BASIC._ARRAY_INIT(
pt := ADR(a),
size := SIZEOF(a),
init := init
); (* после обработки: a = [0.0, 0.0, 0.0, 0.0, 0.0], done = TRUE *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
median : REAL;
END_VAR
median := OSCAT_BASIC._ARRAY_MEDIAN(
pt := ADR(a),
size := SIZEOF(a)
); (* после обработки: a = [-4.0, -2.0, 6.0, 8.0, 12.0], median = 6.0 *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
xMul : REAL := 3.0;
done : BOOL;
END_VAR
done := OSCAT_BASIC._ARRAY_MUL(
pt := ADR(a),
size := SIZEOF(a),
X := xMul
); (* после обработки: a = [-6.0, 36.0, -12.0, 24.0, 18.0], done = TRUE *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
done : BOOL;
END_VAR
done := OSCAT_BASIC._ARRAY_SHUFFLE(
pt := ADR(a),
size := SIZEOF(a)
);
(* После обработки элементы массива a будут перемешаны в случайном порядке.
Конкретный порядок заранее не фиксирован, done = TRUE. *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
done : BOOL;
END_VAR
done := OSCAT_BASIC._ARRAY_SORT(
pt := ADR(a),
size := SIZEOF(a)
); (* после обработки: a = [-4.0, -2.0, 6.0, 8.0, 12.0], done = TRUE *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
avg : REAL;
END_VAR
avg := OSCAT_BASIC.ARRAY_AVG(
pt := ADR(a),
size := SIZEOF(a)
); (* avg = 4.0, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [2.0, 12.0, 4.0, 8.0, 6.0];
gav : REAL;
END_VAR
gav := OSCAT_BASIC.ARRAY_GAV(
pt := ADR(a),
size := SIZEOF(a)
); (* gav ≈ 5.40383959, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
hav : REAL;
END_VAR
hav := OSCAT_BASIC.ARRAY_HAV(
pt := ADR(a),
size := SIZEOF(a)
); (* hav ≈ -13.333334, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
aMax : REAL;
END_VAR
aMax := OSCAT_BASIC.ARRAY_MAX(
pt := ADR(a),
size := SIZEOF(a)
); (* aMax = 12.0, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
aMin : REAL;
END_VAR
aMin := OSCAT_BASIC.ARRAY_MIN(
pt := ADR(a),
size := SIZEOF(a)
); (* aMax = -4.0, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
sdv : REAL;
END_VAR
sdv := OSCAT_BASIC.ARRAY_SDV(
pt := ADR(a),
size := SIZEOF(a)
); (* sdv ≈ 6.78233, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
spr : REAL;
END_VAR
spr := OSCAT_BASIC.ARRAY_SPR(
pt := ADR(a),
size := SIZEOF(a)
); (* spr = 16.0, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
sum : REAL;
END_VAR
sum := OSCAT_BASIC.ARRAY_SUM(
pt := ADR(a),
size := SIZEOF(a)
); (* sum = 20.0 *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
trend : REAL;
END_VAR
trend := OSCAT_BASIC.ARRAY_TREND(
pt := ADR(a),
size := SIZEOF(a)
); (* trend ≈ 1.33333337, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
xVar : REAL;
END_VAR
xVar := OSCAT_BASIC.ARRAY_VAR(
pt := ADR(a),
size := SIZEOF(a)
); (* var = 46.0, массив a не изменяется *)
END_PROGRAM |
VAR
a : ARRAY[0..4] OF REAL := [-2.0, 12.0, -4.0, 8.0, 6.0];
sorted : BOOL;
END_VAR
sorted := OSCAT_BASIC.IS_SORTED(
pt := ADR(a),
size := SIZEOF(a)
); (* sorted = FALSE *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
m : REAL; (* |z| *)
END_VAR
z.re := 2.5;
z.im := 0.5;
m := OSCAT_BASIC.CABS(X := z); (* m ≈ 2.5495098 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = CACOS(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CACOS(X := z); (* результат комплексный: res.re ≈ 0.214,
res.im ≈ -1.59*)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = CACOSH(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CACOSH(X := z); (* результат комплексный: res.re ≈ 1.59,
res.im ≈ 0.214*)
END_PROGRAM |
VAR
x : OSCAT_BASIC.COMPLEX := (re := 2.5, im := 0.5);
y : OSCAT_BASIC.COMPLEX := (re := 4.5, im := 1.5);
res : OSCAT_BASIC.COMPLEX;
res_re : REAL;
res_im : REAL;
END_VAR
res := OSCAT_BASIC.CADD(X := x, Y := y); (* res.re = 7.0, res.im = 2.0*)
res_re := res.re;
res_im := res.im;
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
ang : REAL; (* аргумент z, рад *)
END_VAR
z.re := 2.5;
z.im := 0.5;
ang := OSCAT_BASIC.CARG(X := z); (* ang = atan2(0.5, 2.5) ≈ 0.19739556 рад *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* результат CASIN(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CASIN(X := z);
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* входное комплексное число *)
res : OSCAT_BASIC.COMPLEX; (* результат CASINH(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CASINH(X := z); (* res.re ≈ 1.66, res.re ≈ 0.184 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = CATAN(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CATAN(X := z); (* результат комплексный res.re ≈ -0.369,
res.im ≈ 0.0671 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = CATANH(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CATANH(X := z); (* результат комплексный res.re ≈ 0.402,
res.im ≈ -0.0899 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX;
conj : OSCAT_BASIC.COMPLEX;
END_VAR
z.re := 2.5;
z.im := 0.5;
conj := OSCAT_BASIC.CCON(X := z); (* conj = 2.5 + i*(-0.5) *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = cos(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CCOS(X := z); (* результат комплексный res.re ≈ -0.903,
res.im ≈ -0.312 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = cosh(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CCOSH(X := z); (* результат комплексный res.re ≈ 5.38,
res.im ≈ 2.9 *)
END_PROGRAM |
VAR
X : OSCAT_BASIC.COMPLEX := (Re := 2.5, Im := 0.5);
Y : OSCAT_BASIC.COMPLEX := (Re := 4.5, Im := 1.5);
res : OSCAT_BASIC.COMPLEX; (* Результат деления *)
END_VAR
(* Вызов функции CDIV для деления X на Y *)
res := OSCAT_BASIC.CDIV(X := X, Y := Y); (*res.re ≈ 0.533, res.im ≈ -0.0667 *)
END_PROGRAM |
VAR
x : OSCAT_BASIC.COMPLEX; (* входное комплексное число *)
y : OSCAT_BASIC.COMPLEX; (* результат вычисления экспоненты *)
END_VAR
x.re := 2.5;
x.im := 0.5;
y := OSCAT_BASIC.CEXP(x := x); (* y.re ≈ 10.691, y.im ≈ 5.84 *)
END_PROGRAM |
VAR
x : OSCAT_BASIC.COMPLEX; (* входное комплексное число *)
y : OSCAT_BASIC.COMPLEX; (* результат *)
END_VAR
x.re := 2.5;
x.im := 0.5;
y := OSCAT_BASIC.CINV(x := x); (* y.re ≈ 0.385, y.im ≈ -0.0769 *)
END_PROGRAM |
VAR
x : OSCAT_BASIC.COMPLEX; (* входное комплексное число *)
y : OSCAT_BASIC.COMPLEX; (* значение натурального логарифма *)
END_VAR
x.re := 2.5;
x.im := 0.5;
y := OSCAT_BASIC.CLOG(x := x); (* y.re ≈ 0.936, y.im ≈ 0.197 *)
END_PROGRAM |
VAR
x : OSCAT_BASIC.COMPLEX := (re := 2.5, im := 0.5);
y : OSCAT_BASIC.COMPLEX := (re := 4.5, im := 1.5);
res : OSCAT_BASIC.COMPLEX;
res_re : REAL;
res_im : REAL;
END_VAR
res := OSCAT_BASIC.CMUL(X := x, Y := y); (* res.re = 10.5, res.im = 6.0*)
res_re := res.re;
res_im := res.im;
END_PROGRAM |
VAR
L : REAL := 5.0; (* радиус-вектор*)
A : REAL := 0.785; (* угол в радианах (≈ 45 градусов)*)
res : OSCAT_BASIC.COMPLEX;
END_VAR
(* вызов функции для преобразования полярных координат в комплексное число*)
res := OSCAT_BASIC.CPOL(L := L, A := A); (* res ≈ 3.5355 + 3.5355i*)
END_PROGRAM |
VAR
x : OSCAT_BASIC.COMPLEX := (re := 2.5, im := 0.5);
y : OSCAT_BASIC.COMPLEX := (re := 4.5, im := 1.5);
res : OSCAT_BASIC.COMPLEX;
res_re : REAL;
res_im : REAL;
END_VAR
res := OSCAT_BASIC.CPOW(X := x, Y := y); (* res.re ≈ -33.1, res.im ≈ 37.7*)
res_re := res.re;
res_im := res.im;
END_PROGRAM |
VAR
RE : REAL := 2.5; (* радиус-вектор*)
IM : REAL := 0.5; (* угол в радианах (≈ 45 градусов)*)
res : OSCAT_BASIC.COMPLEX;
END_VAR
(* вызов функции для преобразования вещественных чисел в комплексное число*)
res := OSCAT_BASIC.CSET(RE := RE, IM := IM); (* res = 2.5 + 0.5i*)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = sin(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CSIN(X := z); (* результат комплексный res.re ≈ 0.675,
res.im ≈ -0.417 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = CSINH(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CSINH(X := z); (* результат комплексный: res.re ≈ 5.31,
res.im ≈ 2.94 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* квадратный корень комплексного числа *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CSQRT(X := z); (* результат комплексный: res.re ≈ 1.59,
res.im ≈ 0.157 *)
END_PROGRAM |
VAR
x : OSCAT_BASIC.COMPLEX := (re := 2.5, im := 0.5);
y : OSCAT_BASIC.COMPLEX := (re := 4.5, im := 1.5);
res : OSCAT_BASIC.COMPLEX;
res_re : REAL;
res_im : REAL;
END_VAR
res := OSCAT_BASIC.CSUB(X := x, Y := y); (* res.re = -2.0, res.im = -1.0*)
res_re := res.re;
res_im := res.im;
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = tan(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CTAN(X := z); (* результат комплексный res.re ≈ -0.525,
res.im ≈ 0.643 *)
END_PROGRAM |
VAR
z : OSCAT_BASIC.COMPLEX; (* z = 2.5 + i*0.5 *)
res : OSCAT_BASIC.COMPLEX; (* res = CTANH(z) *)
END_VAR
z.re := 2.5;
z.im := 0.5;
res := OSCAT_BASIC.CTANH(X := z); (* результат комплексный res.re ≈ 0.993,
res.im ≈ 0.0113 *)
END_PROGRAM |
VAR
x : OSCAT_BASIC.REAL2; (* исходное значение REAL2 *)
x_abs : OSCAT_BASIC.REAL2; (* модуль x *)
END_VAR
(* Пример задания отрицательного значения*)
x.RX := -12.345678; (* «грубая» часть *)
x.R1 := -0.000000009876; (* «точная» часть *)
(* Вызов функции модуля *)
x_abs := OSCAT_BASIC.R2_ABS(x); (* «грубая» часть = 12.345678,
«точная» часть = 0.000000009876 *)
END_PROGRAM |
VAR
X : OSCAT_BASIC.REAL2; (* число двойной точности *)
Y : REAL; (* слагаемое REAL *)
S : OSCAT_BASIC.REAL2; (* результат: X + Y *)
END_VAR
(* Пример: X = 1000.123456789 *)
X.RX := 1000.123456; (* «грубая» часть *)
X.R1 := 0.000000789; (* «точная» часть *)
Y := 2.5;
S := OSCAT_BASIC.R2_ADD(X := X, Y := Y); (* Сумма X и Y = 1002.623456789 *)
END_PROGRAM |
VAR
X : OSCAT_BASIC.REAL2; (* первое слагаемое *)
Y : OSCAT_BASIC.REAL2; (* второе слагаемое *)
S : OSCAT_BASIC.REAL2; (* результат: X + Y *)
END_VAR
(* X = 1000.123456789 *)
X.RX := 1000.123456; (* «грубая» часть *)
X.R1 := 0.000000789; (* «точная» часть *)
(* Y = 2.500000111 *)
Y.RX := 2.5; (* «грубая» часть *)
Y.R1 := 0.000000111; (* «точная» часть *)
S := OSCAT_BASIC.R2_ADD2(X := X, Y := Y); (* Сумма X и Y = 1002.623456900 *)
END_PROGRAM |
VAR
X : OSCAT_BASIC.REAL2; (* первый множитель *)
Y : REAL; (* второй множитель *)
S : OSCAT_BASIC.REAL2; (* результат: X * Y *)
END_VAR
(* Пример: X = 12.345678901 *)
X.RX := 12.345678; (* «грубая» часть *)
X.R1 := 0.000000901; (* «точная» часть *)
Y := 3.0;
S := OSCAT_BASIC.R2_MUL(X := X, Y := Y); (* Произведение X и Y = 37.037036703 *)
END_PROGRAM |
VAR
X : REAL := 123.456;
R2 : OSCAT_BASIC.REAL2; (* результат преобразования REAL -> REAL2 *)
END_VAR
(* Присвоить значение REAL переменной типа REAL2 *)
R2 := OSCAT_BASIC.R2_SET(X := X);
(* После преобразования:
R2.RX = 123.456
R2.R1 = 0.0
*)
END_PROGRAM |
VAR
X : REAL := 2.0; (* аргумент *)
A : REAL := 1.5; (* угловой коэффициент *)
B : REAL := -3.0; (* коэффициент сдвига *)
Y : REAL; (* результат *)
END_VAR
(* F_LIN(X) = A * X + B = 1.5 * 2.0 - 3.0 = 0.0 *)
Y := OSCAT_BASIC.F_LIN(X := X, A := A, B := B);
END_PROGRAM
|
VAR
X : REAL := 5.0; (* точка, для которой ищем Y *)
X1 : REAL := 0.0;
Y1 : REAL := 0.0;
X2 : REAL := 10.0;
Y2 : REAL := 100.0;
Y : REAL; (* результат *)
END_VAR
(* Линейная интерполяция между (0,0) и (10,100):
при X = 5 получаем Y = 50 *)
Y := OSCAT_BASIC.F_LIN2(X := X, X1 := X1, Y1 := Y1, X2 := X2, Y2 := Y2);
END_PROGRAM
|
VAR
X : REAL := 1.5;
C : ARRAY [0..7] OF REAL := [1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0];
Y : REAL;
END_VAR
(* Полином:
Y = C0 + C1*X + C2*X^2 + C3*X^3 + C4*X^4 + C5*X^5 + C6*X^6 + C7*X^7
При X = 1.5 и C = [1,1,1,1,2,2,3,3]:
Y = 1 + 1.5 + 2.25 + 3.375 + 2*5.0625 + 2*7.59375 + 3*11.390625 + 3*17.0859375
= 118.0078125
*)
Y := OSCAT_BASIC.F_POLY(X := X, C := C);
END_PROGRAM
|
VAR
a : REAL := 2.0;
x : REAL := 3.0;
n : REAL := 4.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.F_POWER(a := a, X := x, n := n); (* y = 2 * 3^4 = 162 *)
END_PROGRAM
|
VAR
x : REAL := 2.0;
a : REAL := 3.0;
b : REAL := -4.0;
c : REAL := 1.0;
y : REAL;
END_VAR
y := OSCAT_BASIC.F_QUAD(X := x, A := a, B := b, C := c);
(* y = 3*2^2 + (-4)*2 + 1 = 5 *)
END_PROGRAM
|
VAR
start : BYTE := 100; (* стартовое значение *)
dirUp : BOOL := TRUE; (* TRUE: к 255, FALSE: к 0 *)
td : TIME := T#0s; (* прошедшее время *)
tr : TIME := T#10s; (* полное время генерации *)
y : BYTE;
END_VAR
(* Пример: эмуляция прошедшего времени *)
td := T#4s;
y := OSCAT_BASIC.FRMP_B(START := start, DIR := dirUp, TD := td, TR := tr);
(* При START=100, DIR=TRUE, TR=10s и TD=4s:
y ≈ 100 + (255-100)*4/10 = 162 *)
END_PROGRAM
|
VAR (* Таблица узловых точек: [номер_точки, 0 для X, 1 для Y] *)
XY_Table : ARRAY [1..20, 0..1] OF REAL := [
0.0, 0.0, (* Точка 1: X=0.0, Y=0.0 *)
1.0, 2.0, (* Точка 2: X=1.0, Y=2.0 *)
2.0, 4.0, (* Точка 3: X=2.0, Y=4.0 *)
3.0, 8.0, (* Точка 4: X=3.0, Y=8.0 *)
4.0, 16.0, (* Точка 5: X=4.0, Y=16.0 *)
5.0, 32.0 (* Точка 6: X=5.0, Y=32.0 *)
];
InputX : REAL := 1.5; (* Аргумент для интерполяции *)
Pts : INT := 6; (* Количество используемых точек *)
ResultY: REAL; (* Результат интерполяции *)
END_VAR
(* Вызов функции интерполяции из библиотеки OSCAT_BASIC *)
ResultY := OSCAT_BASIC.LINEAR_INT(X := InputX, XY := XY_Table, Pts := Pts);
(* После выполнения:
ResultY будет равен 3.0, так как X=1.5 находится посередине
между точками 1.0 (Y=2.0) и 2.0 (Y=4.0).
*)
END_PROGRAM
|
VAR (* Таблица узловых точек: [номер_точки, 0 для X, 1 для Y] *)
XY_Table : ARRAY [1..5, 0..1] OF REAL := [
0.0, 1.0, (* Точка 1: X=0.0, Y=1.0 *)
1.0, 2.0, (* Точка 2: X=1.0, Y=2.0 *)
2.0, 5.0, (* Точка 3: X=2.0, Y=5.0 *)
3.0, 10.0, (* Точка 4: X=3.0, Y=10.0 *)
4.0, 17.0 (* Точка 5: X=4.0, Y=17.0 *)
];
InputX : REAL := 2.5; (* Аргумент для интерполяции *)
Pts : INT := 5; (* Количество используемых точек (3..5) *)
ResultY: REAL; (* Результат интерполяции *)
END_VAR
(* Вызов функции полиномиальной интерполяции *)
ResultY := OSCAT_BASIC.POLYNOM_INT(X := InputX, XY := XY_Table, Pts := Pts);
(*
Результат:
При X=2.5 и 5 точках, полиномиальная интерполяция даст значение,
которое точно проходит через все заданные точки.
Для данных точек функция соответствует полиному Y = X^2 + 1
При X=2.5: Y = 6.25 + 1 = 7.25
*)
END_PROGRAM |
VAR
rRadius : REAL := 5.0; // Радиус окружности
rAngle : REAL := 90.0; // Угол сектора в градусах
rArea : REAL; // Площадь сектора
END_VAR
rArea := OSCAT_BASIC.CIRCLE_A(rx := rRadius, ax := rAngle);
// Результат: 19.63495 (площадь сектора 90° при радиусе 5)
END_PROGRAM |
VAR
rRadius : REAL := 5.0; // Радиус окружности = 5 единиц
rAngle : REAL := 90.0; // Угол сектора = 90 градусов
rArcLength : REAL; // Длина дуги сектора
END_VAR
rArcLength := OSCAT_BASIC.CIRCLE_C( rx := rRadius, ax := rAngle );
// Результат: 7.85398 (длина дуги 90° при радиусе 5)
END_PROGRAM |
VAR
rRadius : REAL := 5.0; // Радиус окружности = 5 единиц
rHeight : REAL := 1.0; // Высота сегмента = 1 единица
rSegArea : REAL; // Площадь сегмента
END_VAR
rSegArea := OSCAT_BASIC.CIRCLE_SEG( rx := rRadius, hx := rHeight );
// Результат: 4.08752775 (площадь сегмента при радиусе 5 и высоте 1)
END_PROGRAM |
VAR
rRadius : REAL := 3.0; // Радиус основания конуса = 3 единицы
rHeight : REAL := 5.0; // Высота конуса = 5 единиц
rVolume : REAL; // Объем конуса
END_VAR
rVolume := OSCAT_BASIC.CONE_V( rx := rRadius, hx := rHeight );
// Результат: 47.12389 (объем конуса с радиусом 3 и высотой 5)
END_PROGRAM |
VAR
rSemiAxis1 : REAL := 3.0; // Малая полуось эллипса = 3 единицы
rSemiAxis2 : REAL := 5.0; // Большая полуось эллипса = 5 единиц
rArea : REAL; // Площадь эллипса
END_VAR
rArea := OSCAT_BASIC.ELLIPSE_A( R1 := rSemiAxis1, R2 := rSemiAxis2 );
// Результат: 47.12389 (площадь эллипса с полуосями 3 и 5)
END_PROGRAM |
VAR
rSemiAxis1 : REAL := 3.0; // Малая полуось эллипса = 3 единицы
rSemiAxis2 : REAL := 5.0; // Большая полуось эллипса = 5 единиц
rPerimeter : REAL; // Периметр эллипса
END_VAR
rPerimeter := OSCAT_BASIC.ELLIPSE_C( R1 := rSemiAxis1, R2 := rSemiAxis2 );
// Результат: 25.52763 (периметр эллипса с полуосями 3 и 5)
END_PROGRAM |
VAR
rRadius : REAL := 3.0; // Радиус сферы = 3 единицы
rVolume : REAL; // Объем сферы
END_VAR
rVolume := OSCAT_BASIC.SPHERE_V( rx := rRadius );
// Результат: 113.09734 (объем сферы с радиусом 3)
END_PROGRAM |
VAR
rSide1 : REAL := 5.0; // Сторона 1 = 5 единиц
rSide2 : REAL := 7.0; // Сторона 2 = 7 единиц
rAngle : REAL := 60.0; // Угол между сторонами = 60 градусов
rSide3 : REAL := 0.0; // Не используется (должна быть 0)
rArea : REAL; // Площадь треугольника
END_VAR
// Вычисление площади по двум сторонам и углу между ними
rArea := OSCAT_BASIC.TRIANGLE_A( S1 := rSide1,
S2 := rSide2, A := rAngle, S3 := rSide3 );
// Результат: 15.155 (площадь треугольника со сторонами 5 и 7 и углом 60°)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
len : REAL;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
len := OSCAT_BASIC.V3_ABS(A := a); (* len = 5.0 *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
b : OSCAT_BASIC.VECTOR_3;
sum: OSCAT_BASIC.VECTOR_3;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
b.X := 1.0;
b.Y := 2.0;
b.Z := 2.0;
sum := OSCAT_BASIC.V3_ADD(A := a, B := b); (* sum = (4, 6, 2) *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
b : OSCAT_BASIC.VECTOR_3;
ang : REAL;
END_VAR
a.X := 1.0; a.Y := 0.0; a.Z := 0.0;
b.X := 0.0; b.Y := 1.0; b.Z := 0.0;
ang := OSCAT_BASIC.V3_ANG(A := a, B := b); (* ang ≈ 1.5707963 (π/2) *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
b : OSCAT_BASIC.VECTOR_3;
ang : REAL;
END_VAR
a.X := 3.0; a.Y := 4.0; a.Z := 0.0;
b.X := 1.0; b.Y := 2.0; b.Z := 2.0;
ang := OSCAT_BASIC.V3_DPRO(A := a, B := b); (* dot = 11.0 *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
unit : OSCAT_BASIC.VECTOR_3;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
unit := OSCAT_BASIC.V3_NORM(A := a); (* unit ≈ (0.6, 0.8, 0.0) *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
isNul : BOOL;
END_VAR
a.X := 0.0;
a.Y := 0.0;
a.Z := 0.0;
isNul := OSCAT_BASIC.V3_NUL(A := a); (* isNul ≈ TRUE *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
b : OSCAT_BASIC.VECTOR_3;
isPar : BOOL;
END_VAR
a.X := 1.0; a.Y := 2.0; a.Z := 3.0;
b.X := 2.0; b.Y := 4.0; b.Z := 6.0;
isPar := OSCAT_BASIC.V3_PAR(A := a, B := b); (* isPar = TRUE *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
rev : OSCAT_BASIC.VECTOR_3;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
rev := OSCAT_BASIC.V3_REV(A := a); (* rev = (-3, -4, 0) *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
m : REAL := 2.0;
res : OSCAT_BASIC.VECTOR_3;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
res := OSCAT_BASIC.V3_SMUL(A := a, M := m); (* res = (6, 8, 0) *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
b : OSCAT_BASIC.VECTOR_3;
dif : OSCAT_BASIC.VECTOR_3;
END_VAR
a.X := 3.0; a.Y := 4.0; a.Z := 0.0;
b.X := 1.0; b.Y := 2.0; b.Z := 2.0;
dif := OSCAT_BASIC.V3_SUB(A := a, B := b); (* dif = (2, 2, -2) *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
xAng : REAL;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
xAng := OSCAT_BASIC.V3_XANG(A := a); (* xAng ≈ 0.9272952 рад *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
b : OSCAT_BASIC.VECTOR_3;
cross : OSCAT_BASIC.VECTOR_3;
END_VAR
a.X := 1.0; a.Y := 0.0; a.Z := 0.0;
b.X := 0.0; b.Y := 1.0; b.Z := 0.0;
cross := OSCAT_BASIC.V3_XPRO(A := a, B := b); (* cross = (0, 0, 1) *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
yAng : REAL;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
yAng := OSCAT_BASIC.V3_YANG(A := a); (* yAng ≈ 0.6435011 рад *)
END_PROGRAM |
VAR
a : OSCAT_BASIC.VECTOR_3;
zAng : REAL;
END_VAR
a.X := 3.0;
a.Y := 4.0;
a.Z := 0.0;
zAng := OSCAT_BASIC.V3_ZANG(A := a); (* zAng ≈ 1.5707963 рад *)
END_PROGRAM |
VAR
StartDate : DATE := D#2026-06-18; (* начальная дата *)
ResultDate : DATE; (* результат *)
END_VAR
(* Прибавить: +10 дней, +3 недели, +1 месяц, +0 лет *)
ResultDate := OSCAT_BASIC.DATE_ADD(
IDATE := StartDate,
D := 10,
W := 3,
M := 1,
Y := 0
); (* Результат: D#2026-08-19 *)
END_PROGRAM |
VAR
d0 : DATE := D#1970-01-01; (* начальная дата эпохи *)
d1 : DATE := D#2026-06-18; (* исходная дата IDATE *)
days0 : DINT; (* дней с 01.01.1970 до d0 *)
days1 : DINT; (* дней с 01.01.1970 до d1 *)
END_VAR
days0 := OSCAT_BASIC.DAY_OF_DATE(IDATE := d0); (* результат 0 *)
days1 := OSCAT_BASIC.DAY_OF_DATE(IDATE := d1); (* результат 20622 *)
END_PROGRAM |
VAR
d : DATE := D#2026-06-18; (* исходная дата IDATE *)
dayNum: INT; (* номер дня в месяце *)
END_VAR
dayNum := OSCAT_BASIC.DAY_OF_MONTH(IDATE := d); (* вернёт 18 *)
END_PROGRAM |
VAR
d : DATE := D#2026-06-18; (* исходная дата IDATE *)
dow : INT; (* номер дня недели *)
END_VAR
dow := OSCAT_BASIC.DAY_OF_WEEK(IDATE := d); (* вернёт 4 (четверг) *)
END_PROGRAM |
VAR
d : DATE := D#2026-06-18; (* исходная дата IDATE *)
dayOfYear: INT; (* номер дня в году *)
END_VAR
dayOfYear := OSCAT_BASIC.DAY_OF_YEAR(IDATE := d); (* вернёт 169 *)
END_PROGRAM |
VAR
days : REAL := 1.5; (* число дней *)
t : TIME; (* результат *)
END_VAR
t := OSCAT_BASIC.DAY_TO_TIME(IN := days); (* вернёт T#1d12h *)
END_PROGRAM |
VAR
d1 : DATE := D#2026-06-18; (* первая дата *)
d2 : DATE := D#2026-06-28; (* вторая дата *)
delta: DINT; (* разница в днях *)
END_VAR
delta := OSCAT_BASIC.DAYS_DELTA(d1, d2); (* вернёт 10 *)
END_PROGRAM |
VAR
d : DATE := D#2026-02-10; (* исходная дата IDATE *)
daysInMonth: INT; (* число дней в месяце *)
END_VAR
daysInMonth := OSCAT_BASIC.DAYS_IN_MONTH(IDATE := d); (* вернёт 28 *)
END_PROGRAM |
VAR
d : DATE := D#2024-06-18; (* исходная дата IDATE *)
daysInYear : INT; (* число дней в году *)
END_VAR
daysInYear := OSCAT_BASIC.DAYS_IN_YEAR(IDATE := d); (* вернёт 366 *)
END_PROGRAM |
VAR
utc : DT := DT#2026-03-29-01:30:00; (* время UTC *)
isDst : BOOL; (* признак летнего времени *)
END_VAR
isDst := OSCAT_BASIC.DST(IN := utc); (* вернёт TRUE *)
END_PROGRAM |
VAR
dti : DT := DT#2026-06-18-13:45:20; (* исходная дата/время *)
sdt : OSCAT_BASIC.SDT; (* разряды даты/времени *)
END_VAR
sdt := OSCAT_BASIC.DT_TO_SDT(DTI := dti); (* YEAR=2026, MONTH=6, DAY=18, WEEKDAY=4,
HOUR=13, MINUTE=45, SECOND=20, MS=0 *)
END_PROGRAM |
VAR
di : DATE := D#2026-06-18; (* дата *)
ti : TOD := TOD#13:45:20.250; (* время *)
sdt : OSCAT_BASIC.SDT; (* разряды даты/времени *)
y : INT;
mo : INT;
da : INT;
wd : INT;
hh : INT;
mi : INT;
ss : INT;
ms : INT;
END_VAR
sdt := OSCAT_BASIC.DT2_TO_SDT(
DI := di,
TI := ti
);
y := sdt.YEAR; (* 2026 *)
mo := sdt.MONTH; (* 6 *)
da := sdt.DAY; (* 18 *)
wd := sdt.WEEKDAY; (* 4 *)
hh := sdt.HOUR; (* 13 *)
mi := sdt.MINUTE; (* 45 *)
ss := sdt.SECOND; (* 20 *)
ms := sdt.MS; (* 250 *)
END_PROGRAM
|
VAR
year : INT := 2026; (* заданный год *)
eDate : DATE; (* дата Пасхи *)
END_VAR
eDate := OSCAT_BASIC.EASTER(year); (* вернёт D#2026-04-12 *)
END_PROGRAM |
VAR
fbEvents : OSCAT_BASIC.EVENTS;
ELIST : ARRAY[0..2] OF OSCAT_BASIC.HOLIDAY_DATA;
dateIn : DATE;
ena : BOOL;
y : BOOL;
name : STRING(30);
All_Saints: OSCAT_BASIC.HOLIDAY_DATA:=
(NAME:='All Saints Day', DAY :=1, MONTH:=11, USE :=1);
Easter: OSCAT_BASIC.HOLIDAY_DATA:=
(NAME:='Пасха', DAY :=0, MONTH:=0, USE :=1);
SAINT_TRINITY_DAY: OSCAT_BASIC.HOLIDAY_DATA:=
(NAME:='Святая троица', DAY :=49, MONTH:=0, USE :=1);
END_VAR
(* Заполняем календарь мероприятий *)
ELIST[0] := All_Saints;
ELIST[1] := Easter;
ELIST[2] := SAINT_TRINITY_DAY;
ena := TRUE;
(* Пример 1: 01.11.2026 -> All Saints Day *)
dateIn := D#2026-11-01;
fbEvents(ELIST := ELIST, DATE_IN := dateIn, ENA := ena);
y := fbEvents.Y; (* TRUE *)
name := fbEvents.NAME; (* 'All Saints Day' *)
(* Пример 2: 31.05.2026 -> Святая троица (Пасха 12.04.2026 + 49 дней) *)
dateIn := D#2026-05-31;
fbEvents(ELIST := ELIST, DATE_IN := dateIn, ENA := ena);
y := fbEvents.Y; (* TRUE *)
name := fbEvents.NAME; (* 'Святая троица' *)
END_PROGRAM |
VAR
fbHoliday : OSCAT_BASIC.HOLIDAY;
aHolidays : ARRAY[0..29] OF OSCAT_BASIC.HOLIDAY_DATA;
dToday : DATE := D#2026-06-19; (* пятница *)
iLangu : INT := 1; (* язык приложения *)
xFriday : BOOL := TRUE;
xSaturday : BOOL := FALSE;
xSunday : BOOL := FALSE;
xY : BOOL;
sName : STRING(30);
END_VAR
(* Заполняем список праздников (показываем 1 элемент, остальные можно оставить
пустыми/неиспользуемыми*)
aHolidays[0] := (
NAME := 'All Saints Day',
DAY := 1,
MONTH := 11,
USE := 1
);
(* Вызов FB HOLIDAY *)
fbHoliday(
DATE_IN := dToday,
LANGU := iLangu,
FRIDAY := TRUE,
SATURDAY:= FALSE,
SUNDAY := FALSE
);
xY := fbHoliday.Y; (* TRUE, т.к. FRIDAY=TRUE и сегодня пятница *)
sName := fbHoliday.NAME; (* 'Friday' / 'Пятница' — зависит от LANGU
и реализации *)
END_PROGRAM |
VAR
t : TOD := TOD#13:45:20; (* исходное время суток *)
h : INT; (* число часов *)
END_VAR
h := OSCAT_BASIC.HOUR(itod := t); (* вернёт 13 *)
END_PROGRAM |
VAR
dt : DT := DT#2026-06-18-13:45:20; (* исходные дата и время *)
h : INT; (* число часов *)
END_VAR
h := OSCAT_BASIC.HOUR_OF_DT(XDT := dt); (* вернёт 13 *)
END_PROGRAM |
VAR
hours : REAL := 1.5; (* количество часов *)
t : TIME; (* результат *)
END_VAR
t := OSCAT_BASIC.HOUR_TO_TIME(IN := hours); (* вернёт T#1h30m *)
END_PROGRAM |
VAR
hours : REAL := 13.75; (* количество часов *)
xtod : TOD; (* время суток *)
END_VAR
xtod := OSCAT_BASIC.HOUR_TO_TOD(IN := hours); (* вернёт TOD#13:45:00 *)
END_PROGRAM |
VAR
d : DATE := D#2024-02-29; (* заданная дата IDATE *)
isLeapDay : BOOL; (* флаг високосного дня *)
END_VAR
isLeapDay := OSCAT_BASIC.LEAP_DAY(IDATE := d); (* вернёт TRUE *)
END_PROGRAM |
VAR
d : DATE := D#2024-06-18; (* заданная дата IDATE *)
isLeapYear: BOOL; (* флаг високосного года *)
END_VAR
isLeapYear := OSCAT_BASIC.LEAP_OF_DATE(IDATE := d); (* вернёт TRUE *)
END_PROGRAM |
VAR
yr : INT := 2024; (* заданный год *)
isLeap : BOOL; (* флаг високосного года *)
END_VAR
isLeap := OSCAT_BASIC.LEAP_YEAR(yr); (* вернёт TRUE *)
END_PROGRAM |
VAR
lt : DT := DT#2026-06-18-12:00:00; (* местное дата/время *)
dst : BOOL := FALSE; (* учет летнего времени *)
tzOff : INT := 180; (* UTC+3 = 180 минут *)
utc : DT; (* результат UTC *)
END_VAR
utc := OSCAT_BASIC.LTIME_TO_UTC(
LOCAL_TIME := lt,
DST := FALSE,
TIME_ZONE_OFFSET := tzOff
); (* вернёт DT#2026-06-18-09:00:00 *)
END_PROGRAM |
VAR
t : TOD := TOD#13:45:20; (* заданное время суток *)
m : INT; (* число минут *)
END_VAR
m := OSCAT_BASIC.MINUTE(itod := t); (* вернёт 45 *)
END_PROGRAM |
VAR
ndt : DT := DT#2026-06-18-13:45:20; (* заданные дата и время *)
m : INT; (* число минут *)
END_VAR
m := OSCAT_BASIC.MINUTE_OF_DT(XDT := ndt); (* вернёт 45 *)
END_PROGRAM |
VAR
minutes : REAL := 36; (* количество минут *)
t : TIME; (* результат *)
END_VAR
t := OSCAT_BASIC.MINUTE_TO_TIME(IN := minutes); (* вернёт T#36m *)
END_PROGRAM |
VAR
d : DATE := D#2026-06-18; (* заданная дата idate *)
mb : DATE; (* начало месяца *)
END_VAR
mb := OSCAT_BASIC.MONTH_BEGIN(idate := d); (* вернёт D#2026-06-01 *)
END_PROGRAM |
VAR
d : DATE := D#2026-06-18; (* заданная дата idate *)
me : DATE; (* конец месяца *)
END_VAR
me := OSCAT_BASIC.MONTH_END(idate := d); (* вернёт D#2026-06-30 *)
END_PROGRAM |
VAR
d : DATE := D#2026-06-18; (* заданная дата idate *)
m : INT; (* номер месяца *)
END_VAR
m := OSCAT_BASIC.MONTH_OF_DATE(idate := d); (* вернёт 6 *)
END_PROGRAM |
VAR
tIn : TIME := T#2s; (* заданное время t *)
m : REAL := 1.5; (* коэффициент M *)
tOut : TIME; (* результат *)
END_VAR
tOut := OSCAT_BASIC.MULTIME(
t := tIn,
M := m
); (* вернёт T#3s *)
END_PROGRAM |
VAR
d1 : DATE := D#2026-06-01; (* нижняя граница dx1 *)
dx : DATE := D#2026-06-18; (* проверяемая дата dx *)
d2 : DATE := D#2026-06-30; (* верхняя граница dx2 *)
xIn: BOOL; (* результат *)
END_VAR
xIn := OSCAT_BASIC.PERIOD(
d1 := d1,
dx := dx,
d2 := d2
); (* вернёт TRUE *)
END_PROGRAM |
VAR
DP : ARRAY[0..3, 0..1] OF DATE; (* 4 интервала: [начало, конец] *)
dx : DATE := D#2026-06-18; (* проверяемая дата *)
xIn : BOOL; (* результат *)
END_VAR
(* Интервал 0: июнь 2026 *)
DP[0, 0] := D#2026-06-01;
DP[0, 1] := D#2026-06-30;
(* Интервал 1: январь 2025 *)
DP[1, 0] := D#2025-01-01;
DP[1, 1] := D#2025-01-31;
(* Интервал 2: один день (пример) *)
DP[2, 0] := D#2026-12-31;
DP[2, 1] := D#2026-12-31;
(* Интервал 3: произвольный интервал (пример) *)
DP[3, 0] := D#2027-03-01;
DP[3, 1] := D#2027-03-31;
xIn := OSCAT_BASIC.PERIOD2(
DP := DP,
dx := dx
); (* вернёт TRUE *)
END_PROGRAM |
VAR
elev : REAL := 5.0;
r : REAL; (* рефракция, градусы *)
END_VAR
r := OSCAT_BASIC.REFRACTION(ELEV := elev); (* вернёт 0.166*)
END_PROGRAM |
VAR
fbRtc : OSCAT_BASIC.RTC_2;
xSet : BOOL; (* импульс SET *)
dtBase : DT := DT#2026-06-18-12:00:00; (* SDT (UTC) *)
iSms : INT := 250; (* SMS *)
xDen : BOOL := FALSE; (* учет DST отключен *)
iOfs : INT := 180; (* OFS = +180 мин (UTC+3) *)
udt : DT;
ldt : DT;
dso : BOOL;
xms : INT;
END_VAR
(* Формируем импульс SET на один цикл *)
xSet := TRUE;
fbRtc(
SET := xSet,
SDT := dtBase,
SMS := iSms,
DEN := xDen,
OFS := iOfs
);
udt := fbRtc.UDT; (* сразу после SET: UDT = DT#2026-06-18-12:00:00
(далее увеличивается) *)
ldt := fbRtc.LOCAL_DT; (* сразу после SET: LOCAL_DT = DT#2026-06-18-15:00:00
при OFS=180 и DEN=FALSE *)
dso := fbRtc.DSO; (* DSO = FALSE, т.к. DEN=FALSE *)
xms := fbRtc.XMS; (* сразу после SET: XMS = 250 (далее меняется) *)
(* Сбрасываем SET, чтобы импульс был только один цикл *)
xSet := FALSE;
END_PROGRAM |
VAR
fbRtcMs: OSCAT_BASIC. RTC_MS;
xSet : BOOL; (* импульс SET *)
dtBase : DT:= DT#2026-06-18-12:00:00; (* SDT (UTC) *)
iSms : INT := 250; (* SMS *)
xdt : DT; (* выход XDT *)
xms : INT; (* выход XMS *)
END_VAR
(* Формируем импульс SET на один цикл *)
xSet := TRUE;
fbRtcMs(
SET := xSet,
SDT := dtBase,
SMS := iSms
);
xdt := fbRtcMs.XDT; (* сразу после SET: XDT = DT#2026-06-18-12:00:00
(далее увеличивается) *)
xms := fbRtcMs.XMS; (* сразу после SET: XMS = 250 (далее меняется) *)
(* Сбрасываем SET, чтобы импульс был только один цикл *)
xSet := FALSE;
END_PROGRAM |
VAR
sdt : OSCAT_BASIC.SDT; (* дата в формате SDT *)
d : DATE; (* результат DATE *)
END_VAR
(* Заполняем только разряды даты, необходимые для конвертации *)
sdt.YEAR := 2026;
sdt.MONTH := 6;
sdt.DAY := 18;
d := OSCAT_BASIC.SDT_TO_DATE(DTI := sdt); (* вернёт D#2026-06-18 *)
END_PROGRAM |
VAR
sdt : OSCAT_BASIC.SDT; (* дата и время в формате SDT *)
d : DT; (* результат DT *)
END_VAR
(* Заполняем только разряды даты и времени, необходимые для конвертации *)
sdt.YEAR := 2026;
sdt.MONTH := 6;
sdt.DAY := 18;
sdt.HOUR := 13;
sdt.MINUTE := 45;
sdt.SECOND := 15;
d := OSCAT_BASIC.SDT_TO_DT(DTI := sdt); (* вернёт DT#2026-06-18-13:45:15 *)
END_PROGRAM |
VAR
sdt : OSCAT_BASIC.SDT; (* время в формате SDT *)
d : TOD; (* результат TOD *)
END_VAR
(* Заполняем только разряды времени, необходимые для конвертации *)
sdt.HOUR := 13;
sdt.MINUTE := 45;
sdt.SECOND := 15;
sdt.MS := 33;
d := OSCAT_BASIC.SDT_TO_TOD(DTI := sdt); (* вернёт TOD#13:45:15.033 *)
END_PROGRAM |
VAR
t : TOD := TOD#13:45:20.200; (* заданное время суток *)
s : REAL; (* число минут *)
END_VAR
s := OSCAT_BASIC.SECOND(itod := t); (* вернёт 20.2 *)
END_PROGRAM |
VAR
ndt : DT := DT#2026-06-18-13:45:20; (* заданные дата и время *)
s : INT; (* число секунд *)
END_VAR
s := OSCAT_BASIC.SECOND_OF_DT(XDT := ndt); (* вернёт 20 *)
END_PROGRAM |
VAR
seconds : REAL := 36; (* количество секунд *)
t : TIME; (* результат *)
END_VAR
t := OSCAT_BASIC.SECOND_TO_TIME(IN := seconds); (* вернёт T#36s *)
END_PROGRAM |
VAR
y : INT := 2026; (* YEAR *)
m : INT := 6; (* MONTH *)
d : INT := 18; (* DAY *)
dt: DATE; (* результат *)
END_VAR
dt := OSCAT_BASIC.SET_DATE(
YEAR := y,
MONTH := m,
DAY := d
); (* вернёт D#2026-06-18 *)
END_PROGRAM |
VAR
y : INT := 2026; (* YEAR *)
mon : INT := 6; (* MONTH *)
d : INT := 18; (* DAY *)
h : INT := 13; (* HOUR *)
m : INT := 45; (* MINUTE *)
s : INT := 20; (* SECOND *)
dt: DT; (* результат *)
END_VAR
dt := OSCAT_BASIC.SET_DT(
YEAR := y,
MONTH := mon,
DAY := d,
HOUR := h,
MINUTE := m,
SECOND := s
); (* вернёт DT#2026-06-18-13:45:20 *)
END_PROGRAM |
VAR
h : INT := 13; (* HOUR *)
m : INT := 45; (* MINUTE *)
s : INT := 20; (* SECOND *)
dt: TOD; (* результат *)
END_VAR
dt := OSCAT_BASIC.SET_TOD(
hour := h,
minute := m,
second := s
); (* вернёт TOD#13:45:20 *)
END_PROGRAM |
VAR
lon : REAL := 37.6155; (* LON *)
dUtc : DATE := D#2016-02-17; (* UTC *)
midday: TOD; (* результат *)
END_VAR
midday := OSCAT_BASIC.SUN_MIDDAY(
LON := lon,
UTC := dUtc
); (* вернёт TOD#9:43:23:252 *)
END_PROGRAM |
VAR
fbSunPos :OSCAT_BASIC .SUN_POS;
lat : REAL := 55.7522;
lon : REAL := 37.6155;
xutc: DT := DT#2016-02-17-5:35:22;
B : REAL; (* азимут, градусы *)
H : REAL; (* высота, градусы *)
HR : REAL; (* высота с рефракцией, градусы *)
END_VAR
fbSunPos(
latitude := lat,
longitude := lon,
utc := xutc
);
B := fbSunPos.B; (* 120 *)
H := fbSunPos.H; (* 4.78 *)
HR := fbSunPos.HR; (* 4.95 *)
END_PROGRAM |
VAR
fbSunTime : OSCAT_BASIC.SUN_TIME;
lat : REAL := 55.7522;
lon : REAL := 37.6155;
xutc : DATE := D#2016-02-17;
H : REAL := -0.833;;
MIDDAY : TOD; (* время солнечного полудня *)
SUN_RISE : TOD; (* время восхода солнца *)
SUN_SET : TOD; (* время заката солнца *)
SUN_DECLINATION : REAL;(*склонение солнца над горизонтом в полдень в градусах*)
END_VAR
fbSunTime(
latitude := lat,
longitude := lon,
utc := xutc,
h := h
);
MIDDAY := fbSunTime.MIDDAY; (* TOD#9:43:23.252 *)
SUN_RISE := fbSunTime.SUN_RISE; (* TOD#4:50:7.228 *)
SUN_SET := fbSunTime.SUN_SET; (* TOD#14:36:39.276 *)
SUN_DECLINATION := fbSunTime.SUN_DECLINATION; (* 22.2 *)
END_PROGRAM |
VAR
td : TOD := TOD#23:30:00; (* проверяемое время *)
start1 : TOD := TOD#08:00:00;
stop1 : TOD := TOD#17:00:00;
x1 : BOOL; (* результат 1 *)
start2 : TOD := TOD#22:00:00;
stop2 : TOD := TOD#06:00:00;
x2 : BOOL; (* результат 2 *)
END_VAR
x1 := OSCAT_BASIC.TIMECHECK(
TD := td,
START := start1,
STOP := stop1
); (* вернёт FALSE: 23:30 не входит в 08:00..17:00 *)
x2 := OSCAT_BASIC.TIMECHECK(
TD := td,
START := start2,
STOP := stop2
); (* вернёт TRUE: интервал 22:00..06:00 проходит через полночь, 23:30 входит *)
END_PROGRAM |
VAR
utc : DT := DT#2026-06-18-09:00:00; (* дата/время в UTC *)
dst : BOOL := FALSE; (* учет летнего времени *)
tzOff : INT := 180; (* UTC+3 = 180 минут *)
lt : DT; (* местное дата/время *)
END_VAR
lt := OSCAT_BASIC.UTC_TO_LTIME(
UTC := utc,
DST_ENABLE := FALSE,
TIME_ZONE_OFFSET := tzOff
); (* вернёт DT#2026-06-18-12:00:00 *)
END_PROGRAM |
VAR
d : DATE := D#2026-06-18; (* заданная дата idate *)
ww : INT; (* номер недели *)
END_VAR
ww := OSCAT_BASIC.WORK_WEEK(idate := d); (* вернёт 24 *)
END_PROGRAM |
VAR
y : INT := 2026; (* заданный год *)
dBegin : DATE; (* результат *)
END_VAR
dBegin := OSCAT_BASIC.YEAR_BEGIN(y); (* вернёт D#2026-01-01 *)
END_PROGRAM
|
VAR
y : INT := 2026; (* заданный год *)
dEnd : DATE; (* результат *)
END_VAR
dEnd := OSCAT_BASIC.YEAR_END(y); (* вернёт D#2026-12-31 *)
END_PROGRAM
|
VAR
d : DATE := D#2026-06-18; (* исходная дата IDATE *)
y : INT; (* год *)
END_VAR
y := OSCAT_BASIC.YEAR_OF_DATE(IDATE := d); (* вернёт 2026 *)
END_PROGRAM
|
VAR
sBin : STRING(12) := '10101010';
b : BYTE;
END_VAR
b := OSCAT_BASIC.BIN_TO_BYTE(BIN := sBin); (* b = 170 (16#AA) *)
END_PROGRAM |
VAR
sBin : STRING(40) := '0000000000000000000000000000000010101010';
dw : DWORD;
END_VAR
dw := OSCAT_BASIC.BIN_TO_DWORD(BIN := sBin); (* dw = 170 (16#000000AA) *)
END_PROGRAM |
VAR
b : BYTE := 16#AA;
s : STRING(8);
END_VAR
s := OSCAT_BASIC.BYTE_TO_STRB(IN := b); (* s = '10101010' *)
END_PROGRAM |
VAR
b : BYTE := 16#AA;
sHex : STRING(2);
END_VAR
sHex := OSCAT_BASIC.BYTE_TO_STRH(IN := b); (* sHex = 'AA' *)
END_PROGRAM |
VAR
sIn : STRING := 'hello world';
sOut : STRING;
END_VAR
sOut := OSCAT_BASIC.CAPITALIZE(str := sIn); (* sOut = 'Hello World' *)
END_PROGRAM |
VAR
s : STRING(10) := '&'; (* одиночный символ *)
c : BYTE; (* код символа *)
END_VAR
c := OSCAT_BASIC.CHARCODE(STR := s); (* c = 38 (16#26) *)
END_PROGRAM |
VAR
c : BYTE := 38; (* '&' -> amp *)
name : STRING(10); (* результат *)
END_VAR
name := OSCAT_BASIC.CHARNAME(C := c); (* вернёт 'amp' *)
END_PROGRAM |
VAR
c : BYTE := 38; (* ASCII-код символа '&' *)
s : STRING(1); (* результат *)
END_VAR
s := OSCAT_BASIC.CHR_TO_STRING(C := c); (* s = '&' *)
END_PROGRAM |
VAR
sIn : STRING := 'Tel:+7(999)12-34.56';
cx : STRING(80) := '0123456789.'; (* допустимые символы *)
sOut : STRING;
END_VAR
sOut := OSCAT_BASIC.CLEAN(
IN := sIn,
CX := cx
); (* sOut = '79991234.56' *)
END_PROGRAM |
VAR
s : STRING := 'ABC';
pos : INT := 2;
c1 : BYTE; (* код символа *)
c0 : BYTE; (* код при POS=0 *)
END_VAR
c1 := OSCAT_BASIC.CODE(
STR := s,
POS := pos
); (* c1 = 66 (16#42) *)
c0 := OSCAT_BASIC.CODE(
STR := s,
POS := 0
); (* c0 = 0 (16#00) *)
END_PROGRAM |
VAR
s : STRING := 'A-B-C';
ch : BYTE := 16#2D; (* '-' *)
cnt : INT; (* количество вхождений *)
END_VAR
cnt := OSCAT_BASIC.COUNT_CHAR(
STR := s,
chr := ch
); (* cnt = 2 *)
END_PROGRAM |
VAR
s : STRING := 'one two one one';
search : STRING := 'one';
cnt : INT; (* количество вхождений *)
END_VAR
cnt := OSCAT_BASIC.COUNT_SUBSTRING(
SEARCH := search,
STR := s
); (* cnt = 3 *)
END_PROGRAM |
VAR
strInput : STRING(10) := '255';
bResult : BYTE;
END_VAR
bResult := OSCAT_BASIC.DEC_TO_BYTE(strInput); (* bResult = 255 (0xFF) *)
END_PROGRAM
|
VAR
strInput : STRING(10) := '4096';
dResult : DWORD;
END_VAR
dResult := OSCAT_BASIC.DEC_TO_DWORD(strInput); (* dResult = 4096 *)
END_PROGRAM
|
VAR
strInput : STRING(10) := '-1024';
iResult : INT;
END_VAR
iResult := OSCAT_BASIC.DEC_TO_INT(strInput); (* iResult = -1024 *)
END_PROGRAM
|
VAR
strIN : STRING(80) := 'Hello, World! 123';
strCX : STRING(80) := 'o,'; (* что удалить*)
strRes : STRING;
END_VAR
strRes := OSCAT_BASIC.DEL_CHARS(IN := strIN, CX := strCX);
(* результат: 'Hell Wrld' *)
END_PROGRAM
|
VAR
dt : DT := DT#2026-06-18-13:45:20;
ms : INT := 250;
fmt : STRING := '#A-#D-#H #N:#R:#T.#V'; (* YYYY-MM-DD HH:MM:SS.mmm *)
lang : INT := 1; (* язык EN *)
s : STRING;
END_VAR
s := OSCAT_BASIC.DT_TO_STRF(
DTI := dt,
MS := ms,
FMT := fmt,
LANG := lang
);
(* s = '2026-06-18 13:45:20.250' *)
END_PROGRAM
|
VAR
dwValue : DWORD := 16#FF00FF00; (* Шестнадцатеричное значение *)
strBinary : STRING(32);
END_VAR
strBinary := OSCAT_BASIC.DWORD_TO_STRB(IN := dwValue); (* Результат:
'11111111000000001111111100000000'
битовое представление 16#FF00FF00*)
END_PROGRAM
|
VAR
dwValue : DWORD := 12345;
strRes : STRING(20);
strRes2 : STRING(20);
END_VAR
strRes := OSCAT_BASIC.DWORD_TO_STRF(IN := dwValue, N := 8 );
(* вернет '00012345' (дополнено ведущими нулями до 8 символов) *)
strRes2 := OSCAT_BASIC.DWORD_TO_STRF(IN := dwValue, N := 3 );
(* вернет '345' (обрезаны старшие разряды) *)
END_PROGRAM
|
VAR
dwIN : DWORD := 16#CAFEBABE;
hexStr : STRING(8);
END_VAR
hexStr := OSCAT_BASIC.DWORD_TO_STRH(dwIN); (* результат 'CAFEBABE' *)
END_PROGRAM |
VAR
strExp : STRING := '15 + 27';
strExp1 : STRING := '15/0';
strRes : STRING;
strRes1 : STRING;
END_VAR
strRes := OSCAT_BASIC.EXEC(strExp); (* результат '42' *)
strRes1 := OSCAT_BASIC.EXEC(strExp1); (* результат 'ERROR' *)
END_PROGRAM |
VAR
fChar : BYTE := 65; (* ASCII-код 'A' *)
len : INT := 5;
res : STRING;
END_VAR
res := OSCAT_BASIC.FILL(C := fChar, L := len); (* результат: result = "AAAAA" *)
END_PROGRAM |
VAR
testStr : STRING := '$1812';
position : INT;
startPos : INT := 1;
END_VAR
position := OSCAT_BASIC.FIND_CHAR(str := testStr, pos := startPos);
(* вернет 2, т.к. $18 - управляющий символ *)
END_PROGRAM |
VAR
testStr : STRING := '12$18';
position : INT;
startPos : INT := 1;
END_VAR
position := OSCAT_BASIC.FIND_CTRL(str := testStr, pos := startPos);
(* вернет 3, т.к. $18 - управляющий символ *)
END_PROGRAM |
VAR
testStr : STRING := '+7495-727-30-16';
position : INT;
startPos : INT := 2;
END_VAR
position := OSCAT_BASIC.FIND_NONUM(str := testStr, pos := startPos);
(* вернет 6, т.к проверка со второго символа *)
END_PROGRAM |
VAR
testStr : STRING := '+7495-727-30-16';
position : INT;
startPos : INT := 1;
END_VAR
position := OSCAT_BASIC.FIND_NUM(str := testStr, pos := startPos);
(* вернет 2 *)
END_PROGRAM |
VAR
s1 : STRING := 'one two one one';
s2 : STRING := 'one';
p : INT;
END_VAR
p := OSCAT_BASIC.FINDB(str1 := s1, str2 := s2); (* p = 13 *)
END_PROGRAM |
VAR
testStr : STRING := '+7495-727-30-16';
position : INT;
END_VAR
position := OSCAT_BASIC.FINDB_NONUM(str := testStr);
(* 13 *)
END_PROGRAM |
VAR
testStr : STRING := '+7495-727-30-16';
position : INT;
END_VAR
position := OSCAT_BASIC.FINDB_NUM(str := testStr );
(* вернет 15 *)
END_PROGRAM |
VAR
testStr : STRING := 'hello hell';
testStc : STRING := 'hel';
position : INT := 2;
res : INT;
END_VAR
res := OSCAT_BASIC.FINDP(str := testStr, src := testStc,pos := position);
(* вернет 7, т.к. проверка со второй позиции *)
END_PROGRAM |
VAR
inStr : STRING := '1';
ascii : BYTE := 16#61;
lon : INT := 4;
varM : INT;
f0 : STRING;
f1 : STRING;
f2 : STRING;
END_VAR
varM := 0;
f0 := OSCAT_BASIC.FIX(str := inStr, C := ascii, L := lon, M := varM);
(* вернет '1aaa' *)
varM := 1;
f1 := OSCAT_BASIC.FIX(str := inStr, C := ascii, L := lon, M := varM);
(* вернет 'aaa1' *)
varM := 2;
f2 := OSCAT_BASIC.FIX(str := inStr, C := ascii, L := lon, M := varM);
(* вернет 'a1aa' *)
END_PROGRAM |
VAR
str1 : STRING(20) := '123.45';
str2 : STRING(20) := '-67.89';
str3 : STRING(20) := '1.23E-4';
str4 : STRING(20) := '-5.67E+3';
real1 : REAL;
real2 : REAL;
real3 : REAL;
real4 : REAL;
END_VAR
real1 := OSCAT_BASIC.FLOAT_TO_REAL(str1); (* 123.45 *)
real2 := OSCAT_BASIC.FLOAT_TO_REAL(str2); (* -67.89 *)
real3 := OSCAT_BASIC.FLOAT_TO_REAL(str3); (* 0.000123 *)
real4 := OSCAT_BASIC.FLOAT_TO_REAL(str4); (* -5670.0 *)
END_PROGRAM |
VAR
str1 : STRING(12) := '2#01100100';
str2 : STRING(12) := '8#144';
str3 : STRING(12) := '16#64';
str4 : STRING(12) := '100';
real1 : BYTE;
real2 : BYTE;
real3 : BYTE;
real4 : BYTE;
END_VAR
real1 := OSCAT_BASIC.FSTRING_TO_BYTE(str1); (* 100 *)
real2 := OSCAT_BASIC.FSTRING_TO_BYTE(str2); (* 100 *)
real3 := OSCAT_BASIC.FSTRING_TO_BYTE(str3); (* 100 *)
real4 := OSCAT_BASIC.FSTRING_TO_BYTE(str4); (* 100 *)
END_PROGRAM |
VAR
dt1 : DT;
dateStr1 : STRING(60) := '2026 Jul 09 at 14:30:45';
format1 : STRING(60) := '#Y #N #D ** #h:#m:#s';
END_VAR
dt1 := OSCAT_BASIC.FSTRING_TO_DT(SDT := dateStr1, FMT := format1);
// dt1 = 2026-07-09-14:30:45
END_PROGRAM |
VAR
sBin : STRING(40) := '2#01100100';
sOct : STRING(40) := '8#144';
sHex : STRING(40) := '16#64';
sDec : STRING(40) := '100';
dw1 : DWORD;
dw2 : DWORD;
dw3 : DWORD;
dw4 : DWORD;
END_VAR
dw1 := OSCAT_BASIC.FSTRING_TO_DWORD(IN := sBin); (* dw1 = 100 (16#00000064) *)
dw2 := OSCAT_BASIC.FSTRING_TO_DWORD(IN := sOct); (* dw2 = 100 (16#00000064) *)
dw3 := OSCAT_BASIC.FSTRING_TO_DWORD(IN := sHex); (* dw3 = 100 (16#00000064) *)
dw4 := OSCAT_BASIC.FSTRING_TO_DWORD(IN := sDec); (* dw4 = 100 (16#00000064) *)
END_PROGRAM |
VAR
month1 : INT;
month2 : INT;
END_VAR
month1 := OSCAT_BASIC.FSTRING_TO_MONTH(MTH := 'January' ,LANG := 1); // 1
month2 := OSCAT_BASIC.FSTRING_TO_MONTH(MTH := 'März' ,LANG := 2); // 3
END_PROGRAM |
VAR
weekMask1 : BYTE;
weekMask2 : BYTE;
END_VAR
weekMask1 := OSCAT_BASIC.FSTRING_TO_WEEK(WEEK := 'Monday', LANG := 1);
(* 2#0000010 Понедельник*)
weekMask2 := OSCAT_BASIC.FSTRING_TO_WEEK(WEEK := 'Sonntag', LANG := 2);
(* 2#00000001 Воскресенье*)
END_PROGRAM |
VAR
wDay1 : INT;
wDay2 : INT;
END_VAR
wDay1 := OSCAT_BASIC.FSTRING_TO_WEEKDAY(WDAY := 'Monday', LANG := 1);
(* результат 1*)
wDay2 := OSCAT_BASIC.FSTRING_TO_WEEKDAY(WDAY := 'Sonntag', LANG := 2);
(* результат 7 *)
END_PROGRAM |
VAR
str1 : STRING(5) := '1A';
str2 : STRING(5) := 'ED';
res1 : BYTE;
res2 : BYTE;
END_VAR
res1 := OSCAT_BASIC.HEX_TO_BYTE(str1); (* 16#1A *)
res2 := OSCAT_BASIC.HEX_TO_BYTE(str2); (* 16#ED *)
END_PROGRAM |
VAR
str1 : STRING(20) := '1A1A2B3C';
str2 : STRING(20) := 'BABE';
res1 : DWORD;
res2 : DWORD;
END_VAR
res1 := OSCAT_BASIC.HEX_TO_DWORD(str1); (* 16#1A1A2B3C *)
res2 := OSCAT_BASIC.HEX_TO_DWORD(str2); (* 16#BABE *)
END_PROGRAM |
VAR
test1 : STRING := 'Hello123';
test2 : STRING := 'Test@123';
result1 : BOOL;
result2 : BOOL;
END_VAR
result1 := OSCAT_BASIC.IS_ALNUM(str := test1); (* TRUE - только буквы и цифры *)
result2 := OSCAT_BASIC.IS_ALNUM(str := test2); (* FALSE - содержит @ *)
END_PROGRAM
|
VAR
test1 : STRING := 'Hello';
test2 : STRING := 'Hello123';
result1 : BOOL;
result2 : BOOL;
END_VAR
result1 := OSCAT_BASIC.IS_ALPHA(test1); (* TRUE *)
result2 := OSCAT_BASIC.IS_ALPHA(test2); (* FALSE *)
END_PROGRAM
|
VAR
test1 : STRING := 'test';
test2 : STRING := 'Test';
cmp0 : STRING := 'tse';
result1 : BOOL;
result2 : BOOL;
END_VAR
result1 := OSCAT_BASIC.IS_CC(str := test1, cmp :=cmp0); (* TRUE *)
result2 := OSCAT_BASIC.IS_CC(str := test2, cmp := cmp0); (* FALSE *)
END_PROGRAM
|
VAR
str1 : STRING := '$18';
str2 : STRING := '11$18';
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.IS_CTRL(str := str1);
(* TRUE *)
res2 := OSCAT_BASIC.IS_CTRL(str := str2);
(* FALSE *)
END_PROGRAM |
VAR
str1 : STRING := '3AEB1C';
str2 : STRING := '2XL';
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.IS_HEX(str := str1);
(* TRUE *)
res2 := OSCAT_BASIC.IS_HEX(str := str2);
(* FALSE *)
END_PROGRAM |
VAR
str1 : STRING := 'test';
str2 : STRING := 'Test';
str3 : STRING := 'test1';
res1 : BOOL;
res2 : BOOL;
res3 : BOOL;
END_VAR
res1 := OSCAT_BASIC.IS_LOWER(str := str1);
(* TRUE *)
res2 := OSCAT_BASIC.IS_LOWER(str := str2);
(* FALSE *)
res3 := OSCAT_BASIC.IS_LOWER(str := str3);
(* FALSE *)
END_PROGRAM |
VAR
str0 : STRING := 'test';
cmp1 : STRING := 'abcd';
cmp2 : STRING := 'efgd';
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.IS_NCC(str := str0, cmp := cmp1);
(* TRUE *)
res2 := OSCAT_BASIC.IS_NCC(str := str0, cmp := cmp2);
(* FALSE *)
END_PROGRAM |
VAR
str1 : STRING := '123';
str2 : STRING := 'a123';
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.IS_NUM(str := str1);
(* TRUE *)
res2 := OSCAT_BASIC.IS_NUM(str := str2);
(* FALSE *)
END_PROGRAM |
VAR
str1 : STRING := 'TEST';
str2 : STRING := 'Test';
str3 : STRING := 'TEST1';
res1 : BOOL;
res2 : BOOL;
res3 : BOOL;
END_VAR
res1 := OSCAT_BASIC.IS_UPPER(str := str1);
(* TRUE *)
res2 := OSCAT_BASIC.IS_UPPER(str := str2);
(* FALSE *)
res3 := OSCAT_BASIC.IS_UPPER(str := str3);
(* FALSE *)
END_PROGRAM |
VAR
test1 : BYTE := 16#61; (* английский язык *)
test2 : BYTE := 16#E0; (* русский язык *)
test3 : BYTE := 16#21;
res1 : BOOL;
res2 : BOOL;
res3 : BOOL;
END_VAR
res1 := OSCAT_BASIC.ISC_ALPHA(IN := test1); (* TRUE *)
res2 := OSCAT_BASIC.ISC_ALPHA(IN := test2); (* TRUE *)
res3 := OSCAT_BASIC.ISC_ALPHA(IN := test3); (* FALSE *)
END_PROGRAM
|
VAR
test1 : BYTE := 16#61;
test2 : BYTE := 16#14;
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.ISC_CTRL(IN := test1); (* FALSE *)
res2 := OSCAT_BASIC.ISC_CTRL(IN := test2); (* TRUE *)
END_PROGRAM
|
VAR
str1 : BYTE := 16#46; (* F *)
str2 : BYTE := 16#47; (* G *)
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.ISC_HEX(IN := str1);
(* TRUE *)
res2 := OSCAT_BASIC.ISC_HEX(IN := str2);
(* FALSE *)
END_PROGRAM |
VAR
str1 : BYTE := 16#46; (* F *)
str2 : BYTE := 16#66; (* f *)
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.ISC_LOWER(IN := str1);
(* FALSE *)
res2 := OSCAT_BASIC.ISC_LOWER(IN := str2);
(* TRUE *)
END_PROGRAM |
VAR
str1 : BYTE := 16#31; (* 1 *)
str2 : BYTE := 16#46; (* F *)
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.ISC_NUM(IN := str1);
(* TRUE *)
res2 := OSCAT_BASIC.ISC_NUM(IN := str2);
(* FALSE *)
END_PROGRAM |
VAR
str1 : BYTE := 16#46; (* F *)
str2 : BYTE := 16#66; (* f *)
res1 : BOOL;
res2 : BOOL;
END_VAR
res1 := OSCAT_BASIC.ISC_UPPER(IN := str1);
(* TRUE *)
res2 := OSCAT_BASIC.ISC_UPPER(IN := str2);
(* FALSE *)
END_PROGRAM |
VAR
TestVar : STRING := ' tEsT '; // исходная строка
ResVar : STRING;
END_VAR
ResVar := OSCAT_BASIC.LOWERCASE( str := TestVar );
(* результат 'test'*)
END_PROGRAM |
VAR
str1 : STRING := 'this is test';
res : STRING;
;
END_VAR
res := OSCAT_BASIC.MIRROR(str := str1);
(* 'tset si siht' *)
END_PROGRAM |
VAR
month : INT := 3;
res1 : STRING(10);
res2 : STRING(10);
END_VAR
res1 := OSCAT_BASIC.MONTH_TO_STRING(MTH := month, LANG := 1, LX := 0); (* March *)
res2 := OSCAT_BASIC.MONTH_TO_STRING(MTH := month, LANG := 2, LX := 3); (* Mrz *)
END_PROGRAM |
VAR
oct1 : STRING(10) := '11';
oct2 : STRING(10) := '400';
byte1 : BYTE;
byte2 : BYTE;
END_VAR
byte1 := OSCAT_BASIC.OCT_TO_BYTE(OCT := oct1); (* 9 *)
byte2 := OSCAT_BASIC.OCT_TO_BYTE(OCT := oct2); (* 0 - переполнение *)
END_PROGRAM |
VAR
oct1 : STRING(20) := '1265';
oct2 : STRING(20) := '8989';
res1 : DWORD;
res2 : DWORD;
END_VAR
res1 := OSCAT_BASIC.OCT_TO_DWORD(OCT := oct1); (* 693 *)
res2 := OSCAT_BASIC.OCT_TO_DWORD(OCT := oct2); (* 0 - недопустимые символы *)
END_PROGRAM |
VAR
rVal : REAL := 3.1415;
rD1 : STRING(1) := '.';
rD2 : STRING(1) := '_';
res1 : STRING(20);
res2 : STRING(20);
END_VAR
res1 := OSCAT_BASIC.REAL_TO_STRF(IN := rVal, N := 2, D := rD1); (* 3.14 *)
res2 := OSCAT_BASIC.REAL_TO_STRF(IN := rVal, N := 5, D := rD2); (* 3_14150 *)
END_PROGRAM
|
VAR
InputText : STRING := 'Hello, world! Hello, everyone!'; (*Исходная строка*)
SearchStr : STRING := 'Hello'; (*Искомая строка*)
ReplaceStr : STRING := 'Hi'; (*Замещающая строка*)
ResultText : STRING;
END_VAR
ResultText := OSCAT_BASIC.REPLACE_ALL( str := InputText,
src := SearchStr,
rep := ReplaceStr );
(* результат 'Hi, world! Hi, everyone!'*)
END_PROGRAM |
VAR
InputText : STRING := '29738956'; (*Исходная строка*)
SearchStr : STRING := '123456789'; (*Искомые символы*)
ReplaceStr : STRING := 'abcdefghi'; (*Замещающие символы*)
ResultText : STRING;
END_VAR
ResultText := OSCAT_BASIC.REPLACE_CHARS( str := InputText,
SRC := SearchStr,
REP := ReplaceStr );
(* результат 'bigchief'*)
END_PROGRAM |
VAR
InputText : STRING := 'äöü'; (*Исходная строка*)
ResultText : STRING;
END_VAR
ResultText := OSCAT_BASIC.REPLACE_UML( str := InputText);
(* результат 'aeoeue'*)
END_PROGRAM |
VAR
UppVar : BYTE := 16#41; // ASCII-код 'A'
LowVar : BYTE;
END_VAR
LowVar := OSCAT_BASIC.TO_LOWER( IN := UppVar );
(* результат = 16#61 ASCII-код 'a'*)
END_PROGRAM |
VAR
UmlVar : BYTE := 16#C4; // Ä
ResVar : STRING(2);
END_VAR
ResVar := OSCAT_BASIC.TO_UML( IN := UmlVar );
(* результат 'Ae'*)
END_PROGRAM |
VAR
LowVar : BYTE := 16#61; // ASCII-код 'a'
UppVar : BYTE;
END_VAR
UppVar := OSCAT_BASIC.TO_UPPER( IN := LowVar );
(* результат = 16#41 ASCII-код 'A'*)
END_PROGRAM |
VAR
TestVar : STRING := 'hello world !'; // исходная строка
ResVar : STRING;
END_VAR
ResVar := OSCAT_BASIC.TRIM( str := TestVar );
(* результат 'helloworld!'*)
END_PROGRAM |
VAR
TestVar : STRING := ' hello world! '; // исходная строка
ResVar : STRING;
END_VAR
ResVar := OSCAT_BASIC.TRIM1( str := TestVar );
(* результат 'hello world!'*)
END_PROGRAM |
VAR
TestVar : STRING := ' hello world! '; // исходная строка
ResVar : STRING;
END_VAR
ResVar := OSCAT_BASIC.TRIME( str := TestVar );
(* результат 'hello world!'*)
END_PROGRAM |
VAR
TestVar : STRING := ' tEsT '; // исходная строка
ResVar : STRING;
END_VAR
ResVar := OSCAT_BASIC.UPPERCASE( str := TestVar );
(* результат 'TEST'*)
END_PROGRAM |
VAR
DayNumber : INT := 5; // 1 = Понедельник, 7 = Воскресенье
Language : INT := 1; // 1 = Английский
NameType : INT := 0; // 0 = Полное название
DayName : STRING(10);
END_VAR
DayName := OSCAT_BASIC.WEEKDAY_TO_STRING( WDAY := DayNumber,
LANG := Language,
LX := NameType );
// Результат: 'Friday'
END_PROGRAM |
VAR
bcdInput : BYTE := 2#01000010;
decOutput : INT;
END_VAR
decOutput := OSCAT_BASIC.BCDC_TO_INT(bcdInput); // результат 42
END_PROGRAM |
VAR
InputVal : DWORD := 2#0011_0001;
result : INT;
END_VAR
result := OSCAT_BASIC.BIT_COUNT(InputVal); // результат 3
END_PROGRAM |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
VAR
InputVal : BYTE := 2#0001_0110;
result : BYTE;
END_VAR
result := OSCAT_BASIC.BYTE_TO_GRAY(InputVal); // результат 2#0001_1101
END_PROGRAM |
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 |
VAR
InputVal : REAL := 11.22;
result : BYTE;
END_VAR
result := OSCAT_BASIC.CHK_REAL(InputVal); // результат 16#00
END_PROGRAM |
|
VAR
InputVar : DWORD := 16#4133851F;
result : REAL;
END_VAR
result := OSCAT_BASIC.DW_TO_REAL(X := InputVar); // результат 11.22
END_PROGRAM |
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 |
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 |
VAR
inVar : BYTE := 2#0001_1101;
resVar : BYTE;
END_VAR
resVar := OSCAT_BASIC.GRAY_TO_BYTE(IN := inVar); (* результат 2#0001_0110 *)
END_PROGRAM |
VAR
inVar : INT := 31;
resVar : BYTE;
END_VAR
resVar := OSCAT_BASIC.INT_TO_BCDC(IN := inVar); (* результат 2#0011_0001 *)
END_PROGRAM |
VAR
InputVar : BYTE := 2#1111_1000;
result : BOOL;
END_VAR
result := OSCAT_BASIC.PARITY(in := InputVar); // результат TRUE
END_PROGRAM |
VAR
inVar : REAL := 11.22;
resVar : DWORD;
END_VAR
resVar := OSCAT_BASIC.REAL_TO_DW(X := inVar); (* результат 16#4133851F *)
END_PROGRAM |
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 |
VAR
inVar : BYTE := 2#1100_0001;
resVar : BYTE;
END_VAR
resVar := OSCAT_BASIC.REVERSE(IN := inVar); (* результат 2#1000_0011 *)
END_PROGRAM |
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 |
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 |
VAR
inVar : WORD := 16#ADDE;
resVar : WORD;
END_VAR
resVar := OSCAT_BASIC.SWAP_BYTE(IN := inVar); (* результат 16#DEAD *)
END_PROGRAM |
VAR
inVar : DWORD := 16#AABBCCDD;
resVar : DWORD;
END_VAR
resVar := OSCAT_BASIC.SWAP_BYTE2(IN := inVar); (* результат 16#DDCCBBAA *)
END_PROGRAM |
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 |
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 |
VAR
(* Экземпляр ФБ *)
Cnt : OSCAT_BASIC.COUNT_BR;
(* Управление *)
xTrig : BOOL := FALSE;
xMode : BOOL := TRUE; (* TRUE = вверх, FALSE = вниз *)
(* Для фронта *)
xTrig_Edge : BOOL;
xTrig_Old : BOOL;
(* Результат *)
Value : BYTE;
END_VAR
(* Инициализация настроек (однократно) *)
Cnt(in := 0 , STEP := 100 , MX := 255);
Cnt(SET := TRUE); (* Устанавливаем начальное значение 0 *)
Cnt();
Cnt(SET := FALSE);
(* Основной цикл *)
(* Детектор фронта *)
xTrig_Edge := xTrig AND NOT xTrig_Old;
xTrig_Old := xTrig;
(* По фронту xTrig выполняем счет *)
IF xTrig_Edge THEN
IF xMode THEN
Cnt(UP := TRUE); (* Увеличение *)
ELSE
Cnt(DN := TRUE); (* Уменьшение *)
END_IF;
Cnt(); (* Выполняем ФБ *)
(* Сбрасываем управляющие сигналы *)
Cnt(UP := FALSE, DN := FALSE);
END_IF;
(* Сохраняем текущее значение *)
Value := Cnt.CNT;
END_PROGRAM |
VAR
(* Входной цифровой сигнал (например, от АЦП) *)
DigitalValue: DWORD := 1024;
(* Настройки преобразования *)
BitCount: BYTE := 12; (* 12 значащих бит *)
SignBit: BYTE := 16#FF; (* Бит знака отсутствует *)
LowLimit: REAL := 0.0; (* Нижний предел аналогового сигнала *)
HighLimit: REAL := 10.0; (* Верхний предел аналогового сигнала *)
(* Результат преобразования *)
AnalogValue: REAL;
END_VAR
(* Вызов функции AIN *)
AnalogValue := OSCAT_BASIC.AIN(
in := DigitalValue,
Bits := BitCount,
sign := SignBit,
low := LowLimit,
high := HighLimit
);
(* Результат: AnalogValue = 2.5 (В)
Пояснение:
- 1024 / 4095 = 0.25 (25% от максимального значения)
- 0.25 * 10.0 = 2.5 (В)
Таким образом, цифровой код 1024 соответствует напряжению 2.5 В*)
END_PROGRAM |
VAR
(* Входной аналоговый сигнал *)
AnalogValue: REAL := 7.5; (*Напряжение 7.5 В*)
(* Настройки преобразования *)
BitCount: BYTE := 12; (*12 значащих бит*)
SignBit: BYTE := 16#FF; (*Бит знака отсутствует*)
LowLimit: REAL := 0.0; (*Нижний предел 0 В*)
HighLimit: REAL := 10.0; (*Верхний предел 10 В*)
(* Результат преобразования *)
DigitalValue: DWORD;
END_VAR
(* Вызов функции AOUT *)
DigitalValue := OSCAT_BASIC.AOUT(
in := AnalogValue,
Bits := BitCount,
sign := SignBit,
low := LowLimit,
high := HighLimit
);
(* Результат: DigitalValue = 3072 (десятичное) или 16#0C00 (шестнадцатеричное)
Пояснение:
7.5 / 10.0 = 0.75 (75% от диапазона)
0.75 * 4095 = 3071.25 ≈ 3072*)
END_PROGRAM |
VAR
(* Входной аналоговый сигнал *)
AnalogValue: REAL := 2.5; (* 2.5 В *)
(* Настройки преобразования *)
FirstBit: INT := 0; (*Номер первого значащего бита*)
LastBit: INT := 11; (*Номер последнего значащего бита
(всего 12 бит: 0..11)*)
SignBit: INT := 31; (*31-й бит — знак*)
LowLimit: REAL := -10.0; (*Нижний предел -10 В*)
HighLimit: REAL := 10.0; (*Верхний предел 10 В*)
(* Результат преобразования*)
DigitalValue: DWORD;
END_VAR
(* Вызов функции AOUT1 *)
DigitalValue := OSCAT_BASIC.AOUT1(
in := AnalogValue,
Bit_0 := FirstBit,
Bit_N := LastBit,
sign := SignBit,
low := LowLimit,
high := HighLimit
);
(*Итоговое значение: 31-й бит = 0, младшие 12 бит = 2559*)
END_PROGRAM |
VAR
(* Входное значение *)
RawValue: BYTE := 25; (* 25 из диапазона 0..255 *)
(* Границы масштабирования *)
LowLimit: REAL := 0.0; (* Нижний предел *)
HighLimit: REAL := 100.0; (* Верхний предел *)
(* Результат *)
ScaledValue: REAL;
END_VAR
(* Вызов функции BYTE_TO_RANGE *)
ScaledValue := OSCAT_BASIC.BYTE_TO_RANGE(
x := RawValue,
low := LowLimit,
high := HighLimit
);
(* Результат: ScaledValue ≈ 9.803922, т.к
25 / 255 ≈ 0.09804 (9.8% от диапазона)
0.09803922 * (100.0 - 0.0) = 9.803922
То есть значение 25 из диапазона 0..255
соответствует 9.8 из диапазона 0.0..100.0*)
END_PROGRAM |
VAR
(* Исходные значения *)
ValueA: REAL := 6.0; (* Первое значение *)
ValueB: REAL := 15.0; (* Второе значение *)
(* Коэффициент смешения *)
MixFactor: REAL := 0.6666; (* 66.66% от B, 33.34% от A *)
(* Результат *)
Result: REAL;
END_VAR
(* Вызов функции MIX *)
Result := OSCAT_BASIC.MIX(
A := ValueA,
B := ValueB,
M := MixFactor
);
(*Результат: Result ≈ 12.0*)
END_PROGRAM |
VAR
(* Информационные входы *)
Input0: REAL := 10.0; (* Значение при A = FALSE *)
Input1: REAL := 20.0; (* Значение при A = TRUE *)
(* Адресный вход *)
Selector: BOOL := FALSE; (* Выбор входа *)
(* Результат *)
Output: REAL;
END_VAR
(* Вызов функции MUX_R2 *)
Output := OSCAT_BASIC.MUX_R2(
IN0 := Input0,
IN1 := Input1,
A := Selector
);
(*Результат: Output = 10.0*)
END_PROGRAM |
VAR
(* Информационные входы (4 источника) *)
Input0 : REAL := 10.0; (* Выбирается при A0=FALSE, A1=FALSE *)
Input1 : REAL := 20.0; (* Выбирается при A0=TRUE, A1=FALSE *)
Input2 : REAL := 30.0; (* Выбирается при A0=FALSE, A1=TRUE *)
Input3 : REAL := 40.0; (* Выбирается при A0=TRUE, A1=TRUE *)
(* Адресные входы *)
Address0 : BOOL := FALSE; (* Младший бит адреса *)
Address1 : BOOL := FALSE; (* Старший бит адреса *)
(* Результат *)
Output : REAL;
END_VAR
(* Вызов функции MUX_R4 *)
Output := OSCAT_BASIC.MUX_R4(
IN0 := Input0,
IN1 := Input1,
IN2 := Input2,
IN3 := Input3,
A0 := Address0,
A1 := Address1
);
(*Результат: Output = 10.0*)
END_PROGRAM |
VAR
(* Входное значение *)
InputValue : REAL := 100.0;
(* Режимы смещения *)
EnableOffset1 : BOOL := TRUE; (* Включаем смещение 1 *)
EnableOffset2 : BOOL := FALSE;
EnableOffset3 : BOOL := FALSE;
EnableOffset4 : BOOL := FALSE;
(* Коэффициенты смещения *)
Offset_1 : REAL := 10.0;
Offset_2 : REAL := 0.0;
Offset_3 : REAL := 0.0;
Offset_4 : REAL := 0.0;
(* Режим имитации *)
Simulate : BOOL := FALSE;
DefaultValue : REAL := 50.0;
(* Результат *)
Result : REAL;
END_VAR
(* Вызов функции OFFSET *)
Result :=OSCAT_BASIC .OFFSET(
X := InputValue,
O1 := EnableOffset1,
O2 := EnableOffset2,
O3 := EnableOffset3,
O4 := EnableOffset4,
D := Simulate,
Offset_1 := Offset_1,
Offset_2 := Offset_2,
Offset_3 := Offset_3,
Offset_4 := Offset_4,
default := DefaultValue
);
(*Результат: Result = 110.0*)
END_PROGRAM |
VAR
(* Входное значение *)
InputValue : REAL := 100.0;
(* Режимы смещения *)
EnableOffset1 : BOOL := TRUE; (* Включаем смещение 1 *)
EnableOffset2 : BOOL := FALSE;
EnableOffset3 : BOOL := FALSE;
EnableOffset4 : BOOL := FALSE;
(* Коэффициенты смещения *)
Offset_1 : REAL := 10.0;
Offset_2 : REAL := 20.0;
Offset_3 : REAL := 30.0;
Offset_4 : REAL := 40.0;
(* Режим имитации *)
Simulate : BOOL := FALSE;
DefaultValue : REAL := 50.0;
(* Результат *)
Result : REAL;
END_VAR
(* Вызов функции OFFSET2 *)
Result := OSCAT_BASIC.OFFSET2(
X := InputValue,
O1 := EnableOffset1,
O2 := EnableOffset2,
O3 := EnableOffset3,
O4 := EnableOffset4,
D := Simulate,
Offset_1 := Offset_1,
Offset_2 := Offset_2,
Offset_3 := Offset_3,
Offset_4 := Offset_4,
default := DefaultValue
);
(*Результат: Result = 110.0*)
END_PROGRAM |
VAR
(* Исходные значения *)
Value1 : REAL := 50.0;
Value2 : REAL := -30.0;
Value3 : REAL := 20.0;
(* Флаги активности *)
Enable1 : BOOL := TRUE; (* Значение 1 активно *)
Enable2 : BOOL := FALSE;
Enable3 : BOOL := FALSE;
(* Результат *)
Result : REAL;
END_VAR
(* Вызов функции OVERRIDE *)
Result := OSCAT_BASIC.OVERRIDE(
X1 := Value1,
X2 := Value2,
X3 := Value3,
E1 := Enable1,
E2 := Enable2,
E3 := Enable3
);
(*Результат: Result = 50.0*)
END_PROGRAM |
VAR
(* Входное значение с плавающей точкой *)
InputValue: REAL := 25.0; (* 25.0 из диапазона 0.0…100.0 *)
(* Границы исходного диапазона *)
LowLimit: REAL := 0.0; (* Нижний предел *)
HighLimit: REAL := 100.0; (* Верхний предел *)
(* Результат масштабирования *)
OutputByte: BYTE;
END_VAR
(* Вызов функции RANGE_TO_BYTE *)
OutputByte := OSCAT_BASIC.RANGE_TO_BYTE(
X := InputValue,
low := LowLimit,
high := HighLimit
);
(*Результат: OutputByte = 64*)
END_PROGRAM |
VAR
(* Входное значение с плавающей точкой *)
InputValue: REAL := 25.0; (* 25.0 из диапазона 0.0…100.0 *)
(* Границы исходного диапазона *)
LowLimit: REAL := 0.0; (* Нижний предел *)
HighLimit: REAL := 100.0; (* Верхний предел *)
(* Результат масштабирования *)
OutputWord: WORD;
END_VAR
(* Вызов функции RANGE_TO_WORD *)
OutputWord := OSCAT_BASIC.RANGE_TO_WORD(
X := InputValue,
low := LowLimit,
high := HighLimit
);
(*Результат: OutputWord = 16383*)
END_PROGRAM |
VAR
(* Входное значение *)
InputValue: REAL := 25.0; (* Исходное значение *)
(* Коэффициенты масштабирования *)
Gain: REAL := 2.0; (* Коэффициент масштабирования K *)
Offset: REAL := 10.0; (* Сдвиг O *)
(* Границы ограничения *)
MinLimit: REAL := 15.0; (* Нижний предел MN *)
MaxLimit: REAL := 75.0; (* Верхний предел MX *)
(* Результат *)
Result: REAL;
END_VAR
(* Вызов функции SCALE *)
Result := OSCAT_BASIC.SCALE(
X := InputValue,
K := Gain,
O := Offset,
MX := MaxLimit,
MN := MinLimit
);
(* Результат: Result = 60.0
Расчет:
1. Промежуточное значение: K * X + O = 2.0 * 25.0 + 10.0 = 60.0
2. Проверка ограничений: 15.0 <= 60.0 <= 75.0
3. Значение в пределах диапазона, возвращается 60.0 *)
END_PROGRAM |
VAR
(* Входное целочисленное значение *)
InputValue: BYTE := 32; (* 32 из диапазона 0…128 *)
(* Границы исходного диапазона (целочисленные) *)
InLow: BYTE := 0; (* Нижний предел *)
InHigh: BYTE := 128; (* Верхний предел *)
(* Границы выходного диапазона (вещественные) *)
OutLow: REAL := -10.0; (* Нижний предел *)
OutHigh: REAL := 10.0; (* Верхний предел *)
(* Результат масштабирования *)
OutputValue: REAL;
END_VAR
(* Вызов функции SCALE_B *)
OutputValue := OSCAT_BASIC.SCALE_B(
X := InputValue,
I_LO := InLow,
I_HI := InHigh,
O_LO := OutLow,
O_HI := OutHigh
);
(*Результат: OutputValue = -5.0*)
END_PROGRAM |
VAR
(* Входные целочисленные значения (0…255) *)
Input1: BYTE := 32; (* Первое значение *)
Input2: BYTE := 64; (* Второе значение *)
(* Коэффициенты масштабирования результата *)
Gain: REAL := 2.0; (* Коэффициент K *)
Offset: REAL := 4.0; (* Сдвиг O *)
(* Границы масштабирования для IN1 *)
In1_Min: REAL := 0.0; (* Нижний предел для IN1 *)
In1_Max: REAL := 8.0; (* Верхний предел для IN1 *)
(* Границы масштабирования для IN2 *)
In2_Min: REAL := 0.0; (* Нижний предел для IN2 *)
In2_Max: REAL := 8.0; (* Верхний предел для IN2 *)
(* Результат *)
Result: REAL;
END_VAR
(* Вызов функции SCALE_B2 *)
Result := OSCAT_BASIC.SCALE_B2(
IN1 := Input1,
IN2 := Input2,
K := Gain,
O := Offset,
IN1_MIN := In1_Min,
IN1_MAX := In1_Max,
IN2_MIN := In2_Min,
IN2_MAX := In2_Max
);
(* Результат 10.0235294118*)
END_PROGRAM |
VAR
(* Входное целочисленное значение DWORD *)
InputValue: DWORD := 75000; (* 75000 из диапазона 0…100000 *)
(* Границы исходного диапазона (DWORD) *)
InLow: DWORD := 0; (* Нижний предел *)
InHigh: DWORD := 100000; (* Верхний предел *)
(* Границы выходного диапазона (REAL) *)
OutLow: REAL := -10.0; (* Нижний предел *)
OutHigh: REAL := 10.0; (* Верхний предел *)
(* Результат масштабирования *)
OutputValue: REAL;
END_VAR
(* Вызов функции SCALE_D *)
OutputValue := OSCAT_BASIC.SCALE_D(
X := InputValue,
I_LO := InLow,
I_HI := InHigh,
O_LO := OutLow,
O_HI := OutHigh
);
(*Результат = 5.0*)
END_PROGRAM |
VAR
(* Входное значение с плавающей точкой *)
InputValue: REAL := 12.0;
(* Границы исходного диапазона (REAL) *)
InLow: REAL := 4.0; (* Нижний предел *)
InHigh: REAL := 20.0; (* Верхний предел *)
(* Границы выходного диапазона (REAL) *)
OutLow: REAL := 0.0; (* Нижний предел *)
OutHigh: REAL := 100.0; (* Верхний предел *)
(* Результат масштабирования *)
OutputValue: REAL;
END_VAR
(* Вызов функции SCALE_R *)
OutputValue := OSCAT_BASIC.SCALE_R(
X := InputValue,
I_LO := InLow,
I_HI := InHigh,
O_LO := OutLow,
O_HI := OutHigh
);
(*Результат = 50.0*)
END_PROGRAM |
VAR
(* Входные булевые значения *)
Input1: BOOL := TRUE; (* Первое значение *)
Input2: BOOL := FALSE; (* Второе значение *)
(* Коэффициенты масштабирования *)
Gain: REAL := 2.5; (* Коэффициент K *)
Offset: REAL := 5.0; (* Сдвиг O *)
(* Границы масштабирования для IN1 *)
In1_Min: REAL := 20.0; (* Значение при IN1=FALSE *)
In1_Max: REAL := 40.0; (* Значение при IN1=TRUE *)
(* Границы масштабирования для IN2 *)
In2_Min: REAL := 30.0; (* Значение при IN2=FALSE *)
In2_Max: REAL := 40.0; (* Значение при IN2=TRUE *)
(* Результат *)
Result: REAL;
END_VAR
(* Вызов функции SCALE_X2 *)
Result := OSCAT_BASIC.SCALE_X2(
IN1 := Input1,
IN2 := Input2,
K := Gain,
O := Offset,
IN1_MIN := In1_Min,
IN1_MAX := In1_Max,
IN2_MIN := In2_Min,
IN2_MAX := In2_Max
);
(*Результат 180.0*)
END_PROGRAM |
VAR
(* Входное целочисленное значение WORD (0…65535) *)
InputValue : WORD := 8192; (* 8192 из диапазона 0…65535 *)
(* Границы выходного диапазона (REAL) *)
LowLimit : REAL := -100.0; (* Нижний предел *)
HighLimit : REAL := 100.0; (* Верхний предел *)
(* Результат масштабирования *)
OutputValue : REAL;
END_VAR
(* Вызов функции WORD_TO_RANGE *)
OutputValue := OSCAT_BASIC.WORD_TO_RANGE(
X := InputValue,
low := LowLimit,
high := HighLimit
);
(* Результат: OutputValue = -75.0*)
END_PROGRAM |
VAR
(* Исходные значения для обоих вызовов *)
Value1 : REAL := 2.5;
Value2 : REAL := 3.5;
Value3 : REAL := 4.5;
(* Результаты *)
Result1 : REAL; (* Результат первой функции *)
Result2 : REAL; (* Результат второй функции *)
Default1 : REAL := 3.0;
Default2 : REAL := 0.0;
Min1 : REAL := 3.0;
Max1 : REAL := 5.0;
Min2 : REAL := 0.0;
Max2 : REAL := 100.0;
Mode1 : BYTE := 0;
Mode2 : BYTE := 7;
END_VAR
Result1 := OSCAT_BASIC.MULTI_IN(
in_1 := Value1,
in_2 := Value2,
in_3 := Value3,
Default := Default1,
in_min := Min1,
in_max := Max1,
mode := Mode1
);
(* Результат: Result1 = 4, т.к. значение in_1 выходит за диапазон (in_min…in_max),
поэтому функция возвращает среднее арифметическое для значений in_2 и in_3*)
Result2 := OSCAT_BASIC.MULTI_IN(
in_1 := Value1,
in_2 := Value2,
in_3 := Value3,
Default := Default2,
in_min := Min2,
in_max := Max2,
mode := Mode2
);
(* Результат: Result2 = 3.5 - среднее из трех значений*)
END_PROGRAM |
VAR
(*Измеренная температура, °C *)
Temperature : REAL := 50.0; (* 50 °C *)
(*Номинальное сопротивление ТС при 0 °C, Ом *)
R0_Nominal : REAL := 100.0; (* ТС 100 Ом *)
(*Результат - сопротивление ТС, Ом *)
Resistance : REAL;
END_VAR
(*Вызов функции RES_NI *)
Resistance := OSCAT_BASIC.RES_NI(
T := Temperature,
R0 := R0_Nominal
);
(*Результат ≈ 129.11 Ом*)
END_PROGRAM |
VAR
(* Измеренная температура, °C *)
Temperature : REAL := 30.0; (* 30 °C *)
(* Номинальное сопротивление при 25 °C, Ом *)
RN_Nominal : REAL := 10000.0; (* 10 кОм при 25 °C *)
(* Коэффициент температурной чувствительности, К *)
B_Coeff : REAL := 3950.0; (* B = 3950 K *)
(* Результат - сопротивление NTC-термистора, Ом *)
Resistance : REAL;
END_VAR
(* Вызов функции RES_NTC *)
Resistance := OSCAT_BASIC.RES_NTC(
T := Temperature,
RN := RN_Nominal,
B := B_Coeff
);
(*Результат ≈ 8037 Ом*)
END_PROGRAM |
VAR
(* Измеренная температура, °C *)
Temperature : REAL := 50.0; (* 50 °C *)
(* Номинальное сопротивление ТС при 0 °C, Ом *)
R0_Nominal : REAL := 100.0; (* Pt100 *)
(* Результат - сопротивление ТС, Ом *)
Resistance : REAL;
END_VAR
(* Вызов функции RES_PT *)
Resistance := OSCAT_BASIC.RES_PT(
T := Temperature,
R0 := R0_Nominal
);
(*Результат ≈ 119.40 Ом*)
END_PROGRAM |
VAR
(* Измеренная температура, °C *)
Temperature : REAL := 50.0; (* 50 °C *)
(* Номинальное сопротивление при температуре TS, Ом *)
RS_Nominal : REAL := 1000.0; (* 1000 Ом при 25 °C *)
(* Температура при номинальном сопротивлении, °C *)
TS_Nominal : REAL := 25.0; (* 25 °C *)
(* Результат - сопротивление ТС, Ом *)
Resistance : REAL;
END_VAR
(* Вызов функции RES_SI *)
Resistance := OSCAT_BASIC.RES_SI(
T := Temperature,
RS := RS_Nominal,
TS := TS_Nominal
);
(*Результат ≈ 1201.375 Ом*)
END_PROGRAM |
VAR (* Измеренное сопротивление ТС, Ом *)
Resistance : REAL := 129.1; (* 129.1 Ом *)
(* Номинальное сопротивление ТС при 0 °C, Ом *)
R0_Nominal : REAL := 100.0; (* ТС 100 Ом *)
(* Результат - температура, °C *)
Temperature : REAL;
END_VAR
(* Вызов функции TEMP_NI *)
Temperature := OSCAT_BASIC.TEMP_NI(
Res := Resistance,
R0 := R0_Nominal
);
(*Результат ≈ 50 °C*)
END_PROGRAM |
VAR (* Измеренное сопротивление NTC-термистора, Ом *)
Resistance : REAL := 8037.0; (* 8.037 кОм *)
(* Номинальное сопротивление при 25 °C, Ом *)
RN_Nominal : REAL := 10000.0; (* 10 кОм при 25 °C *)
(* Коэффициент температурной чувствительности, К *)
B_Coeff : REAL := 3950.0; (* B = 3950 K *)
(* Результат - температура, °C *)
Temperature : REAL;
END_VAR
(* Вызов функции TEMP_NTC *)
Temperature := OSCAT_BASIC.TEMP_NTC(
Res := Resistance,
RN := RN_Nominal,
B := B_Coeff
);
(*Результат ≈ 30.0 °C*)
END_PROGRAM |
VAR
(* Измеренное сопротивление ТС, Ом *)
Resistance : REAL := 119.4; (* 119.4 Ом *)
(* Номинальное сопротивление ТС при 0 °C, Ом *)
R0_Nominal : REAL := 100.0; (* Pt100 *)
(* Результат - температура, °C *)
Temperature : REAL;
END_VAR
(* Вызов функции TEMP_PT *)
Temperature := OSCAT_BASIC.TEMP_PT(
Res := Resistance,
R0 := R0_Nominal
);
(*Результат: Temperature ≈ 50.0 °C*)
END_PROGRAM |
VAR
(* Измеренное сопротивление, Ом *)
Resistance : REAL := 1200.0; (* 1200 Ом *)
(* Номинальное сопротивление при температуре TS, Ом *)
RS_Nominal : REAL := 1000.0; (* 1000 Ом при 25 °C *)
(* Температура при номинальном сопротивлении, °C *)
TS_Nominal : REAL := 25.0; (* 25 °C *)
(* Результат - стемпература, °C *)
Temperature : REAL;
END_VAR
(* Вызов функции TEMP_SI *)
Temperature := OSCAT_BASIC.TEMP_SI(
Res := Resistance,
RS := RS_Nominal,
TS := TS_Nominal
);
(*Результат ≈ 50 °C*)
END_PROGRAM |
VAR
(* Экземпляр функционального блока ALARM_2 *)
Alarm : OSCAT_BASIC.ALARM_2;
(* Контролируемое значение (температура) *)
Temperature : REAL := 85.0; (* 85 °C *)
(* Настройки пределов *)
LO_1 : REAL := 60.0; (* Нижний предел 1 (тревога) *)
HI_1 : REAL := 80.0; (* Верхний предел 1 (тревога) *)
LO_2 : REAL := 50.0; (* Нижний предел 2 (авария) *)
HI_2 : REAL := 90.0; (* Верхний предел 2 (авария) *)
HYS : REAL := 2.0; (* Гистерезис 2 °C *)
(* Выходные флаги *)
AlarmLO1 : BOOL; (* Меньше нижнего предела 1 *)
AlarmHI1 : BOOL; (* Больше верхнего предела 1 *)
AlarmLO2 : BOOL; (* Меньше нижнего предела 2 *)
AlarmHI2 : BOOL; (* Больше верхнего предела 2 *)
(* Состояние системы *)
StatusMessage : STRING[50];
END_VAR
(* Настройка параметров блока *)
Alarm(
LO_1 := LO_1,
HI_1 := HI_1,
LO_2 := LO_2,
HI_2 := HI_2,
HYS := HYS
);
(* Циклический вызов блока с текущим значением *)
Alarm(X := Temperature);
(* Чтение выходных флагов *)
AlarmLO1 := Alarm.Q1_LO;
AlarmHI1 := Alarm.Q1_HI;
AlarmLO2 := Alarm.Q2_LO;
AlarmHI2 := Alarm.Q2_HI;
(* Логика обработки *)
IF AlarmHI2 THEN
StatusMessage := 'АВАРИЯ: превышение верхнего предела 90 °C!';
ELSIF AlarmLO2 THEN
StatusMessage := 'АВАРИЯ: падение ниже нижнего предела 50 °C!';
ELSIF AlarmHI1 THEN
StatusMessage := 'ПРЕДУПРЕЖДЕНИЕ: температура выше 80 °C';
ELSIF AlarmLO1 THEN
StatusMessage := 'ПРЕДУПРЕЖДЕНИЕ: температура ниже 60 °C';
ELSE
StatusMessage := 'Нормальный режим';
END_IF;
(*Результат при Temperature = 85 °C:
- AlarmHI1 = TRUE (85 > 80)
- AlarmHI2 = FALSE (85 < 90)
- StatusMessage = 'ПРЕДУПРЕЖДЕНИЕ: температура выше 80 °C'*)
END_PROGRAM (*Объявление конца программы*) |
VAR AstroConv: OSCAT_BASIC.ASTRO;
(* Расстояние в световых годах *)
DistanceLJ: REAL := 4.24; (* 4.24 световых года до Проксимы Центавра *)
(* Результаты *)
Meters: REAL;
AE: REAL;
Parsecs: REAL;
LightYears: REAL;
END_VAR
(* Вызов ФБ с входом LJ *)
AstroConv(LJ := DistanceLJ);
(* Чтение результатов *)
Meters := AstroConv.Ym; (* ≈ 4.0113E16 м *)
AE := AstroConv.YAE; (* ≈ 268144.6 а.е. *)
Parsecs := AstroConv.YPC; (* ≈ 1.3 парсека *)
LightYears := AstroConv.YLJ; (* 4.24 световых года *)
(* Результат:
- Ym ≈ 4.0113E16 м
- YAE ≈ 268144.6 а.е.
- YPC ≈ 1.3 парсека
- YLJ = 4.24 световых года*)
END_PROGRAM |
VAR
(* Скорость ветра в баллах Бофорта *)
WindForce : INT := 4; (* 4 балла - «Умеренный ветер» (5.5–7.9 м/с) *)
(* Результат конвертации *)
WindSpeed : REAL;
END_VAR
(* Вызов функции BFT_TO_MS *)
WindSpeed := OSCAT_BASIC.BFT_TO_MS(
BFT := WindForce
);
(*Результат: WindSpeed ≈ 6.696 м/с*)
END_PROGRAM |
VAR
(* Температура в градусах Цельсия *)
TempCelsius : REAL := 25.0; (* 25 °C *)
(* Результат конвертации *)
TempFahrenheit : REAL;
END_VAR
(* Вызов функции C_TO_F *)
TempFahrenheit := OSCAT_BASIC.C_TO_F(
celsius := TempCelsius
);
(*Результат: TempFahrenheit = 77.0 °F*)
END_PROGRAM |
VAR
(* Температура в градусах Цельсия *)
TempCelsius : REAL := 30.0; (* 25 °C *)
(* Результат конвертации *)
TempKelvin : REAL;
END_VAR
(* Вызов функции C_TO_K *)
TempKelvin := OSCAT_BASIC.C_TO_K(
celsius := TempCelsius
);
(*Результат: TempKelvin = 303*)
END_PROGRAM |
VAR (* Азимут в градусах *)
Azimuth : INT := 120; (* 120 градусов *)
(* Количество лучей розы румбов *)
Rays : INT := 2; (* 8 лучей (N=2) *)
(* Язык проекта (0 - английский) *)
Lang : INT := 0; (* Английский язык *)
(* Результат - обозначение румба *)
Direction : STRING(3);
END_VAR
(* Вызов функции DEG_TO_DIR *)
Direction := OSCAT_BASIC.DEG_TO_DIR(
DEG := Azimuth,
N := Rays,
L := Lang
);
(*Результат: Direction = 'SE'*)
END_PROGRAM |
VAR
(* Обозначение румба *)
Direction : STRING(3) := 'SE'; (* Юго-восток *)
(* Язык проекта (0 - английский) *)
Lang : INT := 0; (* Английский язык *)
(* Результат - азимут в градусах *)
Azimuth : INT;
END_VAR
(* Вызов функции DIR_TO_DEG *)
Azimuth := OSCAT_BASIC.DIR_TO_DEG(
DIR := Direction,
L := Lang
);
(*Результат: Azimuth = 135*)
END_PROGRAM |
VAR
(* Экземпляр ФБ ENERGY *)
EnergyConv : OSCAT_BASIC.ENERGY;
(* Исходное значение энергии в джоулях *)
EnergyJ : REAL := 4186.8; (* 4186.8 Дж = 1000 кал *)
(* Результаты конвертации *)
ResultJ : REAL; (* В джоулях *)
ResultC : REAL; (* В калориях *)
ResultWH : REAL; (* В ватт-часах *)
END_VAR
(* Вызов ФБ с заполненными входами J*)
EnergyConv(J := EnergyJ);
(* Чтение результатов *)
ResultJ := EnergyConv.YJ; (*4186.8 Дж *)
ResultC := EnergyConv.YC; (*1000.0 кал*)
ResultWH := EnergyConv.YWH; (* ≈ 1.163 Вт·ч*)
END_PROGRAM |
VAR
(* Температура в градусах Фаренгейта *)
TempFahrenheit : REAL := 77.0; (* 77 °F *)
(* Результат конвертации *)
TempCelsius : REAL;
END_VAR
(* Вызов функции F_TO_C *)
TempCelsius := OSCAT_BASIC.F_TO_C(
fahrenheit := TempFahrenheit
);
(*Результат: TempCelsius = 25.0 °C*) |
VAR
(* Частота, Гц *)
Frequency : REAL := 50.0; (* 50 Гц (промышленная частота) *)
(* Результат конвертации *)
AngularFrequency : REAL; (* Угловая частота, рад/с *)
END_VAR
(* Вызов функции F_TO_OM *)
AngularFrequency := OSCAT_BASIC.F_TO_OM(
F := Frequency
);
(*Результат: AngularFrequency ≈ 314.159 рад/с*)
END_PROGRAM |
VAR
(* Частота колебаний, Гц *)
Frequency : REAL := 50.0; (* 50 Гц (промышленная частота) *)
(* Результат конвертации *)
Period : TIME; (* Период колебаний, с *)
END_VAR
(* Вызов функции F_TO_PT *)
Period := OSCAT_BASIC.F_TO_PT(
F := Frequency
);
(*Результат: Period = T#20ms*)
END_PROGRAM |
VAR
(* Географические координаты в формате DMS *)
Degrees : INT := 55; (* 55 градусов *)
Minutes : INT := 45; (* 45 минут *)
Seconds : REAL := 30.0; (* 30 секунд *)
(* Результат конвертации *)
DecimalDegrees : REAL; (* Десятичные градусы *)
END_VAR
(* Вызов функции GEO_TO_DEG *)
DecimalDegrees := OSCAT_BASIC.GEO_TO_DEG(
D := Degrees,
M := Minutes,
SEC := Seconds
);
(* Результат: DecimalDegrees ≈ 55.758333°*)
END_PROGRAM |
VAR
(* Температура в градусах Цельсия *)
TempKelvin : REAL := 303.15;
(* Результат конвертации *)
TempCelsius : REAL;
END_VAR
(* Вызов функции K_TO_C *)
TempCelsius := OSCAT_BASIC.K_TO_C(
Kelvin := TempKelvin
);
(*Результат: TempCelsius = 30*)
END_PROGRAM |
VAR
(* Скорость в км/ч *)
SpeedKmh : REAL := 180;
(* Результат конвертации *)
SpeedMS : REAL;
END_VAR
(* Вызов функции KMH_TO_MS *)
SpeedMS := OSCAT_BASIC.KMH_TO_MS(
kmh := SpeedKmh
);
(*Результат: SpeedMS = 50.0000038*)
END_PROGRAM |
VAR
(* Экземпляр ФБ LENGTH *)
LengthConv : OSCAT_BASIC.LENGTH;
(* Исходное значение длины в метрах *)
LengthM : REAL := 1000.0; (* 1000 м = 1 км *)
(* Результаты конвертации *)
ResultM : REAL; (* В метрах *)
ResultIn : REAL; (* В дюймах *)
ResultFt : REAL; (* В футах *)
ResultMile : REAL; (* В милях *)
ResultSm : REAL; (* В морских милях *)
END_VAR
(* Вызов ФБ с заполненным входом m *)
LengthConv(m := LengthM);
(* Чтение результатов *)
ResultM := LengthConv.Ym; (* 1000.0 м *)
ResultIn := LengthConv.Yin; (* ≈ 39370.08 дюймов *)
ResultFt := LengthConv.Yft; (* ≈ 3280.84 футов *)
ResultMile := LengthConv.Ymile; (* ≈ 0.6214 мили *)
ResultSm := LengthConv.Ysm; (* ≈ 0.5400 морской мили *)
END_PROGRAM |
VAR
(* Скорость ветра в м/с *)
WindSpeed : REAL := 6.69; (* 6.69 м/с) *)
(* Результат конвертации *)
WindForce : INT;
END_VAR
(* Вызов функции MS_TO_BFT *)
WindForce := OSCAT_BASIC.MS_TO_BFT(
MS := WindSpeed
);
(*Результат: 4 балла "Умеренный ветер"*)
END_PROGRAM |
VAR
(* Скорость в мс *)
SpeedMS : REAL := 50.0000038;
(* Результат конвертации *)
SpeedKmh : REAL;
END_VAR
(* Вызов функции MS_TO_KMH *)
SpeedKmh := OSCAT_BASIC.MS_TO_KMH(
MS := SpeedMS
);
(*Результат: SpeedKmh = 180 км/ч*)
END_PROGRAM |
VAR
(* угловая частота, рад/с *)
AngularFrequency : REAL := 314.15;
(* Результат конвертации *)
Frequency : REAL; (* Частота, Гц *)
END_VAR
(* Вызов функции OM_TO_F *)
Frequency := OSCAT_BASIC.OM_TO_F(
OM := AngularFrequency
);
(*Результат: Frequency = 50 Гц*)
END_PROGRAM |
VAR (* Экземпляр ФБ PRESSURE *)
PressureConv : OSCAT_BASIC.PRESSURE;
(* Исходное значение давления в барах *)
PressureBar : REAL := 1.0; (* 1 бар *)
(* Результаты конвертации *)
ResultBar : REAL; (* В барах *)
ResultPa : REAL; (* В паскалях *)
ResultAtm : REAL; (* В физических атмосферах *)
ResultAtt : REAL; (* В технических атмосферах *)
ResultTorr : REAL; (* В мм ртутного столба *)
ResultMws : REAL; (* В метрах водяного столба *)
END_VAR
(* Вызов ФБ с заполненным входом bar *)
PressureConv(bar := PressureBar);
(* Чтение результатов *)
ResultBar := PressureConv.Ybar; (* 1.0 бар *)
ResultPa := PressureConv.Ypa; (* 100000.0 Па *)
ResultAtm := PressureConv.Yatm; (* ≈ 0.9869 атм *)
ResultAtt := PressureConv.Yatt; (* ≈ 1.0197 ат *)
ResultTorr := PressureConv.Ytorr; (* ≈ 750.06 мм рт. ст. *)
ResultMws := PressureConv.Ymws; (* ≈ 10.197 м вод. ст. *)
END_PROGRAM |
VAR
(* Период колебаний, с *)
Period : TIME := T#20ms;
(* Результат конвертации *)
Frequency : REAL; (*Частота колебаний, Гц *)
END_VAR
(* Вызов функции PT_TO_F *)
Frequency := OSCAT_BASIC.PT_TO_F(
PT := Period
);
(*Результат: Frequency = 50 Гц*)
END_PROGRAM |
VAR
(* Экземпляр ФБ SPEED *)
SpeedConv : OSCAT_BASIC.SPEED;
(* Исходное значение скорости в м/с *)
SpeedMs : REAL := 10.0; (* 10 м/с *)
(* Результаты конвертации *)
ResultMs : REAL; (* В м/с *)
ResultKmh: REAL; (* В км/ч *)
ResultKn : REAL; (* В узлах *)
ResultMh : REAL; (* В милях/ч *)
END_VAR
(* Вызов ФБ с заполненным входом ms *)
SpeedConv(ms := SpeedMs);
(* Чтение результатов *)
ResultMs := SpeedConv.Yms; (* 10.0 м/с *)
ResultKmh := SpeedConv.Ykmh; (* 36.0 км/ч *)
ResultKn := SpeedConv.Ykn; (* ≈ 19.44 узла *)
ResultMh := SpeedConv.Ymh; (* ≈ 22.37 миль/ч *)
END_PROGRAM
|
VAR
(* Экземпляр ФБ TEMPERATURE *)
TempConv : OSCAT_BASIC.TEMPERATURE;
(* Исходное значение температуры в градусах Цельсия *)
TempCelsius : REAL := 100.0; (* 100 °C (точка кипения воды) *)
(* Результаты конвертации *)
ResultK : REAL; (* В кельвинах *)
ResultC : REAL; (* В градусах Цельсия *)
ResultF : REAL; (* В градусах Фаренгейта *)
ResultRe : REAL; (* В градусах Реомюра *)
ResultRa : REAL; (* В градусах Ранкина *)
END_VAR
(* Вызов ФБ с заполненным входом C *)
TempConv(C := TempCelsius);
(* Чтение результатов *)
ResultK := TempConv.YK; (*YK = 373.15 K*)
ResultC := TempConv.YC; (*YC = 100.0 °C*)
ResultF := TempConv.YF; (*YF = 212.0 °F*)
ResultRe := TempConv.YRe; (*YRe = 80.0 °Re*)
ResultRa := TempConv.YRa; (*YRa = 671.67 °Ra*)
END_PROGRAM
|
VAR
(* Значение уставки *)
SetPoint : REAL := 100.0; (* Заданная температура 100 °C *)
(* Измеренное значение регулируемой величины *)
ActualValue : REAL := 98.5; (* Фактическая температура 98.5 °C *)
(* Зона нечувствительности *)
Noise : REAL := 2.0; (* ±2 °C *)
(* Результат - сигнал рассогласования *)
ControlError : REAL;
END_VAR
(* Вызов функции CTRL_IN *)
ControlError := OSCAT_BASIC.CTRL_IN(
SET_POINT := SetPoint,
ACTUAL := ActualValue,
NOISE := Noise
);
(*
Результат: ControlError = 0.0
Пояснение:
|SET_POINT - ACTUAL| = |100.0 - 98.5| = 1.5
|1.5| < NOISE (2.0) → функция возвращает 0
Это означает, что отклонение находится в пределах зоны
нечувствительности, и регулятор не должен реагировать.
*)
END_PROGRAM
|
VAR (* Экземпляр ФБ CTRL_OUT *)
CtrlOutput : OSCAT_BASIC.CTRL_OUT;
(* Входы *)
RegulatorOutput : REAL := 75.0; (* Выход регулятора (CI) *)
Offset : REAL := 5.0; (* Смещение (OFFSET) *)
ManualInput : REAL := 50.0; (* Ручной ввод (MAN_IN) *)
LimitLow : REAL := 0.0; (* Нижний предел (LIM_L) *)
LimitHigh : REAL := 100.0; (* Верхний предел (LIM_H) *)
ManualMode : BOOL := FALSE; (* Автоматический режим *)
(* Выходы *)
ControlValue : REAL; (* Управляющее воздействие *)
LimitReached : BOOL; (* Флаг достижения предела *)
END_VAR
(* Вызов ФБ CTRL_OUT *)
CtrlOutput(
CI := RegulatorOutput,
OFFSET := Offset,
MAN_IN := ManualInput,
LIM_L := LimitLow,
LIM_H := LimitHigh,
MANUAL := ManualMode
);
(* Чтение выходов *)
ControlValue := CtrlOutput.Y;
LimitReached := CtrlOutput.LIM;
(*
Результат:
- MANUAL = FALSE → автоматический режим
- Y = CI + OFFSET = 75.0 + 5.0 = 80.0
- 80.0 находится в пределах [0.0, 100.0]
- LIM = FALSE (предел не достигнут)
Ответ:
- ControlValue = 80.0
- LimitReached = FALSE
*)
END_PROGRAM
|
VAR
(* Входное значение *)
InputValue : REAL := 15.0; (* 15.0 *)
(* Смещение (зона нечувствительности) *)
Offset : REAL := 5.0; (* ±5.0 *)
(* Результат *)
Result : REAL;
END_VAR
(* Вызов функции DEAD_BAND *)
Result := OSCAT_BASIC.DEAD_BAND(
X := InputValue,
L := Offset
);
(*Результат: Result = 10.0*)
END_PROGRAM |
VAR
(* Буфер в виде массива байт *)
Buffer : ARRAY[1..5] OF BYTE := [2, 12, 4, 8, 6];
(* Флаг окончания обработки *)
Done : BOOL;
(* Счетчик для отображения *)
i : INT;
END_VAR
(* Вызов функции _BUFFER_CLEAR *)
Done := OSCAT_BASIC._BUFFER_CLEAR(
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer)
);
(*
Результат:
- Buffer = [0, 0, 0, 0, 0]
- Done = TRUE
Пояснение:
- ADR(Buffer) возвращает адрес массива в памяти
- SIZEOF(Buffer) возвращает размер массива в байтах (5 байт)
- Функция присваивает каждому элементу буфера значение 0
*)
END_PROGRAM |
VAR
(* Буфер в виде массива байт *)
Buffer : ARRAY[1..5] OF BYTE := [2, 12, 4, 8, 6];
(* Присваиваемое значение *)
InitValue : BYTE := 3;
(* Флаг окончания обработки *)
Done : BOOL;
END_VAR
(* Вызов функции _BUFFER_INIT *)
Done := OSCAT_BASIC._BUFFER_INIT(
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer),
INIT := InitValue
);
(*
Результат:
- Buffer = [3, 3, 3, 3, 3]
- Done = TRUE
Пояснение:
- ADR(Buffer) возвращает адрес массива в памяти
- SIZEOF(Buffer) возвращает размер массива в байтах (5 байт)
- Функция присваивает каждому элементу буфера значение INIT (3)
*)
END_PROGRAM |
VAR
(* Буфер в виде массива байт *)
Buffer : ARRAY[0..9] OF BYTE := [2, 12, 4, 8, 6, 0, 0, 0, 0, 0];
(* Записываемая строка *)
TextToInsert : STRING := 'test';
(* Позиция для вставки (0 — начало буфера) *)
InsertPosition : INT := 2;
(* Результат — позиция после вставки *)
NewPosition : INT;
END_VAR
(* Вызов функции _BUFFER_INSERT *)
NewPosition := OSCAT_BASIC._BUFFER_INSERT(
STR := TextToInsert,
POS := InsertPosition,
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer)
);
(*
Результат:
- Buffer = [2, 12, 116, 101, 115, 116, 4, 8, 6, 0]
- NewPosition = 6
Пояснение:
- Исходный буфер: [2, 12, 4, 8, 6, 0, 0, 0, 0, 0]
- Вставляем 'test' с позиции 2 (третья ячейка)
- ASCII-коды: 't'=116, 'e'=101, 's'=115, 't'=116
- Данные после позиции 2 (4, 8, 6, 0, 0, 0, 0) сдвигаются вправо на 4 байта
- Итоговый буфер: [2, 12, 116, 101, 115, 116, 4, 8, 6, 0]
- NewPosition = 2 + 4 = 6 (позиция сразу после вставленной строки)
*)
END_PROGRAM |
VAR (* Буфер в виде массива байт *)
Buffer : ARRAY[0..3] OF BYTE := [242, 229, 241, 242];
(* Флаг окончания обработки *)
Done : BOOL;
END_VAR
(* Вызов функции _BUFFER_UPPERCASE *)
Done := OSCAT_BASIC._BUFFER_UPPERCASE(
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer)
);
(*
Результат:
- Buffer = [210, 197, 209, 210]
- Done = TRUE
Пояснение:
- Исходные ASCII-коды: 242, 229, 241, 242 (буквы "т", "е", "с", "т")
- После конвертации: 210, 197, 209, 210 (буквы "Т", "Е", "С", "Т")
- Все строчные буквы заменены на заглавные
*)
END_PROGRAM |
VAR
(* Буфер в виде массива байт *)
Buffer : ARRAY[0..9] OF BYTE := [2, 12, 4, 8, 6, 0, 0, 0, 0, 0];
(* Записываемая строка *)
TextToWrite : STRING := 'test';
(* Позиция для записи (0 — начало буфера) *)
WritePosition : INT := 2;
(* Результат — позиция после записи *)
NewPosition : INT;
END_VAR
(* Вызов функции _STRING_TO_BUFFER *)
NewPosition := OSCAT_BASIC._STRING_TO_BUFFER(
STR := TextToWrite,
POS := WritePosition,
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer)
);
(*
Результат:
- Buffer = [2, 12, 116, 101, 115, 116, 0, 0, 0, 0]
- NewPosition = 6
Пояснение:
- Исходный буфер: [2, 12, 4, 8, 6, 0, 0, 0, 0, 0]
- Записываем 'test' с позиции 2 (третья ячейка)
- ASCII-коды: 't'=116, 'e'=101, 's'=115, 't'=116
- Данные в позициях 2, 3, 4, 5 перезаписываются
- Данные после позиции 5 (0, 0, 0, 0) остаются без изменений
- Итоговый буфер: [2, 12, 116, 101, 115, 116, 0, 0, 0, 0]
- NewPosition = 2 + 4 = 6 (позиция сразу после записанной строки)
*)
END_PROGRAM |
VAR
(* Буфер 1 — исходный массив *)
Buffer1 : ARRAY[0..9] OF BYTE := [2, 12, 4, 8, 6, 2, 12, 4, 8, 6];
(* Буфер 2 — искомый шаблон *)
Buffer2 : ARRAY[0..1] OF BYTE := [12, 4];
(* Начальная позиция для поиска *)
StartPos : INT := 0;
(* Результат — позиция первого вхождения *)
FoundPos : INT;
END_VAR
(* Вызов функции BUFFER_COMP *)
FoundPos := OSCAT_BASIC.BUFFER_COMP(
PT1 := ADR(Buffer1),
SIZE1 := SIZEOF(Buffer1),
PT2 := ADR(Buffer2),
SIZE2 := SIZEOF(Buffer2),
START := StartPos
);
(*
Результат: FoundPos = 1
Пояснение:
- Buffer1 = [2, 12, 4, 8, 6, 2, 12, 4, 8, 6]
- Buffer2 = [12, 4]
- Поиск начинается с позиции 0
- Первое вхождение [12, 4] — позиции 1 и 2
- Функция возвращает номер начального элемента: 1
Второе вхождение: позиции 6 и 7 (не возвращается, так как найдено первое)
*)
END_PROGRAM |
VAR
(* Буфер с двумя строками: "тест" и "ТЕСТ" *)
Buffer : ARRAY[0..9] OF BYTE := [242, 229, 241, 242, 0, 210, 197, 209, 210, 0];
(* Искомая строка (только заглавные буквы) *)
SearchStr : STRING := 'ТЕСТ';
(* Начальная позиция поиска *)
StartPos : INT := 0;
(* Результаты *)
PosIgnoreCase : INT; (* IGN = TRUE — регистронезависимый *)
PosCaseSensitive : INT; (* IGN = FALSE — регистрозависимый *)
END_VAR
(* Регистронезависимый поиск *)
PosIgnoreCase := OSCAT_BASIC.BUFFER_SEARCH(
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer),
STR := SearchStr,
POS := StartPos,
IGN := TRUE
);
(* Регистрозависимый поиск *)
PosCaseSensitive := OSCAT_BASIC.BUFFER_SEARCH(
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer),
STR := SearchStr,
POS := StartPos,
IGN := FALSE
);
(*
Результаты:
- PosIgnoreCase = 0
- PosCaseSensitive = 5
Пояснение:
Буфер: [242, 229, 241, 242, 0, 210, 197, 209, 210, 0]
- Позиции 0–3: 242/229/241/242 = "тест" (строчные)
- Позиция 4: 0 = разделитель
- Позиции 5–8: 210/197/209/210 = "ТЕСТ" (заглавные)
- Позиция 9: 0 = разделитель
При IGN = TRUE:
- Поиск не учитывает регистр
- Находит "тест" с позиции 0 → возвращает 0
При IGN = FALSE:
- Поиск учитывает регистр
- Строчные "тест" не подходят
- Находит "ТЕСТ" с позиции 5 → возвращает 5
*)
END_PROGRAM |
VAR
(* Буфер с ASCII-кодами *)
Buffer : ARRAY[0..9] OF BYTE := [2, 12, 116, 101, 115, 116, 0, 0, 0, 0];
(* Позиции для извлечения *)
StartPos : INT := 2; (* Начало строки *)
StopPos : INT := 5; (* Конец строки *)
(* Результат — извлечённая строка *)
ExtractedString : STRING;
END_VAR
(* Вызов функции BUFFER_TO_STRING *)
ExtractedString := OSCAT_BASIC.BUFFER_TO_STRING(
PT := ADR(Buffer),
SIZE := SIZEOF(Buffer),
START := StartPos,
STOP := StopPos
);
(*
Результат: ExtractedString = 'test'
Пояснение:
- Buffer = [2, 12, 116, 101, 115, 116, 0, 0, 0, 0]
- Извлекаем с позиции 2 по позицию 5
- ASCII-коды 116/101/115/116 = 't'/'e'/'s'/'t'
- Результат: 'test'
*)
END_PROGRAM |
VAR
(* Список с разделителем '&' (ASCII 16#26) *)
List : STRING(OSCAT_BASIC.LIST_LENGTH) := '&12&345';
(* Разделитель *)
Separator : BYTE := 16#26; (* '&' *)
(* Добавляемая запись *)
NewRecord : STRING := 'ABC';
(* Флаг завершения операции *)
Done : BOOL;
END_VAR
(* Вызов функции LIST_ADD *)
Done := OSCAT_BASIC.LIST_ADD(
SEP := Separator,
INS := NewRecord,
LIST := List
);
(*
Результат:
- List = '&12&345&ABC'
- Done = TRUE
Пояснение:
- Исходный список: '&12&345' (записи '12' и '345')
- Добавляем запись 'ABC' в конец
- Новая запись отделяется разделителем '&'
- Итоговый список: '&12&345&ABC' (записи '12', '345', 'ABC')
*)
END_PROGRAM |
VAR
(* Список с пустыми записями *)
List : STRING(OSCAT_BASIC.LIST_LENGTH) := '&12&345&&ABC';
(* Разделитель *)
Separator : BYTE := 16#26; (* '&' *)
(* Флаг завершения операции *)
Done : BOOL;
END_VAR
(* Вызов функции LIST_CLEAN *)
Done := OSCAT_BASIC.LIST_CLEAN(
SEP := Separator,
LIST := List
);
(*
Результат:
- List = '&12&345&ABC'
- Done = TRUE
Пояснение:
- Исходный список: '&12&345&&ABC' (4 записи: '12', '345', '', 'ABC')
- Пустая запись между '&&' удаляется
- Итоговый список: '&12&345&ABC' (3 записи: '12', '345', 'ABC')
*)
END_PROGRAM |
VAR
(* Список с записями *)
List : STRING(OSCAT_BASIC.LIST_LENGTH) := '&12&345&ABC&XYZ';
(* Разделитель *)
Separator : BYTE := 16#26; (* '&' *)
(* Номер читаемой записи *)
RecordNumber : INT := 2;
(* Прочитанная запись *)
Record : STRING(OSCAT_BASIC.LIST_LENGTH);
END_VAR
(* Вызов функции LIST_GET *)
Record := OSCAT_BASIC.LIST_GET(
SEP := Separator,
POS := RecordNumber,
LIST := List
);
(*
Результат: Record = '345'
Пояснение:
- Список: '&12&345&ABC&XYZ'
- Записи: 1='12', 2='345', 3='ABC', 4='XYZ'
- POS = 2 → возвращается вторая запись '345'
*)
END_PROGRAM |
VAR
(* Список с записями *)
List : STRING(OSCAT_BASIC.LIST_LENGTH) := '&12&345&ABC';
(* Разделитель *)
Separator : BYTE := 16#26; (* '&' *)
(* Позиция для вставки *)
Position : INT := 2;
(* Вставляемая запись *)
NewRecord : STRING := 'NEW';
(* Флаг завершения операции *)
Done : BOOL;
END_VAR
(* Вызов функции LIST_INSERT *)
Done := OSCAT_BASIC.LIST_INSERT(
SEP := Separator,
POS := Position,
INS := NewRecord,
LIST := List
);
(*
Результат:
- List = '&12&NEW&345&ABC'
- Done = TRUE
Пояснение:
- Исходный список: '&12&345&ABC' (записи '12', '345', 'ABC')
- Вставляем 'NEW' в позицию 2
- Запись '345' и последующие сдвигаются вправо
- Итоговый список: '&12&NEW&345&ABC'
*)
END_PROGRAM |
VAR
(* Список с записями *)
List : STRING(OSCAT_BASIC.LIST_LENGTH) := '&12&345&ABC&XYZ';
(* Разделитель *)
Separator : BYTE := 16#26; (* '&' *)
(* Число записей в списке *)
RecordCount : INT;
END_VAR
(* Вызов функции LIST_LEN *)
RecordCount := OSCAT_BASIC.LIST_LEN(
SEP := Separator,
LIST := List
);
(*
Результат: RecordCount = 4
Пояснение:
- Список: '&12&345&ABC&XYZ'
- Записи: '12', '345', 'ABC', 'XYZ'
- Всего 4 записи
*)
END_PROGRAM |
VAR
fbListNext: OSCAT_BASIC.LIST_NEXT;
sList: STRING(OSCAT_BASIC.LIST_LENGTH) := 's34&sAB&1122sTest';
asListElements: ARRAY [1..10] OF STRING(OSCAT_BASIC.LIST_LENGTH);
iPos: INT;
END_VAR
iPos := 0;
fbListNext(LIST := sList, SEP := 16#26);
WHILE NOT fbListNext.NUL AND iPos <= 10 DO
asListElements[iPos] := fbListNext.LEL;
fbListNext(list := sList);
iPos := iPos + 1;
END_WHILE
END_PROGRAM |
VAR
(* Список с записями *)
List : STRING(OSCAT_BASIC.LIST_LENGTH) := '&12&345&ABC&XYZ';
(* Разделитель *)
Separator : BYTE := 16#26; (* '&' *)
(* Номер вырезаемой записи *)
Position : INT := 2;
(* Вырезанная запись *)
RetrievedRecord : STRING(OSCAT_BASIC.LIST_LENGTH);
END_VAR
(* Вызов функции LIST_RETRIEVE *)
RetrievedRecord := OSCAT_BASIC.LIST_RETRIEVE(
SEP := Separator,
POS := Position,
LIST := List
);
(*
Результат:
- RetrievedRecord = '345'
- List = '&12&ABC&XYZ'
Пояснение:
- Исходный список: '&12&345&ABC&XYZ' (записи '12', '345', 'ABC', 'XYZ')
- Вырезаем запись с номером 2 ('345')
- Запись удаляется из списка
- Итоговый список: '&12&ABC&XYZ' (записи '12', 'ABC', 'XYZ')
*)
END_PROGRAM |
VAR
(* Список с записями *)
List : STRING(OSCAT_BASIC.LIST_LENGTH) := '&12&345&ABC&XYZ';
(* Разделитель *)
Separator : BYTE := 16#26; (* '&' *)
(* Вырезанная запись *)
RetrievedRecord : STRING(OSCAT_BASIC.LIST_LENGTH);
END_VAR
(* Вызов функции LIST_RETRIEVE_LAST *)
RetrievedRecord := OSCAT_BASIC.LIST_RETRIEVE_LAST(
SEP := Separator,
LIST := List
);
(*
Результат:
- RetrievedRecord = 'XYZ'
- List = '&12&345&ABC'
*)
END_PROGRAM |