语 言 参 考

项 目 结 构

公 共 对 象

SFC 语 言

FC 语 言

FBD 语 言

LD 语 言

ST 语 言

IL 语 言

标 准 运 算 符、 功 能 块 和 函数


 项 目 结 构

ISaGRAF 的 项 目 包 括 数 个 称 作 程 序 的 编 程 单 元。 项 目 中 的 各 个 程 序 按 树 状 结 构 连 接 在 一 起 。 各 个 程 序 可 以 用 SFC , FC ( 流 程 图 )、 FDB、 LD、 ST、 LT、 图 形 语 言 或 符 号 语 言 描 述 。

程 序

循 环 执 行 和 顺 序 执 行

SFC 子 程 序 和FC 子 程 序

函 数 和 子 程 序

功 能 块

程 序 语 言

执 行 规 则


程 序

程 序 是 一 个 逻 辑 编 程 单 元， 这 个 单 元 可 描 述 数 据 处 理 过 程 中 变 量 之 间 的 执 行 情 况， 程 序 或 者 描 述 顺 序 执 行 情 况 ， 或 者 描 述 循 环 执 行 情 况 。 循 环 程 序 在 每 个 目 标 系 统 循 环 中 执 行 。 顺 序 程 序 的 执 行 过 程 或 者 遵 从 SFC 语 言 的 动 态 规 则 ， 或 者 遵 从 FC 语 言 的 动 态 规 则。

各 种 程 序 以 层 次 树 的 形 式 连 接 在 一 起。 控 制 系 统 激 活 位 于 层 次 树 顶 端 的 程 序。 子 程 序 ( 位 于 层 次 树 较 下 层 的 程 序 ） 由 其 上 层 程 序 激 活。 下 列 的 图 形 语 言 或 文 字 语 言 可 用 于 描 述 程 序 ：

用 于 高 层 编 程 的 顺 序 功 能 图 (SFC)

用 于 高 层 编 程 的 流 程 图 (FC)

用 于 循 环 的 复 杂 操 作 的 功 能 块 图 (FBD)

仅 用 于 布 尔 操 作 的 梯 形 图 (LD)

用 于 一 些 循 环 操 作 的 结 构 化 文 本 (ST)

用 于 低 层 操 作 的 指 令 表 (IL)

在 一 个 程 序 中 ， 除 了 LD 语 言 和 FBD 语 言 可 以 在 一 张 图 中 混 用 外， 其 它 几 种 语 言 不 能 混 用。


循 环 执 行、 顺 序 执 行

程 序 按 层 次 可 分 为 四 个 主 要 的 程 序 段 或 程 序 组：

Begin	在 每 个 循 环 开 始 时 执 行 的 程 序

Sequential	遵 从 SFC 或 FC 动 态 规 则 的 程 序

End	在 每 个 循 环 结 束 时 执 行 的 程 序

Functions	非 专 用 子 程 序集

Begin 或 End 程 序 用 以 描 述 程 序 的 循 环 执 行 情 况， 并 与 时 间 无 关 。Sequential 程 序 描 述 顺 序 执 行 情 况 ， 在 程 序 的 顺 序 执 行 中 ， 时 间 变 量 明 显 与 基 本 操 作 同 步 。 每 次 循 环 开 始 时 ， 控 制 系 统 执 行 Begin 主 程 序 。 每 次 循 环 结 束 时 ， 控 制 系 统 则 执 行 End 主 程 序 。 Sequential 程 序 则 根 据 SFC 或 FC 语 言 的 动 态 规 则 执 行。

Function 程 序 是 一 些 可 由 同 一 项 目 的 其 他 程 序 调 用 的 子 程 序 。 Functions 程 序 也 可 以 调 用 本 段 中 的 其 他 程 序。

Sequential 主 程 序 和 子 程 序 应 采 用 SFC 或 FC 语 言 编 写 。 循 环 ( Begin 和 End ）程 序 不 能 用 SFC 或 FC 语 言 编 写 。 各 段 程 序 都 可 以 有 一 个 或 多 个 子 程 序。 Sequential 程 序 可 以 有 一 个 或 多 个 SFC 或 FC 子 程 序 ( 按 照 各 自 的 编 程 语 言 ) 。 功 能 段 的 子 程 序 不 能 用 SFC 或 FC 语 言 编 写 。

Begin 程 序 一 般 用 于 描 述 输 入 设 备 的 初 始 操 作， 以 建 立 高 层 过 滤 变 量， 这 些 变 量 经 常 被 Sequential 段 的 程 序 使 用 。End 段 程 序 一 般 用 于 描 述 在 向 输 出 设 备 发 送 变 量 值 之 前 的 安 全 操 作 ， 这 些 变 量 也 在 Sequential 段 中 使 用 。


SFC 子 程 序 和 FC 子 程 序

SFC 程 序 可 以 控 制 其 它 SFC 程 序， 这 些 低 层 次 程 序 称 为 SFC 子 程 序 。 SFC 子 程 序 是 一 个 可 以 由 其 主 程 序  并 行 启 动、 停 止、 冻 结 或 重 新 启 动 的程 序 。 主 程 序 和 子 程 序 必 须 使 用 SFC 语 言 编 写 。 SFC 子 程 序 可 以 有 其 局 部 变 量 和 定 义 字 。

当 SFC 主 程 序 启 动 SFC 子 程 序 时， 主 程 序 将 SFC 标 记 （ 激 活 ） 置 于 子 程 序 的 各 个 初 始 步 中 。 该 条 命 令 为 GSTART 语 句 。 当 SFC 主 程 序 停 止 SFC 子 程 序 时， 主 程 序 将 清 除 全 部 存 在 于 子 程 序 各 步 中 的 SFC 标 记 。 该 条 命 令 为 GK LL 语 句。

当 SFC 主 程 序 冻 结 SFC 子 程 序 时， 主 程 序 清 除 子 程 序 中 的 全 部 SFC 标 记， 并 将 标 记 保 留 在 内 存 中 。 该 条 命 令 为 GFREEZE 语 句 。 当 SFC 主 程 序 重 新 启 动 被 冻 结 的 SFC 子 程 序 时 ， 主 程 序 则 恢 复 全 部 的 子 程 序 被 冻 结 时 所 清 除 的 全 部 SFC 标 记 。 该 条 命 令 为 GRST 语 句 。

FC 程 序 可 以 控 制 其 他 FC 子 程 序 。 FC 主 程 序 在 FC 子 程 序 运 行 期 间 被 封 锁 ( 等 待 ) 。 因 此 FC 主 程 序 和 FC 子 程 序 不 能 同 时 运 行。


函 数 和 子 程 序

子 程 序 或 函 数 由 其 主 程 序 起 动 。 子 程 序 或 函 数 运 算 结 束 前 ， 主 程 序 暂 时 停 止 执 行 。

主程序	子程序

各 段 程 序 都 可 以 有 一 个 或 更 多 个 子 程 序。一 个 子 程 序 只 能 属 于 一 个 主 程 序 。 子 程 序 可 以 具 有 局 部 变 量 和 局 部 定 义 。 除 SFC 和 FC 语 言 之 外 的 其 他 语 言 都 可 以 用 来 描 述 子 程 序 。 Functions 段 程 序 是 一 些 可 由 本 项 目 的 其 它 程 序 调 用 的 子 程 序 ， 与 其 它 子 程 序 不 一 样 的 是 ： 它 们 不 为 一 个 主 程 序 所 专 有 。 Functions 段 程 序 可 由 本 段 的 其 他 程 序 调 用 ， 函 数 可 存 于 库 文 件 中。

警 告： ISaGRAF 系 统 在 函 数 调 用 时 不 支 持 递 归。 当 Functions 段 程 序 被 自 身 调 用 或 被 Functions 段 程 序 调 用 的 子 程 序 再 次 调 用 时， 将 会 出 现 运 行 错 误 提 示。

警 告： 一 个 函 数 或 子 程 序 不 能 “存 储” 其 局 部 变 量 的 变 量 值， 函 数 或 子 程 序 也 不 能 被 引 用 ， 因 此 它 们 也 不 能 调 用 功 能 块。

每 次 子 程 序 调 用 和 返 回 参 数 ， 必 须 采 用 同 一 符 号 和 唯 一 名 字 ， 以 明 确 定 义 子 程 序 的 接 口 。 为 了 支 持 ST 语 言 约 定 ， 返 回 参 数 必 须 与 子 程 序 具 有 相 同 名 字。

下 表 中 表 示 各 种 不 同 语 言 在 子 程 序 中 如 何 确 定 返 回 参 数 的 值：

ST:	由 名 字 确 定 返 回 参 数

(与 子 程 序 相 同 的 名 字):

   子 程 序 名 := <表 达 式>;

IL:	在 序 列 结 尾 的 当 前 结 果 的 值 (IL 寄 存 器) 存 至 返 回 参 数

   LD      10

   ADD   20   (* 返 回 参 数 的 值 = 30 *)

FBD:	使 用 名 字 作 为 返 回 参 数：

子程序名

LD:	用 线 圈 符 号 作 为 返 回 参 数 的 名 字：

子程序名


功 能 块

功 能 块 可 用 LD 、 FBD 、 ST 或 IL 语 言 编 写。 功 能 块 可 以 被 引 用 。 这 意 味 ， 每 个 实 例 都 可 以 复 制 功 能 块 的 局 部 变 量 。 当 程 序 调 用 功 能 块 时， 程 序 是 在 调 用 功 能 块 的 实 例 ： 即 调 用 同 一 个 语 句 ， 但 所 用 的 数 据 是 实 例 的 数 据 。 实 例 的 变 量 值 从 一 个 循 环 存 到 另 一 个 循 环 。

警 告：

- 用 IEC 语 言 编 写 的 功 能 块 不 能 调 用 其 他 功 能 块 ： 即 实 例 结 构 仅 可 管 理 自 己 块 内 的 局 部 变 量 。 以 下 标 准 功 能 块 不 能 在 IEC 功 能 块 中 使 用：

SR, RS, R_Trig, F_Trig, SEMA, CTU, CTD, CTUD, TON, TOF, TP, CMP, StackInt, AVERAGE, HYSTER, LIM_ALRM, INTEGRAL, DERIVATE, BLINK, SIG_GEN

- 由 于 相 同 的 原 因 ， 不 能 使 用 正 负 触 点 和 线 圈 、 置 位 或 复 位 线 圈 等 功 能。

- 启 动、停 止 计 时 器 的 TSTART 和 TSTOP 函 数 不 能 用 于 3.0x 版 本 的 功 能 块 中，可 用 于 3.20 版 本 之 后。

- 当 需 要 在 功 能 块 内 进 行 循 环 时 ， 在 做 循 环 之 前， 必 须 使 用 局 部 变 量。 请 看 如 下 例 子：

这 是 错 误:	这 是 正 确 的:


程 序 描 述 语 言

程 序 可 由 下 列 图 形 语 言 或 文 字 语 言 进 行 描 述：

用 于 高 层 编 程 的 顺 序 功 能 图 (SFC)

用 于 高 层 编 程 的 流 程 图(FC)

用 于 循 环 的 复 杂 操 作 的 功 能 块 图(FBD)

仅 用 于 布 尔 操 作 的 梯 形 图 (LD)

用 于 一 些 循 环 操 作 的 结 构 化 文 本 (ST)

用 于 低 层 操 作 的 指 令 表(IL)

在 同 一 个 程 序 不 能 混 用 几 种 语 言 。 当 建 立 程 序 时 ， 首 先 要 选 定 描 述 该 程 序 的 语 言 ， 以 后 不 能 再 改 变。 但 有 唯 一 例 外，在 一 个 独 立 的 程 序 中 可 以 混 合 使 用 FBD 和 LD 语 言。


执 行 规 则

ISaGRAF 是 一 个 同 步 系 统。 所 有 操 作 均 由 时 钟 触 发。 时 钟 的 基 本 持 续 时 间 称 为 循 环 时 间。

在 目 标 周 期 中 的 基 本 运 行 如 下 图：

该 系 统 还 可 以:

- 保 证 输 入 变 量 在 一 个 周 期 内 保 持 同 样 的 值。

- 保 证 输 出 设 备 在 一 个 周 期 内 修 改 不 超 过 一 次。

- 对 于 不 同 程 序 使 用 的 相 同 全 局 变 量 能 够 安 全 地 工 作。

- 估 计 并 控 制 整 个 应 用 程 序 的 响 应 时 间。


 公 共 对 象

ISaGRAF 编 程 数 据 库 中 有 一 些 主 要 特 性 和 公 共 对 象。 这 些 对 象 可 以 用 于由 SFC、 FC、 FBD、 LD、 ST 或 IL语 言 中 的 任 何 一 种 语 言 编 写 的 程 序 。

基 本 类 型

常 数 表 达 式

变 量

注 释

定 义 字


基 本 类 型

用 于 一 个 程 序 ( 该 程 序 可 由 任 何 一 种 语 言 编 写 ) 的 常 数 、 表 达 式 、 变 量 应 该 在 类 型. 上 有 明 显 区 别 。 跟 在 图 形 操 作 和 文 字 语 句 之 后 的 应 是 类 型 说 明 。 下 面 是 编 程 对 象 可 以 使 用 的 基 本 类 型：

布 尔 型:	逻 辑 值(真 或 假)

模 拟 型:	整 型 或 实 型 (浮 点)连 续 值

计 时 器 型:	时 间 值

信 息 型:	字 符 串

注 意 ： 计 时 器 型 的 值 应 小 于 一 天 ， 并 且 不 能 用 于 存 储 日 期 值。


常 数 表 达 式

常 数 表 达 式 与 类 型 有 关。同 一 种 符 号 表 示 法 不 能 用 于 表 示不 同 类 型 的 常 数 表 达 式。

布 尔 常 数 表 达 式

整 型 模 拟 常 数 表 达 式

实 型 模 拟 常 数 表 达 式

计 时 器 常 数 表 达 式

信 息 字 符 串 常 数 表 达 式


布 尔 常 数 表 达 式

 只 有 两 种 布 尔 常 数 表 达 式 :

真	等 同 于 整 型 值 1

假	等 同 于 整 型 值 0

“真” 和 “假” 这 两 个 关 键 字 是 大 小 写 无 关 的。


整 型 模 拟 常 数 表 达 式

整 型 常 数 表 达 式  是 带 符 号 长 整 型 值 (32 位)：

从 -2147483647到 +2147483647

整 型 模 拟 常 量 可 以 表 示 为 以 下 基 本 类 型 中 的 一 种 。 整 型 常 量 应 以 一 个 标 明 其 类 型 的 前 缀 开 头：

基 本 类 型	前 缀	举 例

十 进 制 数	(none)	-908

十 六 进 制 数	"16#"	16#1A2B3C4D

八 进 制 数	"8#"	8#1756402

二 进 制 数	"2#"	2#1101_0001_0101_1101

在 二 进 制 整 型 常 量 中，下 划 线 (‘_’) 用 来 分 开 数 字 组 ， 下 划 线 没 有 特 别 意 义 ， 只 是 用 于 提 高 常 数 表 达 式 的 可 读 性。


实 型 模 拟 常 数 表 达 式

实 型 模 拟 常 数 表 达 式 既 可 用 十 进 制 来 写，也 可 用科 学计 数 法 来 写。十 进 制 小 数 点 (‘.’) 将 整 数 和 小 数 部 分 分 隔 开。 十 进 制 小 数 点 用 来 区 分 实 型 常 数 表 达 式 和 整 型 常 数 表 达 式 。 科 学 计 数 表 示 法 用 字 母 ‘E’ 或 字 母 ‘F’ 将 对 数 的 尾 数 部 分 和 指 数 部 分 分 开 。 采 用 科 学 计 数 法 的 实 数 的 指 数 部 分 必 须 是 带 符 号 的 整 型 值 ， 数 值 在 -37 到 +37。 下 面 是 实 型 模 拟 常 数 表 达 式 的 例 子：

3.14159	-1.0E+12

+1.0	1.0F-15

-789.56	+1.0E-37

表 达 式 “123” 不 是实 型 常 数 表 达 式 。 正 确 的 实 型 常 数 表 达 式 应 为 “123.0”。


计 时 器 常 数 表 达 式

计 时 器 常 数 表 达 式 表 示 从 0 秒 到23 小 时 59 分59 秒 999 毫 秒 的 时 间 值。 系 统 许 可 的 最 小 时 间 单 位 是 毫 秒 。 用 常 数 表 达 式 的 标 准 时 间 单 位 有：

小 时	字 母 “h” 跟 在 小 时 数 后 边

分 钟	字 母 “m” 跟 在 分 钟 数 后 边

秒	字 母 “s” 跟 在 秒 数 后 边

毫 秒	字 母 “ms” 跟 在 毫 秒 数 后 边

计 时 器 常 数 表 达 式 必 须 以 "T#" 或 "TIME#" 的 前 缀 开 头 。 前 缀 和 单 位 字 母 都 对 大 小 写 敏 感。 有 些 单 位 可 以 是 不 显 示 的。 下 面 是 计 时 器 常 数 表 达 式 的 例 子：

T#1H450MS	1 小时, 450 毫秒

time#1H3M	1 小时, 3 分钟

表 达 式 “0” 不 是 时 间 值， 而 是 模 拟 常 数。


信 息 字 符 串 常 数 表 达 式

字 符 串  或 信 息 常 数 表 达 式 表 示 一 个 字 符 串 。 字 符 串 应 括 在 一 对 单 引 号 中， 例 如：

'THIS IS A 信息'

警 告： 单 引 号 不 能 用 在 字 符 串 常 数 表 达 式 之 内 。 一 个 字 符 串 常 数 表 达 式 必 须 写 在 程 序 源 代 码 的 一 行 之 中 。 表 达 式 的 长 度 ， 包 括 空 格 ， 不 能 超 过 255 个 字 符 。

空 字 符 串 常 数 表 达 式 可 以 用 中 间 无 空 格 或 制 表 符 的 一 对 单 引 号 来 表 示。

''   (* 这 是 一 个 空 字 符 串 *)

在 一 个 字 符 串 常 数 表 达 式 中， 以 (‘$’) 开 头 后 随 其 它 专 用 字 符 用 来 表 示 一 个 不 可 打 印 的 字 符。

字 符	含 义	ASCII 码	举 例

$$	'$' 字 符	16#24	'I paid $$5 for this'

$'	上 撇 号	16#27	'Enter $'Y$' for YES'

$L	进 给 一 行	16#0a	'next $L line'

$R	回 车	16#0d	'   llo $R He'

$N	新 一 行	16#0d0a	'This is a line$N'

$P	新 一 页	16#0c	'lastline $P first line'

$T	制 表 符	16#09	'name$Tsize$Tdate'

$hh   (*)	任 意 字 符	16#hh	'ABCD = $41$42$43$44'

(*) “hh” 是 用 于 表 示 的 字 符 的 十 六 进 制ASCII 码 值。


变 量

变 量 可 以 是 一 个 局 部 变 量 或 全 局 变 量. 。局 部 变 量 只 能 供 一 个 程 序 使 用 。 全 局 变 量 可 供 本 项 目 的 任 何 程 序 使 用。

保 留 关 键 字

可 直 接 显 示 的 变 量

布 尔 型 变 量

模 拟 型 变 量

计 时 器 型 变 量

信 息 字 符 串 型 变 量

变 量 名 必 须 符 合 下 列 规 则：:

- 变 量 名 不 能 超 过 16 个 字 符

- 第 一 个 字 符 必 须 是 字 母

- 后 面 的 字 符 可 以 是 字 母、数 字 或 下 划 线


保 留 关 键 字

下 面 是 保 留 关 键 字 一 览 表。这 些 关 键 字 不 能 用 来 命 名 程 序、 变 量 或 “ C” 函 数 或 函 数 块：

A	ANA, ABS, ACOS, ADD, ANA, AND, AND_MASK, ANDN, ARRAY, ASIN, AT, ATAN,

B	BCD_TO_BOOL, BCD_TO_INT, BCD_TO_REAL, BCD_TO_STRING, BCD_TO_TIME, BOO, BOOL, BOOL_TO_BCD, BOOL_TO_INT, BOOL_TO_REAL, BOOL_TO_STRING, BOOL_TO_TIME, BY, BYTE,

C	CAL, CALC, CALCN, CALN, CALNC, CASE, CONCAT, CONSTANT, COS,

D	DATE, DATE_AND_TIME, DELETE, DINT, DIV, DO, DT, DWORD,

E	ELSE, ELSIF, EN, END_CASE, END_FOR, END_FUNCTION, END_IF, END_PROGRAM, END_REPEAT, END_RESSOURCE, END_STRUCT, END_TYPE, END_VAR, END_WHILE, ENO, EQ, EXIT, EXP, EXPT,

F	FALSE, FEDGE, FIND, FOR, FUNCTION,

G	GE, GFREEZE, GKILL, GRST, GSTART, GSTATUS, GT,

I	IF, INSERT, INT, INT_TO_BCD, INT_TO_BOOL, INT_TO_REAL, INT_TO_STRING, INT_TO_TIME,

J	JMP, JMPC, JMPCN, JMPN, JMPNC,

L	LD, LDN, LE, LEFT, LEN, LIMIT, LINT, LN, LOG, LREAL, LT, LWORD,

M	MAX, MID, MIN, MOD, MOVE, MSG, MUL, MUX,

N	NE, NOT,

O	OF, ON, OPERATE, OR, OR_MASK, ORN,

P	PROGRAM

R	R, REDGE, READ_ONLY, READ_WRITE, REAL, REAL_TO_BCD, REAL_TO_BOOL, REAL_TO_INT, REAL_TO_STRING, REAL_TO_TIME, REDGE, REPEAT, REPLACE, RESSOURCE, RET, RETAIN, RETC, RETCN, RETN, RETNC, RETURN, RIGHT, ROL, ROR,

S	S, SEL, SHL, SHR, SIN, SINT, SQRT, ST, STN, STRING, STRING_TO_BCD, STRING_TO_BOOL, STRING_TO_INT, STRING_TO_REAL, STRING_TO_TIME, STRUCT, SUB, SYS_ERR_READ, SYS_ERR_TEST, SYS_INITALL, SYS_INITANA, SYS_INITBOO, SYS_INITTMR, SYS_RESTALL, SYS_RESTANA, SYS_RESTBOO, SYS_RESTTMR, SYS_SAVALL, SYS_SAVANA, SYS_SAVBOO, SYS_SAVTMR, SYS_TALLOWED, SYS_TCURRENT, SYS_TMAXIMUM, SYS_TOVERFLOW, SYS_TRESET, SYS_TWRITE, SYSTEM,

T	TAN, TASK, THEN, TIME, TIME_OF_DAY, TIME_TO_BCD, TIME_TO_BOOL, TIME_TO_INT, TIME_TO_REAL, TIME_TO_STRING, TMR, TO, TOD, TRUE, TSTART, TSTOP, TYPE,

U	UDINT, UINT, ULINT, UNTIL, USINT,

V	VAR, VAR_ACCESS, VAR_EXTERNAL, VAR_GLOBAL, VAR_IN_OUT, VAR_INPUT, ,VAR_OUTPUT,

W	WHILE, WITH, WORD,

X 	XOR, XOR_MASK, XORN

所 有 以 下 划 线 (‘_’) 开 始 的关 键 字 是 内 部 关 键 字 ， 它 们 不 能 被 用 于 文 本 语 句 中。


可 直 接 显 示 的 变 量

ISaGRAF 允 许 用 户 在 源 程 序 中 使 用 可 直 接 显 示 的 变 量 来 描 述 一 个 空 通 道 。 空 通 道 是 那 些 没 有 与 已 经 声 明 的 输 入 / 输 出 变 量 相 连 接 的 通 道 。 可 直 接 显 示 的 变 量 的 变 量 名 总 是 以 字 符 “%” 开 始。

以 下 是 用 于 单 一 插 板 通 道 的 可 直 接 显 示 的 变 量 的 命 名 规 定。 “s” 是 插 板 上 的 板 槽 号。 “c” 是 通 道 号。

%IXs.c	布 尔 型 输 入 插 板 空 通 道

%IDs.c	整 型 输 入 插 板 空 通 道

%ISs.c	信 息 型 输 入 插 板 空 通 道

%QXs.c	布 尔 型 输 出 插 板 空 通 道

%QDs.c	整 型 输 出 插 板 空 通 道

%QSs.c	信 息 型 输 出 插 板 空 通 道

以 下 是 用 于 综 合 设 备 通 道 的 可 直 接 显 示 的 变 量 的 命 名 规 定 。 “s” 是 设 备 的 板 槽 号 。 “b” 是 在 综 合 设 备 内 单 一 插 板 索 引 号 。“c” 是 通 道 号。

%IXs.b.c	布 尔 型 输 入 插 板 空 通 道

%IDs.b.c	整 型 输 入 插 板 空 通 道

%ISs.b.c	信 息 型 输 入 插 板 空 通 道

%QXs.b.c	布 尔 型 输 出 插 板 空 通 道

%QDs.b.c	整 型 输 出 插 板 空 通 道

%QSs.b.c	信 息 型 输 出 插 板 空 通 道

例 子 如 下:

%QX1.6	1 号 插 板 (布 尔 型 变 量 输 出) 的 第 六 通 道

%ID2.1.7	2 号 设 备 上 1 号 插 板(整 型 变 量 输 入)的 第 七 通 道

可 直 接 显 示 的 变 量 不 能 是 实 型 变 量 。


布 尔 型 变 量

布 尔 变 量 是 逻 辑 型 变 量 ， 布 尔 变 量 的 取 值 可 以 是 布 尔 值 ( 真 或 假 ) 中 的 一 种。布 尔 变 量 通 常 用 于 布 尔 表 达 式 。 布 尔 变 量 可 以 有 以 下 属 性：

内 部:	可 由 程 序 修 改 的 内 存 变 量

输 入:	连 接 到 输 入 设 备 的 变 量 (由 系 统 刷 新)

输 出:	连 接 到 输 出 设 备 的 变 量

警 告： 当 声 明 布 尔 变 量 后 ， 在 调 试 过 程 中 可 以 定 义 字 符 串 取 代 '真' 和 '假' 值 。 这 些 字 符 串 不 能 用 于 程 序 中 ， 除 非 它 们 作 为 ‘定 义 字’  输 入。


模 拟 型 变 量

模 拟 型 变 量 是 连 续 变 量。 模 拟 型 变 量 可 以 是 带 符 号 的 整 型 或 实 型 ( 浮 点 ) 值 。 模 拟 型 变 量 的 格 式 为：

整 型	32 位 带 符 号 整 型： 从 -2147483647 到 +2147483647

实 型    	标 准 IEEE 32 位 浮 点 值 (单 精 度)

1 位 符 号 位 + 23 位 底 数+ 8 位 指 数

实 型 模 拟 指 数 值 不 能 小 于 -37 或 大 于 +37。 模 拟 变 量 可 以 有 以 下 属 性：

内 部	可 由 程 序 修 改 的 内 存 变 量

输 入	连 接 到 输 入 设 备 的 变 量(由 系 统 刷 新)

输 出	连 接 到 输 出 设 备 的 变 量

注 意： 当 实 型 变 量 与I / O设 备 相 连 接 时 ， 相 应 的I / O 驱 动 器 处 理 等 价 的 整 型 值 。

警 告：整 型 和 实 型 模 拟 变 量 或 常 数 表 达 式 不 能 在 同 一 个 模 拟 表 达 式 中 混 用。


计 时 器 型 变 量

计 时 器 型 变 量 意 味 着 时 钟 或 者 计 数 器。 该 变 量 有 时 间 值， 并 通 常 被 用 于 时 间 表 达 式 中。 计 时 器 变 量 的 值 不 能 为 负 数， 并 且 不 能 超 过 23 小 时 59 分 钟 59 秒 999 毫 秒。 计 时 器 变 量 按 32 位 字 存 储，并 为 正 的 毫 秒 数。

警 告： 计 时 器 变 量 不 能 有 输 入 或 输 出 属 性。

计 时 器 变 量 可 由 ISaGRAF 系 统 自 动 刷 新 。当 计 时 器 处 于 启 动 状 态 时 ， 其 数 值 根 据 目 标 系 统 的 实 际 时 钟 自 动 增 加。ST 语 言 的 下 列 语 句 可 用 来 控 制 计 时 器：

TSTART	开 始 自 动 刷 新 计 时 器

TSTOP	停 止 自 动 刷 新 计 时 器


信 息 字 符 串 型 变 量

信 息 或 字 符 串 型 变 量 中 包 含 字 符 串， 字 符 串 的 长 度 在 数 据 处 理 过 程 中 可 以 被 改 变。 信 息 变 量 的 长 度 不 能 超 过 该 变 量 声 明 时 指 定 的 容 量 ( 最 大 长 度 ) 。 信 息 容 量 最 大 为 255 个 字 符。信 息 型 变 量 可 以 有 以 下 属性：

内 部	可 由 程 序 修 改 的 内 存 变 量

输 入	连 接 到 输 入 设 备 的 变 量 (由 有 系 统 刷 新)

输 出	连 接 到 输 出 设 备 的 变 量

字 符 串 型 变 量 可 以 有 标 准 ASCII 表(即 从 0 到 255 的 ASCII 码)中 的 任 何 字 符 。 字 符 串 可 以 有 零 字 符 (0)。标准 ISaGRAF 库 中 的 一 些 "C" 函 数 不 能 正 确 地 处 理 含 有 零 字 符 (0) 的 信 息 型 变 量。


注 释

程 序 注 释 可 以 自 由 地 插 入ST、IL 等 语 言 中 。注 释 必 须 以 特 殊 字 符 “(* ”开 始， 以 特 殊 字 符 “*)” 结 束。 注 释 可 以 插 在 ST 程 序 任 何 位 置 上， 并 且 可 以 为 一 行 或 多 行。

下 列 是 注 释 的 例 子:

counter := ivalue;   (* 指 定 主 计 时 器 *)

(*这 是 一 个 用 两 行

表 示 的 注 释 *)

c := counter (*用 户 可 以 将 注 释 放 在 任 何 位 置 上 *) + base_value + 1;

不 能 使 用 嵌 套 注 释 。 这 表 明 字 符 “(*” 不 能 用 于 程 序 注 释 中。

警 告：IL 语 言 中，只 能 在 指 令 行 的 最 后 加 注 程 序 的 注 释。


定 义 字

ISaGRAF 系 统 允 许 用 户 重 新 定 义 常 数 表 达 式 、 具 有 真 和 假 值 的 布 尔 表 达 式 、 关 键 字 或 复 杂 ST 表 达 式 。 为 了 做 到 这 点 ， 必 须 给 予 相 应 表 达 式 一 个 标 识 符  名。例 如：

YES	是	真

PI	是	3.14159

OK	是	(自 动 模 式 AND NOT (闹 钟))

当 定 义 这 样 的 等 式 时， 该 标 识 符 可 用 于 ST 程 序 的 任 何 位 置 上 以 取 代 相 关 的 表 达 式 。 以 下 是 一 个 使 用 “定 义 字” ST 编 程 的 例 子：

If OK Then

   angle := PI / 2;

   isdone := YES;

End_if;

定 义 字 可 以 是 局 部 定 义 字 、 全 局 定 义 字 或 公 共 定 义 字 。

局 部 定 义 字 仅 可 用 于 一 个 程 序 。

全 局 定 义 字 可 用 于 一 个 项 目 的 任 何 程 序 中 。

公 共 定 义 字 可 用 于 任 何 项 目 的 任 何 程 序 中 。

注 意 公 共 定 义 字 可 用 档 案 管 理 器 分 别 存 贮 。

警 告：当 相 同 标 识 符 被 两 个 不 同 的 ST 等 式 定 义 两 次 时， 使 用 最 后 定 义 的 表 达 式。例 如：

定 义:	打 开	is	真

打 开	is	假

意 义:	打 开	is	假

定 义 字 必 须 符 合 下 列 规 则：

- 标 识 符 名 不 能 超 过 16 个 字符

- 第 一 个 字 符 必 须 是 字 母

- 后 面 的 字 符 可 以 是 字 母、数 字 或 下 划 线

警 告：定 义 字 在 定 义 时 不 能 使 用 定 义 字 ， 例 如 ， 用 户 不 能 定 义 如 下 ：

PI	is	3.14159

PI2 	is	PI*2

使 用 常 量 或 变 量 和 运 算 符 写 下 完 整 的 等 式 ：

PI2 	is	6.28318


 IL 指 令 表 语 言

指 令 表 语 言 （Instruction List 或 称 IL）  是 一 种 低 级 语 言， 它 对 于 较 小 的 应 用 程 序 或 某 个 应 用 程 序 的 部 分 优 化 非 常 有 效。 指 令 总 是 与 当 前 结 果 ( 或 IL 寄 存 器 ) 有 关 。 操 作 符 表 示 当 前 值 和 操 作 数 间 的 操 作。 操 作 结 果 再 被 存 入 当 前 结 果 中 。

IL 的 主 要 语 法

IL 的 操 作 符


IL 的 主 要 语 法

IL 程 序 是 一 个 指 令 表 。 每 条 指 令 从 新 的 一 行 开 始， 且 含 有 一 个 操 作 符 ， 与 可 选 的 修 改 符 形 成 一 个 整 体 。 对 于 特 殊 操 作 ， 必 要 时 增 加 一 个 或 多 个 操 作 数 ， 并 用 逗 号 ( ‘，’ ) 将 操 作 数 分 开 。 标 号 后 面 跟 随 冒 号 ( ‘：’ ) ， 放 在 指 令 的 前 面 。 如 果 指 令 中 附 有 注 释 ， 它 必 须 是 在 一 行 的 最 后 。 注 释 以 ‘( * ’ 开 始， 用 ‘* )’ 结 束 。 指 令 之 间 可 以 输 入 空 行 。 注 释 可 放 在 空 行 上。

标 号

操 作 符 的 修 改 符

延 时 操 作

以 下 是 指 令 行 的 例子 :

标 号	操 作 符	操 作 数	注 释

Start:	LD	IX1	(* 按 按 钮*)

ANDN	MX5	(* 命 令 没 有 被 禁 止 *)

ST	QX2	(* 启 动 马 达 *)


标 号

标 号 后 随 冒 号 (‘:’)， 可 以 放 在 指 令 的 前 面 。 标 号 可 放 在 空 行 上 。 对 某 些 操 作 （比 如 跳 转 ） 来 说 ， 标 号 被 用 作 操 作 符 。 命 名 标 号 须 符 合 下 列 规 则 :

- 名 称 不 能 超 过 16 个 字 符

- 第 一 个 字 符 必 须 是 一 个 字 母

- 随 后 的 字 符 必 须 是 字 母、 数 字 或 ‘_’ 字 符

在 同 一 IL 中 ， 标 号 不 可 重 名，但 可 以 和 变 量 的 名 称 相 同。


操 作 修 改 符

可 使 用 的 操 作 修 改 符 如 下 所 示 。 修 改 符 的 字 符 使 操 作 符 的 名 称 完 整， 字 符 间 不 能 有 空 格：

N	操 作 数 的 布 尔 求 反

(	延 时 操 作

C	有 条 件 的 操 作

‘N’ 修 改 符 表 示 操 作 数 布 尔 求 反， 指 令 ORN IX12 表 示 为： result := result OR NOT (IX12).

括 号  ‘(’ 修 改 符 表 示 指 令 的 求 值 必 须 被 延 时 至 出 现 表 示 结 束 的 括 号 ‘)’ 操 作 符。

‘C’ 修 改 符 表 示 只 有 在 当 前 结 果 为 布 尔 值 “真” ( 不 同 于 非 布 尔 值 0  ) 时 ， 才 执 行 相 关 指 令 。 为 了 表 示 只 有 在 当 前 结 果 为 布 尔 值 “假” ( 或 为 非 布 尔 值 0 ) 时 才 执 行 指 令， 可 把 ‘C’ 修 改 符 与 ' N ' 修 改 符 结 合 在 一 起。


延 时 操 作

因 为 只 有 一 个 IL 寄 存 器 （当 前 值） ， 一 些 操 作 不 得 不 被 延 时 , 这 样 就 可 以 改 变 执 行 的 顺 序 或 指 令 。 括 号 被 用 于 表 示 延 时 操 作 :

'('	是 一 个 修 改 符	表 示 操 作 被 延 时

')'	是 一 个 操 作 符	执 行 被 延 时 的 操 作

括 号 '( ' 修 改 符 表 示 指 令 的 求 值 必 须 被 延 时， 直 至 出 现 表 示 结 束 的 括 号 ' ) ' 操 作 符 。 例 如 下 面 的 程 序 :

AND(	IX12

OR	IX35

)

被 理 解 为 :

result := result AND ( IX12 OR IX35 )


IL 操 作 符

  下 面 的 列 表 概 括 了 IL 语 言 的 标 准 操 作 符

操作符	修改符	操作数	描 述

LD	N	变 量, 常 量	装 入 操 作 数

ST	N	变 量	保 存 当 前 结 果

S	BOO 变 量	置 位 为 TRUE

R	BOO 变 量	复 位 为 FALSE

CAL	C   N	FB 状 态 名 称	调 用 一 个 功 能 块

JMP	C   N	标 号	跳 转 到 标 号 处

RET	C   N	从 子 程 序 返 回

 ) 	执 行 被 延 时 的 操 作

Function	调 用 函 数 或 子 程 序

AND	N   (	BOO	布 尔 与 运 算

&	N   (	BOO	布 尔 与 运 算

OR	N   (	BOO	布 尔 或 运 算

XOR	N   (	BOO	异 - 或 运 算

ADD	(	变 量, 常 量	加

SUB	(	变 量, 常 量	减

MUL	(	变 量, 常 量	乘

DIV	(	变 量, 常 量	除

GT	(	变 量, 常 量	检 测: >

GE	(	变 量, 常 量	检 测: >=

EQ	(	变 量, 常 量	检 测: =

LE	(	变 量, 常 量	检 测: <=

LT	(	变 量, 常 量	检 测: <

NE	(	变 量, 常 量	检 测: <>

在 以 下 段 落 中， 只 描 述 与 IL 语 言 中 的 操 作 符， 其 它 标 准 操 作 符 可 在 “ 标 准 操 作 符、 功 能 块 和 功 能 ” 段 落 中 找 到。


LD 操 作 符

操 作	将 一 个 数 值 载 入 到 当 前 结 果 中

允 许 的 修 改 符	N

操 作 数	常 量 表 达 式

内 部 的 、 输 入 或 输 出 变 量

举 例 :

(* LD 操 作 示 例 *)

LDex:	LD	false	(* 结 果 为 FALSE 布 尔 常 量*)

LD	true	(* 结 果 为 TRUE 布 尔 常 量 *)

LD	123	(* 结 果 为 整 型 量 *)

LD	123.1	(* 结 果 为 实 型 量 *)

LD	t#3ms	(* 结 果 为 计 时 器 型 量 *)

LD	boo_var1	(* 结 果 为 布 尔 变 量 *)

LD	ana_var1	(* 结 果 为 模 拟 变 量 *)

LD	tmr_var1	(* 结 果 为 计 时 器 变 量 *)

LDN	boo_var2	(* 结 果 为 NOT 布 尔 变 量 *)


ST 操 作 符

操 作 	把 当 前 结 果 存 到 一 个 变 量 中

当 前 结 果 没 有 被 该 操 作 所 修 改

允 许 的 修 改 符	N

操 作 数	内 部 的 或 输 出 变 量

举 例:

( * ST 操 作 示 例* )

STboo:	LD	false

ST	boo_var1	(* boo_var1 为 FALSE *)

STN	boo_var2	(* boo_var2 为 TRUE *)

STana:	LD	123

ST	ana_var1	(* ana_var1 为 123 *)

STtmr:	LD	t#12s

ST	tmr_var1	(* tmr_var1 为 t#12s *)


S 操 作 符

操 作	如 果 当 前 结 果 为 布 尔 值 TRUE， 则 把 布 尔 值 TRUE 存 到 一 个 布 尔 变 量 中 。 如 果 当 前 结 果 是 FALSE， 则 不 操 作 处 理。 当 前 结 果 没 有 被 该 操 作 所 修 改 。

允 许 的 修 改 符:	( 无 )

操 作 数:	输 出 或 内 部 的 布 尔 变 量

举 例:

( * S 操 作 示 例 * )

SETex:	LD	true	(* 结 果 为 TRUE *)

S	boo_var1	(* boo_var1 为 TRUE *)

(* 结 果 没 有 被 修 改 *)

LD	false	(* 结 果 为 FALSE *)

S	boo_var1	(* 不 做 任 何 事 情， boo_var1 没 有 被 改 变 *)


R 操 作 符

操 作	如 果 当 前 结 果 为 布 尔 值 TRUE， 则 把 布 尔 值 FALSE 存 到 一 个 布 尔 变 量 中。 如 果 当 前 结 果 是 FALSE， 则 不 操 作 处 理。 当 前 的 结 果 没 有 被 该 操 作 所 修 改 。

允 许 的 修 改 符 	 ( 无 )

操 作 数 	 输 出 或 内 部 的 布 尔 变 量

举 例:

(* R 操 作 示 例*)

RESETex:	LD	true	(*结 果 为 TRUE *)

R	boo_var1	(* boo_var1 为 FALSE *)

(*结 果 没 有 被 修 改 *)

ST	boo_var2	(* boo_var2 为 TRUE *)

LD	false	(*结 果 为 FALSE *)

R	boo_var1	(*不 做 任 何 事 情， boo_var1 没 有 被 改 变 *)


JMP 操 作 符

操 作	跳 转 到 给 定 的 标 号

允 许 的 修 改 符	C   N

操 作 数	在 相 同 的 IL 程 序 中 定 义 的 标 号

举 例：

(* 下 例 通 过 测 试 模 拟 选 择 器 的 值 为 0 或 者 为 1 或 者 为 2) 	*)

(* 来 设 置 3 个 布 尔 输 出 值。 值 是 否 为 0 决 定 是 否 进 行 JMPC 操 作	*)

JMPex:	LD	selector	(* 选 择 器 为 0 或 者 为 1 或 者 为 2 *)

BOO	(* 转 换 为 布 尔 变 量 *)

JMPC	test1	(* 如 果 选 择 器 为 0， 那 么*)

LD	true

ST	bo0	(* bo0 为 true *)

JMP	JMPend	(* 结 束 程 序 *)

test1:	LD 	selector

SUB	1	(* 减 去 1， 现 在 选 择 器 为 0 或 者 为 1 *)

BOO	(*转 换 为 布 尔 变 量 *)

JMPC	test2	(*如 果 选 择 器 为 0， 那 么*)

LD	true

ST	bo1	(* bo1 为 true *)

JMP	JMPend	(*结 束 程 序 *)

test2:	LD	true	(* 最 后 可 能 性 *)

ST	bo2	(* bo2 为 true *)

JMPend:	(* 结 束 IL 程 序 *)


RET 操 作 符

操 作 	结 束 当 前 的 指 令 表 。 如 果 I L 是 一 个 子 程 序 ， 则 当 前 结 果 返 回 到 调 用 程 序 。

允 许 的 修 改 符	C   N

操 作 数	( 无 )

举 例 :

(* 下 例 通 过 测 试 模 拟 选 择 器 的 值 为 0 或 者 为 1 或 者 为 2) 	*)

(* 来 设 置 3 个 布 尔 输 出 值。 值 是 否 为 0 决 定 是 否 进 行 JMPC 操 作	*)

JMPex:	LD	selector	(*选 择 器 为 0 或 者 为 1 或 者 为 2 *)

BOO	(*转 换 为 布 尔 变 量 *)

JMPC	test1	(*如 果 选 择 器 为 0， 那 么*)

LD	true

ST	bo0	(* bo0 为 true *)

RET	(* 结 束， 返 回 为 0 *)

(* 减 去 选 择 器 *)

test1:	LD 	selector

SUB	1	(*选 择 器 为 0 或 者 为 1 *)

BOO	(*转 换 为 布 尔 变 量 *)

JMPC	test2	(*如 果 选 择 器 为 0， 那 么*)

LD	true

ST	bo1	(* bo1 为 true *)

LD	1	(* 装 入 实 型 选 择 器 的 值 *)

RET	(* 结 束， 返 回 为 1 *)

(* 最 后 可 能 性 *)

test2:	RETNC	(* 如 果 选 择 器 有 一 个 无 效 的 值， 返 回 *)

LD	true

ST	bo2	(* bo2 为 true *)

LD	2	(*装 入 实 型 选 择 器 的 值 *)

 	(*结 束， 返 回 为 2 *)


")" 操 作 符
")" operator

操 作 符 	执 行 一 个 延 时 操 作 。 用 ' ( ' 符 号 通 知 延 时 操 作

允 许 的 修 改 符	( 无 )

操 作 数	( 无 )

举 例 :

(* 下 面 例 子 包 含 一 个 延 时 操 作: *)

(* res 为 a1 + (a2 * (a3 - a4) * a5) + a6; *)

Delayed:	LD	a1	(* 结 果 为 a1; *)

ADD(	a2	(* 延 时 ADD  结 果 为 a2; *)

MUL(	a3	(* 延 时 MUL  结 果 为 a3; *)

SUB	a4	(* 结 果 为 a3 - a4; *)

)	(* 执 行 延 时 MUL  结 果 为 a2 * (a3-a4); *)

MUL	a5	(* 结 果 为 a2 * (a3 - a4) * a5; *)

)	(* 执 行 延 时 ADD *)

(* 结 果 为 a1 + (a2 * (a3 - a4) * a5); *)

ADD	a6	(* 结 果 为 a1 + (a2 * (a3 - a4) * a5) + a6; *)

ST	res	(* 用 变 量 res 存 储 最 近 的 结 果*)


调 用 子 程 序 或 函 数

从 IL 程 序 中 调 用 一 个 子 程 序  或 一 个 函 数 ( 用IL、 ST LD、 FBD 或 “C” 语 言 中 的 任 何 一 种 语 言 编 写 )， 此 时 把 它 的 名 称 用 作 一 个 操 作 符 。

操 作	执 行 一 个 子 程 序 或 一 个 函 数 - 由 子 程 序 或 函 数 返 回 的 数 值 被 存 入 IL 的 当 前 结 果 中 。

允 许 的 修 改 符	( 无 )

操 作 数	第 一 个 调 用 的 数 据 必 须 在 调 用 之 前 存 到 当 前 的 结 果 中 。 随 后 的 参 数 在 操 作 数 区 域 中 表 示 ， 并 用 逗 号 分 开 。

举 例 :

(* 调 用 程 序： 将 一 个 模 拟 量 转 换 为 一 个 时 间 量*)

Main:	LD	bi0

SUBPRO	bi1,bi2	(* 调 用 子 程 序 以 得 到 模 拟 量 的 值 *)

ST	result	(* result 的 值 为 子 程 序 的 返 回 值*)

GT	vmax	(*  测 试 值 溢 出*)

RETC	(*  如 果 溢 出 将 返 回 *)

LD	result

MUL	1000	(*  转 换 秒 到 毫 秒 *)

TMR	(*  转 换 为 一 个 计 时 器 *)

ST	tmval	(* 在 一 个 计 时 器 中 存 储 转 换 值 *)

(* 调 用 名 字 为 ‘SUBPRO’子 程 序： 评 估 模 拟 量 的 值 *)

(* in0, in1, in2 是 子 程 序 的 三 个 布 尔 变 量 参 数 *)

LD	in2

ANA	(* result 为 ana (in2); *)

MUL	2	(* result 为 2*ana (in2); *)

ST	temporary	(* temporary := result *)

LD	in1

ANA

ADD 	temporary	(* result := 2*ana (in2) + ana (in1); *)

MUL	2	(* 结 果 为 4*ana (in2) + 2*ana (in1); *)

ST	temporary	(* temporary := result *)

LD	in0

ANA

ADD	temporary	(* 结果为 4*ana (in2) + 2*ana (in1)+ana (in0); *)

ST	SUBPRO	(* 返 回 最 近 结 果 以 调 用 程 序 *)


调 用 功 能 块：CAL 操 作 符

操作	调 用 一 个 功 能 块

允 许 的 修 改 符	C   N

操 作 数	功 能 块 实 例 名

在 使 用LD / ST 操 作 顺 序 调 用 功 能 块 之 前 ， 必 须 给 功 能 块 的 输 入 参 数 赋 值。

这 样， 在 使 用 时， 输 出 参 数 是 已 知 的。

例1:

(* 调 用 功 能 块 SR： SR1 是 SR的 一 个 实 例*)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command

(* FBD 等 价 ： *)

例2

(* 假 设 R_TRIG1 是 R_TRIG块 的 一 个 实 例， CTU1 是CTU 块 的 一 个 实 例 *)

LD	command

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTU1.cu

LDN	auto_mode

ST	CTU1.reset

LD	100

ST	CTU1.pv

CAL	CTU1

LD	CTU1.Q

ST	overflow

LD	CTU1.cv

ST	result

(* FBD 等 价 *)


 ST 语 言

ST (结 构 化 文 本) 是 为 自 动 化 过 程 设 计 的 一 种 高 级 结 构 化 语 言。 这 种 语 言 主 要 用 于 完 成 那 些 不 能 简 单 地 用 图 形 语 言 来 表 示 的 复 杂 程 序。 在 对 步 内 动 作 和SFC 语 言 中 的 转 换 条 件 进 行 描 述 时，ST 是 默 认 的 语言。

ST 主 要 语 法

表 达 式 和 括 号

功 能 或 功 能 块 的 调 用

ST 特 殊 的 布 尔 操 作 符

ST 基 本 语 句

ST 扩 展


ST 主 要 语 法

ST 程 序 是 ST 的 语 句 表。 每 条 语 句 用 一 个 分 号 (“；”) 分 隔 符 结 束。 在 源 代 码 中 (变 量 标 识 符、常 量、语 言 的 关 键 词...) 中 所 使 用 的 名 称 文 字 用 非 激 活 分 隔 符 (空 格 符、 行 末 标 记 或 制 表 符) 分 开 或 用 激 活 分 隔 符 分 开， 激 活 分 隔 符 有 一 个 意 义 明 确 的 含 义 (例 如， “>” 分 隔 符 表 示 一 个 “大 于” 比 较)。 注 释 可 被 自 由 地 插 入 文 本 中。 一 个 注 释 必 须 用 符 号 “(*” 开 始 和 用 符 号 “*)” 结 束。 每 条 语 句 用 一 个 分 号 (“；”) 分 隔 符 结 束。 ST 语 句 的 基 本 类 型 是:

- 赋 值 语 句 (变 量 := 表 达 式;)

- 子 程 序 或 函 数 调 用

- 功 能 块 调 用

- 选 择 语 句 (IF, THEN, ELSE, CASE...)

- 循 环 语 句 (FOR, WHILE, REPEAT...)

- 控 制 语 句 (返 回, EXIT...)

- 用 于 与 其 它 语 言 如 SFC 进 行 链 接 的 特 殊 语 句

非 激 活 分 隔 符 可 自 由 地 被 插 入 激 活 分 隔 符、 常 量 表 达 式 和 标 识 符 之 间。 ST 的 非 激 活 分 隔 符 是： 空 格 符、 制 表 符 和 行 结 束 符。 与 讲 究 行 格 式 的 语 言 (如 IL) 不 同， ST 语 言 可 在 程 序 中 的 任 何 地 方 插 入 行 的 结 束 符。 当 使 用 非 激 活 分 隔 符 以 提 高 ST 程 序 的 易 读 性 时， 应 遵 循 以 下 规 则:

- 在 一 行 上 不 要 写 一 条 以 上 的 语 句

- 使 用 制 表 符 对 复 杂 的 语 句 进 行 缩 进 处 理

- 插 入 注 释 以 提 高 行 或 段 落 的 易 读 性

源 程 序 可 读 性 的 举 例:

可 读 性 差	可 读 性 好
imax := max_ite; cond := X12; if not(cond (* alarm *) then return; end_if; for i (* index *) := 1 to max_它e do if i <> 2 then Spcall(); end_if; end_for; (* no effect if alarm *)	(* imax : number of iterations *) (* i: FOR statement index *) (* cond: process validity *) imax := max_ite; cond := X12; if not (cond) then     return; end_if; (* process loop *) for i := 1 to max_ite do     if i <> 2 then         Spcall ();     End_if; End_for;


表 达 式 和 括 号

ST 表 达 式 是 ST 操 作 符 和 变 量 或 常 量 操 作 数 的 组 合。 对 每 个 单 独 的 表 达 式 (操 作 数 与 一 个 ST 操 作 符 组 合 ) 来 说， 操 作 数 的 类 型 必 须 是 相 同 的。 这 个 单 独 的 表 达 式 同 它 的 操 作 数 的 类 型 是 一 样 的， 可 被 用 在 较 复 杂 的 表 达 式 。 例 如：

(boo_var1 和 boo_var2)  为BOO 布 尔 型

not (boo_var1)	为BOO 布 尔 型

(sin (3.14) + 0.72)	为 实 数 模 拟 型

(t#1s23 + 1.78)	是 一 个 无 效 的 表 达 式

括 号 用 于 分 隔 表 达 式 的 各 个 分 项， 并 清 楚 地 安 排 操 作 的 优 先 级。 对 一 个 复 杂 的 表 达 式 来 说， 当 没 有 给 出 括 号 时， 操 作 顺 序 由 ST 操 作 符 之 间 的 缺 省 优 先 级 给 出。例 如:

2 + 3 * 6 	等 于 2+18=20	因 为 乘 法 操 作 数 有 较 高 的 优 先 级

(2+3) * 6	等 于 5*6=30	由 括 号 给 出 优 先 级

警 告: 在 一 个 表 达 式 中， 可 被 嵌 套 的 括 号 层 数 最 多 为8 层。


功 能 或 功 能 块 的 调 用

标 准 的ST 调 用 功 能 可 用 于 以 下 每 个 对 象 ：

- 子 程 序

- 用IEC 语 言 编 写 的 库 功 能 和 功 能 块

- “C” 函 数 和 函 数 块

- 类 型 转 换 函 数

调 用 子 程 序 或 函 数

调 用 功 能 块


调 用 子 程 序 或 函 数

名 称:	用 IEC 语 言 或 “C” 语 言 编 写 的 被 调 用 的 子 程 序 或 库 函 数 的 名 称

含 义:	调 用 一 个ST、IL、 LD 或 FBD 子 程 序 或 函 数 或 一 个 “C” 函 数

并 得 到 它 的 返 回 值。

语 法:	<变 量> := <subprog> (<par1>, ... <parN> );

操 作 数:	返 回 值 的 类 型 和 调 用 的 参 数 必 须 遵 循 为 子 程 序 所 定 义 的 接 口。

返 回 值:	由 子 程 序 返 回 的 数 值

子 程 序 可 以 在 任 何 表 达 式 中 被 调 用， 也 可 以 在 一 个SFC 的 转 换 中 被 调 用。

例1: 子 程 序 的 调 用

(* 主 ST 程 序 *)

(* 得 到 一 个 模 拟 值 并 把 它 转 换 成 一 个 被 限 定 的 时 间 值 *)

ana_timeprog := SPlimit ( tprog_cmd );

appl_timer := tmr (ana_timeprog * 100);

(* 调 用 被 称 为 ‘Splimit’ 的 FBD 程 序 *)

例2: 功 能 调 用

(* 在 一 个 复 杂 表 达 式 中 调 用 的 min, max, right, mlen和left 标 准 “C” 函 数 *)

limited_value := min (16, max (0, input_value) );

rol_msg := right (message, mlen (message) - 1) + left (message, 1);


调 用 功 能 块

名 称:	功 能 块  实 例 的 名 称

含 义:	从 ISaGRAF 库 中 或 从 用 户 的 库 中 调 用 一 个 功 能 块 并 访 问 它 的 返 回  参 数

语 法:	(* 功 能 块 的 调 用 *)

<功 能 块 名 称> ( <p1>, <p2> ... );

(得 到 它 的 返 回 参 数*)

<结 果> := <功 能 块 名 称>. <ret_param1>;

...

<结 果> := <功 能 块 名 称>. <ret_paramN>;

操 作 数:	参 数 是 与 该 功 能 块 的 参 数 类 型 相 对 应 的 表 达 式

返 回 值:	参 见 语 法 中 的 得 到 返 回 参 数 部 分

为 了 找 到 每 个 功 能 块 参 数 的 含 义 和 类 型， 请 查 阅 ISaGRAF 库。 功 能 块 实 例 ( 拷 贝 的 名 称) 必 须 在 字 典 中 声 明。

举 例:

(* ST 程 序 调 用 一 个 功 能 块 *)

(* 在 字 典 中 声 明 功 能 块 的 实 例: *)

(* trigb1 : 块 R_TRIG -上 升 沿 检 测 *)

(*从 ST 语 言 激 活 功 能 块 *)

trigb1 (b1);

(* 存 取 返 回 参 数 *)

if (trigb1.Q) Then nb_edge := nb_edge + 1; End_if;


ST 特 殊 的 布 尔 操 作 符

下 列 布 尔 操 作 符 是 专 门 用 于 ST 语 言 的:

REDGE	上 升 沿 检 测

FEDGE	下 降 沿 检 测

其 它 的 标 准 布 尔 操 作 符， 例 如 可 以 使 用 下 列 操 作 符:

NOT	布 尔 求 反

AND (&)	逻 辑 与

OR	逻 辑 或

XOR	逻 辑 异-或

有 关 对 它 们 的 描 述 可 在 '标 准 操 作 符、 功 能 块 和 功 能' 一 节 中 找 到。


“REDGE” 操 作 符

名 称:	REDGE

含 义:	判 断 一 个 完 整 的 布 尔 表 达 式 的 上 升 沿

语 法:	<edge> := REDGE ( <boo_expression>,<memo_variable> );

操 作 数:	第 一 个 操 作 数 是 任 何 布 尔 变 量 或 综 合 表 达 式

第 二 个 操 作 数 是 一 个 内 部 的 布 尔 变 量， 用 于 保 存 表 达 式 的 最 后 状 态

返 回 值:	当 表 达 式 从 假 (FALSE) 变 为 真 (TRUE) 时， 返 回 值 为 真 (TRUE)

在 所 有 其 它 情 况 下， 返 回 值 为 假 (FALSE)

使 用 REDGE 操 作 符 时， 在 同 一 个 执 行 周 期 中， 一 个 表 达 式 的 上 升 沿 不 能 检 测 一 次 以 上。 这 个 操 作 数 可 用 于 描 述 附 加 给 SFC 转 换 的 条 件。

警 告: 用 于 保 存 表 达 式 最 后 状 态 的 “记 忆 式” 布 尔 变 量 不 能 被 当 作 一 个 不 同 表 达 式 沿 的 触 发 脉 冲 来 使 用。

当 表 达 式 是 一 个 被 命 名 为 “xxx” 的 布 尔 变 量 时， 应 声 明 一 个 名 为 “EDGE_xxx” 的 唯 一 的 内 部 变 量， 并 在 这 个 布 尔 变 量 的REDGE 表 达 式 中 使 用 它。 用 这 种 方 法 可 保 证 在 执 行 其 它 REDGE 时， 记 忆 变 量 不 被 改 写。

举 例:

(* 使 用 REDGE 操 作 符 的 ST 程 序*)

(* 该 程 序 是 对 一 个 布 尔 输 入 的 上 升 沿 进 行 计 数 *)

(* Bi120 是 一 个 输 入 布 尔 变 量 *)

(* Edge_Bi120 变 量 是 Bi120 变 量 状 态 的 记 忆 *)

if REDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

注 意： 这 个 操 作 符 不 在 IEC1131-3 标 准 内。 您 最 好 使 用 R_TRIG 标 准 块。 由 于 兼 容 性 方 面 的 原 因， 它 已 被 保 留。


“FEDGE” 操 作 符

名 称:	FEDGE

含 义:	判 断 一 个 布 尔 表 达 式 的 下 降 沿

语 法:	<edge> := FEDGE ( <boo_expression>, <memo_variable> );

操 作 数:	第 一 个 操 作 数 是 任 何 布 尔 变 量 或 综 合 表 达 式

第 二 个 操 作 数 是 一 个 内 部 的 布 尔 变 量， 用 于 保 存 表 达 式 的 最 后 状 态

返回值:	当 表 达 式 从 假 (FALSE) 变 为 真 (TRUE) 时， 返 回 值 为 真 (TRUE)

在 所 有 其 它 情 况 下， 返 回 值 为 假 (FALSE)

使 用FEDGE 操 作 符 时， 在 同 一 个 执 行 周 期 中， 一 个 表 达 式 的 下 降 沿 不 能 检 测 一 次 以 上。 这 个 操 作 数 可 用 于 描 述 附 加 给 一 个 SFC 转 换 的 条 件。

警 告: 用 于 保 存 表 达 式 最 后 状 态 的 “记 忆 式” 布 尔 变 量 不 能 被 当 作 一 个 不 同 表 达 式 沿 的 触 发 脉 冲 来 使 用。

当 表 达 式 是 一 个 被 命 名 为 “xxx” 的 布 尔 变 量 时 ， 应 声 明 一 个 名 为 “EDGE_xxx” 的 唯 一 的 内 部 变 量 ， 并 在 这 个 布 尔 变 量 的FEDGE 表 达 式 中 使 用 它 。 用 这 种 方 法 可 保 证 在 执 行 其 它 FEDGE 时， 记 忆 变 量 不 被 改 写。

举 例：

(* 使 用 FEDGE 操 作 符 的 ST 程 序 *)

(* 该 程 序 是 对 一 个 布 尔 输 入 的 的 下 降 沿 进 行 计 数*)

(* Bi120 是 一 个 输 入 布 尔 变 量 *)

(*Edge_Bi120 变 量 是 Bi120 变 量 状 态 的 记 忆*)

if FEDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

注 意： 这 个 操 作 符 不 在 IEC1131-3 标 准 内。 你 最 好 使 用 F_TRIG 标 准 块。 由 于 兼 容 性 方 面 的 原 因， 它 已 被 保 留。


ST 基 本 语 句

ST 语 言 的 基 本 语 句 是：

赋 值 语 句

返 回 语 句

IF-THEN-ELSIF-ELSE 结 构

CASE 情 况 语 句

WHILE 循 环 语 句

REPEAT 循 环 语 句

FOR 循 环 语 句

EXIT 退 出 语 句


赋 值 语 句

名 称:	:=

含 义:	把 一 个 变 量 赋 值 给 一 个 表 达 式

语 法:	<variable> := <any_expression> ;

操 作 数:	变 量 必 须 是 内 部 的 或 输 出 变 量

变 量 和 表 达 式 须 有 相 同 的 类 型

表 达 式 可 以 是 对 一 个 子 程 序 或 者 ISaGRAF 库 中 函 数 的 调 用

举 例:

(* 有 赋 值 语 句 的 ST 程 序 *)

(* 变 量 <<= 变 量 *)

bo23 := bo10;

(* 变 量 <<= 表 达 式 *)

bo56 := bx34 OR alrm100 & (level >= over_value);

result := (100 * input_value) / scale;

(* 有 子 程 序 返 回 值 的 赋 值 语 句 *)

rc := PSelect ( );

(* 有 函 数 调 用 的 赋 值 语 句 *)

limited_value := min (16, max (0, input_value) );


返 回 语 句

名 称:	RETURN

含 义:	终 止 当 前 程 序 的 执 行

语 法:	RETURN ;

操 作 数:	(无)

在 一 个 SFC 动 作 块 中 , 返 回 语 句 仅 表 示 该 动 作 块 的 执 行 结 束 。

举 例:

(* 程 序 的 FBD 规 范： 可 编 程 计 数 器 *)

(* ST 程 序 中， 使 用 返 回 语 句 *)

if not (CU) then

Q := false;

CV := 0;

返回;   (* 终 止 该 程 序 *)

end_if;

if R then

CV := 0;

else

if (CV < PV) then

CV := CV + 1;

end_if;

end_if;

Q := (CV >= PV);


IF-THEN-ELSIF-ELSE 语 句

名 称:	IF ... THEN ... ELSIF ... THEN ... ELSE ... END_IF

含 义:	根 据 一 个 布 尔 表 达 式 的 值 选 择

执 行 两 个 ST 语 句 表 中 的 其 中 一 个

语法:	IF <boolean_expression> THEN

   <语 句> ;

   <语 句> ;

   ...

ELSIF <boolean_expression> THEN

   <语 句> ;

   <语 句> ;

   ...

ELSE

   <语 句> ;

   <语 句> ;

   ...

END_IF;

ELSE 和 ELSIF 语 句 是 可 选 择 的。IF 没 有 编 写 ELSE 语 句，那 么 当 条 件 为 假 (FALSE) 时， 没 有 指 令 被 执行。

举 例:

(* 使 用IF 语 句 的 ST 程序 *)

IF manual 和 not (alarm) THEN

level := manual_level;

bx126 := bi12 OR bi45;

ELSIF over_mode THEN

level := max_level;

ELSE

level := (lv16 * 100) / scale;

END_IF;

(* 没 有ELSE 的IF 结 构 *)

IF overflow THEN

alarm_level := true;

END_IF;


CASE 语 句

名 称:	CASE ... OF ... ELSE ... END_CASE

含 义:	根 据 一 个 整 型 表 达 式 选 择 执 行 几 个 ST 语 句 表 中 的 其 中 一 个

语 法:	CASE <integer_expression> OF

   <value> : <语 句> ;

   <value> , <value> : <语 句> ;

   ...

ELSE

   <语 句> ;

END_CASE;

CASE 值 必 须 是 一 个 整 型 的 常 量 表 达 式。 用 逗 号 隔 开 的 几 个 值 可 以 产 生 相 同 的语 句 表 。ELSE 语 句 是 可 选 择 的。

举 例:

(*使 用 CASE 语 句 的 ST 程 序 *)

CASE error_code OF

255:	err_msg := 'Division by zero';

fatal_error := TRUE;

1:	err_msg := 'Overflow';

2, 3:	err_msg := 'Bad sign';

ELSE

err_msg := 'Unknown error';

END_CASE;


WHILE 语 句

名 称:	WHILE ... DO ... END_WHILE

含 义:	用 于 一 组 ST 语 句 的 循 环 结 构

在 任 一 循 环 之 前 判 断 “继 续“ 的 条 件

语 法:	WHILE <boolean_expression> DO

   <语 句> ;

   <语 句> ;

   ...

END_WHILE ;

警 告: 因 为 ISaGRaF 是 一 个 同 步 系 统 ，所 以 在WHILE 的 循 环 期 间 ，不 刷 新 输 入 变 量。一 个 输 入 变 量 状 态 的 变 化 不 能 用 于 描 述 一 个 WHILE 语 句 的 条 件。

举 例:

(*使 用 WHILE 语 句 的 ST 程 序 *)

(* 这 个 程 序 使 用 特 殊 的 “C“ 函 数 读 字 符 *)

(* 在 一 个 串 行 口 上 *)

string := ''; (* 空 字 符 串 *)

nbchar := 0;

WHILE ((nbchar < 16) & ComIsReady ( )) DO

string := string + ComGetChar ( );

nbchar := nbchar + 1;

END_WHILE;


REPEAT 重 复 语 句

名 称:	REPEAT ... UNTIL ... END_REPEAT

含 义:	用 于 一 组 ST 语 句 的 循 环 结 构

在 任 一 循 环 之 后 判 断 “继 续” 的 条 件

语 法:	REPEAT

   <语 句> ;

   <语 句> ;

  ...

UNTIL <boolean_condition>

END_REPEAT ;

警告: 因 为 ISaGRAF 是 一 个 同 步 系 统 ，所 以 在WHILE 的循 环 期 间 ，不 刷 新 输 入 变 量 。一 个 输 入 变 量 状 态 的 变 化 不 能 用 于 描 述 一 个 REPEAT 语 句 的 条 件。

举 例:

(* 使 用 REPEAT 语 句 的 ST 程 序 *)

(* 这 个 程 序 使 用 特 殊 的 “C” 函 数 读 字 符 *)

(* 在 一 个 串 行 口 上 *)

string := ''; (* 空 字 符 串 *)

nbchar := 0;

IF ComIsReady ( ) THEN

REPEAT

string := string + ComGetChar ( );

nbchar := nbchar + 1;

UNTIL ( (nbchar >= 16) OR NOT (ComIsReady ( )) )

END_REPEAT;

END_IF;


FOR 语 句

名 称:	FOR ... TO ... BY ... DO ... END_FOR

含 义:	使 用 一 个 整 形 的 模 拟 索 引 变 量 执 行 一 个 受 限 制 的 循 环 数

语 法:	FOR <index> := <mini> TO <maxi> BY <step> DO

   <语 句> ;

   <语 句> ;

END_FOR;

操 作 数:	index:	在 任 一 循 环 中 增 加 的 内 部 模 拟 变 量

mini:	索 引 的 初 始 值 (在 第 一 个 循 环 之 前)

maxi:	索 引 的 最 大 允 许 值

步:	每 次 循 环 时 的 索 引 增 量

[ BY step ] 语 句 是 可 选 择 的。 如 果 没 有 具 体 规 定， 则 增 量 step 为 1

警 告: ISaGRAF 是 一 个 同 步 系 统， 所 以 在 FOR 循 环 期 间 不 刷 新 输 入 变 量。

这 是 一 个 与 FOR 语 句 等 效 的 “while” 语 句:

index := mini;

while (step <= maxi) do

   <语 句> ;

   <语 句> ;

   index := index + step;

end_while;

举 例:

(*使 用 FOR 语 句 的 ST 程 序*)

(* 该 程 序 提 取 字 符 串 中 的 数 字 符 *)

length := mlen (message);

target := ''; (* 空 字 符 串 *)

FOR index := 1 TO length BY 1 DO

code := ascii (message, index);

IF (code >= 48) & (code <= 57) THEN

target := target + char (code);

END_IF;

END_FOR;


EXIT 退 出 语 句

名 称:	EXIT

含 义:	从 一 个 FOR, WHILE 或REPEAT 循 环 语 句 中 退 出

语 法:	EXIT;

操 作 数:	(无)

EXIT 通 常 用 在 一 个 IF 语 句 内，并 在 一 个 FOR, WHILE 或 REPEAT 块 内。

举 例:

(* 使 用 EXIT 语 句 的 ST 程 序 *)

(* 该 程 序 在 一 个 字 符 串 中 搜 索 一 个 字 符 *)

length := mlen (message);

found := NO;

FOR index := 1 TO length BY 1 DO

code := ascii (message, index);

IF (code  = searched_char) THEN

found := YES;

EXIT;

END_IF;

END_FOR;


ST 扩 展

以 下 功 能 是 对 ST 语 言 的 扩 展：

TSTART - TSTOP： 计 时 器 控 制

下 列 语 句 和 功 能 可 用 于 控 制SFC 子 程 序 的 执 行。 它 们 可 在 ACTION()，. END_ACTION 内 部 使 用;  也 可 用 于 SFC 步 内 的 块。

GSTART	 启 动 一 个 SFC 程 序

GKILL	 终 止 一 个 SFC 程 序

GFREEZE	 冻 结 一 个 SFC 程 序

GRST	 重 新 启 动 一 个  冻 结 的 SFC 程 序

GSTATUS	 获 取 一 个 SFC 程 序 的 当 前 状 态

警告:  这 些 功 能 不 在 IEC 1131-3 标 准 内。

 在 SFC 步 内 使 用 下 面 的 语 法 可 以 为 GSTART 和 GKILL  找 到 等 效 结 果:

child_name(S); (* 与 GSTaRT(child_name) 等 效; *)

child_name(R); (* 与 GKILL(child_name) 等 效; *)

 下 列 符 号 组 可 用 于 访问 一 个 SFC 步 的 状 态:

GSnnn.x	 代 表 步 被 激 活 的 布 尔 值

GSnnn.t	 从 步 的 最 后 一 次 激 活 起 所 化 的 时 间

(“nnn” 是 SFC 步 的 参 考 号)

对 于 在 另 一个 SFC 程 序 中 声 明 的 一 个 步 的 激 活 状 态 也 可 以 进 行 测 试， 此 时 应 使 用 下 列 语 法:

GSnnn(progname).x

警 告:  在 参 考 另 一 个 程 序 的 一 个 步 时， 该 语 法 不 在 IEC 1131-3 标 准 中。  实 现 同 一 操 作 而 又 遵 守 IEC 规 则，有 一 个 简 易 的 方 法 是， 在 字 典 中 声 明 一 个 全 局 布 尔 变 量， 它 表 示 需 要 测 试 的 那 个 步 的 激 活 状 态 (例 如 ref_step_X)。 然 后 你 把 带 N 判 定 的 变 量 (ref_步_X(N);) 插 入 其 中。 接 着 在 准 备 对 步 的 激 活 状 态 进 行 测 试 的 程 序 中 使 用 该 变 量。

Prog 程序	 需 要 Prog 程 序 的 步 激 活 状 态 的 另 一 个 程 序


TSTART 语 句

名 称:	TSTART

含 义:	一 个 计 时 器 变 量 开 始 计 数

TSTART 命 令 不 会 改 变 计 时 器 的 值， 也 就 是 说， 计 数 是 从 计 时 器 的 当 前 值 开 始。

语 法:	TSTART ( <timer_variable> );

操 作 数:	 任 一 非 激 活 的 计 时 器 变 量

返 回 值:	(无)

举 例:

(*使 用 TSTART 和 TSTOP 语 句 的 SFC 程序 *)

如 果 bi100 总 是 FALSE， 则 时 间 图 如 下:

 在 一 个 循 环 里 计 时 器 保 持 相 同 值。


TSTOP 语 句

名 称:	TSTOP

含 义:	 停 止 更 新 一 个 计 时 器 变 量

TSTOP  命 令 不 能 修 改 计 时 器 的 值

语 法:	TSTOP ( <timer_variable> );

操 作 数:	 任 一 激 活 的 计 时 器 变 量

返 回 值:	(无)

举 例: 参 见 (上 面 所 描 述 的) TSTART 功 能


GSTART 语 句

名 称:	GSTART

含 义:	 通 过 把 一 个 标 记 放 入 程 序 的 每 个 初 始 步 中 来 启 动 一 个 子 程 序。

语 法:	GSTART ( <child_program> );

操 作 数:	 给 定 的 SFC 程 序 必 须 是 一 个 子 程 序，  且 在 它 的 主 程 序 中 写 有 上
 述 语 句。

返回值:	(无)

子 程 序 的 子 程 序 不 能 自 动 地 被 GSTART 语 句 启 动。

注 意： 因 为 GSTART 语 句 不 在 IEC 1131-3  标 准 中， 最 好 使 用 S 判 定， 并 且 使 用 下 面 的 语 法 来 启 动 一 个 SFC子 程 序:

Child_name(S);

举 例： GSTART 和 GKILL 的 使 用

(* ‘Sfather’ 序 列*)	(* ‘Schild’ 序 列*)


GKILL 语 句

名 称:	GKILL

含 义:	通 过 去 除 程 序 步 内 当 前 存 在 的 标 记 终 止 一 个SFC 子 程 序

语 法:	GKILL ( <child_程 序> );

操 作 数:	给 定 的 SFC 程 序 必 须 是 一 个 子 程 序， 且 在 它 的 主 程 序 中 写 有 上 述 语 句

返回值:	(无)

子 程 序 的 子 程 序 被 给 定 的 程 序 自 动 地 停 止。

注 意： 因 为 GKILL 语 句 不 在 IEC 1131-3 标 准 中， 最 好 使 用 R 判 定， 并 且 使 用 下 面 的 语 法 来 终 止 一 个 SFC子 程 序:

Child_name(R);

举 例： 参 见 (上 面 所 描 述 的) GSTART 功 能


GFREEZE 语 句

名 称:	GFREEZE

含 义:	 暂 停 一 个 SFC 程 序 的 执 行

 冻 结 的 程 序 可 由 GRST 语 句 重 新 启 动。

语 法:	GFREEZE ( <child_program> );

操 作 数:	给 定 的 SFC 程 序 必 须 是 一 个 子 程 序， 且 在 它 的 主 程 序 中 写 有 上 述 语 句

返回值:	(无)

子 程 序 的 子 程 序 和 给 定 的 程 序 一 起 被 自 动 冻 结。

注 意： GFREEZE 语 句 不 在 IEC 1131-3 标 准 中。

举 例：


GRST 语 句

名 称:	GRST

含 义:	重 新 启 动 一个 由 GFREEZE 语 句 冻 结 的 SFC 子 程 序

语 法:	GRST ( <child_program> );

操 作 数:	给 定 的 SFC 程 序 必 须 是 一 个 子 程 序， 且 在 它 的 主 程 序 中 写 有 上 述 语 句

返回值:	(无)

 	程 序 的 子 程 序 被 GRST 语 句 自 动 地 重 新 启 动。

注 意： GRST 语 句 不 在 IEC 1131-3 标 准 中。

举 例: 参 见 (上 面 所 描 述 的) GFREEZE 功 能


GSTATUS 语 句

名 称:	GSTATUS

含 义:	 返 回 一 个 SFC 程 序 的 当 前 状 态

语 法:	<ana_var> := GSTATUS ( <child_program> );

操 作 数:	给 定 的 SFC 程 序 必 须 是 一 个 子 程 序， 且 在 它 的 主 程 序 中 写 有 上 述 语 句

返 回 值:	0 = 程 序 非 激 活 状 态 (被 终 止)

1 = 程 序 为 激 活 状 态 (被 启 动)

2 = 程 序 被 冻 结

注 意： GFREEZE 语 句 不 在 IEC 1131-3 标 准 中。

举 例:


 FBD 语 言

功 能 块 图 (FBD) 是 一 种 图 形 语 言。 它 允 许 程 序 员 用 ISaGRAF 库 中 现 有 的 功 能 编 制 复 杂 的 程 序， 并 在 框 图 区 域 中 用 线 把 它 们 连 接 在 一 起。

FBD 图 的 主 要 格 式

RETURN 返 回 语 句

跳 转 和 标 号

布 尔 求 反 运 算

调 用 FBD 中 的 功 能 或 功 能 块


FBD 图 的 主 要 格 式

FBD 图 描 述 一 个 在 输 入 变 量 和 输 出 变 量 之 间 的 功 能。 一 个 功 能 被 视 为 基 本 功 能 块 的 一 个 集 合。 连 线 把 输 入 和 输 出 变 量 与 块 相 连， 功 能 块 的 输 出 又 可 以 与 另 一 功 能 块 的 输 入 相 连。

FBD 程 序 所 运 行 的 一 个 完 整 的 功 能 是 由 ISaGRAF 库 中 标 准 的 基 本 功 能 块 组 成 的。 功 能 块 有 确 定 的 输 入 和 输 出 连 接 点 数 量 。 功 能 块 用 矩 形 表 示 。 输 入 端 与 矩 形 的 左 边 框 连 接 ， 输 出 端 与 矩 形 的 右 边 框 连 接 。 基 本 功 能 块 在 它 的 输 入 与 输 出 之 间 完 成 一 个 功 能 。 其 名 称 写 在 矩 形 符 号 内 。 方 框 的 每 个 输 入 或 输 出 都 有 明 确 的 类 型 。

FBD 程 序 的 输 入 变 量 必 须 与 功 能 块 的 输 入 相 连 。 变 量 的 类 型 与 相 关 输 入 所 要 求 的 类 型 相 同 。 FBD 程 序 的 输 入 可 以 是 常 数 表 达 式 、 任 意 内 部 的 或 输 入 或 输 出 的 变 量 。

FBD 程 序 的 输 出 变 量 必 须 与 功 能 块 的 输 出 相 连 。 变 量 类 型 与 相 关 输 出 要 求 的 同 类。 FBD 程 序 的 输 出 可 以 是 任 意 内 部 的 或 输 出 的 变 量 ， 或 者 是 程 序 名 （ 只 就 子 程 序 而 言 ） 。 当 输 出 是 当 前 所 编 辑 的 子 程 序 名 时 ， 它 代 表 子 程 序 的 返 回 值 （ 返 回 到 调 用 程 序 ）。

用 连 接 线 把 输 入 和 输 出 变 量 及 功 能 块 的 输 入 和 输 出 连 接 在 一 起 。 单 独 的 线 可 用 于 连 接 框 图 的 两 个 逻 辑 点 :

 - 输 入 变 量 和 功 能 块 的 输 入

 - 功 能 块 的 输 出 和 另 个 功 能 块 的 输 入

 - 功 能 块 的 输 出 和 输 出 变 量

连 接 具 有 方 向 性 ， 这 就 是 说 ， 连 接 线 是 从 左 端 向 右 端 传 输 数 据 ， 连 线 的 左 右 端 具 有 相 同 的 数 据 类 型 。

多 路 右 连 接 可 用 于 把 信 息 从 左 端 向 右 端 的 每 一 端 口 进 行 传 输 。 所 有 的 连 接 端 口 必 须 具 有 相 同 的 类 型 。


RETURN 语 句

关 键 词 " <RETURN> " 可 以 出 现 在 框 图 输 出 位 置， 它 必 须 与 一 个 功 能 块 的 布 尔 输 出 连 接 点 相 连 。 RETURN 语 句 代 表 程 序 的 一 个 有 条 件 的 结 束 ： 如 果 与 返 回 语 句 相 连 的 方 框 的 输 出 ， 其 布 尔 值 为 TRUE , 那 么 程 序 的 结 尾 （ 剩 余 部 分 ） 不 被 执 行 。

( * 使 用 RETURN 返 回 语 句 编 写 的 FBD 程 序 举 例 * )

(* ST equivalence: *)

If auto_mode OR alarm Then

Return;

End_if;

bo67 := (bi10 AND bi23) OR x_cmd;


 跳 转 和 标 号

跳 转 和 标 号 用 于 控 制 程 序 的 执 行 。 在 一 个 跳 转 或 标 号 符 的 右 边 不 能 连 接 其 它 。 使 用 的 标 志 如 下:

>>LAB	跳 转 到 某 个 标 号   ( 标 号 名 为 " LAB" )

LAB:	某 个 标 号 的 定 义   ( 标 号 名 为  "LAB" )

如 果 跳 转 标 号 左 边 连 接 线 的 布 尔 状 态 值 是 “真”, 那 么 程 序 的 执 行 直 接 跳 转 到 相 应 的 标 号 符 后 面 。

( * 使 用 标 号 和 跳 转 的 FBD 程 序 举 例 * )

(* IL Equivalence: *)

ld	manual

and	b1

jmpc	NOMODIF

ld	input1

or	input2

st	result

NOMODIF:	ld	result

and	valid

st	cmd10


布 尔 求 反 运 算

一 根 右 端 与 某 个 功 能 块 的 输 入 相 接 的 连 接 线 可 用 布 尔 求 反 运 算 结 束 。 求 反 运 算 用 小 圆 圈 来 表 示 。 使 用 布 尔 求 反 运 算 时， 连 线 左 、 右 端 的 数 据 必 须 具 有 布 尔 类 型 。

( * 使 用 标 号 和 跳 转 的 FBD 程 序 举 例 * )

(* ST equivalence: *)

output1 := input1 AND NOT (input2);


调 用 FBD 中 的 功 能 或 功 能 块

FBD 语 言 能 够 调 用 子 程 序、 功 能 或 功 能 块 。 一 个 子 程 序、 功 能 或 功 能 块 用 一 个 功 能 方 块 图 表 示 。 方 块 内 名 称 就 是 子 程 序 或 功 能 或 功 能 块 的 名 称 。

对 一 个 子 程 序 或 一 个 功 能 来 说 ， 其 返 回 值 是 功 能 方 块 图 的 唯 一 输 出 。

功 能 块 可 以 有 多 个 输 出 。

( * 使 用 子 程 序 块 的 FBD 程 序 举 例 * )

(* ST Equivalence *)

net_weight := Weighing (mode, delta); (* call sub-program *)

If (net_weight = 0) Then Return; End_if;

weight := net_weight + tare_weight;


 SFC 语 言

顺 序 功 能 流 程 图 (SFC) 是 用 于 描 述 顺 序 操 作 的 一 种 图 形 语 言 。 顺 序 用 一 组 定 义 明 确 的 步 表 示， 这 些 步 通 过 转 换 链 接 起 来。 每 个 转 换 有 布 尔 条 件 。 这 些 步 内 的 动 作 可 以 用 其 它 语 言 ( ST, IL， LD 和 FDB ) 来 进 行 详 细 的 描 述。

SFC 图 的 主 要 格 式

SFC 的 基 本 元 件

分 支 与 会 合

宏 步

步 内 的 动 作

转 换 的 条 件

SFC 的 动 态 规 则

SFC 程 序 的 层 次


SFC 图 的 主 要 格 式

一 个 SFC 程 序 是 由 步 和 转 换 组 成 的 图 形 组。 通 过 定 向 链 接 把 步 和 转 换 链 接 在 一 起 。 多 个 连 接 的 链 接 用 于 表 示 分 支 和 会 合 。 完 整 程 序 的 某 些 部 分 可 以 被 分 离 并 在 主 流 程 图 中 用 一 个 单 符 号 表 示， 称 为 宏 步。 SFC 的 基 本 图 形 规 则 如 下 :

- 步 的 后 面 不 能 紧 随 另 一 个 步

- 转 换 的 后 面 不 能 紧 随 另 一 个 转 换


SFC 的 基 本 元 件

SFC 的 基 本 元 件 （ 图 形 符 号 ） 是 ： 步 和 初 始 步 ， 转 换 ， 定 向 链 接 ， 以 及 跳 转 到 一 个 步 。

步 和 初 始 步

转 换

定 向 链 接

跳 转 到 一 个 步


步 和 初 始 步

一 个 步用 一 个 单 独 的 正 方 形 表 示。 每 一 个 步 用 写 在 步 的 正 方 形 符 号 内 的 编 号 标 定， 与 步 符 号 相 链 接 的 矩 形 内 写 入 步 的 主 要 描 述 。该 描 述 是 随 意 的 注 释 (不 属 于 编 程 语 言 的 一 个 部 分)。 上 述 信 息 被 称 之 为 步 的 第 一 层：

运 行 时 ， 用 一 个 标 记 显 示 这 个 步 是 激 活 的:

激 活 的 步:	未 激 活 的 步:

SFC 程 序 初 始 情 况 用 初 始 步 来 表 示。 一 个 初 始 步 有 双 边 框 的 图 形 符 号。 当 启 动 程 序 时， 标 记 被 自 动 地 放 在 每 个 初 始 步 内。

初 始 步 :

一 个 SFC 程 序 必 须 至 少 含 有 一 个 初 始 步 。 以 下 是 步 的 标 志。 这 些 域 可 被 用 于 任 何 其 它 的 语 言 中 。 :

GSnnn.x	步 的 动 作 ( 布 尔 值 )

GSnnn.t	步 的 激 活 时 间 ( 时 间 值 )

(在 这 里 nnn 是 步 的 参 考 编 号)


转 换

转 换 用 一 条 与 链 接 线 交 叉 的 短 的 水 平 线 段 来 表 示。 每 一 个 转 换 被 一 个 写 在 其 旁 边 的 编 号 设 定。 在 转 换 符 号 的 右 侧 写 上 有 关 这 个 转 换 的 主 要 描 述 。 该 描 述 是 随 意 的 注 释 (不 属 于 编 程 语 言 的 部 分). 以 上 信 息 被 称 之 为 转 换 的 第 一 层 ：


定 向 链 接

用 单 线 链 接 步 和 转 换。 它 们 是 定 向 链 接 。 在 没 有 给 出 明 确 的 方 向 时 ， 链 接 的 方 向 是 从 顶 部 到 底 部。


跳 转 到 一 个 步

跳 转 符 号 可 用 于 表 明 从 转 换 至 步 的 连 接， 此 时 不 必 画 出 连 接 线 。 跳 转 符 号 用 目 标 步 的 的 编 号 来 标 记：

跳 转 符 号 不 能 用 于 表 示 从 一 个 步 到 一 个 转 换 的 链 接。 跳 转 举 例 - 下 面 的 流 程 图 是 等 效 的 :


分 支 与 会 合

分 支 是 从 一 个 SFC 符 号 ( 步 或 转 换 ) 到 许 多 其 它 的 SFC 符 号 的 多 路 连 接 的 链 接 。会 合 是 从 一 个 以 上 的 SFC 符 号 到 一 个 其 它 符 号 的 多 路 连 接 的 链 接 。 分 支 与 会 合 可 以 是 单 线 或 双 线

单 线 分 支

双 线 分 支


单 线 分 支

单 线 分 支 是 从 一 步 到 许 多 转 换 的 一 个 多 路 链 接 。 它 允 许 激 活 标 记 进 入 许 多 支 路 中 的 一 个 支 路 。 一 个 单 线 会 合 是 从 许 多 转 换 到 同 一 个 步 的 一 个 多 路 链 接 。 一 个 单 线 会 合 通 常 用 于 把 SFC 支 路 组 合 起 来 ， 它 们 起 始 在 一 个 单 线 分 支 上。 单 线 支 路 和 会 合 以 单 根 水 平 线 为 表 示 。

警 告： 在 一 个 单 线 分 支 的 开 始 ， 不 同 的 转 换 所 附 带 的 条 件 并 不 正 好 是 唯 一 的 。 其 唯 一 性 必 须 在 转 换 条 件 中 得 到 详 尽 的 描 述 , 以 保 证 在 运 行 时 ， 在 分 支 的 一 个 支 路 中 只 有 一 个 标 记 前 进 。 下 面 是 单 线 分 支 和 会 合 的 一 个 例 子 :

(*含 有 单 线 分 支 和 会 合 的 SFC 程 序*)


双 线 分 支

一 个 双 分 支 是 从 一 个 转 换 到 许 多 步 的 一 个 多 路 链 接 。 它 适 合 于 过 程 的 并 行 操 作 。 一 个 双 线 会 合 是 从 许 多 步 到 同 一 个 转 换 的 一 个 多 路 链 接 。 一 个 双 线 会 合 通 常 用 于 把 SFC 支 路 组 合 起 来， 曾 在 一 个 双 线 分 支 上 起 始 这 些 支 路 。 双 线 分 支 和 会 合 用 双 水 平 线 表 示 。

双 线 分 支 和 会 合 的 例 子 :

(*含 有 双 线 分 支 和 会 合 的 SFC 程 序 *)


宏 步

一 个 宏 步 是 对 多 个 步 和 转 换 组 合 的 表 示 法。 宏 步 的 主 要 部 分 在 同 一 个 SFC 程 序 的 另 一 个 地 方 被 单 独 描 述 。 在 SFC 的 主 流 程 图 中， 宏 步 以 一 个 单 独 的 符 号 出 现。 以 下 是 用 于 一 个 宏 步 的 符 号：

宏 步 符 号 的 参 考 编 号 是 该 宏 步 体 中 第 一 步 的 参 考 编 号。 宏 步 的 主 要 部 分 必 须 从 一 个 起 始 步 开 始 ， 并 以 一 个 终 止 步结 束， 流 程 图 必 须 是 独 立 的。 一 个 起 始 步 没 有 上 面 的 链 接 ( 没 有 反 向 转 换 ) 。 一 个 终 止 步 没 有 下 面 的 链 接 ( 没 有 正 向 转 换 )。 一 个 宏 步 符 号 可 被 放 在 另 一 个 宏 步 的 主 要 部 分 中 。

警 告： 因 为 宏 步 是 由 多 个 步 和 转 换 特 别 组 合， 所 以 在 一 个 SFC 程 序 中 不 能 多 次 使 用 相 同 的 宏 步。

宏 步 举 例:

(* 主 流 程 图  *)	(* 宏 步 的 主 要 部 分 *)


步 内 动 作

一 个 SFC 步 的 第 二 层 是 对 步 在 激 活 期 间 所 执 行 的 动 作 的 详 细 描 述。 该 描 述 利 用 SFC 的 文 字 特 性 和 其 它 语 言 如 结 构 化 文 本 (ST)   来 完 成。 动 作 的 基 本 类 型 是：

布 尔 动 作

脉 冲 动 作

非 存 储 动 作

SFC 动 作

几 个 动 作 ( 有 相 同 的 或 不 同 的 类 型 ) 可 在 一 个 相 同 的 步 内 描 述。 能 使 用 任 何 其 它 语 言 的 特 性 是：

从 一 个 动 作 调 用 功 能 和 功 能 块

IL 语 言 的 规 则


布 尔 动 作

布 尔 动 作 是 用 步 的 激 活 赋 值 给 一 个 布 尔 变 量 。 布 尔 变 量 可 以 是 一 个 输 出 或 一 个 内 部 量。 每 当 步 的 激 活 启 动 或 停 止 时 ， 它 就 被 赋 值 。 以 下 是 基 本 布 尔 动 作 的 语 法：

<布 尔 _ 变 量> (N) ;	把 步 的 激 活 信 号 赋 值 给 变 量

<布 尔 _ 变 量> ;	相 同 的 结 果 ( N 标 记 是 可 选 项 )

/ <布 尔 _ 变 量> ;	把 步 激 活 的 求 反 信 号 赋 值 给 变 量

当 步 被 激 活 时， 其 它 一 些 特 性 可 供 用 于 置 位 或 复 位 一 个 布 尔 变 量。 以 下 是 置 位 或 复 位 布 尔 动 作 的 语 法：

<布 尔 _ 变 量> (S) ;	当 步 的 激 活 信 号 变 为 TRUE 时， 把 变 量 置 位 为 TRUE

<布 尔 _ 变 量> (R) ;	当 步 的 激 活 信 号 变 为 TRUE 时 ， 把 变 量 复 位 为 FALSE

布 尔 变 量 必 须 是 一 个 输 出 或 一 个 内 部 的 量 。 下 面 的 SFC 编 程 导 致 以 下 动 作：

布 尔 动 作 举 例：

(* 使 用 布 尔 动 作 的 SFC 程 序 *)


脉 冲 动 作

一 个 脉 冲 动 作 是 一 个 ST 或 IL 指 令 表， 这 些 指 令 在 步 激 活 状 态 仅 被 执 行 一 次。 写 指 令 时， 应 遵 照 SFC 语 法：

ACTION (P) :

(* ST 语 句 *)

END_ACTION ;

以 下 显 示 一 个 脉 冲 动 作 的 结 果:

脉 冲 动 作 举 例:


非 存 储 动 作

一 个 非 存 储 ( 正 常 的 ) 动 作 是 一 个 ST 或 IL 指 令， 这 些 指 令 在 步 的 整 个 激 活 期 间 每 次 循 环 时 被 执 行。 写 指 令 应 遵 照 下 面 的 SFC 语 法：

ACTION (N) :

(* ST 语 句 *)

END_ACTION ;

 以 下 是 一 个 非 存 储 动 作 的 结 果 :

非 存 储 动 作 举 例:


SFC 动 作

一 个 SFC 动 作 是 一 个 SFC 的 子 程 序 ， 它 根 据 步 的 激 活 信 号 的 变 化 启 动 或 停 止 。 一 个 SFC 动 作 可 以 有 N ( 非 存 储 )， S (设 置)， 或 R (复 位) 三 种 判 定 。 以 下 是 SFC 基 本 动 作 的 语 法：

<child_prog> (N);	当 步 变 为 激 活 时， 启 动 子 程 序； 当 步 变 为 非 激 活 时， 停 止 子 程 序 。

<child_prog> ;	相 同 的 结 果 ( N 标 记 是 可 选 项 )

<child_prog> (S);	当 步 变 为 激 活 时， 启 动 子 程 序； 当 步 变 为 非 激 活 时， 不 动 作 。

<child_prog> (R);	当 步 变 为 激 活 时， 停 止 子 程 序； 当 步 变 为 非 激 活 时， 不 动 作 。

规 定 为 一 个 动 作 的 SFC 程 序 必 须 是 当 前 正 在 编 辑 的 程 序 的 一 个 SFC 子 程 序 。 值 得 注 意 的 是 ， 用 于 一 个 SFC 动 作 的 S (设 置) 或 R (复 位) 判 定 确 实 与 GSTART 和 GKILL 语 句 的 效 果 相 同， 该 语 句 被 编 写 在 一 个 ST 脉 冲 动 作 中。

下 面 是 一 个 SFC 动 作 的 例 子。 父 SFC 程 序 命 名 为 Father， 它 有 两 个 SFC 子 程 序， 被 命 名 为 SeqMlx 和SeqPump 父 SFC 程 序 的 编 程 如 下：

(* 使 用 SFC 动 作 的 SFC 程 序*)


从 一 个 动 作 中 调 用 功 能 和 功 能 块

子 程 序、 功 能 或 功 能 块 (用ST、 IL、 LD 或 FBD 语 言) 或 “C” 函 数 和 “C” 功 能 块 可 以 直 接 从 一 个 SFC 动 作 块 中 调 用， 它 们 根 据 下 面 的 语 法 编 写：

用 于 子 程 序， 功 能 和 “C” 函 数：

ACTION (P) :

result := sub_program ( ) ;

END_ACTION;

或

ACTION (N) :

result := sub_program ( ) ;

END_ACTION;

对 于 用 “C” 或 者ST、IL、LD、 FBD 语 言 编 写 的 功 能 块:

ACTION (P) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

或

ACTION (N) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

详 细 的 语 法 可 以 在 ST 语 言 一 节 中 找 到 。

在 动 作 块 中 调 用 一 个 子 程 序 的 例 子：

(*在 一 个 动 作 块 中 调 用 一 个 子 程 序 的 SFC 程 序 *)


IL 语 言 规 则

指 令 表 (IL) 的 编 程 可 根 据 下 面 的 语 法 直 接 输 入 到 一 个 SFC 动 作 块 中 :

ACTION (P) :	(* or N *)

#info=IL

     <instruction>

     <instruction>

     ....

#endinfo

END_ACTION;

特 殊 关 键 词 “# info = IL” 和 “# endinfo” 必 须 完 全 用 上 面 的 方 法 输 入， 这 两 个 关 键 词 与 大 小 写 相 关。 在 关 键 词 的 后 面 或 前 面 不 能 插 入 空 格 或 制 表 符。 下 面 是 一 个 动 作 块 内 的 一 个 IL 程 序 的 例 子 :

(* 含 有 一 个 IL 程 序 的 SFC 程 序， IL 程 序 在 动 作 块 内 *)


与 转 换 相 连 的 条 件

每 一 个 转 换 都 有 一 个 布 尔 表 达 式 相 连， 布 尔 表 达 式 给 出 了 该 转 换 的 条 件。 条 件 通 常 是 用 ST 语 言 或 LD 语 言 ( 快 捷 LD 编 辑 器 ) 来 表 示。 这 是 转 换 的 第 二 层。 不 过 也 可 使 用 其 它 结 构：

ST 语 言 规 则

LD 语 言 规 则

IL 语 言 规 则

从 一 个 转 换 调 用 功 能

警 告： 当 没 有 表 达 式 附 加 给 转 换 时， 隐 含 条 件 为 TRUE。


ST 语 言 规 则

结 构 化 文 本 ( ST ) 语 言 可 用 于 描 述 一 个 转 换 条 件。 整 个 表 达 式 必 须 为 布 尔 类 型 ， 并 且 以 一 个 分 号 结 尾， 其 语 法 为：

< boolean_expression > ;

表 达 式 可 以 是 一 个 TRUE 或 FALSE 的 常 量 表 达 式 ， 信 号 输 入 或 内 部 的 布 尔 变 量 ，   或 是 产 生 布 尔 值 的 变 量 组 合 。 下 面 是 以 ST 编 程 的 转 换 例 子 :

( * 用 ST 编 写 转 换 的 SFC 程 序 *)


LD 语 言 规 则

梯 形 图 (LD) 语 言 可 用 于 描 述 转 换 的 条 件。 梯 形 图 由 带 有 一 个 线 圈 的 一 个 梯 级 组 成。 线 圈 值 代 表 转 换 值。

下 面 是 用 LD 编 写 转 换的 例 子 :


IL 语 言 规 则

指 令 表 (IL) 语 言 可 直 接 用 于 描 述 一 个 SFC 转 换， 其 语 法 规 则 为：

#info=IL

<instruction>

<instruction>

....

#endinfo

位 于 IL 程 序 末 端 的 当 前 结 果 ( IL 寄 存 器 ) 所 包 含 的 值， 使 附 加 给 转 换 的 条 件 产 生 结 果 :

current result = 0 	 	条 件 是 FALSE

current result <> 0	条 件 是 TRUE

特 殊 关 键 词 “# info = IL” 和 “# endinfo” 必 须 完 全 用 上 面 的 方 法 输 入， 这 两 个 关 键 词 与 大 小 写 相 关 。 在 关 键 词 的 后 面   或 前 面 不 能 插 入 空 格 或 制 表 符 。 下 面 是 为 转 换 用 IL 编 程 的 例 子：

(* 用 IL 编 写 转 换 的 SFC 程 序 *)


从 一 个 转 换 中 调 用 函 数

为 了 判 断 一 个 转 换 的 条 件 ， 可 以 调 用 任 何 子 程 序 或 功 能 ( 用FBD、LD、 ST 或 IL 语 言 编 写 )， 或 “C” 函 数， 其 语 法 为：

< sub_program > ( ) ;

子 程 序 或 函 数 返 回 的 值 必 须 是 布 尔 量， 并 使 条 件 产 生 结 果 :

return value = 0	条 件 是 FALSE

return value <> 0	条 件 是 TRUE

下 面 是 在 转 换 中 调 用 子 程 序 的 例 子 :

(* 转 换 中 调 用 子 程 序 的 SFC 程 序*)


SFC 的 动 态 规 则

SFC 语 言 的 五 个 动 态 规 则 是:

 初 始 状 态

初 始 状 态 的 特 征 在 初 始 步 中 体 现 ， 初 始 步 被 定 义 为 在 操 作 起 始 时 处 于  激 活 状 态 。 每 个 SFC 程 序 中 必 须 至 少 有 一 个 初 始 步 。

 清 除 一 个 转 换

一 个 转 换 或 为 有 效 或 为 无 效.。 当 所 有 与 相 应 的 转 换 符 链 接 的 先 前 的 步 处 于 激 活 状 态 时， 被 称 为 有 效， 否 则 就 是 无 效。 除 下 列 情 况 以 外， 一 个 转 换 不 能 被 清 除 :

   - 该 转 换 处 于 有 效 状 态 ， 和

   - 有 关 的 转 换 条 件 为 真(“true”) .

 激 活 步 状 态 的 改 变

一 个 转 换 的 清 除 同 时 导 致 紧 跟 下 面 的 步 为 激 活 状 态 ， 并 导 致 前 面 紧 接 的 步 为 非 激 活 状 态 。

 转 换 的 同 步 清 除

双 线 用 于 表 示 必 须 同 时 被 清 除 的 转 换。 如 果 这 样 一 些 转 换 被 单 独 显 示 ， 那 么 前 面 一 些 步 (GSnnn.x)  的 激 活 状 态 可 被 用 于 表 示 它 们 的 条 件 。

 一 个 步 同 时 被 激 活 和 被 解 除 激 活

如 果 在 操 作 期 间， 一 个 步 同 时 被 激 活 和 被 解 除 激 活 ， 那 么 激 活 将 获 得 优 先 。


SFC 程 序 的 层 次 结 构

ISaGRAF 系 统 能 够 描 述 SFC 程 序 垂 直 结 构 。 SFC 程 序 被 按 有 层 次 的 层 状 结 构 组 织。 每 个 SFC 程 序 可 以 控 制 ( 起 动 ， 停 止 . . . ) 其 它 的 SFC 程 序。 这 样 的 程 序 被 称 为 SFC 程 序 的 子 程 序， 它 受 SFC 程 序 控 制 。 采 用 一 种 " 父 子 " 关 系 把 各 个 SFC 程 序 链 接 到 主 层 状 结 构 中。

层 次 结 构 所 包 含 的 基 本 规 则 是 :

- 没 有 父 程 序 的 SFC 程 序 被 称 为 “父” SFC 程 序

- 应 用 程 序 启 动 时 ， 由 系 统 激 活 父 SFC 程 序

- 程 序 可 以 有 几 个 子 程 序

- 子 程 序 不 能 有 一 个 以 上 的 父 程 序

- 子 程 序 仅 由 其 父 程 序 控 制

- 程 序 不 能 控 制 它 自 己 的 子 程 序 的 子 程 序

父 SFC 程 序 为 了 控 制 其 子 程 序 而 能 够 采 取 的 基 本 操 作 为 :

启 动	(GSTART) 启 动 子 程 序： 激 活 它 的 每 一 个 初 始 步。 该 子 程 序 的 子 程 序 不 能 自 动 地 启 动 。

停 止	(GKILL) 通 过 解 除 每 个 激 活 步 的 激 活 状 态 使 子 程 序 停 止 。 该 子 程 序 的 所 有 子 程 序 也 停 止 。

冻 结	(GFREEZE) 暂 停 执 行 程 序 ( 解 除 每 个 激 活 步 的 激 活 状 态 并 暂 停 转 换 的 计 算 ) ， 存 储 程 序 步 的 状 态 ， 以 便 能 重 新 启 动 程 序 。 子 程 序 的 所 有 下 级 程 序 也 被 冻 结 。

重 新 启 动	(GRST) 通 过 重 新 启 动 所 有 的 暂 停 步 ， 重 新 启 动 一 个 被 冻 结 的 S F C 程 序 。 该 程 序 的 子 程 序 不 能 自 动 地 重 新 启 动 。

获 得 状 态	(GSTATUS) 获 得 一 个 子 程 序 的 当 前 状 态 ( 激 活 、 非 激 活 或 冻 结 ) .


 LD 语 言

梯 形 图  (LD) 是 布 尔 方 程 式 的 一 种 图 形 表 示 法。 它 把 触 点 （ 输 入 自 变 量 ） 与 线 圈 （ 输 出 结 果 ） 组 合 在 一 起。 LD 语 言 通 过 把 图 形 符 号 放 入 程 序 图 表 内 的 方 法 ， 使 得 对 测 试 的 描 述 和 对 布 尔 数 据 的 修 改 成 为 可 能 。 LD 图 表 符 号 在 程 序 图 表 内 恰 好 组 成 了 一 个 电 气 接 点 图 。 梯 形 图 的 左 ， 右 侧 被 连 接 到 垂 直 的 电 源 线。

电 源 线 和 连 接 线

多 路 连 接

基 本 的 L D 触 点 和 线 圈

返 回 语 句

跳 转 和 标 号

LD 中 的 块

下 面 是 一 个 梯 形 图 的 一 些 基 本 图 形 元 件 :

左 侧 垂 直 电 源 线

右 侧 垂 直 电 源 线

水 平 连 接 线

垂 直 连 接 线

多 路 连 接 线 ( 所 有 的 线 连 接 在 一 起 )

与 一 个 变 量 相 关 的 触 点

与 一 个 输 出 变 量 或 一 个 内 部 变 量 相 关 的 线 圈


电 源 线 连 接 线

一 个 梯 形 图 的 左 右 两 端 被 两 条 垂 直 线 所 限 定 ， 这 两 条 垂 直 线 被 分 别 命 名 为 左 侧 电 源 线 和 右 侧 电 源 线 。

用 连 接 线 把 梯 形 图 的 图 形 符 号 与 电 源 线 或 其 它 符 号 连 接 起 来 。 连 接 线 是 水 平 的 或 垂 直 的 。

每 条 线 段 有 一 个 布 尔 状 态   F A L S E 或 T R U E .   所 有 直 接 连 接 在 一 起 的 线 段 都 有 相 同 的 布 尔 状 态 。 与 左 侧 垂 直 电 源 线 相 连 的 任 一 水 平 线 都 为 T R U E 状 态 。


多 路 连 接

单 根 水 平 连 接 线 的 布 尔 状 态 在 线 的 左 右 两 端 是 相 同 的 。 把 水 平 和 垂 直 连 接 线 组 合 在 一 起 ， 就 能 建 立 多 路 连 接 。 在 一 个 多 路 连 接 中 ， 各 端 口 的 布 尔 状 态 遵 循 逻 辑 规 则 。

一 个 左 侧 多 路 连 接 可 把 与 一 根 垂 直 线 的 左 侧 相 连 的 多 根 水 平 线 和 一 根 与 垂 直 线 右 侧 相 连 的 线 连 接 在 一 起 。 右 端 的 布 尔 状 态 是 所 有 左 端 口 之 间 的 逻 辑 或 （ OR ）

( * 左 侧 多 路 连 接 举 例* )

( *   右 端 状 态 是   ( v 1   O R   v 2   O R   v 3 )* )

一 个 右 侧 多 路 连 接 可 把 一 根 与 垂 直 线 的 左 侧 相 连 的 水 平 线 和 多 根 与 垂 直 线 右 侧 相 连 的 线 连 接 在 一 起 。 左 端 的 布 尔 状 态 被 传 送 到 右 侧 的 每 一 个 端 口 。

( * 右 侧 多 路 连 接 举 例 * )

(* ST 等 价: *)

output1 := input1;

output2 := input1;

一 个 左 侧 和 右 侧 的 多 路 连 接 可 把 与 一 根 垂 直 线 的 左 侧 相 连 的 多 根 水 平 线 和 多 根 与 垂 直 线 右 侧 相 连 的 线 连 接 在 一 起 。 右 侧 每 一 个 端 口 的 布 尔 状 态 是 所 有 左 端 口 之 间 的 逻 辑 或 （ O R ）

( * 左 右 侧 多 路 连 接 举 例 * )

(* ST 等 价: *)

output1 := input1 OR input2;

output2 := input1 OR input2;

output3 := input1 OR input2;


基 本 的 LD 触 点 和 线 圈

有 以 下 几 个 符 号 可 供 用 于 输 入 触 点：

触 点

反 向 触 点

带 上 升 沿 检 测 的 触 点

带 下 降 沿 检 测 的 触 点

有 以 下 几 个 符 号 可 供 用 于 输 出 触 点 :

线 圈

反 向 线 圈

置 位 线 圈

复 位 线 圈

带 上 升 沿 检 测 的 线 圈

带 下 降 沿 检 测 的 线 圈

变 量 名 称 写 在 所 有 这 些 图 形 符 号 的 上 面:


触 点

一 个 触 点  能 在 一 个 连 接 线 状 态 和 一 个 布 尔 变 量 之 间 实 现 布 尔 操 作 。

触 点 右 侧 连 接 线 的 状 态 是 左 连 接 线 的 状 态 和 与 触 点 有 关 的 变 量 之 间 的 逻 辑 与 。

(* 使 用 触 点 举 例*)

(* ST 等 价: *)

output1 := input1 AND input2;


反 向 触 点

一 个 反 向 触 点  能 在 一 个 连 接 线 状 态 和 一 个 布 尔 变 量 求 反 之 间 实 现 布 尔 操 作 。

触 点 右 侧 连 接 线 的 状 态 是 左 连 接 线 的 状 态 和 与 触 点 有 关 的 变 量 值 布 尔 求 反 之 间 的 逻 辑 与 。

(* 使 用 反 向 触 点 举 例 *)

(* ST 等 价 *)

output1 := NOT (input1) AND NOT (input2);


带 上 升 沿 检 测 的 触 点

这 个 触 点 ( 正 向 ) 能 在 一 个 连 接 线 状 态 和 一 个 布 尔 变 量 的 上 升 沿 之 间 实 现 布 尔 操 作。

当 左 侧 连 接 线 的 状 态 为 “真” 时 ， 并 且 有 关 变 量 的 状 态 从 “假” 上 升 到 “真” ， 触 点 右 侧 连 接 线 的 状 态 被 设 定 为 “真”。 。 在 所 有 其 它 情 况 下 ， 变 量 被 复 位 为 “假”

(* 使 用 上 升 沿 触 点 举 例 *)

(* ST 等 价 *)

output1 := input1 AND (input2 AND NOT (input2prev));

(* input2prev 是 前 一 个 循 环 input2 的 值 *)


带 下 降 沿 检 测 的 触 点

这 个 触 点 ( 反 向 ) 能 在 一 个 连 接 线 状 态 和 一 个 布 尔 变 量 的 下 降 沿 之 间 实 现 布 尔 操 作 。

当 左 侧 连 接 线 的 状 态 为 “真” 时 ， 并 且 有 关 变 量 的 状 态 从 “真” 下 降 到 “假”， 触 点 右 侧 连 接 线 的 状 态 被 设 定 为 “真”。 。 在 所 有 其 它 情 况 下 ， 变 量 被 复 位 为 “假” 。

(* 使 用 下 降 沿 触 点 举 例 *)

(* ST 等 价 *)

output1 := input1 AND (NOT (input2) AND input2prev);

(* input2prev 是 前 一 个 循 环 input2 的 值 *)


线 圈

线 圈 能 实 现 一 个 连 接 线 布 尔 状 态 的 一 个 布 尔 输 出。

用 左 侧 连 接 的 布 尔 状 态 给 有 关 的 变 量 赋 值 。 左 侧 连 接 的 状 态 被 传 送 到 右 侧 连 接 。 右 侧 连 接 可 以 与 右 侧 的 垂 直 电 源 线 相 连 。

有 关 的 布 尔 变 量 必 须 是 输 出 或 内 部 变 量 。

有 关 的 名 称 可 以 是 程 序 名 ( 仅 用 于 子 程 序 ) 。 该 名 称 与 子 程 序 返 回 值 所 规 定 的 名 称 一 致 。

(* 使 用 线 圈 举 例  *)

(* ST 等 价 *)

output1 := input1;

output2 := input1;


反 向 线 圈

反 向 线 圈  能 根 据 一 个 连 接 线 状 态 的 布 尔 求 反 实 现 一 个 布 尔 输 出 。

用 左 侧 连 接 状 态 的 布 尔 求 反 给 有 关 的 变 量 赋 值 。 左 侧 连 接 的 状 态 被 传 送 到 右 侧 连 接 。 右 侧 连 接 可 以 与 右 侧 的 垂 直 电 源 线 相 连 。

有 关 的 布 尔 变 量 必 须 是 输 出 或 内 部 变 量 。

有 关 的 名 称 可 以 是 程 序 名 ( 仅 用 于 子 程 序 )。 该 名 称 与 子 程 序 返 回 值 所 规 定 的 名 称 一 致 。

(* 使 用 反 向 线 圈 举 例 *)

(* ST 等 价 *)

output1 := NOT (input1);

output2 := input1;


置 位 线 圈

" 置 位 " 线 圈 可 实 现 一 个 连 接 线 布 尔 状 态 的 一 个 布 尔 输 出 。

当 左 侧 连 接 的 布 尔 状 态 变 成 TRUE 时 ， 有 关 的 变 量 被 设 置 为 TRUE 。 输 出 变 量 一 直 保 持 该 数 值 ， 直 到 由 一 个 ” 复 位 ” 线 圈 产 生 一 个 相 反 的 命 令 。 左 侧 连 接 的 状 态 被 传 送 到 右 侧 连 接 。 右 侧 连 接 可 以 与 右 侧 的 垂 直 电 源 线 相 连 。

有 关 的 布 尔 变 量 必 须 是 输 出 或 内 部 变 量 。

(*使 用 “置 位” 和 “复 位” 线 圈 举 例*)

(* ST 等 价 *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


复 位 线 圈

" 复 位 " 线 圈  可 实 现 一 个 连 接 线 布 尔 状 态 的 一 个 布 尔 输 出 。

当 左 侧 连 接 的 布 尔 状 态 变 成 T R U E 时 ， 有 关 的 变 量 被 复 位 为 F A L S E 。 输 出 变 量 一 直 保 持 该 数 值 ， 直 到 由 一 个 ” 置 位 ” 线 圈 产 生 一 个 相 反 的 命 令 。 左 侧 连 接 的 状 态 被 传 送 到 右 侧 连 接 。 右 侧 连 接 可 以 与 右 侧 的 垂 直 电 源 线 相 连 。

有 关 的 布 尔 变 量 必 须 是 输 出 或 内 部 变 量 。

(*使 用 “置 位” 和 “复 位” 线 圈 举 例 *)

(* ST 等 价 *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


带 上 升 边 缘 检 测 的 线 圈

" 正 向" 线 圈  可 实 现 一 个 连 接 线 布 尔 状 态 的 一 个 布 尔 输 出 。 这 种 类 型 的 线 圈 只 在 快 捷 梯 形 图 编 辑 器 使 用。

当 左 侧 连 接 的 布 尔 状 态 从 FALSE 上 升 到 TRUE 时 ， 有 关 的 变 量 被 置 为 TRUE 。 在 所 有 其 他 情 况 下 ， 输 出 变 量 复 位 为 FALSE 。 左 侧 连 接 的 状 态 被 传 送 到 右 侧 连 接 。 右 侧 连 接 可 以 与 右 侧 的 垂 直 电 源 线 相 连 。

有 关 的 布 尔 变 量 必 须 是 输 出 或 内 部 变 量 。

(*使 用 一 个 "正 向 " 线 圈 举 例 *)

(* ST 等 价 *)

IF (input1 and NOT(input1prev)) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(* input1prev 是 前 一 个 循 环 input1 的 值 *)


带 下 降 边 缘 检 测 的 线 圈

" 反 向 " 线 圈  可 实 现 一 个 连 接 线 布 尔 状 态 的 一 个 布 尔 输 出 。 这 种 类 型 的 线 圈 只 在 快 捷 梯 形 图 编 辑 器 使 用 。

当 左 侧 连 接 的 布 尔 状 态 从 “真” 下 降 到 “假” 时 ， 有 关 的 变 量 被 置 为 “真” 。 在 所 有 其 他 情 况 下 ， 输 出 变 量 复 位 为 “假”。 左 侧 连 接 的 状 态 被 传 送 到 右 侧 连 接 。 右 侧 连 接 可 以 与 右 侧 的 垂 直 主 线 相 接 。

有 关 的 布 尔 变 量 必 须 是 输 出 或 内 部 变 量 。

(* 使 用 一 个 "反 向" 线 圈 举 例*)

(* ST 等 价 *)

IF (NOT(input1) and input1prev) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(* input1prev 是 前 一 个 循 环 input1 的 值 *)


返 回 语 句

返 回  标 号 可 被 用 作 一 个 输 出 ， 它 表 示 该 程 序 的 一 个 有 条 件 的 结 束 。 在 一 个 返 回 符 号 的 右 侧 不 能 进 行 连 接 。

如 果 左 侧 连 接 线 的 布 尔 状 态 为 “真” ， 那 么 程 序 结 束 ， 不 执 行 之 后 的 程 序 行 。

注 意 : 当 L D 程 序 是 一 个 子 程 序 时， 为 了 设 置 返 回 值 （ 返 回 到 调 用 程 序 ） ， 它 的 名 称 必 须 与 输 出 线 圈 有 关 。

(* 使 用 返 回 符 号 举 例   *)

(* ST 等 价 *)

If Not (manual_mode) Then RETURN; End_if;

result := (input1 OR input3) AND input2;


跳 转 和 标 号

标 号 ， 有 条 件 的 和 无 条 件 的 跳 转 符 号 ， 可 被 用 于 控 制 梯 形 图 的 执 行 。 在 标 号 和 跳 转 符 号 的 右 侧 不 能 进 行 连 接 。 此 时 将 使 用 下 列 符 号 :

>>LAB	跳 转 到 标 号 被 称 为 "LAB"

LAB:	标 号 被 称 为 "LAB"

如 果 跳 转 符 号 的 左 侧 连 接 的 布 尔 状 态 为 “真”， 那 么 在 标 号 符 之 后 的 程 序 被 执 行。

(*使 用 跳 转 和 标 号 符 举 例 *)

(* IL 等 价: *)

ldn	manual_mode

jmpc	other

ld	input1

st	result

jmp	END

OTHER:	ld	input2

st	result

END:	(* 结 束 程 序 *)


LD 中 的 块

使 用 快 捷 LD 编 译 器 可 把 功 能 框 与 布 尔 线 相 连 。 一 个 功 能 实 际 上 可 以 是 一 个 操 作 符 ， 一 个 功 能 块 或 一 个 功 能 。 由 于 所 有 的 方 块 不 总 是 有 一 个 布 尔 输 入 和 / 或 一 个 布 尔 输 出 ， 所 以 把 方 块 插 入 梯 形 图 时 ， 会 给 方 块 接 口 附 加 新 的 参 数 EN ,   ENO 。 如 果 你 使 用FBD / LD 编 辑 器 ， 则 不 会 加 入 EN ， ENO 参 数 ， 因 为 你 可 以 连 接 具 有 所 需 类 型 的 变 量 。

“EN” 输 入

“ENO” 输 出

同 时 使 用 “EN” 和 “ENO”


“EN” 输 入

在 某 些 操 作 符、 功 能 或 功 能 块 上， 第 一 个 输 入 不 是 布 尔 数 据 类 型 。 因 为 第 一 个 输 入 必 须 总 是 与 梯 级 相 连 ， 所 以 被 称 为 “EN” 的 另 一 个 输 入 被 自 动 插 入 到 第 一 个 位 置 。 只 有 EN 输 入 为 “真” 时 ， 块 才 被 执 行。 下 面 是 一 个 比 较 操 作 符 的 例 子 以 及 用 ST 语 言 表 示 的 等 效 代 码：

	IF rung_state THEN    q := (value1 > value 2); ELSE    q := FALSE; END_IF; (* continue rung with q state *)


“ENO” 输 出

在 某 些 操 作 符、 功 能 或 功 能 块 上， 第 一 个 输 出 不 是 布 尔 数 据 类 型 。 因 为 第 一 个 输 出 必 须 总 是 与 梯 级 相 连 ， 所 以 被 称 为 “ENO” 的 另 一 个 输 出 被 自 动 插 入 到 第 一 个 位 置 。 ENO 输 出 总 是 与 方 块 的 第 一 个 输 入 处 于 同 样 的 状 态。 下 面 是 一 个 带 有 平 均 功 能 块 的 例 子 以 及 用 ST 语 言 表 示 的 等 效 代 码：

	AVERAGE(rung_state, Signal, 100); OutSignal := AVERAGE.XOUT; eno := rung_state; (* continue rung with eno state *)


同 时 使 用 “EN” 和 “ENO”

在 某 些 情 况 下 需 要 同 时 使 用 EN 和 ENO。 下 面 是 一 个 带 有 运 算 操 作 符 的 例 子 以 及 用 ST 语 言 表 示 的 等 效 代 码：

	IF rung_state THEN    result := (value1 + value2); END_IF; eno := rung_state; (* continue rung with eno state *)


 标 准 运 算 符， 功 能 块 与 函 数

标 准 运 算 符

标 准 功 能 块

标 准 函 数

按 字 母 排 序 的 索 引


标 准 运 算 符

下 列 是 符 合 IEC 标 准 语 言 的 标 准 运 算 符。

数 据 处 理:

1 gain	赋 值

Neg	模 拟 量 求 反

布 尔 运 算:

& (AND)	布 尔 逻 辑 与

>=1 (OR)	布 尔 逻 辑 或

=1 (XOR)	布 尔 逻 辑 异 或

算 术 运 算:

 + 	加

 - 	减

 * 	乘

 / 	除

逻 辑 运 算:

AND_MASK	模 拟 量 逐 位 与 屏 蔽

OR_MASK	模 拟 量 逐 位 或 屏 蔽

XOR_MASK	模 拟 量 逐 位 异 或 屏 蔽

NOT_MASK	逐 位 求 反

比 较 测 试 运 算:

 < 	小 于

 <= 	小 于 或 等 于

 > 	大 于

 >= 	大 于 或 等 于

 = 	等 于

 <> 	不 等 于

数 据 变 换:

BOO	变 换 为 布 尔 型

ANA	变 换 为 整 型 模 拟 量

实 型	变 换 为 实 型 模 拟 量

TMR	变 换 为 定 时 器 型

信 息	变 换 为 信 息

其 它:

CAT	信 息 串 联

SYSTEM	系 统 访 问

OPERATE	操 作 I/O 通 道


1 gain 赋 值

参 数:

IN	任 何 类 型

Q	任 何 类 型

说 明 :

将 一 个 变 量 赋 值 给 另 一 个 变 量

此 模 块 对 于 将 图 表 的 输 入 直 接 连 接 到 图 表 的 输 出 非 常 有 用 。 它 也 可 用 于 转 化 图 表 输 出 的 状 态（需 要 一 个 布 尔 求 反 的 连 接） 。

(* 赋 值 块 的FBD 例 子 *)

(* 等 价 的 ST 语 言 程 序 : *)

ao23 := ai10;

bo100 := NOT (bi1 AND bi2);

(* 等 价 的 IL 语 言 程 序: *)

LD	ai10

ST 	ao23

LD	bi1

AND	bi2

STN	bo100


NEG 模 拟 量 求 反

参 数:

IN	整 型-实 型 	输 入 和 输 出 的 类 型 必 须 相 同

Q	整 型-实 型

说 明:

对 变 量 求 反

(*求 反 模 块 的FBD 例 子 *)

(*等 价 的 ST 语 言 程 序: *)

ao23 := - (ai10);

ro100 := - (ri1 + ri2);

(*等 价 的 IL 语 言 程 序: *)

LD	ai10

MUL	-1

ST 	ao23

LD	ri1

ADD	ri2

MUL	-1.0

ST	ro100


& AND 布 尔 逻 辑 与

注 意 ： 这 个 运 算 符 的 输 入 可 以 扩 展 到 两 个 以 上 。

参 数 :

(输 入)	布 尔

输 出	布 尔	输 入 项 的 布 尔 逻 辑 与

说 明 :

对 两 个 或 更 多 的 输 入 进 行 布 尔 逻 辑 与 运 算 。

(*“AND” 块 的 FBD 例 子 *)

(*等 价 的 ST 语 言 程 序: *)

bo10 := bi101 AND NOT (bi102);

bo5 := (bi51 AND bi52) AND bi53;

(*等 价 的 IL 语 言 程 序 *)

LD	bi101	(* 当 前 结 果 := bi101 *)

ANDN	bi102	(* 当 前 结 果 := bi101 AND not(bi102) *)

ST	bo10	(* bo10 := 当 前 结 果 *)

LD	bi51	(* 当 前 结 果 := bi51;

&	bi52	(* 当 前 结 果 := bi51 AND bi52 *)

&	bi53	(* 当 前 结 果 := (bi51 AND bi52) AND bi53 *)

ST	bo5	(* bo5 := 当 前 结 果 *)


>=1 OR 布 尔 逻 辑 或

注 意 ： 此 运 算 的 输 入 可 以 扩 展 到 两 个 以 上 。

参 数 :

( 输 入 )	布 尔

输 出	布 尔	输 入 的 布 尔 逻 辑 或

说 明:

Boolean OR of two or more terms.

(*“OR” 块 的 FBD 例 子 *)

(* 等 价 的 ST 语 言 程 序 : *)

bo10 := bi101 OR NOT (bi102);

bo5 := (bi51 OR bi52) OR bi53;

(* 等 价 的 IL 语 言 程 序 : *)

LD	bi101

ORN	bi102

ST	bo10

LD	bi51

OR	bi52

OR	bi53

ST	bo5


=1 XOR 布 尔 逻 辑 异 或

参 数:

IN1	布 尔

IN2	布 尔

Q	布 尔	两 个 输 入 项 的 布 尔 逻 辑 异 或

说 明 :

对 两 个 输 入 求 布 尔 逻 辑 异 或 。

(*“XOR” 块 的 FBD 例 子：*)

(*等 价 的 ST 语 言 程 序: *)

bo10 := bi101 XOR NOT (bi102);

bo5 := (bi51 XOR bi52) XOR bi53;

(*等 价 的 IL 语 言 程 序: *)

LD	bi101

XORN	bi102

ST	bo10

LD	bi51

XOR	bi52

XOR	bi53

ST	bo5


+ 加

注 意 ： 此 运 算 的 输 入 可 以 扩 展 到 两 个 以 上 。

参 数:

( 输 入 )	实 型 -整 型	可 以 是 整 型 或 实 型 数 据

( 所 有 输 入 必 须 类 型 相 同 )

输 出	实 型 -整 型	输 入 的 带 符 号 加

说 明:

对 两 个 或 以 上 的 模 拟 变 量 做 加 法 。

(* 加 法 模 块 的 FBD 例 子: *)

(* 等 价 的 ST 语 言 程 序 : *)

ao10 := ai101 + ai102;

ao5 := (ai51 + ai52) + ai53;

(* 等 价 的 IL 语 言 程 序 : *)

LD	ai101

ADD	ai102

ST	ao10

LD	ai51

ADD	ai52

ADD	ai53

ST	ao5


- 减

参 数:

IN1	整 型-实 型	  可 以 是 整 型 或 实 型 数 据

IN2	整 型-实 型	  （ IN1 和 IN2 必 须 同 类 型 )

Q	整 型-实 型	  减 法 结 果 （ 第 一 个 - 第 二 个 ）

说 明:

对 两 个 模 拟 变 量 做 减 法 （第一个 - 第二个）。

(* 减 法 模 块 的 FBD 例 子: *)

 (* 等 价 的 ST 语 言 程 序 : *)

ao10 := ai101 - ai102;

ao5 := (ai51 - 1) - ai53;

(* 等 价 的 IL 语 言 程 序: *)

LD	ai101

SUB	ai102

ST	ao10

LD	ai51

SUB	1

SUB	ai53

ST	ao5


* 乘

注意：此 运 算 的 输 入 可 以 扩 展 到 两 个 以 上。

参 数:

( 输 入 )	整 型 实 型	可 以 是 整 型 或 实 型 数 据

( 所 有 输 入 必 须 类 型 相 同 )

输 出	整 型 -实 型	输 入 的 带 符 号 乘 法

说 明:

两 个 或 以 上 模 拟 变 量 的 乘 积

(* 乘 法 模 块 的 FBD 例 子：*)

(*等 价 的 ST 语 言 程 序: *)

ao10 := ai101 * ai102;

ao5 := (ai51 * ai52) * ai53;

(*等 价 的 IL 语 言 程 序： *)

LD	ai101

MUL	ai102

ST	ao10

LD	ai51

MUL	ai52

MUL	ai53

ST	ao5


/ 除

参 数:

IN1	整 型-实 型	可 以 是 整 型 或 实 型 （ 被 除 数 ）

IN2	整 型-实 型	非 零 的 模 拟 值 （ 除 数 ）

( IN1 和 IN2 必 须 同 类 型 )

Q	整 型-实 型	IN1 被 IN2 带 符 号 除

说 明:

对 两 个 变 量 做 除 法 （ 第 一 个 被 第 二 个 除 ） 。

(* 除 法 块 的 FBD 例 子：*)

(* 等 价 的 ST 语 言 程 序: *)

ao10 := ai101 / ai102;

ao5 := (ai5 / 2) / ai53;

(* 等 价 的 IL 语 言 程 序：*)

LD	ai101

DIV	ai102

ST	ao10

LD	ai51

DIV	2

DIV	ai53

ST	ao5


AND_MASK 模 拟 量 逐 位 与 屏 蔽

参 数:

IN	整 型	必 须 是 整 型 格 式

MSK	整 型	必 须 是 整 型 格 式

Q	整 型	IN 和MSK 之 间 逐 位 逻 辑 与 运 算

说 明:

整 型 模 拟 值 进 行 逐 位 的 与 运 算 。

(*AND_MASK块的FBD例子：*)

(* 等 价 的 ST 语 言 程 序 ：*)

parity := AND_MASK (xvalue, 1); (*如 果xvalue 为 奇 数 则 为 1  *)

result := AND_MASK (16#abc, 16#f0f); (*等 于 16#a0c *)

(*等 价 的 IL 语 言 程 序: *)

LD	xvalue

AND_MASK	1

ST	parity

LD	16#abc

AND_MASK	16#f0f

ST	result


OR_MASK 模 拟 量 逐 位 或 屏 蔽

参 数:

IN	整 型	必 须 是 整 型 格 式

MSK	整 型	必 须 是 整 型 格 式

Q	整 型	IN 和MSK 之 间 的 逐 位 逻 辑 或

说 明:

对 整 型 模 拟 值 进 行 逐 位 或 运 算 。

(*OR_MASK 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序: *)

is_odd := OR_MASK (xvalue, 1); (* makes value always odd *)

result := OR_MASK (16#abc, 16#f0f); (* equals 16#fbf *)

(*等 价 的 IL 语 言 程 序 *)

LD	xvalue

OR_MASK	1

ST	is_odd

LD	16#abc

OR_MASK	16#f0f

ST	result


XOR_MASK 模 拟 量 逐 位 异 或 屏 蔽

参 数:

IN	整 型	必 须 是 整 型 格 式

MSK	整 型	必 须 是 整 型 格 式

Q	整 型	IN 和MSK 之 间 逐 位 逻 辑 异 或

说 明 ：

对 整 型 模 拟 值 逐 位 进 行 异 或 的 位 屏 蔽 运 算 。

(* XOR_MASK 块 的FBD 例 子： *)

(*等 价 的 ST 语 言 程 序: *)

crc32 := XOR_MASK (prevcrc, nextc);

result := XOR_MASK (16#012, 16#011); (* equals 16#003 *)

(* 等 价 的 IL 语 言 程 序: *)

LD	prevcrc

XOR_MASK	nextc

ST	crc32

LD	16#012

XOR_MASK	16#011

ST	result


NOT_MASK 逐 位 求 反

参 数  :

IN	整 型	必 须 是 整 型 格 式

Q	整 型	IN 的 32 位 数 据 逐 位 求 反

说 明:

整 型 模 拟 值 的 逐 位 求 反 。

(*NOT_MASK 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 *)

result := NOT_MASK (16#1234);

(* result is 16#FFFF_EDCB *)

(* 等 价 的 IL 语 言 程 序：*)

LD	16#1234

NOT_MASK

ST	result


< 小 于

参 数:

IN1	整 型- 实 型-

定 时 器  信 息

IN2	整 型- 实 型

定 时 器 -信 息	两 个 输 入 的 类 型 必 须 相 同

Q	如 果 IN1 < IN2 ， 布 尔 状 态 为 真

说 明:

测 试 一 个 值 是 否 小 于 另 一 个 （ 模 拟 ， 定 时 器 或 信 息 ）

(*“小于” 块 的FBD 例 子： *)

(*等 价 的 ST 语 言 程 序: *)

aresult := (10 < 25); (* aresult is “ 真 ”*)

mresult := ('z' < 'B'); (* mresult is “ 假 ”*)

(*等 价 的 IL 语 言 程 序： *)

LD	10

LT	25

ST	aresult

LD	'z'

LT	'B'

ST	mresult


<= 小 于 等 于

参 数:

IN1	整 型-实 型-信 息

IN2	整 型-实 型-信 息	两 个 输 入 的 类 型 必 须 相 同

Q	如 果 IN1 <= IN2 ， 布 尔 状 态 为 真

说 明 ：

测 试 一 个 值 是 否 小 于 或 等 于 另 一 个 （ 模 拟 ， 或 信 息 ）

(*“小于或等于”块的FBD例子：*)

(*等 价 的 ST 语 言 程 序  *)

aresult := (10 <= 25); (* aresult is “ 真 ”*)

mresult := ('ab' <= 'ab'); (* mresult is “ 真 ” *)

(* 等 价 的 IL 语 言 程 序：*)

LD	10

LE	25

ST	aresult

LD	'ab'

LE	'ab'

ST	mresult


> 大 于

参 数:

IN1	整 型 -实型

定 时 器-信 息

IN2	整 型-实 型-

定 时 器- 信 息	两 个 输 入 的 类 型 必 须 相 同

Q	如 果 IN1 > IN2 ， 布 尔 状 态 为 真

说 明:

测 试 一 个 值 是 否 大 于 或 等 于 另 一 个 （ 模 拟 量 ， 定 时 器 或 信 息 ）

(*“大 于” 块 的FBD 例 子： *)

(*等 价 的 ST 语 言 程 序 ：*)

aresult := (10 > 25); (* aresult is “ 假 ” *)

mresult := ('ab' > 'a'); (* mresult is “ 真 ” *)

(* 等 价 的 IL 语 言 程 序： *)

LD	10

GT	25

ST	aresult

LD	'ab'

GT	'a'

ST	mresult


>= 大 于 或 等 于

参 数:

IN1	整 型-实 型-信 息

IN2	整 型-实 型-信 息 	两 个 输 入 的 类 型 必 须 相 同

Q	如 果 IN1 >= IN2， 布 尔 状 态 为 真

说 明:

测 试 一 个 值 是 否 大 于 或 等 于 另 一 个 （ 模 拟 量 ， 或 信 息 ）

(*“大 于 或 等 于” 块 的FBD 例 子： *)

(*等 价 的 ST 语 言 程 序 ： *)

aresult := (10 >= 25); (* aresult is FALSE *)

mresult := ('ab' >= 'ab'); (* mresult is TRUE *)

(*等 价 的 IL 语 言 程 序：*)

LD	10

GE	25

ST	aresult

LD	'ab'

GE	'ab'

ST	mresult


= 等 于

参 数:

IN1	整 型-实 型-信 息

IN2	整 型-实 型-信 息 	两 个 输 入 的 类 型 必 须 相 同

Q	如 果 IN1 >= IN2 ， 布 尔 状 态 为 真

说 明:

测 试 一 个 值 是 否 大 于 或 等 于 另 一 个 （ 模 拟 量 ， 或 信 息 ）

(*“等 于” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 *)

aresult := (10 = 25); (* aresult is 假 *)

mresult := ('ab' = 'ab'); (* mresult is 真  *)

(*等 价 的 IL 语 言 程 序： *)

LD	10

EQ	25

ST	aresult

LD	'ab'

EQ	'ab'

ST	mresult


<> 不 等 于

参 数

IN1	整型-实 型-信 息

IN2	整型-实 型-信 息 	两 个 输 入 的 类 型 必 须 相 同

Q	如 果 第 一 个 <> 第 二 个 ， 布 尔 状 态 为 真

说 明

测 试 一 个 值 是 否 不 等 于 另 一 个 （ 模 拟 量 ， 或 信 息 ）

(*“不 等 于” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 ：*)

aresult := (10 <> 25); (* aresult is “ 真 ” *)

mresult := ('ab' <> 'ab'); (* mresult is “ 假 ” *)

(*等 价 的 IL 语 言 程 序： *)

LD	10

NE	25

ST	aresult

LD	'ab'

NE	'ab'

ST	mresult


BOO 变 换 为 布 尔 型

参 数:

IN	任 意	任 意 非 布 尔 型 的 值

Q	布 尔	对 非 零 数 值 为 真

对 零 值 为 假

对 “ 真 ” 信 息 为 真

对 “ 假 ” 信 息 为 假

说 明:

把 任 意 类 型 的 变 量 变 换 为 布 尔 型

(*“变 换 到 布 尔 型” 块 的FBD 例 子： *)

(*等 价 的 ST 语 言 程 序 ：*)

ares := BOO (10);	(* ares 为 “ 真 ” *)

tres := BOO (t#0s);	(* tres  为 “ 假 ” *)

mres := BOO ('false');	(* mres  为 “ 假 ” *)

(* 等 价 的 IL 语 言 程 序： *)

LD	10

BOO

ST	ares

LD	t#0s

BOO

ST	tres

LD	'false'

BOO

ST	mres


ANA 变 换 为 整 型 模 拟 量

参 数:

IN	任 意	任 意 非 整 型 的 模 拟 值

Q	整 型	IN 为 假 则 为 零 / IN 为 真 则 为 1

以 毫 秒 表 示 的 定 时 器 值

实 型 模 拟 值 的 整 数 部 分

以 字 符 串 表 示 的 十 进 制 数

说 明:

将 任 意 类 型 的 变 量 变 换 为 整 型 模 拟 量

(*“变 换 为 模 拟 量” 块 的FBD 例 子： *)

(*等 价 的 ST 语 言 程 序: *)

bres := ANA (true);	(* bres is 1 *)

tres := ANA (t#1s46ms);	(* tres is 1046 *)

mres := ANA ('0198');	(* mres is 198 *)

(*等 价 的 IL 语 言 程 序: *)

LD	true

ANA

ST	bres

LD	t#1s46ms

ANA

ST	tres

LD	'0198'

ANA

ST	mres


REAL变 换 为 实 型

参 数 :

IN	布 尔 -整型-

定 时 器	任 意 非 实 型 的 模 拟 值 （ 非 信 息 ）

Q	实 型	IN 为 假 则 为 0.0 / IN 为 真 则 为 1.0

以 毫 秒 计 的 定 时 器 数 值

相 等 的 整 型 数 模 拟 值

说 明:

将 任 意 类 型 的 变 量 变 换 为 实 型

(*“变 换 为 实 型” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序: *)

bres := 实 型 (true);	(* bres 为 1.0 *)

tres := 实 型 (t#1s46ms);	(* tres 为 1046.0 *)

ares := 实 型 (198);	(* ares 为 198.0 *)

(*等 价 的 IL 语 言 程 序: *)

LD	true

REAL

ST	bres

LD	t#1s46ms

REAL

ST	tres

LD	198

实 型

ST	ares


TMR 变 换 为 定 时 器 型

参 数:

IN	整型-实 型	任 意 非 定 时 器 值

IN ( 若IN 为 实 型 ， 则 取IN 的 整 数 部 分 )

为 毫 秒 数

Q	定 时 器	IN 代 表 的 延 时 值

说 明:

将 任 意 的 模 拟 变 量 变 换 为 定 时 器 型

(*“变换 为 定 时 器 型” 块 的FBD 例 子：*)

 (*等 价 的 ST 语 言 程 序 ： *)

ares := TMR (1256);	(* ares := t#1s256ms *)

rres := TMR (1256.3);	(*rres := t#1s256ms *)

(* 等 价 的 IL 语 言 程 序：*)

LD	1256

TMR

ST	ares

LD	1256.3

TMR

ST	rres


MSG变 换 为 信 息

参 数:

IN	布 尔-

整型-实 型	任 意 非 信 息 的 值

Q	信 息	布 尔 逻 辑 的 “ 假 ” 或 “ 真 ” 状 态

如 果I N 为 模 拟 量 ， 则 为 十 进 制 表 示 的 数 字

说 明:

将 任 意 变 量 变 换 为 信 息

(*“变 换 为 信 息” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序: *)

bres := 信 息 (true); (* bres 为 ‘ 真 ’*)

ares := 信 息 (125); (* ares 为 ‘125 ’*)

(*等 价 的 IL 语 言 程 序： *)

LD	true

MSG

ST	bres

LD	125

MSG

ST	ares


CAT 信 息 串 联

注 意 ： 此 运 算 的 输 入 可 以 扩 展 到 两 个 以 上 。

参 数:

(输 入)	信 息	(所 有 输 入 信 息 相 加 后 的 长 度 不 得 超 过 输 出 信 息 的 最 大 长 度)

输 出	信 息	输 入 信 息 的 串 联

说 明:

将 几 个 信 息 串 成 一 个

(*“信 息 串 联” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 ： 使 用 + 运 算 符 **)

myname := ('Mr' + ' ') + 'Jones';

(* means: myname := 'Mr Jones' *)

(*等 价 的 IL 语 言 程 序： *)

LD	'Mr'

ADD	' '

ADD	'Jones'

ST	myname


SYSTEM 系 统 访 问

参 数:

Mode	整型	确 定 系 统 参 数 和 访 问 模 式

Arg	整型-定 时 器	“ 写 ” 访 问 的 新 值

Param	整型	所 访 问 参 数 的 值

说 明:

存 取 系 统 参 数

下 列 是SYSTEM 函数 的 变 量 命 令 （ 预 定 义 的 关 键 词 ） 列 表 ：

命 令	意 义

SYS_TALLOWED	读 允 许 的 循 环 周 期

SYS_TCURRENT	读 当 前 循 环 周 期

SYS_TMAXIMUM	读 最 大 循 环 周 期

SYS_TOVERFLOW	读 循 环 周 期 溢 出

SYS_TRESET	复 位 周 期 计 数 器

SYS_TWRITE	改 变 循 环 周 期

SYS_ERR_TEST	检 查 运 行 周 期 错 误

SYS_ERR_READ	读 最 早 的 运 行 周 期 错 误

下 列 是 执 行SYSTEM 函数 的 预 定 义 函数 所 须 的 参 数 ：

命 令	参 数	返 回 值

SYS_TALLOWED	0	允 许 的 循 环 周 期

SYS_TCURRENT	0	当 前 循 环 周 期

SYS_TMAXIMUM	0	检 测 到 的 最 大 循 环 周 期

SYS_TOVERFLOW	0	循 环 周 期 超 出 次 数

SYS_TRESET	0	0

SYS_TWRITE	新 的 允 许	写 入 的 时 间 值

循 环 周 期

SYS_ERR_TEST	0	如 果 未 检 测 到 错 误 则 为 0

SYS_ERR_READ	0	最 早 错 误 代 码

(*“系 统 访 问” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 ： *)

alarm := (SYSTEM (SYS_TOVERFLOW, 0) <> 0);

If (alarm) Then

nb_err := nb_err + 1;

rc := SYSTEM (SYS_TRESET, 0);

End_If;


OPERATE 操 作

参 数:

IO	任 意	输 入 或 输 出 变 量

Funct	整 型	执 行 的 操 作

Arg	整 型	I/O 操 作 的 参 数

Q	整 型	返 回 校 验

说 明:

访 问 I/O 通 道

OERATE 参 数 的 意 义 取 决 于 I/O 界 面 设 备 。 请 参 看 您 的 硬 件 手 册 或 相 应 的 I/O 板 技 术 注 释 以 了 解 有 关 OPERATE 函数 的 进 一 步 情 况 。


标 准 功 能 块

以 下 是 ISaGRAF 系 统 支 持 的 标 准 功 能 块 。 这 些 功 能 块 都 已 预 定 义 ， 并 不 需 要 在 库 中 声 明 。

布 尔 操 作:

SR	置 位 双 稳 态 触 发 器

RS	复 位 双 稳 态 触 发 器

R_TRIG	上 升 沿 检 测

F_TRIG	下 降 沿 检 测

SEMA	信 号 发 送 器

记 数:

CTU	上 升 计 数 器

CTD	下 降 计 数 器

CTUD	上 升 - 下 降 计 数 器

定 时 器:

TON	开 延 时 定 时

TOF	关 延 时 定 时

TP	脉 冲 定 时

整 型 模 拟 量:

CMP	比 较

STACKINT	整 型 堆 栈

实 型 模 拟 量:

AVERAGE	连 续 均 值

HYSTER	滞 后

LIM_ALRM	超 限 报 警

INTEGRAL	积 分

DERIVATE	微 分

信 号 发 生:

BLINK	闪 烁 信 号

SIG_GEN	信 号 发 生 器

注 意 ：  建 立 了 新 的 “C ” 函数 后 ， 就 可 以 从 FBD 语 言 程 序 中 调 用 它 。


SR 置 位 双 稳 态 触 发 器

参 数:

SET1	布 尔	如 果 为 “ 真 ” ， 将 Q1 置 位 为 “ 真 ” （ 优先 ）

RESET	布 尔	如 果 为 “ 真 ” ， 将 Q1 复 位 为 “ 假 ”

Q1	布 尔	布 尔 存 储 状 态

说 明:

置 位 双 稳 态 触 发 器 ； 参 看 下 列 真 值 表 ：

Set1 	Reset	Q1	输 出 结 果 Q1

0 	0	0	0

0	0	1	0

0	1	0	0

0	1	1	0

1	0	0	1

1	0	1	1

1	1	0	1

1	1	1	1

(* 使 用 “SR” 块 的FBD 例 子： *)

(*等 价 的 ST 语 言 程 序 ： 我 们 假 定 SR1 为 SR 块 的 一 个 实 例 *)

SR1((auto_mode & start_cmd), stop_cmd);

command := SR1.Q1;

(* 等 价 的 IL 语 言 程 序: *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command


RS 复 位 双 稳 态 触 发 器

参 数:

SET	布 尔	如 果 为 “ 真 ” ， 将 Q1 置 位 为 “ 真 ”

RESET1	布 尔	如 果 为 “ 真 ” ， 将 Q1 复 位 为 “ 假 ” （ 优 先 ）

Q1	布 尔	布 尔 存 储 状 态

说 明:

复 位 双 稳 态 触 发 器 ； 参 看 下 列 真 值 表 ：

Set 	Reset1	Q1	输 出 结 果Q1

0 	0	0	0

0	0	1	0

0	1	0	0

0	1	1	0

1	0	0	1

1	0	1	1

1	1	0	0

1	1	1	0

(*使 用 “RS” 块 的FBD 例 子 *)

(*等 价 的 ST 语 言 程 序 ： 我 们 假 定 RS1 为 RS 块 的 一 个 实 例*)

RS1(start_cmd, (stop_cmd OR alarm));

command := RS1.Q1;

(*等 价 的 IL 语 言 程 序: *)

LD	start_cmd

ST	RS1.set

LD	stop_cmd

OR	alarm

ST	RS1.reset1

CAL	RS1

LD	RS1.Q1

ST	command


R_TRIG 上 升 沿 检 测

参 数:

CLK	布 尔	任 何 布 尔 变 量

Q	布 尔	当 CLK 从 “ 假 ” 变 为 “ 真 ” 时 ， 输 出 为 “ 真 ”

其 它 情 况 下 为 “ 假 ”

说 明:

检 测 布 尔 变 量 的 上 升 沿 跳 变

(*“R_TRIG”块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 ： 我 们 假 定 R_TRIG1 是 R_TRIG 块 的 一 个 实 例 *)

R_TRIG1(cmd);

nb_edge := ANA(R_TRIG1.Q) + nb_edge;

(*等 价 的 IL 语 言 程 序: *)

LD	cmd

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


F_TRIG 下 降 沿 检 测

参 数:

CLK	布 尔	任 何 布 尔 变 量

Q	布 尔	当 CLK 从 “ 真 ” 变 为 “ 假 ” 时 ， 输 出 为 “ 真 ”

其 它 情 况 下 为 “ 假 ”

说 明:

检 测 布 尔 变 量 的 下 降 沿

(*“F_TRIG” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 ： 我 们 假 定 F_TRIG1 是 F_TRIG 块 的 一 个 实 例 *)

F_TRIG1(cmd);

nb_edge := ANA(F_TRIG1.Q) + nb_edge;

(* 等 价 的 IL 语 言 程 序: *)

LD	cmd

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


SEMA 信 号 发 送 器

参 数:

CLAIM	布 尔	“测 试 和 置 位” 命 令

RELEASE	布 尔	释 放 信 号

BUSY	布 尔	信 号 状 态

说 明:

(* "x" 是 一 个 初 始 化 为 “ 假 ” 的 布 尔 变 量*)

busy := x;

If claim Then

x := True;

Else

If release Then

busy := False;

x := False;

End_if;

End_if;


CTU 上 升 计 数 器

参 数:

CU	布 尔	计 数 输 入 （ 当 CU 为 ‘ 真 ’ 时 计 数 ）

RESET	布 尔	复 位 命 令 （ 优 先 ）

PV	整 型	可 编 程 的 最 大 值

Q	布 尔	溢 出 ： 当 CV = PV 时 为 “ 真 ”

CV	整 型	计 数 器 当 前 结 果

警 告 ： CTU 块 不 能 检 测 计 数 输 入 （CU） 的 上 升 或 下 降 沿， 它 必 须 与 “ R_TRIG ” 或 “ R_TRIG ” 块 组 合 起 来 才 能 成 为 一 个 脉 冲 计 数 器 。

说 明:

从 0 开 始 以 1 为 步 长 计 （ 整 型 ） 数

(*“CTU” 块 的FBD 例 子：*)

(*等 价 的 ST 语 言 程 序 ： 我 们 假 定 R_TRIG1 是 R_TRIG 块 的 一 个 实 例 ； CTU1 是 CTU 块 的 一 个 实 例*)

CTU1(R_TRIG1(command),NOT(auto_mode),100);

overflow := CTU1.Q;

result := CTU1.CV;

(*等 价 的 IL 语 言 程 序: *)

LD	command

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTU1.cu

LDN	auto_mode

ST	CTU1.reset

LD	100

ST	CTU1.pv

CAL	CTU1

LD	CTU1.Q

ST	overflow

LD	CTU1.cv

ST	result


CTD 下 降 计 数 器

参 数:

CD	布 尔	计 数 输 入

(当 CD 为 ‘ 真 ’ 时 下 降 计 数)

LOAD	布 尔	装 入 命 令 （ 优 先 ）

(当 LOAD 为 ‘ 真 ’ 时 ， 使 CV = PV)

PV	整 型	可 编 程 的 初 始 值

Q	布 尔	下 溢 ： 当 CV = 0 时 为 “ 真 ”

CV	整 型	计 数 结 果

警 告 ： CTD 块 不 能 检 测 计 数 输 入 （ CD ） 的 上 升 或 下 降 沿 ， 它 必 须 与 “ R_TRIG ” 或 “ R_TRIG ” 块 组 合 起 来 才 能 成 为 一 个 脉 冲 计 数 器 。

说 明:

从 给 定 值 开 始 向 下 以 1 为 步 长 计 （ 整 型 ） 数

(*“CTD” 块 的FBD 例 子： *)

 (*等 价 的 ST 语 言 程 序 ： 我 们 假 定 F_TRIG1 是 F_TRIG 块 的 一 个 实 例 ； CTD1 是 CTD 块 的 一 个 实 例*)

CTD1(F_TRIG1(command),load_cmd,100);

underflow := CTD1.Q;

result := CTD1.CV;

(*等 价 的 IL 语 言 程 序: *)

LD	command

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ST	CTD1.cd

LD	load_cmd

ST	CTD1.load

LD	100

ST	CTD1.pv

CAL	CTD1

LD	CTD1.Q

ST	underflow

LD	CTD1.cv

ST	result


CTUD 上 升 - 下 降 计 数 器

参 数:

CU	布 尔	上 升 计 数 （ 当 CU 为 ‘ 真 ’ 时 ）

CD	布 尔	下 降 计 数 （ 当 CD 为 ‘ 真 ’ 时 ）

RESET	布 尔	复 位 命 令 （ 优 先 ）

(当 RESET 为 ‘ 真 ’ 时 ， CV = 0)

LOAD	布 尔	装 入 命 令 （ 当 LOAD 为 ‘ 真 ’ 时 ， 使 CV = PV)

PV	整 型	可 编 程 最 大 值

QU	布 尔	溢 出 ： 当 CV = PV 时 为 “ 真 ”

QD	布 尔	下 溢 ： 当 CV = 0 时 为 “ 真 ”

CV	整型	计 数 结 果

警 告： CTUD 块 不 能 检 测 计 数 输 入  （CU 和CD） 的 上 升 或 下 降 沿 ， 它 必 须 与 “R_TRIG” 或 “ R_TRIG ” 块 组 合 起 来 才 能 成 为 一 个 脉 冲 计 数 器 。

说 明:

从 0 开 始 以 1 为 步 长 向 上 计 （ 整 型 ） 数

或 从 一 个 给 定 值 开 始 向 下，以 1 为 步 长 计 数

(*“CTUD” 块 的FBD 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： 我 们 假 定 R_TRIG1 和 R_TRIG2 是 R_TRIG 块 的 两 个 实 例 ； CTUD1 是 CTUD 块 的 实 例*)

CTUD1(R_TRIG1(add_elt), R_TRIG2(sub_elt), reset_cmd, load_cmd,100);

full := CTUD1.QU;

empty := CTUD1.QD;

nb_elt := CTUD1.CV;

(*等 价 的 IL 语 言 程 序: *)

LD	add_elt

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTUD1.cu

LD	sub_elt

ST	R_TRIG2.clk

CAL	R_TRIG2

LD	R_TRIG2.Q

ST	CTUD1.cd

LD	reset_cmd

ST	CTUD1.reset

LD	load_cmd

ST	CTUD1.load

LD	100

ST	CTUD1.pv

CAL	CTUD1

LD	CTUD1.QU

ST	full

LD	CTUD1.QD

ST	empty

LD	CTUD1.CV

ST	nb_elt


TON 开 延 时 定 时

参 数:

IN	布 尔	如 果 为 上 升 沿 ，打 开 内 部 增 定 时 器

如 果 为 下 降 沿 ，停 止 并 复 位 内 部 定 时 器

PT	定 时 器	最 大 可 编 程 时 间

Q	布 尔	如 果 延 时 到 达， 则 为 “ 真”

ET	定 时 器	当 前 经 过 的 延 时 时 间

说 明:

对 内 部 定 时 器 进 行 增 计 时， 直 到 到 达 设 定 的 延 时 时 间。

时 序 图:


TOF 关 延 时 定 时

参 数:

IN	布 尔	如 果 是 下 降 沿， 则 启 动 内 部 定 时 器

如 果 是 上 升 沿， 则 停 止 并 复 位 定 时 器

PT	定 时 器	最 大 可 变 程 时 间

Q	布 尔	延 时 未 结 束 时 为“ 真”

ET	定 时 器	当 前 经 过 的 延 时 时 间

说 明:

内 部 定 时 器 进 行 升 计 时 直 到 设 定 值。

时 序 图:


TP 脉 冲 定 时

参 数:

IN	布 尔	如 果 为 上 升 沿， 启 动 内 部 上 升 定 时 器（ 如 果 并 非 正 在 上 升）

如 果 为“ 假”， 并 且 定 时 时 间 已 到 达， 复 位 内 部 定 时 器

计 时 的 过 程 中 IN 的 任 何 变 化 都 无 影 响

PT	定 时 器	最 大 可 编 程 时 间

Q	布 尔	定 时 器 正 在 计 时 时 为“ 真”

ET	定 时 器	当 前 经 过 的 延 时 时 间

说 明:

内 部 定 时 器 增 计 时 直 到 设 定 值。

时 序 图:


CMP 比 较
CMP 比 较 器

参 数:

VAL1	整 型	任 意 有 符 号 整 型 模 拟 值

VAL2	整 型	任 意 有 符 号 整 型 模 拟 值

LT	布 尔	如 果 val1 小 于 val2， 则 为“ 真”

EQ	布 尔	等 于 val2， 则 为“ 真”

GT	布 尔	如 果 val1 大 于 val2 则 为“ 真”

说 明:

比 较 第 一 个 值 是 否 等 于， 小 于 或 大 于 第 二 个 值。

(*“CMP” 块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序 ： 假 定 CMP1 为 CMP 块 的 一 个 实 例  *)

CMP1(level, max_level);

pump_cmd�:= CMP1.LT OR CMP1.EQ;

alarm�:= CMP1.GT AND NOT(manual_mode);

(*等 价 的 IL 语 言 程 序：*)

LD	level

ST	CMP1.val1

LD	max_level

ST	CMP1.val2

CAL	CMP1

LD	CMP1.LT

OR	CMP1.EQ

ST	pump_cmd

LD	CMP1.GT

ANDN	manual_mode

ST	alarm


STACKINT 整 型 堆 栈

参 数:

PUSH	布 尔	 压 入 命 令（ 只 在 上 升 沿 时）

 将 IN 的 值 加 入 到 堆 栈 顶 部

POP	布 尔	 弹 出 命 令（ 只 在 上 升 沿 时）

 删 除 堆 栈 的 最 后 一 次 压 入 的 （ 顶 部） 一 个 值

R1	布 尔	 将 堆 栈 复 位 为 空 状 态

IN	整 型	 所 压 入 堆 栈 的 值

N	整 型	 应 用 程 序 定 义 的 堆 栈 大 小

EMPTY	布 尔	 如 果 堆 栈 为 空 则 为“ 真”

OFLO	布 尔	 溢 出： 如 堆 栈 溢 出 则 为“ 真”

OUT	整 型	 堆 栈 顶 部 的  数值

说 明:

管 理 整 型 数 值 堆 栈。

“ STACKINT ” 块 在 执 行 PUSH 和 POP 命 令 时 包 含 了 上 升 沿 检 测。 堆 栈 的 最 大 容 量 为 128， 所 以 由 应 用 程 序 定 义 的 堆 栈 大 小 必 须 在 1 和 128 之 间。

注 意 OFLO 值 只 在 复 位 后 有 效（R1 至 少 为“真”一 次 并 返 回 “ 假” ）

(*使 用 “ STACKINT ” 块 的 FBD 程 序 例 子： 错 误 管 理  *)

(*等 价 的 ST 语 言 程 序 ： 假 定 STACKINT1 是 STACKINT 块 的 一 个 实 例 *)

STACKNT1(err_detect, acknoledge, manual_mode, err_code, max_err);

appli_alarm�:= auto_mode AND NOT(STACKNT1.EMPTY);

err_alarm�:= STACKNT1.OFLO;

last_error�:= STACKNT1.OUT;

(*等 价 的 IL 语 言 程 序：*)

LD	err_detect

ST	STACKINT1.push

LD	acknoledge

ST	STACKINT1.pop

LD	manual_mode

ST	STACKINT1.r1

LD	err_code

ST	STACKINT1.IN

LD	max_err

ST	STACKINT1.N

CAL	STACKINT1

LD	auto_mode

ANDN	STACKINT1.empty

ST	appli_alarm

LD	STACKINT1.OFLO

ST	err_alarm

LD	STACKINT1.OUT

ST	last_error


AVERAGE 连 续 均 值

参 数:

RUN	布 尔	运 行＝“ 真”/ 复 位＝“ 假”

XIN	实 型	任 意 实 型 模 拟 变 量

N	整 型	应 用 程 序 定 义 的 采 样 数 目

XOUT	实 型	求 出 XIN 的 平 均 值

说 明:

每 周 期 存 储 一 个 值， 并 计 算 所 有 存 储 值 的 平 均 值。 只 存 储 N 个 值。

采 样 数 目 N 不 能 超 过 128.

如 果 “  运 行 ” 命 令 为 “ 假 ” （ 复 位 状 态 ）

存 储 的 值 达 到 N 值 时 ， 第 一 个 存 储 的 值 会 被 最 后 一 个 值 所 取 代 。

(*使 用 “ AVERAGE  ” 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序: AVERAGE1 是 AVERAGE 块 的 一 个 实 例 *)

AVERAGE1((auto_mode & store_cmd), sensor_value, 100);

ave_value�:= AVERAGE1.XOUT;

(*等 价 的 IL 语 言 程 序：*)

LD	auto_mode

AND	store_cmd

ST	AVERAGE1.run

LD	sensor_value

ST	AVERAGE1.xin

LD	100

ST	AVERAGE1.N

CAL	AVERAGE1

LD	AVERAGE1.XOUT

ST	ave_value


HYSTER 滞 后

参 数:

XIN1	实 型	任 意 实 型 模 拟 量 值

XIN2	实 型	测 试 XIN1 是 否 超 过 XIN2+EPS

EPS	实 型	滞 后 值 （必 须 大 于 零）

Q	布 尔	当 XIN1 超 出 XIN2+EPS 并 且 不 小 于 XIN2-EPS 时 为“ 真”

说 明:

实 型 值 高 限 幅 的 滞 后 操 作

时 序 图 例 子：


LIM_ALRM 超 限 报 警

参 数:

H	实 型	高 限 幅 值

X	实 型	输 入： 任 意 实 型 模 拟 值

L	实 型	低 限 幅 值

EPS	实 型	滞 后 值（ 必 须 大 于 零）

QH	布 尔	“ 高” 报 警： 当 X 超 出 高 限 幅 H 时 为“ 真”

Q	布 尔	报 警 输 出： 当 X 超 出 限 幅 时 为“ 真”

QL	布 尔	“ 低” 报 警： 当 X 低 于 低 限 幅 L 时 为“ 真”

说 明 :

实 型 值 高 低 限 幅 的 滞 后 操 作

无 论 高 低 限 幅 的 滞 后 差 值 都 为 EPS 参 数 的 一 半。 以 下 是 一 个 示 例 的 时 序 图：


INTEGRAL 积 分

参 数:

RUN	布 尔	模 式： 为“ 真” 时 积 分 /  为“ 假” 时 保 持

R1	布 尔	主 导 复 位

XIN	实 型	输 入： 任 意 实 型 模 拟 值

X0	实 型	初 始 值

CYCLE	TMR	采 样 周 期

Q	布 尔	R1 的 非

XOUT	实 型	积 分 输 出

说 明：

对 实 型 值 的 积 分

如 果“CYCLE ” 参 数 值 小 于 ISaGRAF  应 用 程 序 的 循 环 周 期， 则 采 用 程 序 的 循 环  周 期。

(*使 用“INTEGRA ” 块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序 ： INTEGRAL1  是 INTEGRAL 块 的 一 个 实 例*)

INTEGRAL1(manual_mode, NOT(manual_mode), sensor_value, init_value, t#100ms);

controlled_value := INTEGRAL1.XOUT;

(* IL Equivalence: *)

LD	manual_mode

ST	INTEGRAL1.run

STN	INTEGRAL1.R1

LD	sensor_value

ST	INTEGRAL1.XIN

LD	init_value

ST	INTEGRAL1.X0

LD	t#100ms

ST	INTEGRAL1.CYCLE

CAL	INTEGRAL1

LD	INTEGRAL1.XOUT

ST	controlled_value


DERIVATE 微 分

参 数:

RUN	布 尔	模 式：“ 真” 为 正 常 / “ 假” 为 复 位

XIN	实 型	输 入： 任 意 实 型 模 拟 值

CYCLE	定 时 器	采 样 周 期

XOUT	实 型	微 分 输 出

说 明:

对 实 型 值  求 微 分.

如 果“ CYCLE ” 参 数 小 于ISaGRAF  应 用 程 序 的 循 环 周 期， 则 采 用 程 序 的 循 环 周 期。

(*使 用“DERIVATE ” 块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序 ： DERIVATE1  是 DERIVATE 块 的 一 个 实 例*)

DERIVATE1(manual_mode, sensor_value, t#100ms);

derivated_value := DERIVATE1.XOUT;

(*等 价 的 IL 语 言 程 序: *)

LD	manual_mode

ST	DERIVATE1.run

LD	sensor_value

ST	DERIVATE1.XIN

LD	t#100ms

ST	DERIVATE1.CYCLE

CAL	DERIVATE1

LD	DERIVATE1.XOUT

ST	derivated_value


BLINK 闪 烁 信 号

参 数:

RUN	布 尔	模 式：“ 真” 为 闪 烁 / “ 假” 为 复 位

CYCLE	定 时 器	闪 烁 周 期

Q	布 尔	输 出 闪 烁 信 号

说 明 :

发 生 闪 烁 的 信 号。

时 序 图:


SIG_GEN 信 号 发 生 器

参 数:

RUN	布 尔	模 式：“真” 为 运 行 / “ 假” 为 复 位

PERIOD	定 时 器	采 样 持 续 时 间

MAXIMUM	整 型	最 大 计 数 值

PULSE	布 尔	每 次 采 样 后 翻 转

UP	整 型	上 升 计 数 器， 每 次 采 样 后 增 加

END	布 尔	上 升 计 数 终 止 后 为“ 真”

SINE	实 型	正 弦 信 号（ 周 期 等 于 计 数 周 期）

说 明 ：

发 生 多 种 信 号： 闪 烁 的 布 尔 信 号， 整 型 上 升 计 数， 实 型 正 弦 波。

当 计 数 到 达 最 大 值 时 将 从 0 开 始， 所 以 END 只 在 一 个 周 期 内 为“ 真”。

时 序 图:


标 准 函 数

以 下 是 ISaGRAF 系 统 支 持 的 标 准 函数。 这 些 函 数 已 经 预 定 义， 并 不 需 要 在 库 中 声 明。

数 学:

ABS	绝 对 值

EXPT	指 数

LOG	对 数

POW	乘 方

SQRT	平 方 根

TRUNC	实 数 舍 位

三 角 函 数:

ACOS	反 余 弦

ASIN	反 正 弦

ATAN	反 正 切

COS	余 弦

SIN	正 弦

TAN	正 切

寄 存 器 控 制:

ROL	向 左 循 环 移 位

ROR	向 右 循 环 移 位

SHL	向 左 移 位

SHR	向 右 移 位

数 据 处 理:

MIN	最 小 值

MAX	最 大 值

LIMIT	限 幅

MOD	余数

MUX4	多 路 选 择 器 （4 输 入）

MUX8	多 路 选 择 器 （8 输 入）

ODD	奇 校 验

RAND	随 机 值

SEL	二 进 制 选 择 器

数 据 变 换:

ASCII	字 符  ASCII 码

CHAR	ASCII 码 字 符

字 符 串 管 理：

DELETE	删 除 子 串

INSERT	插 入 串

FIND	查 找 子 串

MLEN	取 得 串 长 度

LEFT	提 取 字 符 串 左 边 字 符

MID	提 取 字 符 串 中 间 字 符

REPLACE	替 换 子 串

RIGHT	提 取 字 符 串 右 边 字 符

DAY_TIME	日 期 时 间

数 组 处 理:

ARCREATE	建 立 整 型 值 数 组

ARREAD	读 数 组 元 素

ARWRITE	写 数 组 元 素

二 进 制 文 件 管 理:

F_ROPEN	在 读 模 式 下 打 开 二 进 制 文 件

F_WOPEN	在 写 模 式 下 打 开 二 进 制 文 件

F_CLOSE	关 闭 二 进 制 文 件

F_EOF	测 试 二 进 制 文 件 尾

FA_READ	从 二 进 制 文 件 中 读 取 模 拟 值

FA_WRITE	向 二 进 制 文 件 中 写 入 模 拟 值

FM_READ	从 二 进 制 文 件 中 读 取 信 息

FM_WRITE	向 二 进 制 文 件 中 写 入 信 息


ABS 绝 对 值

参 数:

IN	实 型	任 意 带 符 号 的 实 型 模 拟 值

Q	实 型	绝 对 值 （ 总 为 正 ）

说 明:

给 出 实 型 值 的 绝 对 值。

(*使 用 “ABS” 块 的 FBD 程 序 例 子：*)

(*等 价 的 ST 语 言 程 序 ： *)

over := (ABS (delta) > range);

(*等 价 的 IL 语 言 程 序： *)

LD	delta

ABS

GT 	range

ST	over


EXPT 指 数

参 数:

IN	实 型	任 意 带 符 号 的 实 型 模 拟 值

EXP	整 型	整 型 模 拟 指 数

Q	实 型	(IN EXP)

说 明:

给 出  [base（底）exponent（指数）]  运 算 的 实 型 结 果； 以 底 为 第 一 个 参 数 ， 指 数 为 第 二 个 参 数 。

(*使 用 “EXPT” 块 的 FBD 程 序 例 子：*)

(*等 价 的 ST 语 言 程 序: *)

tb_size := ANA (EXPT (2.0, range) );

(*等 价 的 IL 语 言 程 序：*)

LD	2.0

EXPT	range

ANA

ST	tb_size


LOG 对 数

参 数:

IN	实 型	必 须 大 于 零

Q	实 型	输 入 值 的 以 10 为 底 的 对 数

说 明:

计 算 实 型 值 的 以 10 为 底 的 对 数。

(*使 用 “LOG” 块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序 : *)

xpos := ABS (xval);

xlog := LOG (xpos);

(*等 价 的 IL 语 言 程 序: *)

LD	xval

ABS

ST	xpos

LOG

ST	xlog


POW 乘 方

参 数:

IN	实 型	将 自 乘 的 模 拟 值

EXP	实 型	幂 （ 指 数 ）

Q	实 型	(IN EXP)

1.0 如 果 IN 非 0.0 并 且 EXP 为 0.0

0.0 如 果 IN 为 0.0 并 且 EXP 为负 数

0.0 如 果 IN 和 EXP 都 为 0.0

0.0 如 果 IN 为 负 数 并 且Y不 对 应 一 个 整 数

说 明:

给 出 [ base（底） exponent（指数） ]  运 算 的 实 型 结 果； 以 ‘ 底 ’ 为 第 一 个 参 数 ， ‘ 指 数 ’ 为 第 二 个 参 数 。 指 数 为 实 型 值 。

(*使 用“POW”块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序 ： *)

result := POW (xval, power);

(*等 价 的 IL 语 言 程 序： *)

LD	xval

POW	power

ST	result


SQRT 平 方 根

参 数:

IN	实 型	必 须 大 于 或 等 于 零

Q	实 型	输 入 值 的 平 方 根

说 明:

计算实型值的平方根

(*使 用 “SQRT” 块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序 ： *)

xpos := ABS (xval);

xroot := SQRT (xpos);

(*等 价 的 IL 语 言 程 序： *)

LD	xval

ABS

ST	xpos

SQRT

ST	xrout


TRUNC 实 数 舍 位

参 数:

IN	实 型	任 意   实 型 模 拟 值

Q	实 型	如 果 IN>0 ，则 为 小 于 或 等 于 输 入 的 最 大 整 数

如 果 IN<0 ，则 为 大 于 或 等 于 输 入 的 最 小 整 数

说 明:

截 取 实 型 数 值 的 整 数 部 分。

(*使 用“TRUNG” 块 的 FBD 程 序 例 子：*)

(*等 价 的 ST 语 言 程 序 ： *)

result := TRUNC (+2.67) + TRUNC (-2.0891);

(* means: result := 2.0 + (-2.0) := 0.0; *)

(*等 价 的 IL 语 言 程 序：: *)

LD	2.67

TRUNC

ST	temporary	(*第 一 个 TRUNC 的 中 间 结 果 *)

LD	-2.0891

TRUNC

ADD	temporary

ST	result


ACOS 反 余 弦

参 数:

IN	实 型	必 须 属 于 集 合[-1.0 .. +1.0]

Q	实 型	输 入 值 的 反 余 弦 （ 在 集 合  [0.0 .. PI] 中 )

= 0.0 ，当 非 法 输 入 时

说 明:

计 算 实 型 数 值 的 反 余 弦。

(*使 用 “COS” 和 “ACOS” 块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序 : *)

cosine := COS (angle);

result := ACOS (cosine); (*结 果 等 于 角 度 *)

(*等 价 的 IL 语 言 程 序: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


ASIN 反 正 弦

参 数:

IN	实 型	必 须 属 于 集 合  [-1.0 .. +1.0]

Q	实 型	输 入 值 的 反 正 弦 （ 在 集 合  [-PI/2 .. +PI/2] 中 )

= 0.0 如 果 输 入 非 法

说 明:

计 算 实 型 数 值 的 反 正 弦。

(*使 用 “SIN” 和 “ASIN” 块 的 FBD 程 序 例 子： *)

(*等 价 的 ST 语 言 程 序: *)

sine := SIN (angle)；

result := ASIN (sine)； (* 结 果 等 于 角 度 *)

(*等 价 的 IL 语 言 程 序: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


ATAN 反 正 切

参 数 :

IN	实 型	任 意 实 型 模 拟 值

Q	实 型	输 入 值 的 反 正 切  ( 在 集 合  [-PI/2 .. +PI/2] 中 )

= 0.0， 如 果 输 入 非 法

说 明 :

计 算 实 型 值 的 反 正 切。

(* 使 用 “TAN” 和 “ATAN” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序: *)

tangent := TAN (angle);

result := ATAN (tangent); (* 结 果 等 于 angle*)

(* 等 价 的 IL 语 言 程 序: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


COS 余 弦

参 数 :

IN	实 型	任 意 实 型 模 拟 值

Q	实 型	输 入 值 的 余 弦 （ 在 集 合 [-1.0 .. +1.0] 之 间 )

说 明 :

计 算 实 型 值 的 余 弦。

(* 使 用 “COS” 和 “ACOS” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 : *)

cosine := COS (angle);

result := ACOS (cosine); (* 结 果 等 于  angle *)

(* 等 价 的 IL 语 言 程 序： *)

LD	angle

COS

ST	cosine

ACOS

ST	result


SIN 正 弦

参 数 :

IN	实 型	任 意  实 型 模 拟 值

Q	实 型	输 入 值 的 正 弦  ( 在 集 合  [-1.0 .. +1.0] 之间 )

说 明 :

计 算 实 型 值 的 正 弦。

(* 使 用 “ SIN ” 和 “ ASIN ” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 : *)

sine := SIN (angle);

result := ASIN (sine); (* 结 果 等 于 angle *)

(* 等 价 的 IL 语 言 程 序: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


TAN 正 切

参 数：

IN	实 型	不 能 等 于 PI/2 至 PI

Q	实 型	输 入 值 的 正 切

= 1E+38， 如 果 输 入 无 效

说 明 :

计 算 实 型 值 的 正 切

(* 使 用 “TAN” 和 “ATAN”  块 的 FBD 程 序 例 子： *)

(*  等 价 的 ST 语 言 程 序: *)

tangent := TAN (angle);

result := ATAN (tangent); (*  结 果 为 角 度 *)

(* 等 价 的 IL 语 言 程 序: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


ROL 向 左 循 环 移 位

参 数 :

IN	整 型	任 意 整 型 模 拟 值

NbR	整 型	循 环 移 位 的 位 数 （ 在 区 间 [1..31] 之 中 ）

Q	整 型	向 左 移 位 后 的 值

NbR <= 0 时 无 操 作

说 明 :

使 整 型 数 值 向 左 循 环 移 位。 循 环 有 32 位 同 时 进 行：

(* 使用“ROL” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

result := ROL (register, 1);

(* register = 2#0100_1101_0011_0101*)

(* result    = 2#1001_1010_0110_1010*)

(*等 价 的 IL 语 言 程 序： *)

LD	register

ROL	1

ST	result


ROR 向 右 循 环 移 位

参 数 :

IN	整 型	任 意 整 型 数 值

NbR	整 型	循 环 移 位 的 位 数  ( 在 [1..31] 之间 )

Q	整 型	向 右 移 位 的 值

如 果 NbR <= 0 ，则 无 操 作

说 明 :

使 整 型 数 值 向 右 循 环 移 位， 移 位 由 32 位 同 时 进 行。

(* 使 用 “ ROR ” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

result := ROR (register, 1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1010_0110_1001_1010 *)

(*等 价 的 IL 语 言 程 序： *)

LD	register

ROR	1

ST	result


SHL 向 左 移 位

参 数 :

IN	整 型	任 意 整 型 模 拟 值

NbS	整 型	移 位 的 位 数 （ 在 [1..31] 之 间 ）

Q	整 型	向 左 移 位 后 的 值

如 果 NbS <= 0 则 无 操 作

最 低 位 由 0 替 换

说 明 :

使 整 型 数 值 向 左 移 位， 32 位 同 时 进 行：

(* 使 用 “ SHL ”  块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 : *)

result := SHL (register,1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1001_1010_0110_1010 *)

(* 等 价 的 IL 语 言 程 序: *)

LD	register

SHL	1

ST	result


SHR 向 右 移 位

参 数 :

IN	整 型	任 意 整 型 模 拟 值

NbS	整 型	移 位 的 位 数 （ 在 [1..31] 之 间 ）

Q	整 型	向 右 移 位 后 的 值

如 果  NbS <= 0  则 无 操 作

最 高 位 在 每 次 移 位 时 向 低 位 复 制

说 明 :

使 整 型 数 值 向 右 移 位， 32 位 同 时 进 行：

(* 使 用 “ SHR ” 块 的 FBD 程 序 例 子：*)

(*  等 价 的 ST 语 言 程 序 ： *)

result := SHR (register,1);

(* register = 2#1100_1101_0011_0101 *)

(* result    = 2#1110_0110_1001_1010 *)

(* 等 价 的 IL 语 言 程 序： *)

LD	register

SHR	1

ST	result


MIN 最 小 值

参 数 :

IN1	整 型	任 意 带 符 号 的 整 型 模 拟 值

IN2	整 型	( 不 能 是 实 型 数 )

Q	整 型	两 个 输 入 值 中 的 最 小 值

说 明 :

给 出 两 个 整 型 值 间 的 最 小 值。

(* 使 用 “ MIN ”和 “MAX” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 ： *)

new_value := MAX (MIN (max_value, value), min_value);

(* bounds the value to the [min_value..max_value] set *)

(* 等 价 的 IL 语 言 程 序：*)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


MAX 最 大 值

参 数 :

IN1	整 型	任 意 带 符 号 的 整 型 模 拟 值

IN2	整 型	( 不 能 是 实 型)

Q	整 型	两 个 输 入 值 中 的 最 大 值

说 明 :

给 出 两 个 整 型 数 值 间 的 最 大 值。

(* 使 用 “ MIN ”和 “ MAX ” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

new_value := MAX (MIN (max_value, value), min_value);

(* bounds the value to the [min_value..max_value] set *)

(*等 价 的 IL 语 言 程 序： *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


LIMIT 限 幅

参 数 :

MIN	整 型	最 小 允 许 值

IN	整 型	任 意 带 符 号 的 模 拟 值

MAX	整 型	最 大 允 许 值

Q	整 型	被 允 许 范 围 限 制 的 输 入 值

说 明 :

将 输 入 整 型 值 限 制 在 一 定 范 围 之 内。 输 入 值 在 限 制 范 围 之 内 时 保 持 原 值； 超 出 最 大 值 时 即 变 为 最 大 值； 低 于 最 小 值 时 即 变 为 最 小 值。

(* 使 用 “LIMIT” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

new_value := LIMIT (min_value, value, max_value);

(* bounds the value to the [min_value..max_value] set *)

(* 等 价 的 IL 语 言 程 序： *)

LD	min_value

LIMIT	value, max_value

ST	new_value


MOD 余 数

参 数 :

IN	整 型	任 意 带 符 号 的 整 型 模 拟 值

Base	整 型	必 须 大 于 零

Q	整 型	求 余 数 计 算 （ 以 输 入 的 base 为 底 ）

如 果 Base <= 0 则 返 回 -1

说 明 ：

计 算 整 型 值 的 余 数。

(* 使 用“MOD” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ：*)

division_result := (value / divider); (* 整 数 除 法*)

rest_of_division := MOD (value, divider); (* 除 法 的 余 数  *)

(* 等 价 的 IL 语 言 程 序： *)

LD	value

DIV	divider

ST	division_result

LD	value

MOD	divider

ST	rest_of_division


MUX4 4 路 输 入 选 择 器

参 数 :

SEL	整 型	选 择 器 整 型 值 （ 必 须 在 [0..3] 之 间 )

IN1..IN4	整 型	任 意 的 整 型 模 拟 值

Q	整 型	= 值 IN1 当 SEL = 0 时

= 值 IN2 当 SEL = 1 时

= 值 IN3 当 SEL = 2 时

= 值 IN4 当 SEL = 3 时

= 0 当 SEL 为 所 有 其 它 值 时

说 明 :

4 输 入 多 路 选 择 器： 在 4 个 整 型 值 中 选 择 一 个。

(* 使 用 “MUX4” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

range := MUX4 (choice, 1, 10, 100, 1000);

(* 从 4 个 预 定 的 范 围 （range） 中 选 定 一 个，例 如， 当 choice 为 1 时， range 将 为 10 *)

(* 等 价 的 IL 语 言 程 序： *)

LD	choice

MUX4	1,10,100,1000

ST	range


MUX8 8 路 输 入 选 择 器

参 数 :

SEL	整 型	选 择 器 整 型 值 （ 必 须 在 [0..7] 之 间 )

IN1..IN8	整 型	任 意 整 型 模 拟 值

Q	整 型	= 值 IN1 当 SEL = 0 时

= 值 IN2 当 SEL = 1 时

...

= 值 IN8 当 SEL = 7 时

= 0 当 SEL 为 其 它 任 何 值 时

说 明 :

8 输 入 多 路 选 择 器： 从 8 个 整 型 值 中 选 择 一 个。

(*使 用 “MUX8” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 : *)

range := MUX8 (choice, 1, 5, 10, 50, 100, 500, 1000, 5000);

(* 从 8 个 预 定 义 的 范 围 （range） 中 选 择 一 个， 例 如 choice 为 3 时， range 将 为 50 *)

(* 等 价 的 IL 语 言 程 序 : *)

LD	choice

MUX8	1,5,10,50,100,500,1000,5000

ST	range


ODD 奇 校 验

参 数 :

IN	整 型	任 意 带 符 号 的 整 型 模 拟 值

Q	布 尔	输 入 值 为 奇 时， 为 “真”

输 入 值 为 偶 时 为 “假”

说 明 :

测 试 整 型 值 的 奇 偶， 结 果 为 奇 或 偶。

(* 使 用 “ODD” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序: *)

If Not (ODD (value)) Then Return; End_if;

value := value + 1;

(* 使 值 总 为 偶 *)

(* 等 价 的 IL 语 言 程 序: *)

LD	value

ODD

RETNC

LD	value

ADD	1

ST	value


RAND 随 机 值

参 数 :

base	整 型	定 义 数 值 的 允 许 区 间

Q	整 型	在 区 间 [0..base-1] 之 间 的 随 机 值

说 明 :

给 出 一 个 在 给 定 范 围 内 的 随 机 整 型 数 值。

(* 使 用 “RAND” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

selected := MUX4 ( RAND (4), 1, 4, 8, 16 );

(*

自 4 个 预 定 义 数 值 中 随 机 选 择 一 个

RAND 调 用 的 结 果 是 在 区 间 [0..3] 中 的 数 值，

所 以 MUX4 的 选 择 结 果 ‘selected’ 将 为 ‘随机地’ 取 得 的 值

1 ， 当 RAND 的 结 果 为 0 时

4 ， 当 RAND 的 结 果 为 1 时

8 ， 当 RAND 的 结 果 为 2 时

16 ， 当 RAND 的 结 果 为 3 时

*)

(* 等 价 的 IL 语 言 程 序： *)

LD	4

RAND

MUX4	1,4,8,16

ST	selected


SEL 二 进 制 选 择 器

参 数 :

SEL	布 尔	指 出 所 选 择 的 值

IN1, IN2	整 型	任 意 整 型 模 拟 值

Q	整 型	= IN1 ，当 SEL 为 “假” 时

= IN2 ，当 SEL 为 “真” 时

说 明 :

二 进 制 选 择 器： 从 两 个 整 型 输 入 值 中 选 择 一 个。

(* 使 用 “SEL” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序: *)

ProCmd := SEL (AutoMode, ManuCmd, InpCmd);

(* 加 工 命 令 选 择 *)

(* 等 价 的 IL 语 言 程 序： *)

LD	AutoMode

SEL	ManuCmd,InpCmd

ST	ProCmd


ASCII 字 符 ASCII 码

参 数 :

IN	信 息	任 意 非 空 的 串

Pos	整 型	所 选 择 字 符 的 位 置

在 区 间 [1.. len] 中 ( len 为 IN 信 息 的 长 度 )

Code	整 型	所 选 择 字 符 的 编 码

（在 区 间 [0 .. 255] 内 ）

如 果 Pos 的 值 处 于 串 外， 则 返 回 0

说 明 ：

给 出 在 信 息 串 中 的 字 符 的 ASCII 码

(* 使 用 “ASCII” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 ：*)

FirstChr := ASCII (message, 1);

(* FirstChr 是 message 串 的 第 一 个 字 符 的 Ascii 码  *)

(* 等 价 的 IL 语 言 程 序： *)

LD	message

ASCII	1

ST	FirstChr


CHAR ASCII 码 字 符

参 数 :

Code	整 型	在 区 间 [0 .. 255] 内 的 码 值

Q	信 息	单 字 符 的 串

具 有 Code 给 出 的 ASCII 码 的 字 符

(ASCII 码 在 256 之 内)

说 明 ：

从 给 定 的 ASCII 码 求 出 单 字 符 信 息 串。

(* 使 用 “CHAR” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

Display := CHAR ( value + 48 );

(* value 在 区 间 [0..9] 内 *)

(* 48 是 ‘0’ 的 ASCII 码 值 *)

(* 结 果 是 范 围 在 ‘0’ 至 ‘9’ 的 一 个 单 字 符 串*)

(* 等 价 的 IL 语 言 程 序： *)

LD	value

ADD	48

CHAR

ST	Display


DELETE 删 除 子 串

参 数 :

IN	信 息	任 意 非 空 的 信 息 串

NbC	整 型	将 删 除 的 字 符 数

Pos	整 型	将 删 除 的 第 一 个 字 符 的 位 置

（ 串 内 的 第 一 个 字 符 的 位 置 为 1 ）

Q	信 息	修 改 后 的 串

Pos < 1 如 果 Pos < 1， 返 回 空 串

如 果 Pos > IN 串 长 度， 返 回 初 始 串

如 果 NbC <= 0， 返 回 初 始 串

说 明 :

删 除 部 分 信 息 串。

(*使 用 “DELETE” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string is 'ABCDEFGH' *)

sub_string := DELETE (complete_string, 4, 3); (* sub_string is 'ABGH' *)

(* 等 价 的 IL 语 言 程 序: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

DELETE	4,3

ST 	sub_string


INSERT 插 入 串

参 数 :

IN	信 息	初 始 字 符 串

Str	信 息	将 插 入 的 串

Pos	整 型	插 入 的 位 置

插 入 到 插 入 位 置 之 前

( 第 一 个 有 效 的 位 置 是 1)

Q	信 息	修 改 后 的 串

如 果 Pos <= 0 则 返 回 空 串

如 果 Pos 大 于 IN 串 的 长 度， 则 返 回 两 个 串 的 串 联 体

说 明 :

在 信 息 串 的 指 定 位 置 插 入 一 个 子 串。

(* 使 用 “INSERT” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序: *)

MyName := INSERT ('Mr JONES', 'Frank ', 4);

(* MyName is 'Mr Frank JONES' *)

(* 等 价 的 IL 语 言 程 序: *)

LD	'Mr JONES'

INSERT	'Frank ',4

ST 	MyName


FIND 查 找 子 串

参 数 :

In	信 息	任 意 信 息 串

Pat	信 息	任 意 非 空 的 串 （ 样 板 ）

Pos	整 型	= 0 ， 如 果 未 找 到 子 串 Pat

= 子 串 Pat 第 一 次 出 现 时 其 第 一 个 字 符 的 位 置

(可 能 的 第 一 个 位 置 是 1)

此 函数 的 结 果 与 大 小 写 有 关

说 明 :

在 信 息 串 中 查 找 子 串， 给 出 子 串 在 串 中 的 位 置。

(* 使 用 “FIND” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string is 'ABCDEFGH' *)

found := FIND (complete_string, 'CDEF'); (* found is 3 *)

(* 等 价 的 IL 语 言 程 序: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

FIND	'CDEF'

ST 	found


MLEN 取 得 串 长 度

参 数 :

IN	信 息	任 意 信 息 串

NbC	整 型	IN 串 的 字 符 数

说 明 :

计 算 信 息 串 的 长 度。

(* 使 用 “MLEN” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ：*)

nbchar := MLEN (complete_string);

If (nbchar < 3) Then Return; End_if;

prefix := LEFT (complete_string, 3);

(* 此 程 序 提 取 字 符 串 左 侧 的 3 个 字 符 并 将 结 果 赋 值 给 信 息 变 量 prefix

如 果 串 长 度 小 于 3 则 不 进 行 操 作 （返回） *)

(* 等 价 的 IL 语 言 程 序： *)

LD	complete_string

MLEN

ST	nbchar

LT	3

RETC

LD	complete_string

LEFT	3

ST	prefix


LEFT 提 取 字 符 串 左 边 字 符

参 数 :

IN	信 息	任 意 非 空 的 串

NbC	整 型	要 提 取 的 字 符 数

不 能 大 于 IN 串 长 度

Q	信 息	IN 串 的 左 边 部 分 （ 长 度 = NbC ）

如 果 NbC <= 0 则 返 回 空 串

如 果 NbC >= IN 串 长 度 则 返 回 完 整 的 IN 串

说 明 :

提 取 信 息 串 的 左 边 部 分， 提 取 的 字 符 数 是 指 定 的。

(* 使 用 “LEFT” 和 “RIGHT” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 : *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string is '56781234'

RIGHT 调 用 的 结 果 为 '5678'

LEFT 调 用 的 结 果 为 '1234'

*)

(* 等 价 的 IL 语 言 程 序： 首 先 完 成 LEFT 调 用*)

LD	'12345678'

LEFT	4

ST	sub_string 	(* 中 间 结 果 *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


MID 提 取 字 符 串 中 间 字 符

参 数 :

IN	信 息	任 意 非 空 串

NbC	整 型	要 提 取 的 字 符 数

不 能 大 于 IN 串 的 长 度

Pos	整 型	子 串 的 位 置

Pos 指 向 子 串 的 第 一 个 字 符

( 第 一 个 有 效 的 位 置 为 1 )

Q	信 息	串 的 中 间 部 分 （ 其 长 度 = NbC ）

如 果 参 数 无 效 则 返 回 空 串

说 明 ：

提 取 信 息 串 的 一 部 分， 给 定 提 取 的 字 符 数 和 起 始 位 置  。

(* 使 用 “MID” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

sub_string := MID ('abcdefgh', 2, 4);

(* sub_string is 'de' *)

(* 等 价 的 IL 语 言 程 序： *)

LD	'abcdefgh'

MID	2,4

ST	sub_string


REPLACE 替 换 子 串

参 数 :

IN	信 息	任 意 字 符 串

Str	信 息	将 插 入 的 字 符 串 （ 替 换 NbC 指 定 的 字 符 ）

NbC	整 型	将 删 除 的 字 符 数

Pos	整 型	要 修 改 的 第 一 个 字 符 的 位 置

（ 第 一 个 有 效 位 置 为 1 ）

Q	信 息	修 改 后 的 字 符 串：

- 从 由 Pos 指 定 的 位 置 起 删 除 NbC 个 字 符

- 再 插 入 子 串 Str 到 此 位 置

如 果 Pos <= 0 则 返 回 空 串

如 果 Pos 大 于 IN 串 的 长 度 则 返 回 串 联 的 字 符 串 （ IN+Str ）

如 果 NbC <= 0 则 返 回 初 始 串 IN

说 明 :

以 一 组 新 字 符 替 换 信 息 串 的 一 部 分。

(* 使 用 “REPLACE” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 : *)

MyName := REPLACE ('Mr X JONES, 'Frank', 1, 4);

(* MyName is 'Mr Frank JONES' *)

(* 等 价 的 IL 语 言 程 序: *)

LD	'Mr X JONES'

REPLACE	'Frank',1,4

ST	MyName


RIGHT 提 取 字 符 串 右 边 字 符

参 数 :

IN	信 息	任 意 非 空 的 串

NbC	整 型	不 能 大 于 IN 串 的 长 度

Q	信 息	串 的 右 边 部 分 （ 长 度 = NbC ）

如 果 NbC <= 0 则 返 回 空 串

如 果 NbC >= 串 长 度， 则 返 回 整 个 串

说 明 :

提 取 信 息 串 的 右 边 部 分。 提 取 的 字 符 数 目 已 给 定。

(* 使 用 “LEFT” 和 “RIGHT” 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 : *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string is '56781234'

RIGHT 调 用 的 结 果 为 '5678'

LEFT 调 用 的 结 果 为 '1234'

*)

(* 等 价 的 IL 语 言 程 序： 首 先 完 成 LEFT 调 用*)

LD	'12345678'

LEFT	4

ST	sub_string 	(* 中 间 结 果 *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


DAY_TIME 日 期 时 间

参 数 :

SEL	整 型	选 择 输 出 结 果

0= 取 当 前 日 期

1= 取 当 前 时 间

2= 取 星 期 值

Q	信 息	以 字 符 串 表 示 的 时 间 / 日 期

如 果 SEL = 0 则 为 ‘YYYY/MM/DD’

如 果 SEL = 1 则 为 ‘HH:MM:SS’

如 果 SEL = 2 则 为 星 期 名 ( 例 如： ‘Monday’ )

说 明 ：

以字符串的形式给出日期和时间。

(* 使 用 “DAY_TIME” 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

Display := Day_Time (0) + ' ; ' + Day_Time (1);

(* Display 的 文 本 格 式 为： 'YYYY/MM/DD ; HH:MM:SS'  *)

(* 等 价 的 IL 语 言 程 序： 首 先 完 成 day_time(1) 调 用*)

LD	1

DAY_TIME

ST	hour_str 	(* 中 间 结 果 *)

LD	0

DAY_TIME

ADD	' ; '

ADD	hour_str

ST 	Display


ARCREATE 建 立 整 型 值 数 组

参 数 :

ID	整 型	数 组 的 标 识 符 ( 必 须 在 区 间 [0..15] 内 )

Size	整 型	数 组 元 素 的 个 数

ok	整 型	执 行 状 态：

1 = 数 组 已 成 功 建 立

2 = 无 效 的 数 组 标 识 符 或 数 组 已 存 在

3 = 无 效 数 组 大 小

4 = 无 足 够 内 存

说 明 ：

建 立 整 型 数 组。

警告： 应 用 程 序 中 最 多 可 有 16 个 数 组， 数 组 内 总 包 含 整 型 模 拟 值。 在 执 行 动 态 内 存 分 配 时， 当 数 组 大 小 接 近 于 可 用 内 存 的 数 量 时， 此 函数 有 可 能 引 起 系 统 出 错。

(* 使 用 FBD 程 序 建 立 一 个 整 型 数 组 *)

(* 等 价 的 ST 语 言 程 序 ： *)

array_error := (ARCREATE (ident, 16) <> 1));

(* 等 价 的 IL 语 言 程 序：*)

LD	ident

ARCREATE	16

NE 	1

ST	array_error


ARREAD 读 数 组 元 素

参 数 :

ID	整 型	数 组 的 标 识 符 （ 必 须 在 区 间 [0..15] 内 ）

Pos	整 型	数 组 内 元 素 的 位 置

必 须 在 区 间 [0 .. size-1]

value	整 型	所 读 元 素 的 值

如 果 参 数 无 效 则 返 回 0

说 明 :

读 整 型 数 组 的 元 素 值。

(* 使 用 数 组 管 理 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 : *)

If (array_error) Then Return; End_if;

read_value := ARREAD (ident, index);

(* array_error 来 自 ARCREATE 调 用*)

(* 等 价 的 IL 语 言 程 序: *)

LD	array_error

RETC

LD	ident

ARREAD	index

ST	read_value


ARWRITE 写 数 组 元 素

参 数 :

ID	整 型	数 组 标 识 符 （ 必 须 在 区 间 [0..15] 内 ）

Pos	整 型	数 组 内 元 素 的 位 置

必 须 在 区 间 [0 .. size-1] 内

IN	整 型	元 素 的 新 值

ok	整 型	执 行 状 态：

1 = 已 成 功 写 入

2 = 无 效 数 组 标 识 符

3 = 无 效 索 引

说 明:

存 储 （ 写 入 ） 数 值 到 整 型 数 组。

(* 使 用 数 组 管 理 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 : *)

If (array_error) Then Return; End_if;

write_status := ARWRITE (Ident, Index, value);

(* array_error 来 自 ARCREATE 调 用 *)

(* 等 价 的 IL 语 言 程 序: *)

LD	array_error

RETC

LD	ident

ARWRITE	index,value

ST	write_status


F_ROPEN 在 读 模 式 下 打 开 二 进 制 文 件

参 数 :

Path	信 息	文 件 名

可 以 使 用 / 或 \ 符 号 指 定 访 问 路 径 以 增 加 应 用 程 序 的 可 移 植 性。 / 和 \ 符 号等 效。

ID	整 型	文 件 号

如 果 出 错则 为 0： 文 件 不 存 在。

说 明 :

以 读 模 式 打 开 二 进 制 文 件。 与 FX_READ 和 F_CLOSE 一 起 使 用。

此 函数 不 包 括 在 ISaGRAF 仿 真 器 中。

(* 使 用 文 件 管 理 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

file_id := F_ROPEN('c:\data \data.bin');

error := (file_id=0);

(*等 价 的 IL 语 言 程 序： *)

LD	'c:\data\data.bin'

F_ROPEN

ST	file_id

EQ	0

ST	error


F_WOPEN 在 写 模 式 下 打 开 二 进 制 文 件

参 数 :

Path	信 息	文 件 名

可 以 使 用 / 或 \ 符 号 指 定 访 问 路 径 以 增 加 应 用 程 序 的 可 移 植 性。 / 和 \ 符 号等 效。

ID	整 型	文 件 号

出 错 时 为 0 ， 如 果 文 件 已 存 在， 它 将 被 覆 盖

说 明 :

以 写 模 式 打 开 二 进 制 文 件。 与 FX_WRITE 和 F_CLOSE 一 起 使 用。

此 函数 不 包 括 在 ISaGRAF 仿 真 器 中。

(* 使 用 文 件 管 理 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序: *)

file_id := F_WOPEN('c:\data \data.bin');

error := (file_id=0);

(* 等 价 的 IL 语 言 程 序: *)

LD	'c:\data\data.bin'

F_WOPEN

ST	file_id

EQ	0

ST	error


F_CLOSE 关 闭 二 进 制 文 件

参 数:

ID	整 型	文 件 号：由 F_ROPEN 或 F_WOPEN 返 回

ok	布 尔	返 回 状 态：

“真”， 如 果 文 件 成 功 关 闭

“假”， 如 果 发 生 错 误

说 明 :

关 闭 由 F_ROPEN 或 F_WOPEN 函数打开的文件。

此 函 数 不 包 括 在 ISaGRAF 仿 真 器 中。

(* 使 用 文 件 管 理 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 : *)

file_id := F_ROPEN('data.bin');

ok := F_CLOSE(file_id);

(* 等 价 的 IL 语 言 程 序: *)

LD	'data.bin'

F_ROPEN

ST	file_id

F_CLOSE	(* file_id 已 存 在 于 当 前 的 IL 结 果 中 *)

ST 	ok


F_EOF 测 试 二 进 制 文 件 尾

参 数 :

ID	整 型	文 件 号： 由 F_ROPEN 或 F_WOPEN 返 回

ok	布 尔	文 件 尾 指 示 器

当 最 后 一 次 写 或 读 调 用 过 程 中 遇 到 文 件 尾 时 为 “真”

与 FM_READ 一 同 使 用 时， 如 果 最 后 一 个 字 符 不 是 字 符 串 结 束 符， 最 后 读 出 的 信 息 可 能 不 正 确

说 明 :

测 试 是 否 到 达 文 件 尾。

此 函数 不 包 括 在 ISaGRAF 仿 真 器 中。

(* 使 用 文 件 管 理 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ： *)

file_id := F_ROPEN('data.bin');

WHILE not(F_EOF(file_id))

VAL := FA_READ(file_id);

END_WHILE;

MESSAGE := 'last val = ' + msg(VAL);

ok := F_CLOSE(file_id);

(* 等 价 的 IL 语 言 程 序 ：*)

LD	'data.bin'

F_ROPEN

ST	file_id

LD 	file_id

F_EOF

JMPC	END_OF_FILE

NOT_EOF:	LD 	file_id

FA_READ

ST	VAL

LD 	file_id

F_EOF

JMPNC	NOT_EOF 	(* 如 果 不 是 文 件 尾， 继 续 读  *)

END_OF_FILE:	LD	VAL

信 息

ST	val_msg	(* 将 VAL 变 换 为 信 息 *)

LD	'last val = '

ADD	val_msg

ST	MESSAGE

LD 	file_id

F_CLOSE

ST	ok


FA_READ 从 二 进 制 文 件 中 读 取 模 拟 值

参 数 :

ID	整 型	文 件 号， 由 F_ROPEN 返 回

Q	整 型	自 文 件 读 出 的 整 型 模 拟 值

说 明 :

从 二 进 制 文 件 中 读 模 拟 变 量。 与 F_ROPEN 和 F_CLOSE 一 起 使 用。

此 过 程 从 先 前 的 位 置 开 始 对 文 件 进 行 顺 序 访 问。

第 一 次 调 用 F_ROPEN 读 取 文 件 的 起 始 4 字 节。

每 次 调 用 都 将 读 指 针 压 入 堆 栈。

要 检 测 是 否 到 达 文 件 尾，使 用 F_EOF.

此 函 数 不 包 括 在 ISaGRAF 仿 真 器 中。

(* 使 用 文 件 管 理 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序: *)

file_id := F_ROPEN('voltramp.bin');

vstart := FA_READ(file_id);

vend := FA_READ(file_id);

vinc := FA_READ(file_id);

delta_tim := tmr(FA_READ(file_id));

ok := F_CLOSE(file_id);

(* 等 价 的 IL 语 言 程 序: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FA_READ	(* 读 vstart *)

ST	vstart

LD 	file_id

FA_READ	(* 读 vend *)

ST	vend

LD 	file_id

FA_READ	(* 读 vinc *)

ST	vinc

LD 	file_id

FA_READ	(* 读 delta_tim *)

TMR	(* 变 换 为 定 时 器*)

ST	delta_tim

LD 	file_id

F_CLOSE

ST	ok


FA_WRITE 向 二 进 制 文 件 中 写 入 模 拟 值

参 数 :

ID	整 型	文 件 号： 由 F_WOPEN 返 回

IN	整 型	将 被 写 入 文 件 的 整 型 模 拟 值

OK	布 尔	执 行 状 态： 如 果 成 功 为 “真”

说 明 :

向 二 进 制 文 件 内 写 入 模 拟 变 量。

此 过 程 从 先 前 的 位 置 开 始 对 文 件 进 行 顺 序 访 问。

第 一 次 调 用 F_WOPEN 后 写 入 文 件 的 起 始 4 字 节。

每 次 写 入 都 将 写 指 针 压 入 堆 栈。

此 函数 不 包 括 在 ISaGRAF 仿 真 器 中。

(* FBD 程 序 *)

(* 等 价 的 ST 语 言 程 序 : *)

file_id := F_WOPEN('voltramp.bin');

nb_written  := 0;

nb_written := nb_written + ana(FA_WRITE(file_id,vstart));

nb_written := nb_written + ana(FA_WRITE(file_id,vend));

nb_written := nb_written + ana(FA_WRITE(file_id,vinc));

nb_written := nb_written + ana(FA_WRITE(file_id,ana(delta_tim)));

ok := F_CLOSE(file_id);

IF ( nb_written <> 4) THEN

ERROR := ERR_FILE;

END_IF;

(* 等 价 的 IL 语 言 程 序: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

LD	0

ST	nb_written

LD 	file_id	(* 写 vstart *)

FA_WRITE	vstart

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* 写 vend *)

FA_WRITE	vend

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* 写 vinc *)

FA_WRITE	vinc

ANA

ADD	nb_written

LD	(* 写 delta_tim *)

ANA	(* 变 换 为 整 型*)

ST	ana_delta_tim

LD 	file_id

FA_WRITE	ana_delta_tim

ANA

ADD	nb_written

ST	nb_written

F_CLOSE

ST	ok

LD	nb_written

EQ	4

RETC	(* 等 于 4 时 返 回 *)

LD	ERR_FILE	(* else 错 误 *)

ST	ERROR


FM_READ 从 二 进 制 文 件 中 读 取 信 息

参 数 :

ID	整 型	文 件 号： 由 F_ROPEN 返 回

Q	信 息	从 文 件 读 取 的 信 息 值

说 明 :

自 二 进 制 文 件 中 读 取 信 息 变 量。

与 F_ROPEN 和 F_CLOSE 一 起 使 用。

此 过 程 从 先 前 的 位 置 开 始 对 文 件 进 行 顺 序 访 问。

第 一 次 F_ROPEN 调 用 读 取 文 件 的 第 一 个 字 符 串。

每 次 调 用 将 读 指 针 压 入 堆 栈。

一 个 字 符 串 以 零 符 号 （0）， 行 尾 ('\n') 或 回 车 ('\r') 结 束。

使 用 F_EOF 检 测 是 否 到 达 文 件 尾。

此 函数 不 包 括 在 ISaGRAF 仿 真 器 中。

(* 使 用 文 件 管 理 块 的 FBD 程 序 例 子： *)

(* 等 价 的 ST 语 言 程 序 ：*)

file_id := F_ROPEN('voltramp.bin');

status1 := FM_READ(file_id);

status2 := FM_READ(file_id);

IF (F_EOF(file_id)) THEN

ERROR := ERR_FILE;

unused_eof_mes := FM_READ(file_id);

END_IF;

ok := F_CLOSE(file_id);

(* 等 价 的 IL 语 言 程 序： *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FM_READ	(* 读  status1 *)

ST	status1

LD 	file_id

FM_READ	(* 读  status2 *)

ST	status2

LD 	file_id

F_EOF

JMPNC	CLOSE_FILE (* 如 果 到 达 文 件 尾 则 不 跳 转 *)

LD	ERR_FILE

ST	ERROR

LD 	file_id

FM_READ	(* 读 unused_eof_mes *)

ST	unused_eof_mes

CLOSE_FILE	LD 	file_id

F_CLOSE

ST	ok


FM_WRITE 向 二 进 制 文 件 中 写 入 信 息

参 数 :

ID	整 型	文 件 号： 由 F_WOPEN 返 回

IN	信 息	message value to be written in the file

ok	布 尔	执 行 状 态：

如 果 成 功 则 为 “真”

说 明 ：

向 二 进 制 文 件 中 写 入 信 息 变 量。.

与 F_WOPEN 和 F_CLOSE 一 起 使 用。

写 入 到 文 件 的 信 息 以 null 字 符 结 束。

此 过 程 从 先 前 的 位 置 开 始 对 文 件 进 行 顺 序 访 问。

第 一 次 调 用 F_WOPEN 时 向 文 件 中 写 入 第 一 个 字 符 串。

每 次 调 用 都 将 写 指 针 压 入 堆 栈

此 函数 不 包 括 在 ISaGRAF 仿 真 器 中。

(*  使 用 文 件 管 理 块 的 FBD 程 序 例 子：*)

(* 等 价 的 ST 语 言 程 序 ：: *)

file_id := F_WOPEN('trace.txt');

ok := FM_WRITE(file_id,'First message');

ok := FM_WRITE(file_id,'Last message');

ok := F_CLOSE(file_id);

(* 等 价 的 IL 语 言 程 序: *)

LD	'trace.txt'

F_WOPEN

ST	file_id

FM_WRITE	'First message'	(* write first 信 息 *)

ST	ok

LD 	file_id

FM_WRITE	'Last message'	(* write second 信 息 *)

ST	ok

LD 	file_id

F_CLOSE

ST	ok


按 字 母 排 序 的 索 引

-	ARWRITE	F_ROPEN	MSG	SHR
& (AND)	ASCII	F_TRIG	MUX4	SIG_GEN
*	ASIN	F_WOPEN	MUX8	SIN
/	ATAN	FA_READ	Neg	SQRT
+	AVERAGE	FA_WRITE	NOT_MASK	SR
<	BLINK	FIND	ODD	STACKINT
<=	BOO	FM_READ	OPERATE	SYSTEM
<>	CAT	FM_WRITE	OR_MASK	TAN
=	CHAR	HYSTER	POW	TMR
=1 (XOR)	CMP	INSERT	R_TRIG	TOF
>	COS	INTEGRAL	RAND	TON
>=	CTD	LEFT	REAL	TP
>=1 (OR)	CTU	LIM_ALRM	REPLACE	TRUNC
1 gain	CTUD	LIMIT	RIGHT	XOR_MASK
ABS	DAY_TIME	LOG	ROL
ACOS	DELETE	MAX	ROR
ANA	DERIVATE	MID	RS
AND_MASK	EXPT	MIN	SEL
ARCREATE	F_CLOSE	MLEN	SEMA
ARREAD	F_EOF	MOD	SHL


 FC 语 言

流 程 图 (FC) 是 用 于 描 述 顺 序 操 作 的 一 种 图 形 语 言。 流 程 图 由 动 作 和 测 试 组 成。 在 动 作 和 测 试 之 间 是 代 表 数 据 流 的 定 向 链 接。 动 作 和  测 试 可 用 ST, LD, IL 语 言 描 述。 可 以 从 动 作 和 测 试 中 调 用 任 何 语 言 （ SFC 除 外） 的 功 能 和 功 能 块。一 个 流 程 图 程 序 可 以 调 用 另 一 个 流 程 图 程 序。 被 调 用 的 FC 程 序 是 正 在 进 行 调 用 的 FC  程 序 的 子 程 序。

FC 基 本 部 件

FC 复 杂 结 构 举 例

FC 动 态 行 为

FC 校 验


FC 基 本 部 件

下 面 是 流 程 图 语 言 的 图 形 部 件：

FC 图 的 开 始

FC 图 的 结 束

FC 流 程 的 链 接

FC 动 作

FC 条 件

FC 子- 程 序

FC 输 入 输 出 特 有 的 动 作

FC 连 接 符

FC 注 释


FC 图 的 开 始

一 个 " 开 始" 符 必 须 出 现 在 一 个 流 程 图 程 序 的 开 头。 它 是 唯 一 的  并 且 不 能 省 略。 当 它 被 激 活 时， 它 表 示 流 程 图 的 初 始 状 态。 下 面 是 一 个 " 开 始" 符 的 图 形:

“开 始” 符 总 是 与 流 程 图 的 其 它 对 象 处 于 连 接 状 态 (在 底 部)。 如 果 从 “开 始” 到 其 它 目 标 没 有 画 连 接 线， 则 该 流 程 图 无 效。


FC 图 的 结 束

 一 个 “结 束” 符 必 须 出 现 在 一 个 流 程 图 程 序 的 结 尾。 它 是 唯 一 的， 并 且 不 能 省 略。 有 时 可 能 没 有 给 “结 束” 符 画 连 线 ( 永 远 循 环 的 流 程 图)， 但 不 管 怎 样， 在 流 程 图 的 底 部 仍 要 画 出 “结 束” 符。 当 程 序 的 执 行 被 完 成 时， 它 表 示流 程 图 的 最 后 状 态。 下 面 是 一 个 “结 束” 符 的 图 形:

一 般 来 说，" 结 束" 符 与 流 程 图 的 其 它 目 标 处 于 连 接 状 态 (在 顶 部)。 一 张 流 程 图 与 " 结 束" 对 象 没 有 连 接 ( 永 远 循 环 的 流 程 图)。 在 这 种 情 况 下， 在 流 程 图 的 底 部 仍 可 看 到 " 结 束" 目 标。


FC 流 程 的 链 接

一 个 流 程 的 链 接 是 表 示 图 形 两 点 之 间 信 息 流 的 一 条 线。 一 个 链 接 总 是 以 一 个 箭 头 结 束。 下 面 是 一 个 流 程 的 链 接:

两 个 链 接 不 能 与 同 一 个 源 连 接 点 相 连。


FC 动 作

一 个 动 作 符 号 代 表 将 被 完 成 的 动 作。 一 个 动 作 用 一 个 号 码 和 一 个 名 称 来 识 别。 下 面 是 一 个 “动 作” 符 号 的 图 形:

同 一 个 流 程 图 的 两 个 不 同 对 象 不 能 使 用 同 一 名 称 或 逻 辑 号。 一 个 动 作 的 编 程 语 言 可 以 是 ST, LD 或IL. 一 个 动 作 总 是 与 链 接 相 连， 其 中 一 个 链 接 表 示 到 达 动 作， 另 一 个 链 接 表 示 从 动 作 开 始。


FC 条 件

一 个 条 件 表 示 一 个 布 尔 量 的 测 试。 一 个 条 件 用 一 个 号 码 和 一 个 名 称 来 识 别。 根 据 对 所 附 带 的 ST, LD  或 IL 表 达 式 所 作 的 判 定， 程 序 的 流 程 被 指 向 "YES"  或 "NO"  路 经。 下 面 是 一 个 条 件 符 号 可 能 具 有 的 图 形:

同 一 个 流 程 图 的 两 个 不 同 对 象 不 能 使 用 同 一 名 称 或 逻 辑 号。 一 个 测 试 的 编 程 或 是

- 一 个 ST 语 言 的 表 达 式， 或 者 是

- LD 语 言 的 一 个 单 独 梯 级， 在 唯 一 的 一 个 线 圈 上 不 附 带 符 号。 或 者 是

- 几 条 IL 指 令。 IL 寄 存 器 （ 或 当 前 结 果） 被 用 于 评 判 条 件。

当 用 ST 文 本 编 程 时，  可 供 选 择 的 一 种 方 式 是， 在 表 达 式 后 跟 一 个 分 号。 用 LD 编 程 时， 那 个 唯 一 的 线 圈 表 示 条 件 值。 一 个 条 件 等 于:

- 0 或 FALSE 把 流 程 引 向 NO

- 1 或 TRUE  把 流 程 引 向 YES

一 个 测 试 总 是 与 一 个 到 达 的 链 接 相 连， 并 且 必 须 对 两 个 向 前 的 连 接 进 行 定 义。


FC 子 程 序

本 系 统 能 够 对 FC 程 序 的 垂 直 结 构 进 行 描 述。 FC 程 序 是 一 个 有 层 次 的 树 形 结 构。 每 一 个 FC 程 序 可 以 调 用 另 一 个 FC 程 序。 这 样 的 一 个 程 序 被 称 为 FC 程 序 的 子 程 序， 子 程 序 由 FC 程 序 来 调 用。 调 用 FC 子 程 序 的 FC  程 序 被 称 为 父 程 序。 用 一  种 " 父 - 子" 关 系 把 FC 程 序 链 接 在 一 起， 形 成 一 个 有 层 次 的 树 状 主 干 结 构:

流 程 图 中 的 一 个 子 程 序 符 号 表 示 对 一 个 流 程 图 子 程 序 的 调 用。 正 在 调 用 子 程 序 的 FC 程 序 被 暂 停 执 行， 直 到 子 程 序 执 行 完 毕。 一 个 流 程 图 的 子 程 序 用 一 个 号 码 和 一 个 名 称 来 识 别， 作 为 另 外 的 程 序、 功 能 或 功 能 块。 下 面  是 一 个 “子 程 序 调 用” 符 号 的 图 形:

同 一 个 流 程 图 的 两 个 不 同 的 目 标 不 能 使 用 相 同 的 逻 辑 编 号。 FC 层 次 结 构 所 包 含 的 基 本 规 则 是:

- 没 有 上 级 程 序 的 FC 主程 序

- 当 应 用 程 序 启 动 时， 由 系 统 激 活 FC 主 程 序

- 一 个 程 序 可 以 有 几 个 子 程 序

- 一 个 程 序 的 子 程 序 不 能 有 一 个 以 上 的 主 程 序

- 一 个 子 程 序 仅 由 其 主 程 序 调 用

- 一 个 程 序 不 能 调 用 它 自 己 的 子 程 序 的 子 程 序

同 一 个 子 程 序 可 以 在 主 流 程 图 中 出 现 数 次。 一 个 流 程 图 调 用 子 程 序 表 示 该 子 流 程 图 被 完 全 执 行。 在 子 流 程 图 运 行 期 间， 暂 停 执 行 主 流 程 图。 子 程 序 正 在 调 用 的 功 能 块 所 必 须 遵 循 的 连 接 规 则 与 为 FC 动 作 所 制 定 的 规 则 相 同。


FC 输 入 / 输 出 特 定 动 作

一 个 输 入/ 输 出 特 定 动 作 符 号 表 示 所 要 完 成 的 动 作。 与 其 它 动 作 一 样， 一 个 输 入/ 输 出 特 定 动 作 也 是 用 一 个 号 码 和 一 个 名 称 来 识 别。 在 标 准 动 作 和 输 入/输 出 特 定 的 动 作 上 使 用 相 同 的 语 义。 输 入/输 出 特 定 动 作 的 目 的 仅 仅 是 使 流 程 图 更 加 易 读 ，并 集 中 在 流 程 图 的 不 可 移 动 部 分。 使 用 输 入/输 出 特 定 动 作 是 一 个 供 用 户 选 择 的 功 能。 下 面 是 一 个 “ 输 入 / 输 出 特 定 动 作” 符 的 图 形:

输 入 / 输 出 特 殊 块 与 标 准 动 作 具 有 完 全 相 同 的 特 点， 包 括 相 同 的 属 性， 相 同 的 ST, LD  或 IL 编 程 及 相 同 的 连 接 规 则。


FC 连 接 符

连 接 符 用 于 表 示 未 画 出 的 图 形 两 点 之 间 的 一 个 链 接。 一 个 连 接 符 用 一 个 圆 来 表 示 并 被 连 接 到 流 程 的 源 点。 连 接 符 图 形 是 在 适 当 的 边 上 （取 决 于 数 据 流 的 方 向） 通 过 对 目 标 点 （一 般 是 目 标 符 的 名 称） 的 识 别 来 完 成 的。 下 面 是 一 个 连 接 符 的 标 准 图 形:

一 个 连 接 符 总 是 把 一 个 定 义 的 流 程 图 符 号 作 为 目 标。 目 标 符 用 它 的 逻 辑 编 号 来 识 别。


FC 注 释

一 个 注 释 框 包 含 有 文 本， 该 文 本 没 有 流 程 图 语 义 上 的 意 义。 在 流 程 图 文 件 窗 口 上 可 以 把 文 本 插 入 到 未 使 用 空 间 的 任 何 地 方， 并 用 于 给 程 序 提 供 资 料。 下 面 是 一 个“ 注 释” 符 的 图 形：


FC 复 杂 结 构 举 例

这 部 分 给 出 了 复 杂  结 构 的 例 子， 可 以 把 它 们 定 义 在 流 程 图 中。 这 种 结 构 是 链 接 在 一 起 的 基 本 对 象 的 组 合。

	IF / THEN / ELSE (1) 用 于 插 入 "THEN"  动 作 的 地 方 (2) 用 于 插 入 "ELSE"  动 作 的 地 方
	REPEAT / UNTIL (3) 用 于 插 入 循 环 动 作 的 地 方
	WHILE / DO (4) 用 于 插 入 循 环 动 作 的 地 方


FC 动 态 行 为

 对 流 程 图 的 执 行 可 作 如 下 解 释：

- 开 始 符 号 获 得 一 个 目 标 周 期

- 结 束 符 号 获 得 一 个 目 标 周 期 并 结 束 流 程 图 的 执 行。 在 程 序 到 达 该 符 号  后 不 再 执 行 流 程 图 的 动 作。

- 在 同 一 目 标 周 期 中， 如 果 流 程 遇 到 一 个 已 经 被 执 行 的 动 作 或 判 定， 流 程 将 被 中 断。 在 上 述 情 况 下， 流 程 将 继 续 下 一 个 周 期。

注 意： 与 SFC 相 反， 一 个 动 作 不 是 一 个 稳 定 的 状 态。 在 动 作 符 号 高 亮 显 示 期 间 不 重 复 执 行 指 令。


FC 校 验

除 了 附 加 的 ST, LD  或 IL 编 程 外, 其 它 一 些 语 法 规 则 也 适 用 于 流 程 图 本 身。 下 面 是 主 要 规 则 表：

- 所 有 符 号 的 所 有 “连 接” 点 必 须 用 线 连 接。（ 可 以 省 略 与 “结 束” 符 号 的 连 接）

- 所 有 符 号 必 须 链 接 在 一 起 （ 不 应  出 现 分 隔 部 分）

- 所 有 连 接 符 应 该 有 有 效 的 目 标

其 它 小 的 语 法 错 误 告 知 如 下：

- 空 动 作 （ 没 有 编 程） 被 认 为 是 运 行 时 间 表 内 的 步

- 空 测 试 （ 没 有 编 程） 被 认 为 “ 总 是 真 ”