西门子S7-1200 SCL编程指令手册

SCL (S7-1200, S7-1500)
SCL
该章节包括以下主题的信息:
• 位逻辑运算 (S7-1200, S7-1500)
• 定时器操作 (S7-1200, S7-1500)
• 计数器操作 (S7-1200, S7-1500)
• 比较运算 (S7-1200, S7-1500)
• 数学函数 (S7-1200, S7-1500)
• 移动操作 (S7-1200, S7-1500)
• 转换操作 (S7-1200, S7-1500)
• 程序控制指令 (S7-1200, S7-1500)
• 字逻辑运算 (S7-1200, S7-1500)
• 移位和循环 (S7-1200, S7-1500)
• 传统 (S7-1500)
-1-
位逻辑运算 (S7-1200, S7-1500)
位逻辑运算
• R_TRIG:检测信号上升沿 (S7-1200, S7-1500)
• F_TRIG:检测信号下降沿 (S7-1200, S7-1500)
-2-
R_TRIG:检测信号上升沿 (S7-1200, S7-1500)
R_TRIG:检测信号上升沿
说明
使用“检测信号上升沿”指令，可以检测输入 CLK 的从“0”到“1”的状态变化。该指令将输入 CLK 的当前值
与保存在指定实例中的上次查询（边沿存储位）的状态进行比较。如果该指令检测到输入 CLK 的状态
从“0”变成了“1”，就会在输出 Q 中生成一个信号上升沿，输出的值将为 TRUE 或“1”一个周期。
在其它任何情况下，该指令输出的信号状态均为“0”。
将该指令插入程序中时，将自动打开“调用选项”(Call options) 对话框。在该对话框中，可以指定将边沿
存储位存储在自身数据块中（单背景）或者作为局部变量存储在块接口中（多重背景）。
语法
“检测信号上升沿”指令的语法如下所示：
SCL
<实例>(CLK:= <操作数>,
Q => <操作数>)
参数
下表列出了“检测信号上升沿”指令的参数：
参数声明数据类型存储区说明
到达信号，将查询该信号的边
CLK Input BOOL I、Q、M、D、L
沿
Q Output BOOL I、Q、M、D、L 边沿检测的结果
示例
以下示例说明了该指令的工作原理：
SCL
"R_TRIG_DB"(CLK := "TagIn",
Q => "TagOut");
输入 CLK 中变量的上一个状态存储在“R_TRIG_DB”变量中。如果在操作数“TagIn_1”和“TagIn_2”或在
操作数“TagIn_3”中检测到信号状态从“0”变为“1”，则输出“TagOut_Q”的信号状态为“1”一个周期。
-3-
F_TRIG:检测信号下降沿 (S7-1200, S7-1500)
F_TRIG:检测信号下降沿
说明
使用“检测信号下降沿”指令，可以检测输入 CLK 的从“1”到“0”的状态变化。该指令将输入 CLK 的当前值
与保存在指定实例中的上次查询（边沿存储位）的状态进行比较。如果该指令检测到输入 CLK 的状态
从“1”变成了“0”，就会在输出 Q 中生成一个信号下降沿，即输出的值将为 TRUE 或“1”一个周期。
在其它任何情况下，该指令输出的信号状态均为“0”。
将该指令插入程序中时，将自动打开“调用选项”(Call options) 对话框。在该对话框中，可以指定将边沿
存储位存储在自身数据块中（单背景）或者作为局部变量存储在块接口中（多重背景）。
语法
“检测信号下降沿”指令的语法如下所示：
SCL
<实例>(CLK:= <操作数>,
Q => <操作数>)
参数
下表列出了“检测信号下降沿”指令的参数：
到达信号，将查询该
CLK Input BOOL I、Q、M、D、L
信号的边沿
Q Output BOOL I、Q、M、D、L 边沿检测的结果
示例
SCL
"F_TRIG_DB"(CLK := "TagIn",
Q => "TagOut");
输入 CLK 中变量的上一个状态存储在“F_TRIG_DB”变量中。如果检测到操作数“TagIn”的信号状态从
“1”变为“0”，则输出“TagOut”的信号状态为“1”。
-4-
定时器操作 (S7-1200, S7-1500)
定时器操作
• TP：生成脉冲 (S7-1200, S7-1500)
• TON：接通延时 (S7-1200, S7-1500)
• TOF：关断延时 (S7-1200, S7-1500)
• TONR：时间累加器 (S7-1200, S7-1500)
• RESET_TIMER：复位定时器 (S7-1200, S7-1500)
• PRESET_TIMER：加载持续时间 (S7-1200, S7-1500)
• 传统 (S7-1500)
-5-
TP：生成脉冲 (S7-1200, S7-1500)
TP：生成脉冲
说明
使用“生成脉冲”指令来设置持续时间 PT 的参数 Q。当参数 IN 的逻辑运算结果 (RLO) 从“0”变为“1”（信
号上升沿）时，启动该指令。指令启动时，预设的时间 PT 即开始计时。随后无论输入信号如何改变，
都会将参数 Q 设置为时间 PT。如果持续时间 PT 仍在计时，即使检测到新的上升沿，参数 Q 的信号状
态也不会受到影响。
可通过 ET 参数查询当前的时间值。该时间值从 T#0s 开始，在达到持续时间 PT 后结束。达到持续时
间 PT 时，且参数 IN 的信号状态为“0”，则复位参数 ET。
说明
如果程序中未调用定时器（这是因为会忽略定时器），则输出 ET 会在定时器计时结束后立即返回一
个常数值。
每次调用“生成脉冲”指令，都会为其分配一个 IEC 定时器用于存储指令数据。
对于 S7-1200 CPU
IEC 定时器是一个 IEC_TIMER 或 TP_TIME 数据类型的结构，可如下声明：
• 声明为一个系统数据类型为 IEC_TIMER 的数据块（例如，“MyIEC_TIMER”）
• 声明为块中“Static”程序段内类型为 TP_TIME 的局部变量（例如，#MyTP_TIMER）
对于 S7-1500 CPU
IEC 定时器是一个 IEC_TIMER、IEC_LTIMER、TP_TIME 或 TP_LTIME 数据类型的结构，可如下声明：
• 声明为一个系统数据类型为 IEC_TIMER 或 IEC_LTIMER 的数据块（例如，“MyIEC_TIMER”）
• 声明为块中“Static”部分的 TP_TIME 或 TP_LTIME 类型的局部变量（例如，#MyTP_TIMER）
在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 定时器将存储在自身数

据块中（单个背景）或者作为局部变量存储在块接口中（多重背景）。如果创建了一个单独的数据块，
则该数据块将保存到项目树“程序块 > 系统块”(Program blocks > System blocks) 路径中的“程序资源”
(Program resources) 文件夹内。有关本主题的更多信息，请参见“另请参见”。
只有在调用该指令且每次都会访问 Q 或 ET 输出时，才会更新指令数据。
语法
“生成脉冲”指令的语法如下所示：
• 系统数据类型为 IEC_Timer 的数据块（全局 DB）：
SCL
<IEC_Timer_DB> TP(IN := <操作数>,
PT := <操作数>,
Q => <操作数>,
ET => <操作数>)
• 局部变量：
-6-
TP：生成脉冲 (S7-1200, S7-1500)
SCL
#myLocal_timer(IN := <操作数>,
PT := <操作数>,
Q => <操作数>,
ET => <操作数>)
该指令的语法由以下部分组成：
S7-1200 S7-1500
I、Q、M、D、
IN Input BOOL BOOL 启动输入
L、P
脉冲的持续时
TIME, I、Q、M、D、间。
PT Input TIME
LTIME L、P PT 参数的值必
须为正数。
在 PT 持续时间
I、Q、M、D、
Q Output BOOL BOOL 内保持置位状
L、P
态的操作数。
TIME, I、Q、M、D、
ET Output TIME 当前时间值
LTIME L、P
有关有效数据类型的更多信息，请参见“另请参见”。
脉冲时序图
下图显示了“生成脉冲”指令的脉冲时序图：
示例
-7-
TP：生成脉冲 (S7-1200, S7-1500)
SCL
"TP_DB".TP(IN := "Tag_Start",
PT := "Tag_PresetTime",
Q => "Tag_Status",
ET => "Tag_ElapsedTime");
当“Tag_Start”操作数的信号状态从“0”变为“1”时，PT 参数预设的时间段开始计时，同时“Tag_Status”操
作数置位为“1”。当前时间值存储在“Tag_ElapsedTime”操作数中。
-8-
TON：接通延时 (S7-1200, S7-1500)
TON：接通延时
说明
可以使用“接通延时”指令将 Q 参数的设置延时 PT 指定的一段时间。当参数 IN 的逻辑运算结果 (RLO)
从“0”变为“1”（信号上升沿）时，启动该指令。指令启动时，预设的时间 PT 即开始计时。超过持续时
间 PT 时，参数 Q 的信号状态变为“1”。只要启动输入仍为“1”，参数 Q 就保持置位。如果 IN 参数的信
号状态从“1”变为“0”，则复位参数 Q。当在参数 IN 上检测到一个新的信号上升沿时，将重新启动定时器
功能。
可通过 ET 参数查询当前的时间值。该时间值从 T#0s 开始，在达到持续时间 PT 后结束。只要参数 IN
的信号状态变为“0”，就立即复位 ET 参数。
说明
个常数值。
每次调用“接通延时”指令，必须将其分配给存储指令数据的 IEC 定时器。
对于 S7-1200 CPU
IEC 定时器是一个 IEC_TIMER 或 TON_TIME 数据类型的结构，可如下声明：
• 声明为块中“Static”程序段内类型为 TON_TIME 的局部变量（例如，#MyTON_TIMER）
对于 S7-1500 CPU
IEC 定时器是一个 IEC_TIMER、IEC_LTIMER、TON_TIME 或 TON_LTIME 数据类型的结构，可如下
声明：
• 声明为块中“Static”部分的 TON_TIME 或 TON_LTIME 类型的局部变量（例如，#MyTON_TIMER）

语法
“接通延时”指令的语法如下所示：
SCL
<IEC_Timer_DB> TON(IN := <操作数>,
PT := <操作数>,
Q => <操作数>,
ET => <操作数>)
-9-
TON：接通延时 (S7-1200, S7-1500)
• 局部变量：
SCL
PT := <操作数>,
Q => <操作数>,
ET => <操作数>)
S7-1200 S7-1500
I、Q、M、D、
L、P
接通延时的持
TIME, I、Q、M、D、续时间。
PT Input TIME
须为正数。
定时器 PT 内时
I、Q、M、D、间用完时，保持
Q Output BOOL BOOL
L、P 置位状态的操
作数。
LTIME L、P
脉冲时序图
下图显示了“接通延时”指令的脉冲时序图：
- 10 -
TON：接通延时 (S7-1200, S7-1500)
示例
SCL
"TON_DB".TON(IN := "Tag_Start",
Q => "Tag_Status",
当“Tag_Start”操作数的信号状态从“0”变为“1”时，则 PT 参数指定的时间开始计时。在巴氏消毒时段结束
后，操作数“Tag_Status”的信号状态将置位为“1”。只要操作数“Tag_Start”的信号状态为“1”，操作数
“Tag_Status”就会保持信号状态设置为“1”。当前时间值存储在“Tag_ElapsedTime”操作数中。当操作
数 Tag_Start 的信号状态从“1”变为“0”时，将复位操作数 Tag_Status。
- 11 -
TOF：关断延时 (S7-1200, S7-1500)
TOF：关断延时
说明
可以使用“关断延时”指令将 Q 参数的复位延时 PT 指定的一段时间。当参数 IN 的逻辑运算结果 (RLO)
从“0”变为“1”（信号上升沿）时，置位参数 Q。当 IN 参数的信号状态变回“0”时，预设的时间 PT 开始计
时。只要持续时间 PT 仍在计时，参数 Q 就保持置位状态。超过时间 PT 时，将复位参数 Q。如果参
数 IN 的信号状态在持续时间 PT 用完之前变为“1”，则复位此定时器。参数 Q 的信号状态保持置位为
“1”。
可通过 ET 参数查询当前的时间值。该时间值从 T#0s 开始，在达到持续时间 PT 后结束。在持续时间
PT 过后，在参数 IN 重新变为“1”之前，参数 ET 会一直保持为当前值。如果参数 IN 在时间 PT 用完之
前变为“1”，则参数 ET 将复位为值 T#0s。
说明
个常数值。
每次调用“关断延时”指令，必须将其分配给存储指令数据的 IEC 定时器。
对于 S7-1200 CPU
IEC 定时器是一个 IEC_TIMER 或 TOF_TIME 数据类型的结构，可如下声明：
• 声明为块中“Static”程序段内类型为 TOF_TIME 的局部变量（例如，#MyTOF_TIMER）
对于 S7-1500 CPU
IEC 定时器是一个 IEC_TIMER、IEC_LTIMER、TOF_TIME 或 TOF_LTIME 数据类型的结构，可如下声
明：
• 声明为块中“Static”部分的 TOF_TIME 或 TOF_LTIME 类型的局部变量（例如，#MyTOF_TIMER）

语法
“关断延时”指令的语法如下所示：
SCL
<IEC_Timer_DB> TOF(IN := <操作数>,
PT := <操作数>,
Q => <操作数>,
- 12 -
TOF：关断延时 (S7-1200, S7-1500)
ET => <操作数>)
• 局部变量：
SCL
PT := <操作数>,
Q => <操作数>,
ET => <操作数>)
S7-1200 S7-1500
I、Q、M、D、
L、P
关断延时的持
TIME, I、Q、M、D、续时间。
PT Input TIME
须为正数。
I、Q、M、D、超出时间 PT 后
Q Output BOOL BOOL
L、P 复位的操作数。
LTIME L、P
脉冲时序图
下图为“关断延时”指令的时序图：
- 13 -
TOF：关断延时 (S7-1200, S7-1500)
示例
SCL
"TOF_DB".TOF(IN := "Tag_Start",
Q => "Tag_Status",
“Tag_Start”操作数的信号状态从“0”变为“1”时，将置位“Tag_Status”操作数。当“Tag_Start”操作数的信号
状态从“1”变为“0”时，则 PT 参数指定的时间开始计时。只要该时间仍在计时，“Tag_Status”操作数就会
保持置位状态。该时间计时完毕后，将复位“Tag_Status”操作数。当前时间值存储在“Tag_Elapsed‐
Time”操作数中。
- 14 -
TONR：时间累加器 (S7-1200, S7-1500)
TONR：时间累加器
说明
“时间累加器”指令用于在参数 PT 设置时间段内的计时。参数 IN 的信号状态变为“1”时，执行该指令并且
从 PT 设置的时间开始计时。时间 PT 计时过程中，如果 IN 参数信号状态为“1”，则记录的时间值将进
行累加。累加后的时间将在参数 ET 中输出以供查询。达到时间 PT 时，参数 Q 的信号状态变为“1”。
即使 IN 参数的信号状态变为“0”，Q 参数仍将保持置位为“1”。
不论参数 IN 的信号状态如何，参数 R 都将复位参数 ET 和 Q。
每次调用“时间累加器”指令，必须将其分配给存储指令数据的 IEC 定时器。
对于 S7-1200 CPU
IEC 定时器是一个 IEC_TIMER 或 TONR_TIME 数据类型的结构，可如下声明：
• 声明为块中“Static”程序段内类型为 TONR_TIME 的局部变量（例如，#MyTONR_TIMER）
对于 S7-1500 CPU
IEC 定时器是一个 IEC_TIMER、IEC_LTIMER、TONR_TIME 或 TONR_LTIME 数据类型的结构，可如
下声明：
• 声明为块中“Static”部分的 TONR_TIME 或 TONR_LTIME 类型的局部变量（例如，#MyTONR_TIM‐
ER）
语法
“时间累加器”指令的语法如下所示：
SCL
<IEC_Timer_DB> TONR(IN := <操作数>,
R := <操作数>,
PT := <操作数>,
Q => <操作数>,
ET => <操作数>)
• 局部变量：
- 15 -
TONR：时间累加器 (S7-1200, S7-1500)
SCL
R := <操作数>,
PT := <操作数>,
Q => <操作数>,
ET => <操作数>)
S7-1200 S7-1500
I、Q、M、D、
L、P
I、Q、M、D、复位参数 ET 和
R Input BOOL BOOL
L、P Q
时间记录的最
TIME, I、Q、M、D、长持续时间。
PT Input TIME
须为正数。
定时器 PT 内时
I、Q、M、D、间用完时，仍保
Q Output BOOL BOOL
L、P 持置位状态的
操作数。
ET Output TIME 累计的时间
LTIME L、P
脉冲时序图
下图为“时间累加器”指令的脉冲时序图：
- 16 -
TONR：时间累加器 (S7-1200, S7-1500)
示例
SCL
"TONR_DB".TONR(IN := "Tag_Start",
R := "Tag_Reset",
Q => "Tag_Status",
ET => "Tag_Time");
当“Tag_Start”操作数的信号状态从“0”变为“1”时，则 PT 参数指定的时间开始计时。当定时器正在运行
时，将累加操作数“Tag_Start”信号状态为“1”时所记录的定时器值。累加后的时间将存储在“Tag_Time”操
作数中。达到 PT 参数处所显示的定时器值时，“Tag_Status”操作数将置位为信号状态“1”。当前时间值
存储在“Tag_Time”操作数中。
- 17 -
RESET_TIMER：复位定时器 (S7-1200, S7-1500)
RESET_TIMER：复位定时器
说明
使用“复位定时器”指令，可将 IEC 定时器复位为“0”。将指定数据块中定时器的结构组件复位为“0”。
该指令不会影响 RLO。在 TIMER 参数中，将“复位定时器”指令分配给程序中所声明的 IEC 定时器。该
指令必须在 IF 指令中编程。只有在调用指令时才更新指令数据，而不是每次都访问分配的 IEC 定时
器。只有在指令的当前调用到下一次调用期间，数据查询的结果才相同。
语法
“复位定时器”指令的语法如下所示：
SCL
RESET_TIMER（TIMER := <IEC 定时器>）
参数
下表列出了“复位定时器”指令的参数：
S7-1200 S7-1500
IEC_TIM‐
ER、
IEC_LTI‐
MER、
TP_TIME、
IEC_TIMER, TP_LTIME、
TP_TIME, TON_TIME、
TON_TIME, TON_LTIME 待复位的 IEC 定
<IEC 定时器> Output D、L
TOF_TIME, 、时器
TONR_TIM TOF_TIME、
E TOF_LTIME
、
TONR_TIM
E、
TONR_LTIM
E
示例
SCL
IF #started = false THEN
- 18 -
RESET_TIMER：复位定时器 (S7-1200, S7-1500)
Q => "Tag_Status",
#started := true;
END_IF;
IF "TON_DB".ET < T#25s THEN

RESET_TIMER(TIMER := "TON_DB");
#started := false;
END_IF;
当变量 #started 的信号状态为“0”时，则在操作数“Tag_Start”上出现信号上升沿时执行“接通延时”指令。
存储在背景数据块“TON_DB”中的 IEC 定时器启动，持续操作数“Tag_PresetTime”中已指定的一段时
间。 // 如果超出“Tag_PresetTime”操作数中指定的持续时间，则置位操作数 Tag_Status。 // 只要操作
数“Tag_Start”的信号状态为“1”，则参数 Q 将保持置位。启动输入的信号状态从“1”变为“0”时，复位参
数 Q 的操作数。
如果 IEC 定时器“TON_DB”的超出时间小于 25s，则执行“复位定时器”指令，并复位存储在“TON_DB”背
景数据块中的定时器。
- 19 -
PRESET_TIMER：加载持续时间 (S7-1200, S7-1500)
PRESET_TIMER：加载持续时间
说明
可以使用“加载持续时间”指令为 IEC 定时器设置时间。如果该指令输入逻辑运算结果 (RLO) 的信号状
态为“1”，则每个周期都执行该指令。该指令将指定时间写入指定 IEC 定时器的结构中。
说明
如果在指令执行时指定 IEC 定时器正在计时，指令将覆盖该指定 IEC 定时器的当前值。这将更改
IEC 定时器的定时器状态。
可以将在程序中声明的 IEC 定时器赋给“加载持续时间”指令。

只有在调用指令时才更新指令数据，而且每次都访问分配的 IEC 定时器。查询 Q 或 ET 时（例如
“MyTimer”.Q 或“MyTimer”.ET），将更新 IEC_TIMER 的结构。
语法
“加载定时器值”指令的语法如下所示：
SCL
PRESET_TIMER(PT := <操作数>,
TIMER := <IEC 定时器>
参数
下表列出了“加载持续时间”指令的参数：
S7-1200 S7-1500
TIME, IEC 定时器运行
<持续时间> Input TIME I、Q、M、D、L
LTIME 的持续时间。
IEC_TIMER,
IEC_LTI‐
MER,
TP_TIME,
TP_LTIME,
IEC_TIMER,
TON_TIME,
TP_TIME,
TON_LTIME
TON_TIME, 设置了持续时间
<IEC 定时器> Output , D、L
TOF_TIME, 的 IEC 定时器。
TOF_TIME,
TONR_TIM
TOF_LTIME
E
,
TONR_TIM
E,
TONR_LTIM
E
- 20 -
PRESET_TIMER：加载持续时间 (S7-1200, S7-1500)
示例
SCL
IF #started := false; THEN
Q => "Tag_Status",
#started := true;
#preset = true
END_IF;
IF "TON_DB".ET < T#10s AND #preset = true THEN

PRESET_TIMER(PT := T#25s,
TIMER := "TON_DB");
#preset := false;
END_IF;
当变量 #started 的信号状态为“0”时，则在操作数“Tag_Start”上出现信号上升沿时执行“接通延时”指令。
存储在背景数据块“TON_DB”中的 IEC 定时器启动，持续操作数“Tag_PresetTime”中已指定的一段时
间。 // 如果超出“Tag_PresetTime”操作数中指定的持续时间 PT，则置位操作数 Tag_Status。 // 只要操
作数“Tag_Start”的信号状态为“1”，则参数 Q 将保持置位。启动输入的信号状态从“1”变为“0”时，复位参
数 Q 的操作数。
当 IEC 定时器“TON_DB”的超出时间小于 10s，且变量 #preset 的信号状态为“1”时，执行“加载持续时
间”指令。该指令将参数 PT 处指定的持续时间写入背景数据块“TON_DB”中，因此将覆盖背景数据块中
操作数“Tag_PresetTime”的时间值。因此，在下一次查询或访问“TON_DB”.Q 或“TON_DB”.ET 时，定
时器状态的信号状态可能会发生变化。
- 21 -
传统 (S7-1500)
传统
• S_PULSE：分配脉冲定时器参数并启动 (S7-1500)
• S_PEXT：分配扩展脉冲定时器参数并启动 (S7-1500)
• S_ODT：分配接通延时定时器参数并启动 (S7-1500)
• S_ODTS：分配保持型接通延时定时器参数并启动 (S7-1500)
• S_OFFDT：分配关断延时定时器参数并启动 (S7-1500)
- 22 -
S_PULSE：分配脉冲定时器参数并启动 (S7-1500)
S_PULSE：分配脉冲定时器参数并启动
说明
当检测到参数 S 的逻辑运算结果 (RLO) 从“0”到“1”的变化（信号上升沿）时，“分配脉冲定时器参数并启
动”指令开始计时参数 T_NO 中预设的一段时间。只要 S 参数的信号状态为“1”，定时器便将运行一段预
设的时间 (TV)。
当参数 S 的信号状态在超出预设的时间之前变为“0”时，定时器停止计时，同时“Q”参数复位为“0”。
在内部此时间包括一个时间值和一个时间基准，并在参数 TV 中进行设定。指令启动时，编程的时间值
减计数到 0。时间基准指定时间值更改时的时间增量。通过参数 BI 提供当前时间值。
如果定时器正在计时且输入端 R 的信号状态变为 “1”，则当前时间值和时间基准也将设置为 0。如果定
时器未在计时，则输入 R 的信号状态为“1”不会有任何作用。
只要定时器正在计时且参数 S 的信号状态为“1”，参数 Q 就将返回信号状态“1”。当参数 S 的信号状态在
超出预设的时间之前变为“0”时，则“Q”参数将返回信号状态“0”。如果定时器通过参数 R 复位或超时，则
参数 Q 也将返回信号状态“0”。
每次访问都更新指令数据。因此，周期开始时与周期结束时的数据查询可能会返回不同的值。
说明
在时间单元，操作系统通过时基指定的间隔，以一个时间单位缩短时间值，直到该值为“0”。递减操作
与用户程序不同步执行。因此，定时器中的值比预期的时基最多短一个时间间隔值。
以下给出了如何构造时间单元的一个示例：另请参见“L：加载定时器值”。
语法
“分配脉冲定时器参数并启动”指令的语法如下所示：
SCL
S_PULSE(T_NO := <操作数>,
S := <操作数>,
TV := <操作数>,
R := <操作数>,
Q => <操作数>,
BI => <操作数>)
已启动的定时器。
T_NO Input TIMER, INT T
定时器的数量取决于 CPU。
I、Q、M、D、
S Input BOOL 启动输入
L
- 23 -
S5TIME, I、Q、M、D、
TV Input 预设时间值
WORD L
I、Q、M、D、
R Input BOOL 复位输入
L、P
I、Q、M、D、
Q Output BOOL 定时器的状态
L、P
I、Q、M、D、
BI Output WORD 当前二进制编码的时间值
L、P
I、Q、M、D、
函数值 S5TIME 当前时间值
L
脉冲时序图
下图显示了指令“分配脉冲定时器参数并启动”的脉冲时序图：
示例
SCL
"Tag_Result" := S_PULSE(T_NO := "Timer_1",
- 24 -
S := "Tag_1",
TV := "Tag_Number",
R := "Tag_Reset",
Q := "Tag_Status",
BI := "Tag_Value");
"如果操作数“Tag_1”的信号状态从“0”变为“1”，将启动“Timer_1”。定时器使用操作数“Tag_Number”的时
间值进行减计数，直到操作数 Tag_1 返回信号状态”1“。
如果 S 参数的信号状态在超出预设的时间之前变为“0”，则操作数 Tag_Status 将复位为“0”。如果定时器
由 R 参数复位或定时器已超时，则操作数 Tag_Status 也将返回信号状态“0”。
当前时间值在操作数“Tag_Value”中以二进制编码形式存储，并作为函数值返回。
- 25 -
S_PEXT：分配扩展脉冲定时器参数并启动 (S7-1500)
S_PEXT：分配扩展脉冲定时器参数并启动
说明
当检测到参数 S 的信号上升沿时，“分配扩展脉冲定时器参数并启动”指令将启动预设的定时器。只要 S
参数的信号状态更改为“0”，定时器便将运行一段预设的时间 (TV)。定时器计时时，参数 Q 将返回信号
状态“1”。
定时器达到预置时间时，参数 Q 将复位为“0”。如果在定时器计时期间参数 S 的信号状态从“0”变为“1”，
定时器将在 TV 参数中设置的时间内重新启动。
如果定时器正在计时且参数 R 的信号状态变为 “1”，则当前时间值和时间基准也将设置为 0。如果定时
器未在计时，则参数 R 的信号状态“1”将不起作用。
说明
语法
“分配扩展脉冲定时器参数并启动”指令的语法如下所示：
SCL
S_PEXT(T_NO := <操作数>,
S := <操作数>,
TV := <操作数>,
R := <操作数>,
Q => <操作数>,
BI =><操作数>)
I、Q、M、D、
S Input BOOL 启动输入
L
S5TIME, I、Q、M、D、
TV Input 预设时间值
WORD L
- 26 -
I、Q、M、D、
L、P
I、Q、M、D、
L、P
I、Q、M、D、
L、P
I、Q、M、D、
函数值 S5TIME 当前时间值
L
脉冲时序图
下图为指令“分配扩展脉冲定时器参数并启动”的脉冲时序图：
示例
SCL
"Tag_Result" := S_PEXT(T_NO := "Timer_1",
S := "Tag_1",
TV := "Tag_Number",
- 27 -
R := "Tag_Reset",
Q := "Tag_Status",
BI := "Tag_Value");
"如果操作数“Tag_1”的信号状态从“0”变为“1”，将启动“Timer_1”。定时器计时时，操作数“Tag_Status”将
返回信号状态“1”。定时器达到预置时间时，操作数“Tag_Status”将复位为“0”。如果在定时器计时期间
输入 S 的信号状态从“0”变为“1”，定时器将在“Tag_Number”时间内重新启动。
- 28 -
S_ODT：分配接通延时定时器参数并启动 (S7-1500)
S_ODT：分配接通延时定时器参数并启动
说明
当检测到参数 S 的信号上升沿时，“分配接通延时定时器参数并启动”指令将启动预设的定时器作为接通
延时定时器。只要 S 参数的信号状态为“1”，定时器便将运行一段预设的时间 (TV)。
如果定时器达到预置时间且参数 S 的信号状态仍为“1”，则参数 Q 将返回信号状态“1”。如果在定时器计
时期间参数 S 的信号状态从“1 变为“0”，定时器将停止计时。在这种情况下，将输出 Q 的信号状态复位
为“0”。
如果正在计时且输入端 R 的信号状态从“0”变为 “1”，则当前时间值和时间基准也将设置为 0。这种情况
下，参数 Q 的信号状态为“0”。如果参数 R 的信号状态为“1”，即使定时器尚未运行同时参数 S 处的逻辑
运算结果 (RLO) 为“1”，则将复位定时器。
说明
语法
“分配接通延时定时器参数并启动”指令的语法如下所示：
SCL
S_ODT(T_NO := <操作数>,
S := <操作数>,
TV := <操作数>,
R := <操作数>,
Q => <操作数>,
BI =><操作数>)
S Input BOOL I、Q、M、D、L 启动输入
S5TIME,
TV Input I、Q、M、D、L 预设时间值
WORD
- 29 -
I、Q、M、D、L、
P
P
P
函数值 S5TIME I、Q、M、D、L 当前时间值
脉冲时序图
下图显示了指令“分配接通延时定时器参数并启动”的脉冲时序图：
示例
SCL
"Tag_Result" := S_ODT(T_NO := "Timer_1",
S := "Tag_1",
TV := "Tag_Number",
R := "Tag_Reset",
Q := "Tag_Status",
- 30 -
BI := "Tag_Value");
"如果操作数“Tag_1”的信号状态从“0”变为“1”，将启动“Timer_1”。只要操作数“Tag_1”的信号状态为“1”，
定时器就将在持续时间“Tag_Number”内一直计时。
如果定时器达到预置时间且操作数“Tag_Status”的信号状态为“1”，则操作数“Tag_Status”将复位为“1”。
如果在定时器计时期间操作数“Tag_1”的信号状态从“1 变为“0”，定时器将停止计时。这种情况下，操作
数“Tag_Status”将返回信号状态“0”。
- 31 -
S_ODTS：分配保持型接通延时定时器参数并启动 (S7-1500)
S_ODTS：分配保持型接通延时定时器参数并启动
说明
当检测到参数 S 的信号上升沿时，“分配保持型接通延时定时器参数并启动”指令将启动预设的定时器。
只要 S 参数的信号状态更改为“0”，定时器便将运行一段预设的时间 (TV)。
无论“S”参数的信号状态如何，只要定时器超时，参数“Q”都将返回信号状态“1”。如果在定时器计时期间
参数 S 的信号状态从“0”变为“1”，定时器将在预设的时间 TV 内重新启动。
参数 R 的信号状态为“1”则当前时间值和时间基准被复位为“0”，而与参数 S 的信号状态无关。这种情况
下，参数 Q 的信号状态为“0”。
说明
语法
“分配保持型接通延时定时器参数并启动”指令的语法如下所示：
SCL
S_ODTS(T_NO := <操作数>,
S := <操作数>,
TV := <操作数>,
R := <操作数>,
Q => <操作数>,
BI =><操作数>)
S5TIME,
WORD
P
- 32 -
P
P
脉冲时序图
下图为指令“分配保持型接通延时定时器参数并启动”的脉冲时序图：
示例
SCL
"Tag_Result" := S_ODTS(T_NO := "Timer_1",
S := "Tag_1",
TV := "Tag_Number",
R := "Tag_Reset",
Q := "Tag_Status",
BI := "Tag_Value");
"如果操作数“Tag_1”的信号状态从“0”变为“1”，将启动“Timer_1”。定时器的运行时间为“Tag_Number”。
如果定时器已达到预置时间，则操作数“Tag_Status”将返回信号状态“1”，而与操作数“Tag_1”的信号状态
无关。如果在定时器计时期间操作数 Tag_1 的信号状态从“0”变为“1”，定时器将在“Tag_Number”时间内
重新启动。
- 33 -
- 34 -
S_OFFDT：分配关断延时定时器参数并启动 (S7-1500)
S_OFFDT：分配关断延时定时器参数并启动
说明
当检测到参数 S 的信号下降沿时，“分配关断延时定时器参数并启动”指令将启动预设的定时器。定时器
将运行一段预设的时间 (TV)。只要定时器在计时或参数 S 返回信号状态“1”，参数 Q 的信号状态就为
“1”。
如果定时器已达到预置时间且信号状态为“0”，则参数 Q 的信号状态将复位为“0”。如果定时器计时期间
参数 S 的信号状态从“0”变为“1”，定时器将停止。只有在检测到参数 S 的信号下降沿后，才会重新启动
定时器。
参数 R 的信号状态为“1”则当前时间值和时间基准被复位为“0”。这种情况下，参数 Q 的信号状态为“0”。
说明
语法
“分配关断延时定时器参数并启动”指令的语法如下所示：
SCL
S_OFFDT(T_NO := <操作数>,
S := <操作数>,
TV := <操作数>,
R := <操作数>,
Q => <操作数>,
BI =><操作数>)
S5TIME,
WORD
I、Q、M、D、
L、P
- 35 -
I、Q、M、D、
L、P
I、Q、M、D、
L、P
脉冲时序图
下图显示了指令“分配关断延时定时器参数并启动”的脉冲时序图：
示例
SCL
"Tag_Result" := S_OFFDT(T_NO := "Timer_1",
S := "Tag_1",
TV := "Tag_Number",
R := "Tag_Reset",
Q := "Tag_Status",
BI := "Tag_Value");
"如果操作数“Tag_1”的信号状态从“0”变为“1”，将启动“Timer_1”。定时器的运行时间为“Tag_Number”。
只要定时器在计时或操作数“Tag_1”返回信号状态“1”，操作数“Tag_Status”的信号状态就为“1”。
如果定时器已达到预置时间且操作数“Tag_1”的信号状态为“0”，则操作数“Tag_Status”的信号状态将复位
为“0”。如果在定时器计时期间操作数“Tag_1”的信号状态从“0 变为“1”，将复位定时器。只有在检测到参
数 S 的下降沿后，才会重新启动定时器。
- 36 -
- 37 -
计数器操作 (S7-1200, S7-1500)
计数器操作
• CTU：增计数 (S7-1200, S7-1500)
• CTD：减计数 (S7-1200, S7-1500)
• CTUD：加减计数 (S7-1200, S7-1500)
• 传统 (S7-1500)
- 38 -
CTU：增计数 (S7-1200, S7-1500)
CTU：增计数
说明
可以使用“加计数”指令递增 CV 参数的值。如果参数 CU 的信号状态从“0”变为“1”（信号上升沿），则执
行该指令，同时参数 CV 的当前计数器值加“1”。每检测到一个上升沿，计数器值就会递增，直到其达到
参数 CV 中所指定数据类型的上限。达到上限时，参数 CU 的信号状态将不再影响该指令。
可以通过参数 Q 查询计数状态。参数 Q 的信号状态由参数 PV 决定。如果当前计数器值大于或等于参
数 PV 的值，则参数 Q 的信号状态将置位为“1”。在其它任何情况下，参数 Q 的信号状态均为“0”。也可
以为参数 PV 指定一个常数。
参数 R 的信号状态变为“1”时，参数 CV 的值将复位为“0”。只要参数 R 的信号状态为“1”，参数 CU 的信
号状态就不会影响该指令。
说明
只需在程序中的某一位置处使用计数器，即可避免计数错误的风险。
每次调用“加计数”指令，都会为其分配一个 IEC 计数器用于存储指令数据。 IEC 计数器是一种具有以下

某种数据类型的结构：
对于 S7-1200 CPU
系统数据类型 IEC_<Counter> 的数据块（共享局部变量

DB）
• IEC_SCOUNTER / IEC_USCOUNTER • CTU_SINT / CTU_USINT
• IEC_COUNTER / IEC_UCOUNTER • CTU_INT / CTU_UINT
• IEC_DCOUNTER / IEC_UDCOUNTER • CTU_DINT / CTU_UDINT
对于 S7-1500 CPU

DB）
• IEC_SCOUNTER / IEC_USCOUNTER • CTU_SINT / CTU_USINT
• IEC_COUNTER / IEC_UCOUNTER • CTU_INT / CTU_UINT
• IEC_DCOUNTER / IEC_UDCOUNTER • CTU_DINT / CTU_UDINT
• IEC_LCOUNTER / IEC_ULCOUNTER • CTU_LINT / CTU_ULINT
可以按如下方式声明 IEC 计数器：

• 系统数据类型 IEC_<Counter> 的数据块声明（例如，“MyIEC_COUNTER”）
• 声明为块中“Static”部分的 CTU_<Data type> 类型的局部变量（例如 #MyCTU_COUNTER）
在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 计数器将存储在自身数

据块中（单背景）还是作为局部变量存储在块接口中（多重背景）。如果创建了一个单独的数据块，则
该数据块将保存到项目树“程序块 > 系统块”(Program blocks > System blocks) 路径中的“程序资源”
如果在单独的数据块中设置 IEC 计数器（单背景），则将默认使用“优化的块访问”(optimized block
access) 创建背景数据块，并将各个变量定义为具有保持性。有关在背景数据块中设置保持性的更多信
息，请参见“另请参见”。
- 39 -
CTU：增计数 (S7-1200, S7-1500)
如果在函数块中使用“优化的块访问”(optimized block access) 设置 IEC 计数器作为本地变量（多重背

景），则其在块接口中定义为具有保持性。
语法
“加计数”指令的语法如下所示：
系统数据类型为 IEC_counter 的数据块（全局 DB）
SCL
<IEC_Counter_DB>.CTU(CU := <操作数>,
R := <操作数>,
PV := <操作数>,
Q => <操作数>,
CV => <操作数>)
局部变量
SCL
#myLocal_counter(CU := <操作数>,
R := <操作数>,
PV := <操作数>,
Q => <操作数>,
CV => <操作数>)
CU Input BOOL I、Q、M、D、L 计数输入
P
PV Input 整数置位输出 Q 的目标值
P
Q Output BOOL I、Q、M、D、L 计数器状态
整数、CHAR、 I、Q、M、D、L、
CV Output 当前计数器值
WCHAR、DATE P
示例
- 40 -
CTU：增计数 (S7-1200, S7-1500)
SCL
"IEC_COUNTER_DB".CTU(CU := "Tag_Start",
R := "Tag_Reset",
PV := "Tag_PresetValue",
Q => "Tag_Status",
CV => "Tag_CounterValue");
当“Tag_Start”操作数的信号状态从“0”变为“1”时，将执行“加计数”指令，同时“Tag_CounterValue”操作数
的当前计数器值加 1。每检测到一个额外的信号上升沿，计数器值都会递增，直至达到所指定数据类型
的上限值 (INT = 32767)。
只要当前计数器值大于或等于操作数“Tag_PresetValue”的值，输出“Tag_Status”的信号状态就为“1”。在
其它任何情况下，输出“Tag_Status”的信号状态均为“0”。当前计数器值存储在“Tag_CounterValue”操作
数中。
- 41 -
CTD：减计数 (S7-1200, S7-1500)
CTD：减计数
说明
“减计数”指令用于递减 CV 参数的值。如果参数 CD 的信号状态从“0”变为“1”（信号上升沿），则执行该
指令，同时参数 CV 的当前计数器值减 1。每检测到一个信号上升沿，计数器值就会递减 1，直到达到
指定数据类型的下限为止。达到下限时，参数 CD 的信号状态将不再影响该指令。
可以通过参数 Q 查询计数状态。如果当前计数器值小于或等于“0”，则参数 Q 的信号状态将置位为“1”。
在其它任何情况下，参数 Q 的信号状态均为“0”。也可以为参数 PV 指定一个常数。
当参数 LD 的信号状态变为“1”时，参数 CV 的值会设置为参数 PV 的值。只要参数 LD 的信号状态为
“1”，参数 CD 的信号状态就不会影响该指令。
说明
每次调用“减计数”指令，都会为其分配一个 IEC 计数器用于存储指令数据。 IEC 计数器是一种具有以下

某种数据类型的结构：
对于 S7-1200 CPU

DB）
• IEC_SCOUNTER / IEC_USCOUNTER • CTD_SINT / CTD_USINT
• IEC_COUNTER / IEC_UCOUNTER • CTD_INT / CTD_UINT
• IEC_DCOUNTER / IEC_UDCOUNTER • CTD_DINT / CTD_UDINT
对于 S7-1500 CPU

DB）
• IEC_SCOUNTER / IEC_USCOUNTER • CTD_SINT / CTD_USINT
• IEC_COUNTER / IEC_UCOUNTER • CTD_INT / CTD_UINT
• IEC_DCOUNTER / IEC_UDCOUNTER • CTD_DINT / CTD_UDINT
• IEC_LCOUNTER / IEC_ULCOUNTER • CTD_LINT / CTD_ULINT

• 声明为块中“Static”部分的 CTD_<Data type> 类型的局部变量（例如 #MyCTD_COUNTER）

- 42 -
CTD：减计数 (S7-1200, S7-1500)

语法
“减计数”指令的语法如下所示：
SCL
<IEC_Counter_DB>.CTD(CD := <操作数>,
LD := <操作数>,
PV := <操作数>,
Q => <操作数>,
CV => <操作数>)
局部变量
SCL
#myLocal_counter(CD := <操作数>,
LD := <操作数>,
PV := <操作数>,
Q => <操作数>,
CV => <操作数>)
CD Input BOOL I、Q、M、D、L 计数输入
LD Input BOOL 装载输入
P
I、Q、M、D、L、使用 LD = 1 置位输出 CV 的
PV Input 整数
P 目标值。
WCHAR、DATE P
示例
- 43 -
CTD：减计数 (S7-1200, S7-1500)
SCL
"IEC_SCOUNTER_DB".CTD(CD := "Tag_Start",
LD := "Tag_Load",
Q => "Tag_Status",
当“Tag_Start”操作数的信号状态从“0”变为“1”时，执行该指令且“Tag_CounterValue”操作数的值减 1。每
检测到一个额外的上升沿，计数器值都会递减，直至达到指定数据类型的下限 (-128)。
只要当前计数器值小于或等于 0，操作数“Tag_Status”的信号状态就为“1”。在其它任何情况下，输出
“Tag_Status”的信号状态均为“0”。当前计数器值存储在“Tag_CounterValue”操作数中。
- 44 -
CTUD：加减计数 (S7-1200, S7-1500)
CTUD：加减计数
说明
使用“加减计数”指令递增和递减 CV 参数的计数器值。如果参数 CU 的信号状态从“0”变为“1”（信号上升
沿），则参数 CV 的当前计数器值加 1。如果参数 CD 的信号状态从“0”变为“1”（信号上升沿），则参
数 CV 的计数器值减 1。如果在一个程序周期内输入 CU 和 CD 都出现了一个信号上升沿，则参数 CV
的当前计数器值保持不变。
计数器值达到参数 CV 指定数据类型的上限后，停止递增。达到上限后，即使出现信号上升沿，计数器
值也不再递增。达到指定数据类型的下限后，计数器值便不再递减。
当参数 LD 中的信号状态变为“1”时，参数 CV 的计数器值会设置为参数 PV 的值。只要参数 LD 的信号
状态为“1”，参数 CU 和 CD 的信号状态就不会影响该指令。
当 R 参数的信号状态变为“1”时，计数器值将置位为 0。只要 R 参数的信号状态仍为“1”，参数 CU、CD
和 LD 信号状态的改变就不会影响“加减计数”指令。
可以在 QU 参数中查询加计数器的状态。如果当前计数器值大于或等于参数 PV 的值，则参数 QU 的信
号状态将置位为“1”。在其它任何情况下，参数 QU 的信号状态均为“0”。也可以为参数 PV 指定一个常
数。
可以在 QD 参数中查询减计数器的状态。如果当前计数器值小于或等于“0”，则参数 QD 的信号状态将置
位为“1”。在其它任何情况下，参数 QD 的信号状态均为“0”。
说明
每次调用“加减计数”指令，都会为其分配一个 IEC 计数器用来存储指令数据。 IEC 计数器是一种具有以

下某种数据类型的结构：
对于 S7-1200 CPU

DB）
• IEC_SCOUNTER / IEC_USCOUNTER • CTUD_SINT / CTUD_USINT
• IEC_COUNTER / IEC_UCOUNTER • CTUD_INT / CTUD_UINT
• IEC_DCOUNTER / IEC_UDCOUNTER • CTUD_DINT / CTUD_UDINT
对于 S7-1500 CPU

DB）
• IEC_SCOUNTER / IEC_USCOUNTER • CTUD_SINT / CTUD_USINT
• IEC_COUNTER / IEC_UCOUNTER • CTUD_INT / CTUD_UINT
• IEC_DCOUNTER / IEC_UDCOUNTER • CTUD_DINT / CTUD_UDINT
• IEC_LCOUNTER / IEC_ULCOUNTER • CTUD_LINT / CTUD_ULINT

- 45 -
CTUD：加减计数 (S7-1200, S7-1500)
• 声明为块中“Static”部分的 CTUD_<Data type> 类型的局部变量（例如 #MyCTUD_COUNTER）

语法
“加减计数”指令的语法如下所示：
SCL
<IEC_Counter_DB>.CTUD(CU := <操作数>,
CD := <操作数>,
R := <操作数>,
LD := <操作数>,
PV := <操作数>,
QU=> <操作数>,
QD := <操作数>,
CV => <操作数>)
局部变量
SCL
myLocal_counter(CU := <操作数>,
CD := <操作数>,
R := <操作数>,
LD := <操作数>,
PV := <操作数>,
QU=> <操作数>,
QD := <操作数>,
CV => <操作数>)
- 46 -
CTUD：加减计数 (S7-1200, S7-1500)
CU Input BOOL I、Q、M、D、L 加计数输入
CD Input BOOL I、Q、M、D、L 减计数输入
P
LD Input BOOL 装载输入
P
置位输出 QU 的目标值。 /
PV Input 整数使用 LD = 1 置位输出 CV 的
P
目标值。
QU Output BOOL I、Q、M、D、L 加计数器的状态
QD Output BOOL I、Q、M、D、L 减计数器的状态
WCHAR、DATE P
示例
SCL
"IEC_COUNTER_DB".CTUD(CU := "Tag_Start1",
CD := "Tag_Start2",
LD := "Tag_Load",
R := "Tag_Reset",
QU => "Tag_CU_Status",
QD => "Tag_CD_Status",
如果“Tag_Start1”操作数的信号状态出现上升沿，当前计数器的值加 1 并存储在“Tag_CounterValue”操
作数中。如果“Tag_Start2”操作数的信号状态出现信号上升沿，则计数器值减 1 并存储在“Tag_Coun‐
terValue”操作数中。参数 CU 出现信号上升沿时计数器的值将递增，直至达到指定数据类型 (INT) 的上
限。如果 CD 参数出现上升沿，计数器值将递减，直至达到指定数据类型 (INT) 的下限。
只要当前计数器值大于或等于操作数“Tag_PresetValue”的值，操作数“Tag_CU_Status”的信号状态就为
“1”。在其它情况下，输出“Tag_CU_Status”的信号状态都为“0”。
只要当前计数器值小于或等于 0，操作数“Tag_CD_Status”的信号状态就为“1”。在其它情况下，输出
“Tag_CD_Status”的信号状态都为“0”。
- 47 -
传统 (S7-1500)
传统
• S_CU：分配参数并加计数 (S7-1500)
• S_CD：分配参数并减计数 (S7-1500)
• S_CUD：分配参数并加/减计数 (S7-1500)
- 48 -
S_CU：分配参数并加计数 (S7-1500)
S_CU：分配参数并加计数
说明
可使用“分配参数并加计数”指令递增计数器值。当 CU 参数的信号状态从“0”变为“1”（信号上升沿）时，
当前计数器值递增 1。通过参数 CV 提供当前计数器值。计数器值达到上限 999 后，停止增加。如果
达到限值，即使出现信号上升沿，计数器值也不再递增。
当参数 S 的信号状态从“0”变为“1”时，计数器值将置位为参数 PV 的值。如果置位计数器且输入 CU 处
的逻辑运算结果 (RLO) 为“1”，即使没有检测到信号边沿变化，计数器也会在下一周期计数一次。
当 R 参数的信号状态变为“1”时，计数器值将设置为 0。只要 R 参数的信号状态为“1”，参数 CU 和 S 的
信号状态变化就不会影响计数值。
如果计数器值大于 0，参数 Q 的信号状态就为“1”。计数器值等于 0 时，参数 Q 将返回信号状态“0”。
说明
只需在程序中的某一位置处使用计数器，即可避免发生计数错误。
语法
“分配参数并加计数”指令的语法如下所示：
SCL
S_CU(C_NO := <操作数>,
CU := <操作数>,
S := <操作数>,
PV := <操作数>,
R := <操作数>,
Q => <操作数>,
CV => <操作数>)
计数器
COUNTER,
C_NO Input C 计数器的数量取决
INT
于 CPU。
用于预置计数器的
S Input BOOL I、Q、M、D、L
输入端
预置 BCD 格式的
PV Input WORD I、Q、M、D、L 计数器值（C#0 至
C#999）
R Input BOOL I、Q、M、D、L 复位输入
- 49 -
S_CU：分配参数并加计数 (S7-1500)

WORD,
CV Output S5TIME, I、Q、M、D、L 当前计数器值
DATE
WORD,
当前计数器值（BCD
函数值 S5TIME, I、Q、M、D、L
格式）
DATE
示例
SCL
"Tag_Result" := S_CU(C_NO := "Counter_1",
CU := "Tag_Start",
S := "Tag_1",
R := "Tag_Reset",
Q => "Tag_Status",
CV => "Tag_Value");
如果参数“Tag_Start”的信号状态从“0”变为“1”（信号上升沿）且当前计数器值小于“999”时，则计数器值
递增 1。如果“Tag_1”输入的信号状态从“0”变为“1”，则将 BCD 格式的计数器值设置为操作数“Tag_Pre‐
setValue”的值。当“Tag_Reset”操作数的信号状态为“1”时，计数器值将复位为“0”。
当前计数器值以十六进制编码的形式存储在操作数“Tag_Value”中。
只要当前计数器值不等于“0”，输出“Tag_Status”的信号状态便为“1”。当前计数器值在“Tag_Value”操作
数中，并作为函数值返回。
- 50 -
S_CD：分配参数并减计数 (S7-1500)
S_CD：分配参数并减计数
说明
可使用“分配参数并减计数”指令递减计数器值。当 CD 参数的信号状态从“0”变为“1”（信号上升沿）时，
当前计数器值递减 1。通过参数 CV 提供当前计数器值。计数器值达到下限 0 时，将停止递减。如果
达到下限值，即使出现信号上升沿，计数器值也不再递减。
当参数 S 的信号状态从“0”变为“1”时，计数器值将置位为参数 PV 的值。如果置位计数器且参数 CD 处
的逻辑运算结果 (RLO) 为“1”，即使没有检测到信号边沿变化，计数器也会在下一周期计数一次。
当 R 参数的信号状态变为“1”时，计数器值将设置为 0。只要 R 参数的信号状态为“1”，参数 CD 和 S 的
信号状态变化就不会影响计数值。
说明
语法
“分配参数并减计数”指令的语法如下所示：
SCL
S_CD(C_NO:= <操作数>,
CD := <操作数>,
S := <操作数>,
PV := <操作数>,
R := <操作数>,
Q => <操作数>,
CV => <操作数>)
计数器
COUNTER,
INT
于 CPU。
输入端
C#999）
- 51 -
S_CD：分配参数并减计数 (S7-1500)
WORD,
CV Output S5TIME, I、Q、M、D、L 当前计数器值
WORD
WORD,
格式）
DATE
示例
SCL
"Tag_Result" := S_CD(C_NO := "Counter_1",
CD := "Tag_Start",
S := "Tag_1",
R := "Tag_Reset",
Q => "Tag_Status",
CV => "Tag_Value");
当“Tag_Start”操作数的信号状态从“0”变为“1”（信号上升沿）且当前计数器值大于“0”时，计数器值将递
减 1。如果“Tag_1”操作数的信号状态从“0”变为“1”，则将 BCD 格式的计数器值设置为“Tag_PresetVal‐
ue”操作数的值。当“Tag_Reset”操作数的信号状态为“1”时，计数器值将复位为“0”。
当前计数器值以二进制编码的形式存储在操作数“Tag_Value”中。
只要当前计数器值不等于“0”，那么“Tag_Status”操作数的信号状态便会返回“1”。当前计数器值在
“Tag_Value”操作数中，并作为函数值返回。
- 52 -
S_CUD：分配参数并加/减计数 (S7-1500)
S_CUD：分配参数并加/减计数
说明
可使用“分配参数并加/减计数”指令递增和递减计数器值。当 CU 参数的信号状态从“0”变为“1”（信号上
升沿）时，当前计数器值递增 1。当 CD 参数的信号状态从“0”变为“1”（信号上升沿）时，计数器值递
减 1。通过参数 CV 提供当前计数器值。如果在一个程序周期内参数 CU 和 CD 出现了信号上升沿，计
数器值将保持不变。
计数器值达到上限 999 后，停止递增。达到上限后，即使出现信号上升沿，计数器值也不再递增。达到
下限值“0”时，计数器值不再递减。
当参数 S 的信号状态从“0”变为“1”时，计数器值将置位为参数 PV 的值。如果置位计数器且 CU 和 CD
参数的逻辑运算结果 (RLO) 为“1”，即使没有检测到信号边沿变化，计数器也会在下一周期计数一次。
当 R 参数的信号状态变为“1”时，计数器值将设置为 0。只要 R 参数的信号状态为“1”，参数 CU、 CD
和 S 信号状态的改变就不会影响该计数器值。
说明
语法
“分配参数并加/减计数”指令的语法如下所示：
SCL
S_CUD(C_NO:= <操作数>,
CU := <操作数>,
CD := <操作数>,
S := <操作数>,
PV := <操作数>,
R := <操作数>,
Q => <操作数>,
CV => <操作数>)
计数器
COUNTER,
INT
于 CPU。
输入端
- 53 -
S_CUD：分配参数并加/减计数 (S7-1500)
C#999）
WORD,
当前计数器值（十六
CV Output S5TIME, I、Q、M、D、L
进制）
DATE
WORD,
格式）
DATE
示例
SCL
"Tag_Result" := S_CD(C_NO := "Counter_1",
CU := "Tag_CU",
CD := "Tag_CD",
S := "Tag_1",
R := "Tag_Reset",
Q => "Tag_Status",
CV => "Tag_Value");
当检测到操作数“Tag_CU”的信号状态为上升沿且当前计数器值小于“999”，则计数器值将递增 1。当检
测到操作数“Tag_CD”的信号状态为上升沿且当前计数器值大于“0”，则计数器值将递减 1。
如果“Tag_1”操作数的信号状态从“0”变为“1”，则将 BCD 格式的计数器值设置为“Tag_PresetValue”操作
数的值。当“Tag_Reset”操作数的信号状态为“1”时，计数器值将复位为“0”。
当前计数器值以二进制编码的形式存储在操作数“Tag_Value”中。
只要当前计数器值不等于“0”，那么“Tag_Status”操作数的信号状态便会返回“1”。当前计数器值在
“Tag_Value”操作数中，并作为函数值返回。
- 54 -
比较运算 (S7-1200, S7-1500)
比较运算
• TypeOf：检查 VARIANT 变量的数据类型 (S7-1200, S7-1500)
• TypeOfElements：检查 VARIANT 变量的 ARRAY 元素的数据类型 (S7-1200, S7-1500)
• IS_ARRAY：检查 ARRAY (S7-1200, S7-1500)
- 55 -
TypeOf：检查 VARIANT 变量的数据类型 (S7-1200, S7-1500)
TypeOf：检查 VARIANT 变量的数据类型
说明
可以使用“检查 VARIANT 变量的数据类型”指令查询 VARIANT 变量所指向的变量的数据类型。可以将
块接口中声明的 <操作数> 变量的数据类型与其它变量的数据类型或一个直接数据类型进行比较，以确
定它们是“相等”还是“不相等”。
操作数必须具有 VARIANT 数据类型。比较操作数可以是基本数据类型或 PLC 数据类型。
只能使用 IF 指令中的“检查 VARIANT 变量的数据类型”指令。
语法
“检查 VARIANT 变量的数据类型”指令的语法如下所示：
SCL
TypeOf(<操作数>)
参数
下表列出了“检查 VARIANT 变量的数据类型”指令的参数：
<操作数> Input VARIANT I、Q、M、L 第一个操作数
示例
以下示例说明了与其它变量的比较：
SCL
IF TypeOf(#TagVARIANT) = TypeOf("TagBYTE") THEN
...;
END_IF;
以下示例说明了与某个数据类型的比较：
SCL
IF TypeOf(#TagVARIANT) = BYTE THEN
...;
END_IF;
如果 VARIANT #TagVARIANT 所指向的操作数具有 BYTE 数据类型，则符合比较条件。
- 56 -
TypeOfElements：检查 VARIANT 变量的 ARRAY 元素的数据类型 (S7-1200, S7-1500)
TypeOfElements：检查 VARIANT 变量的 ARRAY 元素的数据

类型
说明
可以使用“检查 VARIANT 变量的 ARRAY 元素的数据类型”指令查询 VARIANT 变量所指向的变量的数
据类型。比较该变量的数据类型与在块接口中声明的变量的数据类型，确定这两者是“相等”还是“不相
等”。
操作数必须具有 VARIANT 数据类型。比较操作数可以是基本数据类型或 PLC 数据类型。
如果 VARIANT 变量的数据类型是 ARRAY，将比较 ARRAY 元素的数据类型。
只能使用 IF 指令中的指令。
语法
“检查 VARIANT 变量的 ARRAY 元素的数据类型”指令的语法如下所示：
SCL
TypeOfElements(<操作数>)
参数
下表列出了“检查 VARIANT 变量的 ARRAY 元素的数据类型”指令的参数：
<操作数> Input VARIANT I、Q、M、L 第一个操作数
示例
SCL
IF TypeOfElements(#Tag_VARIANT) = TypeOf("Glob-
alDB".Product[1]) THEN
"Tag_Result" := "GlobalDB".Product[1] * 3;
END_IF;
下表将通过具体的操作数值对该指令的工作原理进行说明：
操作数值
#Tag_VARIANT 1.5
"GlobalDB".Product[1] 3.5
如果 VARIANT 指向的变量和“GlobalDB”Product[1] 操作数具有 REAL 数据类型，“GlobalDB”Product[1]
操作数将乘以 3，结果写入“Tag_Result”操作数。
- 57 -
IS_ARRAY：检查 ARRAY (S7-1200, S7-1500)
IS_ARRAY：检查 ARRAY
说明
可以使用“检查 ARRAY”指令查询 VARIANT 是否指向 ARRAY 数据类型的变量。
<操作数> 必须具有 VARIANT 数据类型。
只能使用 IF 指令中的“检查 ARRAY”指令。
语法
“检查 ARRAY”指令的语法如下所示：
SCL
IS_ARRAY(<操作数>)
参数
下表列出了“检查 ARRAY”指令的参数：
<操作数> Input VARIANT I、Q、M、L 为 ARRAY 查询的操作数
函数值 UDINT I、Q、M、D、L 指令的结果
示例
SCL
IF IS_ARRAY(#Tag_VARIANTToArray) THEN
"Tag_Result" := CountOfElements(#Tag_VARIANT);
END_IF;
如果 VARIANT 指向的变量是 ARRAY，将输出 ARRAY 元素的数量。
- 58 -
数学函数 (S7-1200, S7-1500)
数学函数
• ABS：计算绝对值 (S7-1200, S7-1500)
• MIN：获取最小值 (S7-1200, S7-1500)
• MAX：获取最大值 (S7-1200, S7-1500)
• LIMIT：设置限值 (S7-1200, S7-1500)
• SQR：计算平方 (S7-1200, S7-1500)
• SQRT：计算平方根 (S7-1200, S7-1500)
• LN：计算自然对数 (S7-1200, S7-1500)
• EXP：计算指数值 (S7-1200, S7-1500)
• SIN：计算正弦值 (S7-1200, S7-1500)
• COS：计算余弦值 (S7-1200, S7-1500)
• TAN：计算正切值 (S7-1200, S7-1500)
• ASIN：计算反正弦值 (S7-1200, S7-1500)
• ACOS：计算反余弦值 (S7-1200, S7-1500)
• ATAN：计算反正切值 (S7-1200, S7-1500)
• FRAC：返回小数 (S7-1200, S7-1500)
- 59 -
ABS：计算绝对值 (S7-1200, S7-1500)
ABS：计算绝对值
说明
使用“计算绝对值”指令可计算输入值的绝对值，并将结果保存到指定的操作数中。
语法
“计算绝对值”指令的语法如下所示：
SCL
ABS(<表达式>)
S7-1200 S7-1500
SINT、INT、
SINT、INT、 I、Q、M、D、
<表达式> Input DINT、LINT、输入值
DINT、浮点数 L、P
浮点数
SINT、INT、
SINT、INT、 I、Q、M、D、输入值的绝对
函数值 DINT、LINT、
DINT、浮点数 L、P 值
浮点数
示例
SCL
"Tag_Result1" := ABS("Tag_Value");
"Tag_Result2" := ABS("Tag_Value1"*"Tag_Value2");
输入值的绝对值作为函数值以输入值的格式返回。
操作数值
Tag_Value -2
Tag_Result1 2
Tag_Value1 4
Tag_Value2 -1
Tag_Result2 4
- 60 -
MIN：获取最小值 (S7-1200, S7-1500)
MIN：获取最小值
说明
使用“获取最小值”指令比较可用输入的值，并将最小的值作为结果返回。
在该指令处，最少需要指定 2 个输入，最多可以指定 32 个输入。
如果满足以下任何条件，则结果值无效：
• 在执行该指令的过程中，后台转换数据类型失败。
• 浮点数的值无效。
语法
“获取最小值”指令的语法如下所示：
SCL
MIN(IN1:= <操作数>,
IN2 := <操作数>)
参数
下表列出了“获取最小值”指令的参数：
S7-1200 S7-1500
整数、浮点
数、TIME、
整数、浮点数、 LTIME、
I、Q、M、D、
IN1 Input TIME、TOD、 TOD、第一个输入值
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
整数、浮点
数、TIME、
I、Q、M、D、
IN2 Input TIME、TOD、 TOD、第二个输入值
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
整数、浮点
数、TIME、
整数、浮点数、 LTIME、其它插入的输
I、Q、M、D、
INn Input TIME、TOD、 TOD、入（其值待比
L、P
DATE、DTL LTOD、较）
DATE、LDT、
DT、DTL
- 61 -
MIN：获取最小值 (S7-1200, S7-1500)
整数、浮点
数、TIME、
I、Q、M、D、
函数值 TIME、TOD、 TOD、指令的结果
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
如果未启用 IEC 测试，则不能使用数据类型 TOD、LTOD、DATE 和 LDT。
示例
SCL
"Tag_Result" := MIN(IN1 := "Tag_Value1",
IN2 := "Tag_Value2",
IN3 := "Tag_Value3");
参数操作数值
IN1 Tag_Value1 12222
函数值 Tag_Result 12222
该指令比较输入值，并将最小值（“Tag_Value1”）复制到操作数“Tag_Result”中。
- 62 -
MAX：获取最大值 (S7-1200, S7-1500)
MAX：获取最大值
说明
使用“获取最大值”指令，比较输入值，并将最大的值作为结果返回。
在该指令处，最少需要指定 2 个输入，最多可以指定 32 个输入。
如果满足以下任何条件，则结果值无效：
• 在执行该指令的过程中，后台转换数据类型失败。
• 浮点数的值无效。
语法
“获取最大值”指令的语法如下所示：
SCL
MAX(IN1:= <操作数>,
IN2 := <操作数>)
参数
下表列出了“获取最大值”指令的参数：
S7-1200 S7-1500
整数、浮点
数、TIME、
I、Q、M、D、
IN1 Input TIME、TOD、 TOD、第一个输入值
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
整数、浮点
数、TIME、
I、Q、M、D、
IN2 Input TIME、TOD、 TOD、第二个输入值
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
整数、浮点
数、TIME、
整数、浮点数、 LTIME、其它插入的输
I、Q、M、D、
INn Input TIME、TOD、 TOD、入（其值待比
L、P
DATE、DTL LTOD、较）
DATE、LDT、
DT、DTL
- 63 -
MAX：获取最大值 (S7-1200, S7-1500)
整数、浮点
数、TIME、
I、Q、M、D、
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
示例
SCL
"Tag_Result" := MAX(IN1 := "Tag_Value1",
IN2 := "Tag_Value2",
IN3 := "Tag_Value3");
参数操作数值
IN1 Tag_Value1 12 222
函数值 Tag_Result 14 444
该指令比较指定操作数的值，并将最大的值（“Tag_Value2”）复制到操作数“Tag_Result”中。
- 64 -
LIMIT：设置限值 (S7-1200, S7-1500)
LIMIT：设置限值
说明
可使用“设置限值”指令，将参数 IN 的值限制在参数 MN 和 MX 值之间。参数 MN 的值不能大于参数 MX
的值。
如果参数 IN 的值满足 MN 条件 <=IN <= MX，则它将作为该指令的结果返回。如果不满足该条件，而且
输入值 (IN) 小于下限 MN，则将参数 MN 的值作为结果返回。如果超出了上限 MX，则将参数 MX 的值
作为结果返回。
如果输入 MN 的值大于输入 MX 的值，则结果为未定义。
只有当所有参数的操作数均为同一种数据类型时，才能执行该指令。
语法
“设置限值”指令的语法如下所示：
SCL
LIMIT(MN := <操作数>,
IN := <操作数>,
MX := <操作数>)
S7-1200 S7-1500
整数、浮点
数、TIME、
I、Q、M、D、
MN Input TIME、TOD、 TOD、下限
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
整数、浮点
数、TIME、
I、Q、M、D、
IN Input TIME、TOD、 TOD、输入值
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
整数、浮点
数、TIME、
I、Q、M、D、
MX Input TIME、TOD、 TOD、上限
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
- 65 -
LIMIT：设置限值 (S7-1200, S7-1500)
整数、浮点
数、TIME、
I、Q、M、D、
L、P
DATE、DTL LTOD、
DATE、LDT、
DT、DTL
示例
SCL
"Tag_Result" := LIMIT(MN := "Tag_Minimum",
IN := "Tag_Value",
MX := "Tag_Maximum");
参数操作数值
MN Tag_Minimum 12 000
IN Tag_Value 8 000
MX Tag_Maximum 16 000
函数值 Tag_Result 12 000
将操作数“Tag_Value”的值与操作数“Tag_Minimum”和“Tag_Maximum”的值进行比较。由于操作数
“Tag_Value”的值小于下限值，因此将操作数“Tag_Minimum”的值复制到操作数“Tag_Result”中。
- 66 -
SQR：计算平方 (S7-1200, S7-1500)
SQR：计算平方
说明
使用“计算平方”指令，可以计算输入值的平方值，并将结果保存到指定的操作数中。
语法
“计算平方”指令的语法如下所示：
SCL
SQR(<表达式>)
<表达式> Input 浮点数 I、Q、M、D、L、P 输入值
函数值浮点数 I、Q、M、D、L、P 输入值的平方
示例
SCL
"Tag_Result1" := SQR("Tag_Value");
"Tag_Result2" := SQR((SQR("Tag_Value1"))*"Tag_Val-
ue2");
输入值的平方作为函数值在“Tag_Resultxy”操作数中返回。
操作数值
Tag_Value 2.5
Tag_Result1 6.25
Tag_Value1 6.0
Tag_Value2 2.0
Tag_Result2 5184.0
- 67 -
SQRT：计算平方根 (S7-1200, S7-1500)
SQRT：计算平方根
说明
使用“计算平方根”指令，可以计算输入值的平方根，并将结果保存到指定的操作数中。如果输入值大于
零，则该指令的结果为正数。如果输入值小于零，则该指令返回一个无效浮点数。如果输入值为“0”，
则结果也是“0”。
语法
“计算平方根”指令的语法如下所示：
SCL
SQRT(<表达式>)
<表达式> Input 浮点数输入值
P
函数值浮点数输入值的平方根
P
示例
SCL
"Tag_Result1" := SQRT("Tag_Value");
"Tag_Result2" := SQRT((SQR("Tag_Value1"))+"Tag_Val-
ue2");
输入值的平方根作为函数值在“Tag_Resultxy”操作数中返回。
操作数值
Tag_Value 4.0
Tag_Result1 2.0
Tag_Value1 3.0
Tag_Value2 16.0
Tag_Result2 5.0
- 68 -
LN：计算自然对数 (S7-1200, S7-1500)
LN：计算自然对数
说明
使用“计算自然对数”指令，可以计算输入值的以 e (e=2.718282) 为底的自然对数。如果输入值大于零，
则该指令的结果为正数。如果输入值小于零，则该指令返回一个无效浮点数。
语法
“计算自然对数”指令的语法如下所示：
SCL
LN(<表达式>)
P
函数值浮点数输入值的自然对数
P
示例
SCL
"Tag_Result1" := LN("Tag_Value");
"Tag_Result2" := LN("Tag_Value1"+"Tag_Value2");
该指令的结果作为函数值在“Tag_Resultxy”操作数中返回。
操作数值
Tag_Value 2.5
Tag_Result1 0.916
Tag_Value1 1.5
Tag_Value2 3.2
Tag_Result2 1.548
- 69 -
EXP：计算指数值 (S7-1200, S7-1500)
EXP：计算指数值
说明
使用“计算指数值”指令，可通过底数 (e = 2,718282) 及输入值来计算指数，并将结果保存在指定的操作
数中。
语法
“计算指数值”指令的语法如下所示：
SCL
EXP(<表达式>)
P
函数值浮点数输入值的指数值
P
示例
SCL
"Tag_Result1" := EXP("Tag_Value");
"Tag_Result2" := EXP("Tag_Value1"/"Tag_Value2");
操作数值
Tag_Value 20.5
Tag_Result1 799 902 200
Tag_Value1 15.5
Tag_Value2 30.2
Tag_Result2 1.671
- 70 -
SIN：计算正弦值 (S7-1200, S7-1500)
SIN：计算正弦值
说明
使用“计算正弦值”指令，可以计算输入值的正弦值。输入值的单位必须为弧度。
语法
“计算正弦值”指令的语法如下所示：
SCL
SIN(<表达式>)
输入值（采用弧度形
<表达式> Input 浮点数 I、Q、M、D、L、P
式的角度值）
函数值浮点数 I、Q、M、D、L、P 指令的结果
示例
SCL
"Tag_Result" := SIN("Tag_Value");
该指令的结果作为函数值在“Tag_Result”操作数中返回。
操作数值
Tag_Value +1.570796 (π/2)
Tag_Result 1.0
- 71 -
COS：计算余弦值 (S7-1200, S7-1500)
COS：计算余弦值
说明
使用“计算余弦值”指令，可以计算输入值的余弦值。输入值的单位必须为弧度。
语法
“计算余弦值”指令的语法如下所示：
SCL
COS(<表达式>)
式的角度值）
示例
SCL
"Tag_Result" := COS("Tag_Value");
操作数值
Tag_Value +1.570796 (π/2)
Tag_Result 0
- 72 -
TAN：计算正切值 (S7-1200, S7-1500)
TAN：计算正切值
说明
使用“计算正切值”指令，可以计算输入值的正弦值。输入值的单位必须为弧度。
语法
“计算正切值”指令的语法如下所示：
SCL
TAN(<表达式>)
式的角度值）
示例
SCL
"Tag_Result" := TAN("Tag_Value");
操作数值
Tag_Value +3.141593 (π)
Tag_Result 0
- 73 -
ASIN：计算反正弦值 (S7-1200, S7-1500)
ASIN：计算反正弦值
说明
使用“计算反正弦值”指令，可以计算正弦值所对应的角度值。输入值只能是 -1 到 +1 范围内的有效浮点
数。计算出的角度值以弧度为单位，范围在 -π/2 到 +π/2 之间。
语法
“计算反正弦值”指令的语法如下所示：
SCL
ASIN(<表达式>)
<表达式> Input 浮点数 I、Q、M、D、L、P 正弦值
函数值浮点数 I、Q、M、D、L、P 角度值（弧度形式）
示例
SCL
"Tag_Result" := ASIN("Tag_Value");
操作数值
Tag_Value 1.0
Tag_Result +1.570796 (π/2)
- 74 -
ACOS：计算反余弦值 (S7-1200, S7-1500)
ACOS：计算反余弦值
说明
使用“计算反余弦值”指令，可以计算余弦值所对应的角度值。输入值只能是 -1 到 +1 范围内的有效浮点
数。计算出的角度值以弧度为单位，范围在 0 到 +π 之间。
语法
“计算反余弦值”指令的语法如下所示：
SCL
ACOS(<表达式>)
<表达式> Input 浮点数 I、Q、M、D、L、P 余弦值
函数值浮点数 I、Q、M、D、L、P 角度值（弧度形式）
示例
SCL
"Tag_Result" := ACOS("Tag_Value");
操作数值
Tag_Value 0
Tag_Result +1.570796 (π/2)
- 75 -
ATAN：计算反正切值 (S7-1200, S7-1500)
ATAN：计算反正切值
说明
使用“计算反正切值”指令，可以计算正切值所对应的角度值。输入值只能是有效的浮点数（或 -NaN/
+NaN）。计算出的角度值以弧度为单位，范围在 -π/2 到 +π/2 之间。
语法
“计算反正切值”指令的语法如下所示：
SCL
ATAN(<表达式>)
<表达式> Input 浮点数正切值
P
函数值浮点数角度值（弧度形式）
P
示例
SCL
"Tag_Result" := ATAN("Tag_Value");
操作数值
Tag_Value 1.0
Tag_Result +0.785398 (π/4)
- 76 -
FRAC：返回小数 (S7-1200, S7-1500)
FRAC：返回小数
说明
“返回小数”指令的结果将返回数值的小数位。例如，输入值 123.4567 时，将返回值 0.4567。
语法
“返回小数”指令的语法如下所示：
SCL
FRAC(<表达式>)
FRAC_<数据类型>(<表达式>)
I、Q、M、D、
L、P
函数值的数据类型：
1. 可以使用“_”明确指定指
令的数据类型。
2. 如果未明确指定数据类
浮点数型，将由使用的变量或
_<数据类型> - 类型编码的常数来确
默认： REAL 定。
3. 如果既未明确指定数据
类型，也未指定定义的
变量或类型编码的常
数，则使用默认数据类
型。
I、Q、M、D、
函数值浮点数输入值的小数位
L、P
示例
SCL
"Tag_Result1" := FRAC("Tag_Value");
"Tag_Result2" := FRAC_LREAL("Tag_Value");
- 77 -
FRAC：返回小数 (S7-1200, S7-1500)
操作数值
Tag_Value 2.555 -1.4421
Tag_Result1 0.555 -0.4421
- 78 -
移动操作 (S7-1200, S7-1500)
移动操作
• Deserialize：取消序列化 (S7-1200, S7-1500)
• Serialize：序列化 (S7-1200, S7-1500)
• MOVE_BLK：存储区移动 (S7-1200, S7-1500)
• MOVE_BLK_VARIANT：存储区移动 (S7-1200, S7-1500)
• UMOVE_BLK：不可中断的存储区移动 (S7-1200, S7-1500)
• FILL_BLK：填充块 (S7-1200, S7-1500)
• UFILL_BLK：不可中断的存储区填充 (S7-1200, S7-1500)
• SWAP：交换 (S7-1200, S7-1500)
• ARRAY 数据块 (S7-1500)
• 读/写访问权 (S7-1200, S7-1500)
• VARIANT (S7-1200, S7-1500)
• 传统 (S7-1500)
- 79 -
Deserialize：取消序列化 (S7-1200, S7-1500)
Deserialize：取消序列化
说明
可以使用“取消序列化”指令将 PLC 数据类型 (UDT) 块的顺序表示转换回 PLC 数据类型并填充所有内
容。
保存 PLC 数据类型的顺序表示的存储区必须有 BYTE 数据类型的 ARRAY，并且可以通过标准访问来声
明。标准存储区的容量为 64 KB。在转换之前确保有充足的存储空间。
该指令可以逐步将已转换的 PLC 数据类型的多个顺序表示转换回原始状态。
如果只想转换回 PLC 数据类型 (UDT) 的单个顺序表示，则还可以直接使用指令“TRCV：通过通信连接
接收数据”。
说明
适用于 S7-1500 系列的 CPU
对于块属性为“优化块访问”的块，一位的长度为 1 个字节。
语法
“取消序列化”指令的语法如下所示：
SCL
Deserialize(SRC_ARRAY := <操作数>,
DEST_VARIABLE := <操作数>,
POS := <操作数>)
参数
下表列出了“取消序列化”指令的参数：
SRC_AR‐ 保存生成的数据流的全局数
Input VARIANT I、Q、M、L
RAY 据块
DEST_VARI‐ 保存已返回的转换 PLC 数据
InOut VARIANT I、Q、M、L
ABLE 类型 (UDT) 的变量
转换的 PLC 数据类型使用的
POS InOut DINT I、Q、M、D、L 字节数量。 POS 参数将从 0
开始计算。
函数值 INT I、Q、M、D、L 错误信息
RET_VAL 参数
下表列出了 RET_VAL 参数值的含义：
- 80 -
错误代码* 说明
(W#16#...)
0000 无错误
80B0 参数 SRC_ARRAY 和 DEST_VARIABLE 的存储区重叠。
8136 DEST_VARIABLE 参数中的数据块不是具有标准访问权限的块。
8150 SRC_ARRAY 参数的数据类型 VARIANT 不包含值。
8151 SRC_ARRAY 参数中的代码生成错误
8153 SRC_ARRAY 参数没有足够的可用存储空间。
8250 DEST_VARIABLE 参数的数据类型 VARIANT 不包含值。
8251 DEST_VARIABLE 参数中的代码生成错误
8254 DEST_VARIABLE 参数中的数据类型无效
8382 POS 参数的值超出 ARRAY 的限制。
* 在程序编辑器中，错误代码可显示为整数或十六进制值。有关切换显示格式的更多信息，请参见“另
请参见”。
示例
SCL
#Tag_RetVal := Deserialize(SRC_ARRAY := "Buf-
fer".Field,
DEST_VARIABLE := "Tar-
get".Client,
POS := #BufferPos);

fer".Field,
DEST_VARIABLE := #Label,
POS := #BufferPos);
IF #Label = 'arti' THEN

fer".Field,
get".Article[#DeliverPos],
POS := #BufferPos);
ELSIF #Label = 'Bill' THEN
fer".Field,
get".Bill[#DeliverPos],
POS := #BufferPos);
;
ELSE
- 81 -
;
END_IF;
“取消序列化”指令对“Buffer”数据块的客户数据的顺序表示进行取消序列化，并将其写入“Target”数据块。
经过转换的客户数据占用的字节数保存在 #BufferPos 操作数中。
“取消序列化”指令对“Buffer”数据块的分隔表（使用客户数据后的顺序表示进行存储）的顺序表示取消序
列化，并将字符写入“#Label”操作数。使用比较指令“arti”和“Bill”比较字符。如果“arti”的比较为 TRUE，
则该数据为已取消序列化的物品数据，并写入“Target”数据块。如果“Bill”的比较为 TRUE，则该数据为
已取消序列化的计费数据，并写入“Target”数据块。
下表列出了操作数的声明：
操作数数据类型声明
DeliverPos INT 在块接口的“Input”部分
BufferPos DINT 在块接口的“Temp”部分
Error INT 在块接口的“Temp”部分
Label STRING[4] 在块接口的“Temp”部分
下表列出了 PLC 数据类型的声明：
PLC 数据类型的名称名称数据类型

Number DINT
Article Declaration STRING
Colli INT
Title INT
Client First name STRING[10]
Surname STRING[10]
下表列出了数据块的声明：
数据块的名称名称数据类型
Client "Client"（PLC 数据类型）
Array[0..10] of "Article"（PLC 数
Target Article
据类型）
Bill Array[0..10] of INT
Buffer Field Array[0..294] of BYTE
- 82 -
Serialize：序列化 (S7-1200, S7-1500)
Serialize：序列化
说明
可以使用“序列化”指令将多个 PLC 数据类型 (UDT) 转换为顺序表示，而不会丢失部分结构。
可以使用该指令临时将用户程序的多个结构化数据项保存到缓冲区中（最好位于全局数据块中），并发
送到其它 CPU。保存经过转换的 PLC 数据类型的存储区必须有 BYTE 数据类型的 ARRAY，并且可以
通过标准访问来声明。标准存储区的容量为 64 KB。在转换之前确保有充足的存储空间。
参数 POS 的操作数包含的信息为经过转换的 PLC 数据类型占用的字节数。
如果要发送单个 PLC 数据类型 (UDT)，可以直接调用指令“TSEND：通过通信连接发送数据”。
说明
适用于 S7-1500 系列的 CPU
对于块属性为“优化块访问”的块，一位的长度为 1 个字节。
语法
“序列化”指令的语法如下所示：
SCL
Serialize(SRC_VARIABLE := <操作数>,
DEST_ARRAY := <操作数>,
POS := <操作数>)
参数
下表列出了“序列化”指令的参数：
SRC_VARIA‐ 转换为顺序表示的 PLC 数据
Input VARIANT I、Q、M、L
BLE 类型 (UDT)。
DEST_AR‐
InOut VARIANT I、Q、M、L 保存生成的数据流的数据块。
RAY
转换的 PLC 数据类型使用的
POS InOut DINT I、Q、M、D、L 字节数量。 POS 参数将从 0
开始计算。
函数值 INT I、Q、M、D、L 错误信息
RET_VAL 参数
- 83 -
(W#16#...)
0000 无错误
80B0 参数 SRC_VARIABLE 和 DEST_ARRAY 的存储区重叠。
8150 SRC_VARIABLE 参数的数据类型 VARIANT 不包含值。
8152 SRC_VARIABLE 参数中的代码生成错误
8236 DEST_ARRAY 参数中的数据块不是具有标准访问权限的块。
8250 DEST_ARRAY 参数的数据类型 VARIANT 不包含值。
8252 DEST_ARRAY 参数中的代码生成错误
8253 DEST_ARRAY 参数没有足够的可用存储空间。
8254 DEST_ARRAY 参数中的数据类型无效
请参见”。
示例
SCL
#Tag_RetVal := Serialize(SRC_VARIABLE := "Source".Cli-
ent,
DEST_ARRAY := "Buffer".Field,
POS := #BufferPos);
#Label := STRING_TO_WSTRING('arti');
#Tag_RetVal := Serialize(SRC_VARIABLE := #Label,

POS := #BufferPos);
#Tag_RetVal := Serialize(SRC_VARIABLE := "Source".Ar-

ticle[#DeliverPos],
POS := #BufferPos);
“序列化”指令对“Source”数据块的客户数据进行序列化，并将其按照顺序表示写入“Buffer”数据块。顺序
表示占用的字节数保存在 #BufferPos 操作数中。
现在将插入一种分隔表，以更方便地对顺序表示进行取消序列化。 “移动字符串”指令将“arti”字符移动到
#Label 操作数。 “序列化”指令将客户数据后的这些字符写入“Buffer”数据块。字符需要的字节数被添加
到已经保存在 #BufferPos 操作数中的数值。
“序列化”指令对“Source”数据块的特定物品（运行时进行计算）的数据进行序列化，并在“arti”字符后将其
按照顺序表示写入“Buffer”数据块。
下表列出了操作数的声明：
- 84 -
操作数数据类型声明
DeliverPos INT 在块接口的“Input”部分
BufferPos DINT 在块接口的“Temp”部分
Error INT 在块接口的“Temp”部分
Label STRING[4] 在块接口的“Temp”部分
下表列出了 PLC 数据类型的声明：
PLC 数据类型的名称名称数据类型

Number DINT
Article Declaration STRING
Colli INT
Title INT
Client First name STRING[10]
Surname STRING[10]
下表列出了数据块的声明：
数据块的名称名称数据类型
Client "Client"（PLC 数据类型）
Source
Array[0..10] of "Article"（PLC 数
Article
据类型）
Buffer Field Array[0..294] of BYTE
- 85 -
MOVE_BLK：存储区移动 (S7-1200, S7-1500)
MOVE_BLK：存储区移动
说明
可以使用“存储区移动”指令将一个存储区（源区域）的数据移动到另一个存储区（目标区域）中。使用
参数 COUNT 可以指定待复制到目标区域中的元素个数。待移动元素的宽度由源区域中第一个元素的
宽度决定。
仅当源区域和目标区域的数据类型相同时，才能执行该指令。
如果满足以下条件，则输出 OUT 的值无效：
• 在 IN 参数或 OUT 参数处，可移动更多的数据。
语法
“存储区移动”指令的语法如下所示：
SCL
MOVE_BLK(IN := <操作数>,
COUNT := <操作数>,
OUT => <操作数>)
参数
下表列出了“存储区移动”指令的参数：
S7-1200 S7-1500
二进制数、整
二进制数、整数、浮点数、
数、浮点数、定定时器、
待复制源区域
IN 1) Input 时器、DATE、 DATE、 D、L
中的首个元素
CHAR、 CHAR、
WCHAR、TOD WCHAR、
TOD、LTOD
USINT,
要从源区域复
USINT, UINT, UINT, I、Q、M、D、
COUNT Input 制到目标区域
UDINT UDINT, L、P
的元素个数
ULINT
二进制数、整
源区域内容要
复制到的目标
OUT 1) Output 时器、DATE、 DATE、 D、L
区域中的首个
CHAR、 CHAR、
元素
TOD、LTOD
1) ARRAY 结构中的元素只能使用指定的数据类型。
- 86 -
MOVE_BLK：存储区移动 (S7-1200, S7-1500)
示例
SCL
MOVE_BLK(IN := #a_array[2],
COUNT := "Tag_Count",
OUT => #b_array[1]);
参数操作数值
操作数 a_array 的数据类型为
IN a_array[2] ARRAY [0..5] of INT。它包含 6
个 INT 数据类型的元素。
COUNT Tag_Count 3
操作数 b_array 的数据类型为
OUT b_array[1] ARRAY [0..6] of INT。它包含 7
从第三个元素开始，该指令选择 #a_array 变量中的三个 INT 元素，并将其内容复制到 #b_array 输出变
量中，从第二个元素开始。
- 87 -
MOVE_BLK_VARIANT：存储区移动 (S7-1200, S7-1500)
MOVE_BLK_VARIANT：存储区移动
说明
可以使用“存储区移动”指令将一个存储区（源区域）的数据移动到另一个存储区（目标区域）中。可以
将一个完整的 ARRAY 或 ARRAY 的元素复制到另一个相同数据类型的 ARRAY 中。源 ARRAY 和目
标 ARRAY 的大小（元素个数）可能会不同。可以复制一个 ARRAY 内的多个或单个元素。
如果在创建块时使用该指令，则无需知道该 ARRAY，因为源 ARRAY 和目标 ARRAY 使用 VARIANT 进
行传输。
无论后期如何声明该 ARRAY，参数 SRC_INDEX 和 DEST_INDEX 始终从下限“0”开始计数。
如果复制的数据多于可用的数据，则不执行该指令。
说明
与 BOOL 数据类型连接的 VARAINT
如果要将 VARIANT 数据类型的参数（源区域或目标区域）与 BOOL 数据类型的变量或 ARRAY of
BOOL 互连，则可以选择：
1. 对其进行符号寻址
示例：参数 SRC： "Data_block".myArray
2. 借助于 ANY 指针对其进行寻址。但必须注意，指定的区域长度必须是 8 的整数倍，否则无法执
行该指令。
示例：参数 SRC： P#DB123.DBX456.0 BOOL 1000
语法
“存储区移动”指令的语法如下所示：
SCL
MOVE_BLK_VARIANT(SRC := <操作数>,
SRC_INDEX := <操作数>,
DEST_INDEX := <操作数>,
DEST => <操作数>)
参数
下表列出了“存储区移动”指令的参数：
VARIANT（指向一
个 ARRAY 或一个
SRC Input ARRAY 元素）， I、Q、M、L 待复制的源块
ARRAY of <数据
类型>
COUNT Input UDINT I、Q、M、D、L 已复制的元素数目
- 88 -
如果参数 DEST 或参数 AR‐

RAY 中未指定任何 SRC，则
将参数 COUNT 的值设置为
“1”。
• SRC_INDEX 参数将从 0
开始计算。如果参数 AR‐
RAY 中指定了 SRC，则参
数 SRC_INDEX 中的整数
将指定待复制源范围中的
第一个元素。而与所声明
SRC_INDEX Input DINT I、Q、M、D、L 的 ARRAY 限值无关。
• 如果 ARRAY 参数中未指
定 SRC 或者仅指定了
ARRAY 的某个元素，则
将 SRC_INDEX 参数的值
赋值为“0”。
• DEST_INDEX 参数将从 0
开始计算。如果参数 AR‐
RAY 中指定了 DEST，则
参数 DEST_INDEX 中的
整数将指定待复制目标范
DEST_IN‐ 围中的第一个元素。而与
Input DINT I、Q、M、D、L 所声明的 ARRAY 限值无
DEX
关。
• 如果参数 ARRAY 中未指
定任何 DEST，则将在参
数 DEST_INDEX 中指定
值“0”。
源块中内容将复制到的目标
DEST Output 1) VARIANT I、Q、M、L
区域。
函数值 (RET_VAL) INT I、Q、M、D、L 错误信息
1) DEST 参数声明为 Output，因为数据流入变量。但此变量本身在块接口中必须声明为 InOut。
RET_VAL 参数
(W#16#...)
0000 无错误
80B4 数据类型不匹配
8151 无法访问 SRC 参数。
8152 未输入参数 SRC 的操作数。
8153 SRC 参数中的代码生成错误
8154 参数 SRC 的操作数具有 BOOL 数据类型。
8281 参数 COUNT 的值无效
8382 参数 SRC_INDEX 的值超出了 VARIANT 的限值。
8383 SRC_INDEX 参数的值超出 ARRAY 的上限。
- 89 -
8482 参数 DEST_INDEX 的值超出了 VARIANT 的限值。

8483 DEST_INDEX 参数的值超出 ARRAY 的上限。
8534 DEST 参数为写保护
8551 无法访问 DEST 参数。
8552 未输入参数 DEST 的操作数。
8553 DEST 参数中的代码生成错误
8554 参数 DEST 的操作数具有 BOOL 数据类型。
请参见”。
示例
SCL
"Tag_Result" := MOVE_BLK_VARIANT(SRC := #SrcField,
SRC_INDEX :=
"Tag_Src_Index",
DEST_INDEX :=
"Tag_Dest_Index",
DEST => #DestField);
参数块接口中的声明操作数值
本地操作数 #SrcField
使用了一个在编程块时
SRC Input #SrcField 仍然未知的 PLC 数据类
型。 (ARRAY[0..10] of
"MOVE_UDT"
COUNT Input Tag_Count 2
SRC_INDEX Input Tag_Src_Index 3
DEST_INDEX Input Tag_Dest_Index 3
本地操作数 #DestField
使用了一个在编程块时
DEST InOut #DestField 仍然未知的 PLC 数据类
型。 (ARRAY[10..20] of
"MOVE_UDT"
将两个元素从源区域（从 ARRAY of UDT 的第 4 个元素开始）移动到目标区域。复制的元素将从第 4
个元素开始，插入到 ARRAY of UDT。
- 90 -
UMOVE_BLK：不可中断的存储区移动 (S7-1200, S7-1500)
UMOVE_BLK：不可中断的存储区移动
说明
可以使用“不可中断的存储区移动”指令将一个存储区（源区域）的数据移动到另一个存储区（目标区域）
中。该指令不可中断。使用参数 COUNT 可以指定待复制到目标区域中的元素个数。待移动元素的宽
度由源区域中第一个元素的宽度决定。
说明
此移动操作不会被操作系统的其它任务打断。这也解释了在执行“不可中断的存储区移动”指令期间，
CPU 中断响应次数增加的原因。

• 在 IN 参数或 OUT 参数处，可移动更多的数据。
可以使用“不可中断的存储区移动”指令移动最多 16 KB 大小的数据。注意：CPU 对此有特定限制。
语法
“不可中断的存储区移动”指令的语法如下所示：
SCL
UMOVE_BLK(IN := <操作数>,
OUT => <操作数>)
参数
下表列出了“不可中断的存储区移动”指令的参数：
S7-1200 S7-1500
二进制数、整
待复制源区域
IN 1) Input 时器、DATE、 DATE、 D、L
中的首个元素
CHAR、 CHAR、
TOD、LTOD
USINT,
要从源区域复
USINT, UINT, UINT, I、Q、M、D、
COUNT Input 制到目标区域
UDINT UDINT, L、P
的元素个数
ULINT
二进制数、整二进制数、整
源区域内容要
OUT 1) Output 数、浮点数、定数、浮点数、 D、L
复制到的目标
时器、DATE、定时器、
- 91 -
UMOVE_BLK：不可中断的存储区移动 (S7-1200, S7-1500)
DATE、
CHAR、 CHAR、区域中的首个
WCHAR、TOD WCHAR、元素
TOD、LTOD
示例
SCL
UMOVE_BLK(IN := #a_array[2],
参数操作数值
COUNT Tag_Count 3
从第三个元素开始，该指令选择 #a_array 变量中的三个 INT 元素，并将其内容复制到 #b_array 输出变
量中，从第二个元素开始。此复制操作不能被其它操作系统任务打断。
- 92 -
FILL_BLK：填充块 (S7-1200, S7-1500)
FILL_BLK：填充块
说明
“填充块”指令用于将一个存储区（源区域）的内容复制到选定存储区（目标区域）。可以使用参数 COUNT
指定复制操作的重复次数。执行该指令时，由参数 COUNT 指定填充的次数之后，将选择源区域并将其
移动到目标区域。
• 移动的数据量超出输入 IN 或输出 OUT 所能容纳的数据量。
语法
“填充块”指令的语法如下所示：
SCL
FILL_BLK(IN := <操作数>,
OUT => <操作数>)
参数
下表列出了“填充块”指令的参数：
S7-1200 S7-1500
二进制数、整
I、Q、M、D、用于填充目标
IN 1) Input 时器、TOD、 DATE、
L、P 区域的元素
DATE、CHAR、 CHAR、
WCHAR WCHAR、
TOD、LTOD
USINT,
USINT, UINT, UINT, I、Q、M、D、复制操作的重
COUNT Input
UDINT UDINT, L、P 复次数
ULINT
二进制数、整
目标区域中填
OUT 2) Output 时器、TOD、 DATE、 D、L
充的起始地址
WCHAR WCHAR、
TOD、LTOD
1) ARRAY 结构中的元素也可以使用指定的数据类型。
- 93 -
FILL_BLK：填充块 (S7-1200, S7-1500)
示例
SCL
FILL_BLK(IN := #a_array[2],
参数操作数值
COUNT Tag_Count 3
该指令将“#a_array”变量的第三个元素 (#a_array[2]) 复制到“#b_array”输出变量中三次。
- 94 -
UFILL_BLK：不可中断的存储区填充 (S7-1200, S7-1500)
UFILL_BLK：不可中断的存储区填充
说明
“不可中断的存储区填充”指令用于将一个存储区（源区域）的内容复制到选定存储区（目标区域）。可
以使用参数 COUNT 指定复制操作的重复次数。执行该指令时，将选择 IN 输入的值，并复制到目标区
域 COUNT 参数中指定的次数。
说明
此移动操作不会被操作系统的其它任务打断。这也解释了在执行“不可中断的存储区填充”指令期间，
CPU 中断响应次数增加的原因。

• 移动的数据量超出输入 IN 或输出 OUT 所能容纳的数据量。
语法
“不可中断的存储区填充”指令的语法如下所示：
SCL
UFILL_BLK(IN := <操作数>,
OUT=> <操作数>)
参数
下表列出了“不可中断的存储区填充”指令的参数：
S7-1200 S7-1500
二进制数、整
I、Q、M、D、用于填充目标
IN 1) Input 时器、DATE、 DATE、
L、P 区域的元素
CHAR、 CHAR、
TOD、LTOD
USINT,
USINT, UINT, UINT, I、Q、M、D、复制操作的重
COUNT Input
UDINT UDINT, L、P 复次数
ULINT
目标区域中填
OUT 2) Output 数、浮点数、定数、浮点数、 D、L
充的起始地址
时器、TOD、定时器、
- 95 -
UFILL_BLK：不可中断的存储区填充 (S7-1200, S7-1500)
DATE、
WCHAR WCHAR、
TOD、LTOD
1) ARRAY 结构中的元素也可以使用指定的数据类型。
示例
SCL
UFILL_BLK(IN := #a_array[2],
参数操作数值
COUNT Tag_Count 3
该指令将“#a_array”变量的第三个元素 (#a_array[2]) 复制到“#b_array”输出变量中三次。此复制操作不
能被其它操作系统任务打断。
- 96 -
SWAP：交换 (S7-1200, S7-1500)
SWAP：交换
说明
使用“交换”指令，可以更改输入值中字节的排列顺序，并将结果保存在指定的操作数中。
下图说明了如何使用“交换”指令交换数据类型为 DWORD 的操作数的字节：
语法
“交换”指令的语法如下所示：
SCL
SWAP(<表达式>)
S7-1200 S7-1500
WORD,
WORD, I、Q、M、D、
<表达式> Input DWORD, 输入值
DWORD L、P
LWORD
WORD,
WORD, I、Q、M、D、
函数值 DWORD, 指令的结果
DWORD L、P
LWORD
示例
- 97 -
SWAP：交换 (S7-1200, S7-1500)
SCL
"Tag_Result" := SWAP("Tag_Value");
指令结果作为函数值返回。
操作数值
Tag_Value 0000 1111 0101 0101
Tag_Result 0101 0101 0000 1111
- 98 -
ARRAY 数据块 (S7-1500)
ARRAY 数据块
• ReadFromArrayDB：从数组数据块中读取 (S7-1500)
• WriteToArrayDB：写入数组数据块 (S7-1500)
• ReadFromArrayDBL：从装载内存的数组数据块中读取 (S7-1500)
• WriteToArrayDBL：写入装载内存的数组数据块中 (S7-1500)
- 99 -
ReadFromArrayDB：从数组数据块中读取 (S7-1500)
ReadFromArrayDB：从数组数据块中读取
说明
可以使用“从数组数据块中读取”指令从 ARRAY 数据块中读取数据并写入目标区域中。
ARRAY 数据块是仅包含一个 ARRAY of [数据类型] 的数据块。 ARRAY 的元素可以是 PLC 数据类型
或其它任何基本数据类型。无论后期如何声明该 ARRAY，它始终从下限“0”开始计数。
语法
“从数组数据块中读取”指令的语法如下所示：
SCL
ReadFromArrayDB(DB := <操作数>,
INDEX := <操作数>,
VALUE => <操作数>)
参数
下表列出了“从数组数据块中读取”指令的参数：
DB Input DB_ANY I、Q、M、D、L 待读取的数据块
INDEX Input DINT 待读取的元素
P
VALUE Output 1) VARIANT I、Q、M、L 待读取并输出的值
函数值 (RET_VAL) INT I、Q、M、D、L 指令的结果
1) VALUE 参数声明为 Output，因为数据流入变量。但此变量本身在块接口中必须声明为 InOut。
RET_VAL 参数
(W#16#...)
0000 无错误
80B4 存储在 ARRAY 数据块中的元素数据类型与 VARIANT 中传输的元素数据类型不匹配。
80B5 复制操作被中断。
8132 数据块不存在、太短、设置了写保护或位于装载内存中。
8135 ARRAY 数据块中包含无效值。
8154 该数据块的数据类型不正确。
- 100 -
ReadFromArrayDB：从数组数据块中读取 (S7-1500)
8282 INDEX 参数的值超出 ARRAY 的上限。

8450 VALUE 参数的数据类型 VARIANT 提供值“0”。
8452 代码生成错误
8453 VALUE 参数的大小与 ARRAY 数据块中的元素长度不匹配。
请参见”。
示例
SCL
"TagResult" := ReadFromArrayDB(DB := "ArrayDB",
INDEX := "Ar-
rayDB"."THIS"[2],
VALUE => "Target-
Field[10]".Data2[1]);
参数操作数值
操作数“ArrayDB”的数据类型为
DB ArrayDB
Array [0 to 10] of INT。
INDEX ArrayDB."THIS"[2] “ArrayDB”的第三个元素
操作数“TargetField”的数据类型
VALUE "TargetField[10]".Data2[1] 为 Array [10 to 20] of
"MOVE_UDT"。
将读取“ArrayDB”中的第三个元素并写入操作数 "TargetField[10]".Data2[1] 中。
- 101 -
WriteToArrayDB：写入数组数据块 (S7-1500)
WriteToArrayDB：写入数组数据块
说明
可以使用“写入数组数据块”指令将数据写入 ARRAY 数据块中。
语法
“写入数组数据块”指令的语法如下所示：
SCL
WriteToArrayDB(DB := <操作数>,
VALUE := <操作数>)
参数
下表列出了“写入数组数据块”指令的参数：
DB Input DB_ANY I、Q、M、D、L 待写入数据的数据块
I、Q、M、D、L、待写入数据的数据块中的元
INDEX Input DINT
P 素
VALUE Input VARIANT I、Q、M、L 待写入的值
函数值 (RET_VAL) INT I、Q、M、D、L 指令的结果
RET_VAL 参数
(W#16#...)
0000 无错误
80B5 复制操作被中断。
8132 数据块不存在、太短或位于装载内存中。
8134 该数据块被写保护。
8135 该数据块不是 ARRAY 数据块。
- 102 -
WriteToArrayDB：写入数组数据块 (S7-1500)

请参见”。
示例
SCL
"TagResult" := WriteToArrayDB(DB := "ArrayDB",
INDEX := "Ar-
rayDB"."THIS"[2],
VALUE := "Source-
Field[1]".Data1[6]);
参数操作数值
DB ArrayDB
操作数“SourceField”的数据类型
VALUE "SourceField[1]".Data1[6] 为 Array [0 to 10] of
"MOVE_UDT"。
将操作数“SourceField”中第二个元素内的“Data1[6]”元素写入“ArrayDB”中。将第三个元素写入“Ar‐
rayDB”中。
- 103 -
ReadFromArrayDBL：从装载内存的数组数据块中读取 (S7-1500)
ReadFromArrayDBL：从装载内存的数组数据块中读取
说明
可以使用“从装载内存的数组数据块中读取”指令从装载内存的数组数据块中读取数据。
如果 ARRAY 数据块使用块属性“仅存储在装载内存”进行指定，则该数组数据块将仅存储在装载内存中。
当 REQ 参数中检测到信号上升沿时，将执行该指令。参数 BUSY 的信号状态将为“1”。当 BUSY 参数
中检测到信号下降沿时，将终止该指令。在一个程序周期内，DONE 参数的信号状态为“1”，而且在该
周期内，读取的值将输出到 VALUE 参数中。在所有其它程序周期内，参数 VALUE 的值将保持不变。
在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定块参数将存储在单个数据块
中（单背景）或者作为局部变量存储在块接口中（多重背景）。如果创建了一个单独的数据块，则该数
据块将保存到项目树“程序块 > 系统块”(Program blocks > System blocks) 路径中的“程序资源”(Program
resources) 文件夹内。有关本主题的更多信息，请参见“另请参见”。
说明
ARRAY 数据块必须使用“已优化”块属性进行创建。
语法
“从装载内存的数组数据块中读取”指令的语法如下所示：
SCL
"Instance DB"(REQ := <操作数>,
DB := <操作数>,
VALUE := <操作数>,
BUSY => <操作数>,
DONE => <操作数>,
ERROR => <操作数>)
参数
下表列出了“从装载内存的数组数据块中读取”指令的参数：
REQ = "1"：开始读取 AR‐
REQ Input BOOL I、Q、M、D、L
RAY 数据块
DB Input DB_ANY I、Q、M、D、L 待读取的数据块
INDEX Input DINT 待读取的元素
P
VALUE InOut VARIANT I、Q、M、L 待读取并输出的值
- 104 -
不必使用“TEMP”部分的本地
常数或变量。
BUSY = "1"：仍在读取数组
BUSY Output BOOL I、Q、M、D、L
数据块
DONE = "1"：该指令执行成
DONE Output BOOL I、Q、M、D、L
功
错误信息：
ERROR Output INT I、Q、M、D、L 如果指令执行期间出错，则在

参数 ERROR 中输出错误代
码。
ERROR 参数
下表列出了 ERROR 参数值的含义：
(W#16#...)
0000 无错误
8230 数据块编号不正确。
8231 数据块不存在。
8232 该数据块太短，或者不在装载内存中。
8235 该数据块不是一个 ARRAY 数据块。
请参见”。
有关执行指令“READ_DBL：从装载内存的数据块中读取”和“WRIT_DBL：写入装载内存的数据块中”触
发的错误代码，请参见“另请参见”。
示例
SCL
"ReadFromArrayDBL_DB"(REQ := "TagReg",
DB := "ArrayDB",
INDEX := "ArrayDB"."THIS"[2],
- 105 -
VALUE := "SourceTarget-
Field[1]".Data1[6],
BUSY => "TagBusy",
DONE => "TagDone",
ERROR => "TagError");
参数操作数值
REQ TagReq BOOL
DB ArrayDB
操作数“SourceTargetField”的数
VALUE "SourceTargetField[1]".Data1[6] 据类型为 Array [0 to 10] of
"MOVE_UDT"。
BUSY TagBusy BOOL
DONE TagDone BOOL
如果操作数“TagReq”处检测到上升沿，则执行指令“从装载内存的数组数据块中读取”。将读取“Ar‐
rayDB”中的第三个元素并输出到操作数 "SourceTargetField[1]".Data1[6] 中。在操作数“TagBusy”处检
测到下降沿时，将中止该指令的执行同时参数 VALUE 将不再变化。执行该指令后，操作数“TagDone”
的信号状态将为“1”。
- 106 -
WriteToArrayDBL：写入装载内存的数组数据块中 (S7-1500)
WriteToArrayDBL：写入装载内存的数组数据块中
说明
可以使用“写入装载内存的数组数据块中”指令将数据写入到装载内存的 ARRAY 数据块中。
如果 ARRAY 数据块使用块属性“仅存储在装载内存”进行指定，则该数组数据块将仅存储在装载内存中。
当 REQ 参数中检测到信号上升沿时，将执行该指令。参数 BUSY 的信号状态将为“1”。如果在 BUSY
参数中检测到信号下降沿，则将终止该指令同时将 VALUE 参数中的值写入该数据块中。在一个程序周
期内，参数 DONE 的信号状态为“1”。
说明
ARRAY 数据块必须使用“已优化”块属性进行创建。
语法
“写入装载内存的数组数据块中”指令的语法如下所示：
SCL
"Instance DB"(REQ := <操作数>,
DB := <操作数>,
BUSY => <操作数>,
DONE => <操作数>,
ERROR => <操作数>)
参数
下表列出了“写入装载内存的数组数据块中”指令的参数：
REQ = "1"：开始写入数组数
REQ Input BOOL I、Q、M、D、L
据块
DB Input DB_ANY I、Q、M、D、L 待写入数据的数据块
I、Q、M、D、L、待写入数据的数据块中的元
INDEX Input DINT
P 素
VALUE Input VARIANT I、Q、M、L 待写入的值
- 107 -
不必使用“TEMP”部分的本地
常数或变量。
BUSY = "1"：仍在写入到数
BUSY Output BOOL I、Q、M、D、L
组数据块
DONE = "1"：该指令执行成
DONE Output BOOL I、Q、M、D、L
功
错误信息：
ERROR Output INT I、Q、M、D、L 如果指令执行期间出错，则在

参数 ERROR 中输出错误代
码。
ERROR 参数
下表列出了 ERROR 参数值的含义：
(W#16#...)
0000 无错误
8230 数据块编号不正确。
8231 数据块不存在。
8232 该数据块太短，或者不在装载内存中。
8235 该数据块不是一个 ARRAY 数据块。
请参见”。
有关执行指令“READ_DBL：从装载内存的数据块中读取”和“WRIT_DBL：写入装载内存的数据块中”触
发的错误代码，请参见“另请参见”。
示例
SCL
"WriteToArrayDBL_DB"(REQ := "TagReg",
DB := "ArrayDB",
INDEX := "ArrayDB"."THIS"[2],
- 108 -
VALUE := "SourceTarget-
Field[1]".Data1[6],
BUSY => "TagBusy",
DONE => "TagDone",
ERROR => "TagError");
参数操作数值
REQ TagReq BOOL
DB ArrayDB
操作数“SourceTargetField”的数
VALUE "SourceTargetField[1]".Data1[6] 据类型为 Array [0 to 10] of
"MOVE_UDT"。
BUSY TagBusy BOOL
DONE TagDone BOOL
如果操作数 “TagReq”处检测到上升沿，则执行指令“写入装载内存的数组数据块中”。在操作数
“TagBusy”处检测到下降沿时，将中止该指令的执行同时将参数 VALUE 的值写入“ArrayDB”中的第三个
元素中。执行该指令后，操作数“TagDone”的信号状态将为“1”。
- 109 -
读/写访问权 (S7-1200, S7-1500)
读/写访问权
• PEEK：读取存储地址 (S7-1200, S7-1500)
• PEEK_BOOL：读取存储位 (S7-1200, S7-1500)
• POKE：写入存储地址 (S7-1200, S7-1500)
• POKE_BOOL：写入存储位 (S7-1200, S7-1500)
• POKE_BLK：写入存储区 (S7-1200, S7-1500)
• READ_LITTLE：以小端格式读取数据 (S7-1200, S7-1500)
• WRITE_LITTLE：以小端格式写入数据 (S7-1200, S7-1500)
• READ_BIG：以大端格式读取数据 (S7-1200, S7-1500)
• WRITE_BIG：以大端格式写入数据 (S7-1200, S7-1500)
- 110 -
PEEK：读取存储地址 (S7-1200, S7-1500)
PEEK：读取存储地址
说明
“读取存储地址”指令用于在不指定数据类型的情况下从存储区读取存储地址。
如果在 AREA 参数中指定数据块的 16#84 区域，则只能通过块属性“标准”访问数据块。
说明
该指令仅用于访问“标准”存储区。
语法
“读取存储地址”指令的语法如下所示：
SCL
PEEK(AREA:= <操作数>,
DBNUMBER := <操作数>,
BYTEOFFSET:= <操作数>)
SCL
PEEK_<数据类型>(AREA := <操作数>,
BYTEOFFSET:= <操作数>)
可以选择以下区域：
• 16#81: Input
• 16#82: Output
AREA Input BYTE I、Q、M、D、L
• 16#83: 位存储区
• 16#84: DB
• 16#1: 外设输入（仅 S7-1500）
DBNUM‐ DINT, 如果 AREA = DB，则为数据块数量，否
Input D
BER DB_ANY 则为“0”
BYTEOFF‐ 待读取的地址
Input DINT I、Q、M、D、L
SET 仅使用 16 个最低有效位。
位字符串
_<数据类型> -
默认： BYTE 1. 可以使用“_”明确指定指令的数据类
型。
- 111 -
PEEK：读取存储地址 (S7-1200, S7-1500)
2. 如果未明确指定数据类型，将由使
用的变量或类型编码的常数来确
定。
3. 如果既未明确指定数据类型，也未
指定定义的变量或类型编码的常
数，则使用默认数据类型。
函数值位字符串 I、Q、M、D、L 指令的结果
说明
如果要读取输入、输出或位存储区中的存储地址，则必须将参数 DBNUMBER 的值设置为“0”，否则指
令将无效。
示例
SCL
"Tag_Result1" := PEEK(AREA := "Tag_Area",
DBNUMBER := "Tag_DBNumber",
BYTEOFFSET := "Tag_Byte");
SCL
"Tag_Result2" := PEEK_WORD(AREA := "Tag_Area",
BYTEOFFSET := "Tag_Byte");
参数操作数值
AREA Tag_Area 16#84
DBNUMBER Tag_DBNumber 5
BYTEOFFSET Tag_Byte 20
函数值 Tag_Result1 字节值“20”
函数值 Tag_Result2 字值“20”
该指令从数据块“5”中的“Tag_Byte”操作数内读取地址值“20”，并将结果作为“Tag_Result”操作数的函数值
返回。
- 112 -
PEEK_BOOL：读取存储位 (S7-1200, S7-1500)
PEEK_BOOL：读取存储位
说明
“读取存储位”指令用于在不指定数据类型的情况下从存储区读取存储位。
说明
语法
“读取存储位”指令的语法如下所示：
SCL
PEEK_BOOL(AREA := <操作数>,
BYTEOFFSET := <操作数>,
BITOFFSET := <操作数>)
• 16#81: 输入
• 16#82: 输出
• 16#83: 位存储区
• 16#84: DB
• 16#1: 外设输入（仅 S7-1500）
DBNUM‐ DINT, 如果 AREA = DB，则为数据块数量，
Input D
BER DB_ANY 否则为“0”
BYTEOFF‐ 待读取的地址
BITOFFSET Input INT I、Q、M、D、L 待读取的位
函数值 BOOL I、Q、M、D、L 指令的结果
说明
如果要读取输入、输出或位存储区中的存储位，则必须将参数 DBNUMBER 的值设置为“0”，否则指令
将无效。
示例
- 113 -
PEEK_BOOL：读取存储位 (S7-1200, S7-1500)
SCL
"Tag_Result" := PEEK_BOOL(AREA := "Tag_Area",
BYTEOFFSET := "Tag_Byte",
BITOFFSET := "Tag_Bit");
参数操作数值
AREA Tag_Area 16#84
BITOFFSET Tag_Bit 3
函数值 Tag_Result 3
该指令从数据块“5”中字节“20”的“Tag_Bit”操作数内读取存储位值“3”，并将结果作为函数值在“Tag_Re‐
sult”操作数中返回。
- 114 -
POKE：写入存储地址 (S7-1200, S7-1500)
POKE：写入存储地址
说明
“写入存储地址”指令用于在不指定数据类型的情况下将存储地址写入存储区。
说明
语法
“写入存储地址”指令的语法如下所示：
SCL
POKE(AREA := <操作数>,
• 16#81: 输入
• 16#82: 输出
• 16#83: 位存储区
• 16#84: DB
• 16#2: 外设输出（仅 S7-1500）
DBNUM‐ DINT, 如果 AREA = DB，则为数据块数量，否
Input D
BER DB_ANY 则为“0”
BYTEOFF‐ 待写入的地址
VALUE Input 位字符串 I、Q、M、D、L 待写入的值
说明
如果要将存储地址写入输入、输出或位存储区，则必须将参数 DBNUMBER 的值设置为“0”，否则指令
将无效。
示例
- 115 -
POKE：写入存储地址 (S7-1200, S7-1500)
SCL
POKE(AREA := "Tag_Area",
BYTEOFFSET := "Tag_Byte"),
VALUE := "Tag_Value";
参数操作数值
AREA Tag_Area 16#84
VALUE Tag_Value 16#11
该指令使用值“16#11”覆盖数据块“5”中的存储地址“20”。
- 116 -
POKE_BOOL：写入存储位 (S7-1200, S7-1500)
POKE_BOOL：写入存储位
说明
“写入存储位”指令用于在不指定数据类型的情况下将存储位写入存储区。
说明
语法
“写入存储位”指令的语法如下所示：
SCL
POKE_BOOL(AREA := <操作数>,
BITOFFSET := <操作数>,
• 16#81: 输入
I、Q、M、D、 • 16#82: 输出
AREA Input BYTE
L • 16#83: 位存储区
• 16#84: DB
• 16#2: 外设输出（仅 S7-1500）
DBNUM‐ DINT, 如果 AREA = DB，则为数据块数量，否则
Input D
BER DB_ANY 为“0”
BYTEOFF‐ I、Q、M、D、待写入的地址

Input DINT
SET L 仅使用 16 个最低有效位。
I、Q、M、D、
BITOFFSET Input INT 待写入的位
L
I、Q、M、D、
VALUE Input BOOL 待写入的值
L
说明
- 117 -
POKE_BOOL：写入存储位 (S7-1200, S7-1500)
如果要将存储位写入输入、输出或位存储区，则必须将参数 DBNUMBER 的值设置为“0”，否则指令将

无效。
示例
SCL
POKE_BOOL(AREA := "Tag_Area",
BYTEOFFSET := "Tag_Byte",
BITOFFSET := "Tag_Bit",
VALUE := "Tag_Value");
参数操作数值
AREA Tag_Area 16#84
BITOFFSET Tag_Bit 3
VALUE Tag_Value M0.0
该指令使用值“M0.0”覆盖数据块“5”中字节“20”的存储位“3”。
- 118 -
POKE_BLK：写入存储区 (S7-1200, S7-1500)
POKE_BLK：写入存储区
说明
“写入存储区”指令用于在不指定数据类型的情况下将存储区内容复制到另一个存储区。
说明
语法
“写入存储区”指令的语法如下所示：
SCL
POKE_BLK(AREA_SRC:= <操作数>,
DBNUMBER_SRC:= <操作数>,
BYTEOFFSET_SRC:= <操作数>,
AREA_DEST:= <操作数>,
DBNUMBER_DEST:= <操作数>,
BYTEOFFSET_DEST:= <操作数>,
COUNT := <操作数>)
可以在源存储区中选择以下区域：
• 16#81: Input
AREA_SRC Input BYTE I、Q、M、D、L • 16#82: Output
• 16#83: 位存储区
• 16#84: DB
DINT, 如果 AREA = DB，则为源存储区中
DBNUMBER_SRC Input D
DB_ANY 的数据块数量，否则为“0”
BYTEOFF‐ 源存储区中待写入的地址
SET_SRC 仅使用 16 个最低有效位。
可以在目的存储区中选择以下区
域：
• 16#81: Input
AREA_DEST Input BYTE I、Q、M、D、L • 16#82: Output
• 16#83: 位存储区
• 16#84: DB
- 119 -
POKE_BLK：写入存储区 (S7-1200, S7-1500)
DBNUM‐ DINT, 如果 AREA = DB，则为目的存储区

Input D
BER_DEST DB_ANY 中的数据块数量，否则为“0”
BYTEOFF‐ 目的存储区中待写入的地址
SET_DEST 仅使用 16 个最低有效位。
COUNT Input DINT I、Q、M、D、L 已复制的字节数目
说明
如果要将存储地址写入输入、输出或位存储区，则必须将参数 DBNUMBER 的值设置为“0”，否则指令
将无效。
示例
SCL
POKE_BLK(AREA_SRC := "Tag_Source_Area",
DBNUMBER_SRC := "Tag_Source_DBNumber",
BYTEOFFSET_SRC := "Tag_Source_Byte"),
AREA_DEST := "Tag_Destination_Area",
DBNUMBER_DEST := "Tag_Destination_DBNumber",
BYTEOFFSET_DEST := "Tag_Destination_Byte",
COUNT := "Tag_Count");
参数操作数值
AREA_SRC Tag_Source_Area 16#84
DBNUMBER_SRC Tag_Source_DBNumber 5
BYTEOFFSET_SRC Tag_Source_Byte 20
AREA_DEST Tag_Destination_Area 16#83
DBNUMBER_DEST Tag_Destination_DBNumber 0
BYTEOFFSET_DEST Tag_Destination_Byte 30
COUNT Tag_Count 100
该指令将数据块“5”中从地址“20”开始的 100 个字节写入位存储器中从地址“30”开始的存储区内。
- 120 -
READ_LITTLE：以小端格式读取数据 (S7-1200, S7-1500)
READ_LITTLE：以小端格式读取数据
说明
可以使用“以小端格式读取数据”指令以小端字节序列从存储区读取数据并将此数据写入单个变量。使用
小端格式时，首先保存具有最低有效位的字节，即保存在最低存储器地址。
参数 SRC_ARRAY 和 DEST_VARIABLE 属于 VARIANT 数据类型。但对于参数可以互连的数据类型，
有几点限制。参数 DEST_VARIABLE 的 VARIANT 必须指向基本数据类型。 SRC_ARRAY 参数的
VARIANT 指向要读取的存储区，并且必须为 ARRAY of BYTE。
参数 POS 的操作数确定存储区中读取数据的起始位置。
说明
读取 VARIANT 或 BOOL 数据类型的变量
如果要读取 VARIANT 指向的变量，请使用“序列化”或“取消序列化”指令。
如果要读取 BOOL 数据类型的变量，则使用“片段访问”。
语法
“以小端格式读取数据”指令的语法如下所示：
SCL
READ_LITTLE(SRC_ARRAY := <操作数>,
DEST_VARIABLE => <操作数>,
POS := <操作数>)
参数
下表列出了“以小端格式读取数据”指令的参数：
S7-1200 S7-1500
SRC_AR‐ ARRAY of ARRAY of I、Q、M、
Input 待读取的存储区
RAY BYTE BYTE D、L
位字符串、整
位字符串、整数、浮点数、
数、浮点数、 LDT、TOD、
DEST_VARI‐ I、Q、M、
Output TOD、DATE、 LTOD、读取值
ABLE D、L
CHAR、 DATE、
WCHAR CHAR、
WCHAR
确定读取数据的起始位
I、Q、M、
POS InOut DINT DINT 置。 POS 参数将从 0
D、L
开始计算。
I、Q、M、
函数值 (RET_VAL) INT INT 错误信息
D、L
- 121 -
READ_LITTLE：以小端格式读取数据 (S7-1200, S7-1500)
RET_VAL 参数
(W#16#...)
0000 无错误
80B4 SRC_ARRAY 参数的数据类型不是 ARRAY of BYTE。
8383 POS 参数的值在 ARRAY 的限制范围内，但存储区的大小超出了 ARRAY 的上限。
示例
SCL
#TagResult := READ_LITTLE(SRC_ARRAY := #SourceField,
DEST_VARIABLE => #DINTVaria-
ble,
POS := #TagPos);
参数操作数值
BYTE 类型的 ARRAY [0..3]
SRC_ARRAY #SourceField := 16#1A, 16#2B, 16#3C,
16#4D
1295788826
DEST_VARIABLE #DINTVariable
16#4D3C2B1A
POS #TagPos 0 => 4
该指令从 #SourceField 存储区读取整数 1_295_788_826，并将其以小端格式写入操作数 #DINTVaria‐
ble。 DEST_VARIABLE 参数的数据类型指定读取多少字节。数量 4 将存储在 #TagPos 操作数中。
- 122 -
WRITE_LITTLE：以小端格式写入数据 (S7-1200, S7-1500)
WRITE_LITTLE：以小端格式写入数据
说明
可以使用“以小端格式写入数据”指令以小端字节序列将单个变量的数据写入存储区。使用小端格式时，
首先保存具有最低有效位的字节，即保存在最低存储器地址。
参数 SRC_VARIABLE 和 DEST_ARRAY 属于 VARIANT 数据类型。但对于参数可以互连的数据类型，
有几点限制。参数 SRC_VARIABLE 的 VARIANT 必须指向基本数据类型。参数 DEST_ARRAY 的
VARIANT 指向写入数据的存储区，并且必须是 ARRAY of BYTE。
参数 POS 的操作数确定存储区中写入数据的起始位置。
说明
写入 VARIANT 或 BOOL 数据类型的变量
如果要写入 VARIANT 指向的变量，请使用“序列化”或“取消序列化”指令。
如果要写入 BOOL 数据类型的变量，则使用“片段访问”。
语法
“以小端格式写入数据”指令的语法如下所示：
SCL
WRITE_LITTLE(SRC_VARIABLE := <操作数>,
POS := <操作数>)
参数
下表列出了“以小端格式写入数据”指令的参数：
S7-1200 S7-1500
位字符串、整位字符串、整
数、浮点数、数、浮点数、
SRC_VARIA‐ TOD、 LDT、TOD、 I、Q、M、
Input 写入其数据的变量
BLE DATE、 LTOD、DATE、 D、L
CHAR、 CHAR、
WCHAR WCHAR
DEST_AR‐ ARRAY of ARRAY of I、Q、M、
InOut 待写入数据的存储区
RAY BYTE BYTE D、L
确定写入数据的起始位
I、Q、M、
POS InOut DINT DINT 置。POS 参数将从 0 开
D、L
始计算。
I、Q、M、
D、L
- 123 -
WRITE_LITTLE：以小端格式写入数据 (S7-1200, S7-1500)
RET_VAL 参数
(W#16#...)
0000 无错误
示例
SCL
#TagResult := WRITE_LITTLE(SRC_VARIABLE := #DINTVaria-
ble,
DEST_ARRAY := #TargetField,
POS := #TagPos);
参数操作数值
1295788826
SRC_VARIABLE #DINTVariable
16#4D3C2B1A
DEST_ARRAY #TargetField
= 16#1A, 16#2B, 16#3C, 16#4D
POS #TagPos 0 => 4
该指令将整数 1_295_788_826 以小端格式从 #DINTVariable 操作数写入 #TargetField 存储区。
SRC_VARIABLE 参数的数据类型指定写入多少字节。数量 4 将存储在 #TagPos 操作数中。
- 124 -
READ_BIG：以大端格式读取数据 (S7-1200, S7-1500)
READ_BIG：以大端格式读取数据
说明
可以使用“以大端格式读取数据”指令以大端字节序列从存储区读取数据并将此数据写入单个变量。使用
大端格式时，首先保存具有最高有效位的字节，即保存在最低存储器地址。
参数 SRC_ARRAY 和 DEST_VARIABLE 属于 VARIANT 数据类型。但对于参数可以互连的数据类型，
有几点限制。参数 DEST_VARIABLE 的 VARIANT 必须指向基本数据类型。 SRC_ARRAY 参数的
VARIANT 指向要读取的存储区，并且必须为 ARRAY of BYTE。
参数 POS 的操作数确定存储区中读取数据的起始位置。
说明
读取 VARIANT 或 BOOL 数据类型的变量
如果要读取 VARIANT 指向的变量，请使用“序列化”或“取消序列化”指令。
如果要读取 BOOL 数据类型的变量，则使用“片段访问”。
语法
“以大端格式读取数据”指令的语法如下所示：
SCL
READ_BIG(SRC_ARRAY := <操作数>,
DEST_VARIABLE => <操作数>,
POS := <操作数>)
参数
下表列出了“以大端格式读取数据”指令的参数：
S7-1200 S7-1500
SRC_AR‐ ARRAY of ARRAY of I、Q、M、
Input 待读取的存储区
RAY BYTE BYTE D、L
位字符串、整
位字符串、整数、浮点数、
数、浮点数、 LDT、TOD、
DEST_VARI‐ I、Q、M、
Output TOD、DATE、 LTOD、读取值
ABLE D、L
CHAR、 DATE、
WCHAR CHAR、
WCHAR
确定读取数据的起始位
I、Q、M、
D、L
始计算。
I、Q、M、
D、L
- 125 -
READ_BIG：以大端格式读取数据 (S7-1200, S7-1500)
RET_VAL 参数
(W#16#...)
0000 无错误
示例
SCL
#TagResult := READ_BIG(SRC_ARRAY := #SourceField,
DEST_VARIABLE => #DINTVariable,
POS := #TagPos);
参数操作数值
SRC_ARRAY #SourceField := 16#1A, 16#2B, 16#3C,
16#4D
439041101
DEST_VARIABLE #DINTVariable
16#1A2B3C4D
POS #TagPos 0 => 4
该指令从 #SourceField 存储区读取整数 439_041_101，并将其以大端格式写入操作数 #DINTVariable。
DEST_VARIABLE 参数的数据类型指定读取多少字节。数量 4 将存储在 #TagPos 操作数中。
- 126 -
WRITE_BIG：以大端格式写入数据 (S7-1200, S7-1500)
WRITE_BIG：以大端格式写入数据
说明
可以使用“以大端格式写入数据”指令以大端字节序列将单个变量的数据写入存储区。使用大端格式时，
首先保存具有最高有效位的字节，即保存在最低存储器地址。
参数 SRC_VARIABLE 和 DEST_ARRAY 属于 VARIANT 数据类型。但对于参数可以互连的数据类型，
有几点限制。参数 SRC_VARIABLE 的 VARIANT 必须指向基本数据类型。参数 DEST_ARRAY 的
VARIANT 指向写入数据的存储区，并且必须是 ARRAY of BYTE。
参数 POS 的操作数确定存储区中写入数据的起始位置。
说明
写入 VARIANT 或 BOOL 数据类型的变量
如果要写入 VARIANT 指向的变量，请使用“序列化”或“取消序列化”指令。
如果要写入 BOOL 数据类型的变量，则使用“片段访问”。
语法
“以大端格式写入数据”指令的语法如下所示：
SCL
WRITE_BIG(SRC_VARIABLE := <操作数>,
POS := <操作数>)
参数
下表列出了“以大端格式写入数据”指令的参数：
S7-1200 S7-1500
位字符串、整
位字符串、整
数、浮点数、
数、浮点数、
SRC_VARIA‐ LDT、TOD、 I、Q、M、
Input TOD、DATE、写入其数据的变量
BLE LTOD、DATE、 D、L
CHAR、
CHAR、
WCHAR
WCHAR
DEST_AR‐ ARRAY of ARRAY of I、Q、M、
InOut 待写入数据的存储区
RAY BYTE BYTE D、L
确定写入数据的起始位
I、Q、M、
D、L
始计算。
I、Q、M、
D、L
- 127 -
WRITE_BIG：以大端格式写入数据 (S7-1200, S7-1500)
RET_VAL 参数
(W#16#...)
0000 无错误
示例
SCL
#TagResult := WRITE_BIG(SRC_VARIABLE := #DINTVariable,
DEST_ARRAY := #TargetField,
POS := #TagPos);
参数操作数值
439041101
SRC_VARIABLE #DINTVariable
16#1A2B3C4D
DEST_ARRAY #TargetField
= 16#1A, 16#2B, 16#3C, 16#4D
POS #TagPos 0 => 4
该指令将整数 439_041_101 以大端格式从 #DINTVariable 操作数写入 #TargetField 存储区。
SRC_VARIABLE 参数的数据类型指定写入多少字节。数量 4 将存储在 #TagPos 操作数中。
- 128 -
VARIANT (S7-1200, S7-1500)
VARIANT
• VariantGet：读出 VARIANT 变量值 (S7-1200, S7-1500)
• VariantPut：写入 VARIANT 变量值 (S7-1200, S7-1500)
• CountOfElements：获取 ARRAY 元素的数量 (S7-1200, S7-1500)
- 129 -
VariantGet：读出 VARIANT 变量值 (S7-1200, S7-1500)
VariantGet：读出 VARIANT 变量值
说明
可以使用“读出 VARIANT 变量值”指令读取 SRC 参数的 VARIANT 指向的变量值，并将其写入 DST 参
数的变量。
SRC 参数具有 VARIANT 数据类型。可以在 DST 参数上指定除 VARIANT 外的任何数据类型。
DST 参数变量的数据类型必须匹配 VARIANT 指向的数据类型。
说明
要复制结构和 ARRAY，可以使用“MOVE_BLK_VARIANT：块移动”指令。更多信息，请参见“另请参
见”。
语法
“读出 VARIANT 变量值”指令的语法如下所示：
SCL
VariantGet(SRC := <操作数>,
DST=> <操作数>)
参数
下表列出了“读出 VARIANT 变量值”指令的参数：
SRC Input VARIANT I、Q、M、L 待读取的变量
位字符串、整数、
浮点数、定时器、
DST Output 日期时间、字符串、 I、Q、M、D、L 指令的结果
ARRAY 元素、PLC
数据类型
示例
SCL
VariantGet(SRC := #TagIn_Source,
DST => "TagOut_Dest");
读取“#TagIn_Source”操作数的 VARIANT 指向的变量值，并写入到“TagOut_Dest”操作数。
- 130 -
VariantPut：写入 VARIANT 变量值 (S7-1200, S7-1500)
VariantPut：写入 VARIANT 变量值
说明
可以使用“写入 VARIANT 变量值”指令将 SRC 参数的变量值写入 VARIANT 指向的 DST 参数的变量。
DST 参数具有 VARIANT 数据类型。可以在 SRC 参数上指定除 VARIANT 外的任何数据类型。
SRC 参数变量的数据类型必须匹配 VARIANT 指向的参数的数据类型。
说明
要复制结构和 ARRAY，可以使用“MOVE_BLK_VARIANT：块移动”指令。更多信息，请参见“另请参
见”。
语法
“写入 VARIANT 变量值”指令的语法如下所示：
SCL
VariantPut(SRC := <操作数>,
DST := <操作数>)
参数
下表列出了“写入 VARIANT 变量值”指令的参数：
位字符串、整数、
SRC Input 日期时间、字符串、 I、Q、M、D、L 待读取的变量
ARRAY 元素、PLC
数据类型
DST Input VARIANT I、Q、M、L 指令的结果
示例
SCL
VariantPut(SRC := "TagIn_Source",
DST := "#TagIn_Dest");
将“TagIn_Source”操作数的值写入到“#TagIn_Dest”操作数的 VARIANT 指向的变量。
- 131 -
CountOfElements：获取 ARRAY 元素的数量 (S7-1200, S7-1500)
CountOfElements：获取 ARRAY 元素的数量
说明
可以使用“获取 ARRAY 元素的数量”指令查询 VARIANT 指向的变量所包含的 ARRAY 元素数量。
如果是一个一维 ARRAY，将输出上限和下限 +1 的差值作为结果。如果是多维 ARRAY，将输出所有维
的乘积作为结果。
<操作数> 必须具有 VARIANT 数据类型。
如果 VARIANT 变量不是 ARRAY，则结果为“0”。
如果 VARIANT 指向 ARRAY of BOOL，那么填充元素也包含在总数中。（例如，ARRAY[0..1] of BOOL
将返回 8）
语法
“获取 ARRAY 元素的数量”指令的语法如下所示：
SCL
CountOfElements(<操作数>)
参数
下表列出了“获取 ARRAY 元素的数量”指令的参数：
<操作数> Input VARIANT I、Q、M、L 要查询的变量
函数值 UDINT I、Q、M、D、L 指令的结果
示例
SCL
IF IS_ARRAY(#Tag_VARIANTToArray) THEN
"Tag_Result" := CountOfElements(#Tag_VARIANT);
END_IF;
如果 VARIANT 指向的变量是 ARRAY，将输出 ARRAY 元素的数量。
- 132 -
传统 (S7-1500)
传统
• BLKMOV：块移动 (S7-1500)
• UBLKMOV：不可中断的存储区移动 (S7-1500)
• FILL：填充块 (S7-1500)
- 133 -
BLKMOV：块移动 (S7-1500)
BLKMOV：块移动
说明
可以使用“块移动”指令将一个存储区（源区域）的数据移动到另一个存储区（目标区域）中。移动操作
沿地址升序方向执行。可使用 VARIANT 来定义源区域和目标区域。
说明
该指令的变量仅适用于尚未置位属性“优化的块访问”的数据块中。如果变量的保持性设置“在 IDB 中
设置”已声明，则还可以使用变量“优化访问”。
下图说明了移动操作的原理：
源和目标数据的一致性
请注意，执行“块移动”指令时，源数据需保持不变，否则将无法保证目标数据的一致性。
可中断性
嵌套深度没有限制。
存储区
可以使用“块移动”指令移动以下存储区的数据：
• 数据块区域
• 位存储区
• 过程映像输入
• 过程映像输出
- 134 -
移动操作的通用规则
源区域和目标区域不得重叠。如果源和目标区域长度不同，则只能移动较小长度的区域。
如果源区域小于目标区域，则将整个源区域的数据都写入到目标区域中。而目标区域的其余字节则保持
不变。
如果目标区域小于源区域，将写满整个目标区域。而忽略源区域的剩余字节。
如果数据类型为 BOOL 的块被移动，则必须对变量进行绝对寻址，且为该区域指定的长度必须为 8 的倍
数，否则不执行该指令。
移动字符串的规则
还可以使用“块移动”指令移动 STRING 数据类型的源区域和目标区域。如果只有源区域为 STRING 数
据类型，则仅移动字符串中实际包含的字符。有关实际和最大长度的信息，将写入目标区域。如果源和
目标区域都是 STRING 数据类型，则将目标区域中字符串的当前长度设置为实际移动的字符数。
如果要移动字符串实际长度和最大长度的信息，则需要以字节为单位将相关区域指定给 SRCBLK 和
DSTBLK 参数。
语法
“块移动”指令的语法如下所示：
SCL
BLKMOV(SRCBLK := <操作数>,
DSTBLK => <操作数>)
参数
下表列出了“块移动”指令的参数：
指定待移动的存储区（源区
SRCBLK Input VARIANT I、Q、M、L、P
域）。
指定要将块移动到的存储区
DSTBLK Output 1) VARIANT I、Q、M、L、P
（目标区域）。
1) DSTBLK 参数声明为 Output，因为数据流入变量。但此变量本身在块接口中必须声明为 InOut。
RET_VAL 参数
(W#16#...)
0000 无错误
8092 源或目标区域只能在装载内存中。
8152 SRCBLK 参数中不支持 WSTRING、WCHAR 和 BOOL 数据类型。
- 135 -
8352 DSTBLK 参数中不支持 WSTRING、WCHAR 和 BOOL 数据类型。

常见错误信息另请参见："GET_ERR_ID：获取本地错误 ID
请参见”。
示例
SCL
"Tag_RetVal" := BLKMOV(SRCBLK := P#M100.0 BYTE 10,
DSTBLK => P#DB1.DBX0.0 BYTE
10);
该指令将复制从 MB100 开始的 10 个字节，并写入 DB1 中。如果在移动操作期间出错，则在变量
“Tag_RetVal”中输出其错误代码。
- 136 -
UBLKMOV：不可中断的存储区移动 (S7-1500)
UBLKMOV：不可中断的存储区移动
说明
可以使用“不可中断的存储区移动”指令将一个存储区（源区域）的数据移动到另一个存储区（目标区域）
中。移动操作沿地址升序方向执行。可使用 VARIANT 来定义源区域和目标区域。
此移动操作不会被操作系统的其它任务打断。因此，在执行“不可中断的存储区移动”指令期间，CPU 中
断响应次数将增加。
说明
存储区
可以使用“不可中断的存储区移动”指令移动以下存储区的数据：
• 数据块区域
• 位存储区
在执行“不可中断的存储区移动”指令期间，源区域和目标区域不可以重叠。如果源区域小于目标区域，
则将整个源区域的数据都写入到目标区域中。而目标区域的其余字节则保持不变。
如果目标区域小于源区域，将写满整个目标区域。而忽略源区域的剩余字节。
如果定义为形参的源区域或目标区域比 SRCBLK 或 DSTBLK 参数中所指定的源区域或目标区域小，则
不传送任何数据。
如果数据类型为 BOOL 的块被移动，则必须对变量进行绝对寻址，且为该区域指定的长度必须为 8 的倍
数，否则不执行该指令。
移动字符串的规则
还可以使用“不可中断的存储区移动”指令移动 STRING 数据类型的源和目标区域。如果只有源区域为
STRING 数据类型，则仅移动字符串中实际包含的字符。而不会将关于实际长度和最大长度的信息写入
目标区域中。如果源和目标区域都是 STRING 数据类型，则将目标区域中字符串的当前长度设置为实际
移动的字符数。如果要移动 STRING 数据类型的区域，则必须将区域长度指定为“1”。
语法
“不可中断的存储区移动”指令的语法如下所示：
SCL
UBLKMOV(SRCBLK := <操作数>,
DSTBLK => <操作数>)
- 137 -
UBLKMOV：不可中断的存储区移动 (S7-1500)
参数
下表列出了“不可中断的存储区移动”指令的参数：
指定待移动的存储区（源区
SRCBLK Input VARIANT I、Q、M、L、P
域）。
指定要将块移动到的存储区
DSTBLK Output 1) VARIANT I、Q、M、L、P
（目标区域）。
1) DSTBLK 参数声明为 Output，因为数据流入变量。但此变量本身在块接口中必须声明为 InOut。
RET_VAL 参数
错误代码说明
(W#16#...)
0000 无错误
8152 SRCBLK 参数中不支持 WSTRING、WCHAR 和 BOOL 数据类型。
8352 DSTBLK 参数中不支持 WSTRING、WCHAR 和 BOOL 数据类型。
常见错误信息另请参见：GET_ERR_ID：获取本地错误 ID
请参见”。
示例
SCL
"Tag_RetVal" := UBLKMOV(SRCBLK := P#M100.0 BYTE 10,
DSTBLK => P#DB1.DBX0.0 BYTE
10);
该指令将复制从 MB100 开始的 10 个字节，并写入 DB1 中。如果在移动操作期间出错，则在变量
“Tag_RetVal”中输出其错误代码。
- 138 -
FILL：填充块 (S7-1500)
FILL：填充块
说明
可以使用“填充块”指令将一个存储区（源区域）的内容填充到另一存储区（目标区域）。 “填充块”指令将
源区域的数据移动到目标区域，直到目标区域写满为止。移动操作沿地址升序方向执行。
可使用 VARIANT 来定义源区域和目标区域。
说明
您还可以使用 ANY 数据类型来定义源区域和目标区域
如果使用 ANY 数据类型，那么在连接 STRING 和 WSTRING 数据类型时必须遵守以下几点：
• 在 STRING（目标区域）后使用 ANY 分配 STRING（源区域）时，STRING 的内容将重复地复制
到目标区域，直至填满目标区域。
源区域： String#'STEP7-SCL-TIA-Portal'
目标区域：'STEP7-SCL-TIA-PortalSTEP7-SCL-TIA-PortalSTEP7-SCL'
说明
对于具有“优化的块访问”属性的块，可以使用“FILL_BLK：填充块”指令。
下图说明了移动操作的原理：
示例：使用存储器字 MW14 到 MW20 中的内容预设置 MW100 到 MW118 中的内容。
源和目标数据的一致性
请注意，执行“填充块”指令时，源数据需保持不变，否则将无法保证目标数据的一致性。
- 139 -
存储区
可使用“填充块”指令移动以下存储区的数据：
• 数据块区域
• 位存储区
源区域和目标区域不得重叠。如果要预设的目标区域不是输入参数 BVAL 长度的整数倍，目标区域仍然
可写至最后一个字节。
如果要预置的目标区域小于源区域，此功能仅复制可以写入目标区域的数据量。
如果实际的目标或源区域小于源或目标区域分配的存储区（参数 BVAL 和 BLK），则不传输任何数据。
如果 ANY 指针（源或目标）为 BOOL 数据类型，则必须对其进行绝对寻址，且指定的长度必须能被 8
整除；否则将不会执行该指令。
如果目标区域为 STRING 数据类型，则指令将写入包含管理信息在内的整个字符串。
语法
“填充块”指令的语法如下所示：
SCL
FILL(BVAL := <操作数>,
BLK => <操作数>)
参数
下表列出了“填充块”指令的参数：
指定存储区域（源区域），将
使用该存储区域中的内容填
BVAL Input VARIANT I、Q、M、L、P
充 BLK 参数中指定的目标区
域。
指定要使用源区域的数据填
BLK Output 1) VARIANT I、Q、M、L、P
充的存储区。
1) BLK 参数声明为 Output，因为数据流入变量。但此变量本身在块接口中必须声明为 InOut。
BVAL 参数
请注意：当将结构作为输入参数传送时，结构的长度应始终为偶数个字节。如果声明一个具有奇数个字
节的结构，此结构还需要另一个字节的存储空间。
- 140 -
RET_VAL 参数
错误代码说明
(W#16#...)
0000 无错误
8152 BVAL 参数中不支持 WSTRING、WCHAR 和 BOOL 数据类型。
8352 BLK 参数中不支持 WSTRING、WCHAR 和 BOOL 数据类型。
常见错误信
另请参见：GET_ERR_ID：获取本地错误 ID
息
请参见”。
示例
SCL
"Tag_RetVal" := FILL(BVAL := P#M14.0 WORD 4,
BLK => P#M100.0 WORD 10);
该指令复制从 MW14 到 MW20 的源区域，并使用 BVAL 参数中存储区内包含的 4 个字的内容填充从
MW100 到 MW118 的目标区域。
- 141 -
转换操作 (S7-1200, S7-1500)
转换操作
• CONVERT：转换值 (S7-1200, S7-1500)
• ROUND：取整 (S7-1200, S7-1500)
• CEIL：浮点数向上取整 (S7-1200, S7-1500)
• FLOOR：浮点数向下取整 (S7-1200, S7-1500)
• TRUNC：截尾取整 (S7-1200, S7-1500)
• SCALE_X：缩放 (S7-1200, S7-1500)
• NORM_X：标准化 (S7-1200, S7-1500)
• VARIANT (S7-1200, S7-1500)
• 传统 (S7-1500)
- 142 -
CONVERT：转换值 (S7-1200, S7-1500)
CONVERT：转换值
说明
使用“转换值”指令设定显式转换。插入该指令时，“转换”(CONVERT) 对话框打开。可以在此对话框中
指定转换的源数据类型和目标数据类型。将读取源值并将其转换为指定的目标数据类型。
有关可能的转换的信息，请参见“另请参见”中的“显式转换”部分。
语法
“转换值”指令的语法如下所示：
SCL
<目标值> := <???_TO_???(<源值>)
二进制数、整数、
浮点数、时间、日 I、Q、M、D、L、
<源值> Input 要转换的值。
期和时间、字符串、 P 或常数
BCD16 和 BCD32
指定要转换的数据类型的功
???_TO_??? - -
能。
浮点数、时间、日 I、Q、M、D、L、
<目标值> Output 转换结果
期和时间、字符串、 P 或常数
BCD16 和 BCD32
示例
SCL
"Tag_INT" := REAL_TO_INT("Tag_REAL");
操作数数据类型值
Tag_REAL REAL 20.56
Tag_INT INT 21
在转换过程中，将“Tag_REAL”操作数的值四舍五入为最接近的整数，并保存在“Tag_INT”操作数中。
- 143 -
ROUND：取整 (S7-1200, S7-1500)
ROUND：取整
说明
“取整”指令用于将输入 IN 的值取整为最接近的整数。该指令将输入 IN 的值解释为浮点数，并将其转换
为一个整数或浮点数。如果输入值恰好是在一个偶数和一个奇数之间，则选择偶数。
语法
“取整”指令的语法如下所示：
SCL
ROUND(<表达式>)
<表达式> Input 浮点数 I、Q、M、D、L、P 要取整的输入值。
函数值整数、浮点数 I、Q、M、D、L、P 取整运算的结果
示例
SCL
"Tag_Result" := ROUND("Tag_Value");
操作数值
Tag_Value 1.50000000 -1.50000000
Tag_Result 2 -2
- 144 -
CEIL：浮点数向上取整 (S7-1200, S7-1500)
CEIL：浮点数向上取整
说明
使用“浮点数向上取整”指令将值取整为最近接的整数。该指令将输入值解释为浮点数，并将其转换为紧
邻的较大整数。函数值可以大于或等于输入值。
语法
“浮点数向上取整”指令的语法如下所示：
SCL
CEIL(<表达式>)
CEIL_<数据类型>(<表达式>)
P
1. 可以使用“_”明确指定指令的
数据类型。
2. 如果未明确指定数据类型，将
整数、浮点数。
_<数据类型> - 由使用的变量或类型编码的
默认： DINT
常数来确定。
3. 如果既未明确指定数据类型，
也未指定定义的变量或类型
编码的常数，则使用默认数据
类型。
函数值整数、浮点数 I、Q、M、D、L 输入值向上取整
示例
SCL
"Tag_Result1" := CEIL("Tag_Value");
"Tag_Result2" := CEIL_REAL("Tag_Value");
- 145 -
CEIL：浮点数向上取整 (S7-1200, S7-1500)
操作数值
Tag_Value 0.5 -0.5
Tag_Result1 1 0
Tag_Result2 1.0 0.0
- 146 -
FLOOR：浮点数向下取整 (S7-1200, S7-1500)
FLOOR：浮点数向下取整
说明
使用“浮点数向下取整”指令将一个浮点数的值取整为紧邻的较小整数。该指令将输入值解释为浮点数，
并将其转换为紧邻的较小整数。函数值可等于或小于输入值。
语法
“浮点数向下取整”指令的语法如下所示：
SCL
FLOOR(<表达式>)
FLOOR_<数据类型>(<表达式>)
P
1. 可以使用“_”明确指定指令
的数据类型。
2. 如果未明确指定数据类型，
整数、浮点数。
_<数据类型> - 将由使用的变量或类型编
默认：DINT
码的常数来确定。
3. 如果既未明确指定数据类
型，也未指定定义的变量或
类型编码的常数，则使用默
认数据类型。
函数值整数、浮点数 I、Q、M、D、L 输入值被取整
示例
SCL
"Tag_Result1" := FLOOR("Tag_Value");
"Tag_Result2" := FLOOR_REAL("Tag_Value");
- 147 -
FLOOR：浮点数向下取整 (S7-1200, S7-1500)
操作数值
Tag_Value 0.5 -0.5
Tag_Result1 0 -1
Tag_Result2 0.0 -1.0
- 148 -
TRUNC：截尾取整 (S7-1200, S7-1500)
TRUNC：截尾取整
说明
“截尾取整”指令用于直接从输入值中截取整数。该指令仅选择输入值的整数部分，并将这一部分（不含
小数位）作为函数值返回。
语法
“截尾取整”指令的语法如下所示：
SCL
TRUNC(<表达式>)
TRUNC_<数据类型>(<表达式>)
<表达式> Input 浮点数 I、Q、M、D、L 输入值
1. 可以使用“_”明确指定
指令的数据类型。
2. 如果未明确指定数据
类型，将由使用的变量
整数、浮点数
_<数据类型> - 或类型编码的常数来
默认：DINT
确定。
3. 如果既未明确指定数
据类型，也未指定定义
的变量或类型编码的
常数，则使用默认数据
类型。
函数值整数、浮点数 I、Q、M、D、L 输入值的整数部分
示例
SCL
"Tag_Result1" := TRUNC("Tag_Value1");
"Tag_Result2" := TRUNC("Tag_Value2"+"Tag_Value3");
"Tag_Result3" := TRUNC_SINT("Tag_Value4");
- 149 -
TRUNC：截尾取整 (S7-1200, S7-1500)
操作数值
Tag_Value1 -1.5
Tag_Result1 -1
Tag_Value2 2.1
Tag_Value3 3.2
Tag_Result2 5
Tag_Result3 2
Tag_Value4 2.4
- 150 -
SCALE_X：缩放 (S7-1200, S7-1500)
SCALE_X：缩放
说明
使用“缩放”指令将浮点数映射到指定的取值范围来进行缩放。可使用 MIN 和 MAX 参数指定取值范围。
缩放的结果为整数。
下图举例说明如何缩放值：
“缩放”指令通过以下公式进行计算：
OUT = [VALUE ∗ (MAX – MIN)] + MIN
说明
有关转换模拟值的更多信息，请参见相应的手册。
语法
“缩放”指令的语法如下所示：
SCL
SCALE_X(MIN := <操作数>,
MAX := <操作数>)
SCALE_X_<数据类型>(MIN := <操作数>,
MAX := <操作数>)
- 151 -
SCALE_X：缩放 (S7-1200, S7-1500)
I、Q、M、D、
MIN Input 整数、浮点数取值范围的下限
L
I、Q、M、D、要缩放的值。在指定常数时，
VALUE Input 浮点数
L 必须声明这一点。
I、Q、M、D、
MAX Input 整数、浮点数取值范围的上限
L
1. 可以使用“_”明确指定指
令的数据类型。
整数、浮点数
_<数据类型> - 型，将由使用的变量或类
默认： INT
型编码的常数来确定。
类型，也未指定定义的变
量或类型编码的常数，则
使用默认数据类型。
函数值整数、浮点数 - 缩放的结果
有关符号常数的详细信息，请参见“另请参见”。
示例
SCL
"Tag_Result1" := SCALE_X(MIN := "Tag_Value1",
VALUE := "Tag_Real",
MAX := "Tag_Value2");
"Tag_Result2" := SCALE_X_REAL(MIN := "Tag_Value1",
VALUE := "Tag_Real",
操作数值
Tag_Real 0.5
Tag_Value1 10
Tag_Value2 30
Tag_Result1 20
Tag_Result2 20.0
- 152 -
NORM_X：标准化 (S7-1200, S7-1500)
NORM_X：标准化
说明
可以使用“标准化”指令，通过将输入 VALUE 中变量的值映射到线性标尺对其进行标准化。可以使用参
数 MIN 和 MAX 定义（应用于该标尺的）值范围的限值。根据要标准化的值在其取值范围内的位置，计
算出输出 OUT 的结果并将其另存为一个浮点数。如果要标准化的值等于输入 MIN 中的值，则该指令将
返回结果“0.0”。如果要标准化的值等于输入 MAX 中的值，则该指令将返回结果“1.0”。
下图举例说明如何标准化值：
“标准化”指令通过以下公式进行计算：
OUT = (VALUE – MIN) / (MAX – MIN)
说明
有关转换模拟值的更多信息，请参见相应的手册。
语法
“标准化”指令的语法如下所示：
SCL
NORM_X(MIN := <操作数>,
MAX := <操作数>)
NORM_X_<数据类型>(MIN := <操作数>,
MAX := <操作数>)
- 153 -
NORM_X：标准化 (S7-1200, S7-1500)
MIN 1) Input 整数、浮点数 I、Q、M、D、L 取值范围的下限
VALUE 1) Input 整数、浮点数 I、Q、M、D、L 要标准化的值。
MAX 1) Input 整数、浮点数 I、Q、M、D、L 取值范围的上限

1. 可以使用“_”明确指定
指令的数据类型。
型，将由使用的变量或
浮点数
_<数据类型> - 类型编码的常数来确
默认：REAL
定。
类型，也未指定定义的
变量或类型编码的常
数，则使用默认数据类
型。
函数值浮点数 I、Q、M、D、L 标准化结果
1) 如果在这三个参数中都使用常数，则仅需声明其中一个。
有关符号常数的详细信息，请参见“另请参见”。
示例
SCL
"Tag_Result1" := NORM_X(MIN := "Tag_Value1",
VALUE := "Tag_InputValue",
"Tag_Result2" := NORM_X_LREAL(MIN := "Tag_Value1",
VALUE := "Tag_InputVal-
ue",
操作数值
Tag_InputValue 20
Tag_Value1 10
Tag_Value2 30
- 154 -
NORM_X：标准化 (S7-1200, S7-1500)
Tag_Result1 0.5
Tag_Result2 0.5
- 155 -
VARIANT (S7-1200, S7-1500)
VARIANT
• VARIANT_TO_DB_ANY：将 VARIANT 转换为 DB_ANY (S7-1200, S7-1500)
• DB_ANY_TO_VARIANT：将 DB_ANY 转换为 VARIANT (S7-1200, S7-1500)
- 156 -
VARIANT_TO_DB_ANY：将 VARIANT 转换为 DB_ANY (S7-1200, S7-1500)
VARIANT_TO_DB_ANY：将 VARIANT 转换为 DB_ANY
说明
可以使用指令“将 VARIANT 转换为 DB_ANY”查询 IN 参数地址指定的操作数的数据块编号。它可以是
背景数据块或 ARRAY 数据块。 IN 参数的操作数具有数据类型 VARIANT，这意味着在创建程序时不需
要知道将被查询编号的数据块的数据类型。在运行期间将会读取数据块编号，并将其写入 RET_VAL 参
数指定的操作数。
要求
如果满足条件，则执行该指令。如果不满足条件，则输出“0”作为数据块编号。
输出变量... 转换结果... 转换选项

... 作为 PLC 数据类型或系统数
可以将该输出变量转换为数据块
VARIANT 据类型 (SDT) 的背景数据块的数
编号。
据块。
... 作为 ARRAY 数据块的数据可以将该输出变量转换为数据块
VARIANT
块。编号。
由于数据块中并不仅仅只包含一
VARIANT ... 具有基本数据类型的变量。个基本块类型，因此无法将该输
出变量转换为数据库编号。
由于该结构仅仅是数据块中的一
VARIANT ... 数据块中的结构。部分，因此无法将该输出变量转
换为数据库编号。
语法
“将 VARIANT 转换为 DB_ANY”指令的语法如下所示：
SCL
VARIANT_TO_DB_ANY(IN := <操作数>,
ERR => <操作数>)
参数
下表列出了“将 VARIANT 转换为 DB_ANY”指令的参数：
IN Input VARIANT I、Q、M、L 待读取的变量
ERR Output INT I、Q、M、D、L 错误信息
函数值 (RET_VAL) DB_ANY I、Q、M、D、L 结果：背景数据块的编号
ERR 参数
下表列出了 ERR 参数值的含义：
- 157 -
VARIANT_TO_DB_ANY：将 VARIANT 转换为 DB_ANY (S7-1200, S7-1500)
(W#16#...)
0000 无错误
252C IN 参数的 VARIANT 数据类型的值为“0”，并且 CPU 更改为 STOP 模式。
8132 该数据块太短或不是 ARRAY 数据块。
IN 参数的数据类型 VARIANT 提供值“0”。要接收此错误消息，必须激活“在块内处理错
8150
误”块属性。否则 CPU 将更改为 STOP 模式并发送错误代码 16#252C。
IN 参数的 VARIANT 数据类型不指向 ARRAY 数据块的起点，或者 VARIANT 的长度与
8153
数据块的长度不匹配。
请参见”。
示例
SCL
"OutputDBNumber" := VARIANT_TO_DB_ANY(IN := "Input-
Tag",
ERR := "Tag_Er-
ror");
IN Input #InputTag -
<函数值> Output OutputDBNumber 11
读取 #InputTag 操作数中指定的数据块的编号。由于操作数具有数据类型 VARIANT，所以在创建程序
时不需要知道变量的数据类型。编号将写入具有 DB_ANY 数据类型的“OutputDBNumber”变量。
- 158 -
DB_ANY_TO_VARIANT：将 DB_ANY 转换为 VARIANT (S7-1200, S7-1500)
DB_ANY_TO_VARIANT：将 DB_ANY 转换为 VARIANT
说明
可以使用指令“将 DB_ANY 转换为 VARIANT”从符合以下要求的数据块生成 VARIANT 变量。 IN 参数
的操作数具有数据类型 DB_ANY，这意味着在创建程序时不需要知道数据块。将在运行时读取数据块编
号。
要求
如果满足条件，则执行该指令。如果不满足条件或数据块不存在，则在 RET_VAL 参数中输出值
NULL。所有使用 RET_VAL 变量的其它访问都将失败。
以下数据类型的输入变量 ... 转换结果... 转换选项

...作为 PLC 数据类型或系统数
DB_ANY 据类型 (SDT) 的背景数据块的数可以转换
据块。
...作为 ARRAY 数据块的数据
DB_ANY 可以转换
块。
...作为函数块或全局数据块中的
DB_ANY 不可转换
背景数据块的数据块。
语法
“将 DB_ANY 转换为 VARIANT”指令的语法如下所示：
SCL
DB_ANY_TO_VARIANT(IN := <操作数>,
ERR => <操作数>)
参数
下表列出了“DB_ANY 转换为 VARIANT”指令的参数：
IN Input DB_ANY I、Q、M、D、L 待引用和读取的变量
ERR Output INT I、Q、M、D、L 错误信息
函数值 (RET_VAL) 1) VARIANT I、Q、M、L 数据块编号
1) RET_VAL 参数声明为 Output，因为数据流入变量。但此变量本身在块接口中必须声明为 InOut。
ERR 参数
下表列出了 ERR 参数值的含义：
- 159 -
DB_ANY_TO_VARIANT：将 DB_ANY 转换为 VARIANT (S7-1200, S7-1500)
(W#16#...)
0000 无错误
8130 数据块的编号为“0”
8132 该数据块太短或不是 ARRAY 数据块。
8155 该数据块的数据类型未知。
请参见”。
示例
SCL
#tempVARIANT := DB_ANY_TO_VARIANT(IN := "InputDB",
ERR := "Tag_Error");
IN Input InputDB 11
<函数值> Temp #tempVARIANT -
在“InputDB”操作数中指定的所有数据块的编号将用于生成对数据块进行寻址的 VARIANT 数据类型的
变量。由于 IN 参数的操作数具有 DB_ANY 数据类型，所以在创建程序时不需要知道将在运行时使用的
数据块（既不需要知道数据块的名称，也不需要知道其编号）。. 由于参数 RET_VAL 的操作数具有数据
类型 VARIANT，所以在创建程序时不需要知道数据块的数据类型。
- 160 -
传统 (S7-1500)
传统
• SCALE：刻度 (S7-1500)
• UNSCALE：取消缩放 (S7-1500)
- 161 -
SCALE：刻度 (S7-1500)
SCALE：刻度
说明
使用“缩放”指令，将参数 IN 中的整数转换为浮点数，此浮点数可在下限和上限之间按物理单位缩放。通
过参数 LO_LIM 和 HI_LIM 来指定缩放输入值取值范围的下限和上限。指令的结果在参数 OUT 中输
出。
“缩放”指令通过以下公式进行计算：
OUT = [((FLOAT (IN) – K1)/(K2–K1)) ∗ (HI_LIM–LO_LIM)] + LO_LIM
常数“K1”和“K2”的值取决于参数 BIPOLAR 的信号状态。参数 BIPOLAR 可能有下列信号状态：
• 信号状态“1”：假设参数 IN 的值为双极性且取值范围是 -27648 到 27648。在这种情况下，常数“K1”
的值为“-27648.0”，而常数“K2”的值为“+27648.0”。
• 信号状态“0”：假设参数 IN 的值为单极性且取值范围是 0 到 27648。在这种情况下，常数“K1”的值
为“0.0”，而常数“K2”的值为“+27648.0”。
如果参数 IN 的值大于常数“K2”值，则指令结果为上限值 (HI_LIM) 并输出错误。
如果参数 IN 的值小于常数“K1”值，则指令结果为下限值 (LO_LIM) 并输出一个错误。
如果指定的下限值大于上限值 (LO_LIM >HI_LIM)，则结果将对输入值进行反向缩放。
语法
“缩放”指令的语法如下所示：
SCL
SCALE(IN:= <表达式>,
HI_LIM := <操作数>,
LO_LIM := <操作数>,
BIPOLAR := <操作数>,
OUT => <操作数>)
IN Input INT 待缩放的输入值。
P
HI_LIM Input REAL 上限
P
LO_LIM Input REAL 下限
P
指示将 IN 参数的值解释为单
极性还是双极性。该参数可
BIPOLAR Input BOOL I、Q、M、D、L 采用以下值：
1: 双极性
- 162 -
SCALE：刻度 (S7-1500)
0: 单极性
OUT Output REAL 指令的结果
P
函数值 (RET_VAL) WORD 错误信息
P
RET_VAL 参数
错误代码说明
(W#16#...)
0000 无错误
0008 参数 IN 的值大于 27,648 或小于 0 （单极性）或小于 -27,648（双极性）。
常见错误信
另请参见： "GET_ERR_ID：获取本地错误 ID
息
请参见”。
示例
SCL
"Tag_ErrorCode" := SCALE(IN := "Tag_InputValue",
HI_LIM := "Tag_HighLimit",
LO_LIM := "Tag_LowLimit",
BIPOLAR := "Tag_Bipolar",
OUT => "Tag_Result");
该错误信息将作为函数值在“Tag_ErrorCode”操作数中返回。
参数操作数值
IN Tag_InputValue 22
HI_LIM Tag_HighLimit 100.0
LO_LIM Tag_LowLimit 0.0
BIPOLAR Tag_Bipolar 1
OUT Tag_Result 50.03978588
RET_VAL Tag_ErrorCode W#16#0000
- 163 -
UNSCALE：取消缩放 (S7-1500)
UNSCALE：取消缩放
说明
“取消缩放”指令，取消参数 IN 中的浮点数按物理单位在上下限之间的缩放，并将其转换为整数。通过参
数 LO_LIM 和 HI_LIM 来指定缩放输入值取值范围的下限和上限。指令的结果在参数 OUT 中输出。
“取消缩放”指令通过以下公式进行计算：
OUT = [((IN–LO_LIM)/(HI_LIM–LO_LIM)) ∗ (K2–K1)] + K1
常数“K1”和“K2”的值取决于参数 BIPOLAR 的信号状态。参数 BIPOLAR 可能有下列信号状态：
• 信号状态“1”：假设参数 IN 的值为双极性且取值范围是 -27648 到 27648。在这种情况下，常数“K1”
的值为“-27648.0”，而常数“K2”的值为“+27648.0”。
• 信号状态“0”：假设参数 IN 的值为单极性且取值范围是 0 到 27648。在这种情况下，常数“K1”的值
为“0.0”，而常数“K2”的值为“+27648.0”。
如果参数 IN 的值大于常数“HI_LIM”的值，则指令结果设置为常数 (K2) 的值并输出一个错误。
如果参数 IN 的值小于下限 (LO_LIM) 的常数值，则将指令的结果设置为常数 (K1) 的值并输出错误。
语法
“取消缩放”指令的语法如下所示：
SCL
UNSCALE(IN := <表达式>,
HI_LIM := <操作数>,
LO_LIM := <操作数>,
BIPOLAR := <操作数>,
OUT => <操作数>)
I、Q、M、D、L、待取消缩放并转换为整数的
IN Input REAL
P 输入值。
HI_LIM Input REAL 上限
P
LO_LIM Input REAL 下限
P
指示将 IN 参数的值解释为单
极性还是双极性。该参数可
采用以下值：
BIPOLAR Input BOOL I、Q、M、D、L
1: 双极性
0: 单极性
- 164 -
UNSCALE：取消缩放 (S7-1500)
OUT Output INT 指令的结果
P
函数值 (RET_VAL) WORD 错误信息
P
RET_VAL 参数
错误代码说明
(W#16#...)
0000 无错误
0008 参数 IN 的值大于上限 (HI_LIM) 的值或小于下限 (LO_LIM) 的值。
常见错误信
另请参见： "GET_ERR_ID：获取本地错误 ID
息
请参见”。
示例
"Tag_ErrorCode" := UNSCALE(IN := "Tag_InputValue",

HI_LIM := "Tag_HighLimit",
LO_LIM := "Tag_LowLimit",
BIPOLAR := "Tag_Bipolar",
OUT => "Tag_Result");
该错误信息将作为函数值在“Tag_ErrorCode”操作数中返回。
参数操作数值
IN Tag_InputValue 50.03978588
HI_LIM Tag_HighLimit 100.0
LO_LIM Tag_LowLimit 0.0
BIPOLAR Tag_Bipolar 1
OUT Tag_Result 22
RET_VAL Tag_ErrorCode W#16#0000
- 165 -
程序控制指令 (S7-1200, S7-1500)
程序控制指令
• IF：条件执行 (S7-1200, S7-1500)
• CASE：创建多路分支 (S7-1200, S7-1500)
• FOR：在计数循环中执行 (S7-1200, S7-1500)
• WHILE：满足条件时执行 (S7-1200, S7-1500)
• REPEAT：不满足条件时执行 (S7-1200, S7-1500)
• CONTINUE：复查循环条件 (S7-1200, S7-1500)
• EXIT：立即退出循环 (S7-1200, S7-1500)
• GOTO：跳转 (S7-1200, S7-1500)
• RETURN：退出块 (S7-1200, S7-1500)
• (*...*)：插入注释段 (S7-1200, S7-1500)
• 运行时控制 (S7-1200, S7-1500)
- 166 -
IF：条件执行 (S7-1200, S7-1500)
IF：条件执行
说明
使用“条件执行”指令，可以根据条件控制程序流的分支。该条件是结果为布尔值（TRUE 或 FALSE）的
表达式。可以将逻辑表达式或比较表达式作为条件。
执行该指令时，将对指定的表达式进行运算。如果表达式的值为 TRUE，则表示满足该条件；如果其值
为 FALSE，则表示不满足该条件。
语法
根据分支的类型，可以对以下形式的指令进行编程：
• IF 分支：
SCL
IF <条件> THEN <指令>
END_IF;
如果满足该条件，则将执行 THEN 后编写的指令。如果不满足该条件，则程序将从 END_IF 后的下一条
指令开始继续执行。
• IF 和 ELSE 分支：
SCL
IF <条件> THEN <指令 1>
ELSE <指令 0>;
END_IF;
如果满足该条件，则将执行 THEN 后编写的指令。如果不满足该条件，则将执行 ELSE 后编写的指
令。程序将从 END_IF 后的下一条指令开始继续执行。
• IF、ELSIF 和 ELSE 分支：
SCL
IF <条件 1> THEN <指令 1>
ELSIF <条件 2> THEN <指令 2>
ELSE <指令 0>;
END_IF;
如果满足第一个条件（<条件 1>），则将执行 THEN 后的指令（<指令 1>）。执行这些指令后，程序将
从 END_IF 后继续执行。
如果不满足第一个条件，则将检查第二个条件（<条件 2>）。如果满足第二个条件（<条件 2>），则将
执行 THEN 后的指令（<指令 2>）。执行这些指令后，程序将从 END_IF 后继续执行。
如果不满足任何条件，则先执行 ELSE 后的指令（<指令 0>），再执行 END_IF 后的程序部分。
- 167 -
IF：条件执行 (S7-1200, S7-1500)
在 IF 指令内可以嵌套任意多个 ELSIF 和 THEN 组合。可以选择对 ELSE 分支进行编程。

IF 指令的语法如下所示：
参数数据类型存储区说明
<条件> BOOL I、Q、M、D、L 待求值的表达式
在满足条件时，要执行的指令。如果不满足条件，
<指令> - 则执行 ELSE 后编写的指令。如果不满足程序循
环内的任何条件，则执行这些指令。
示例
SCL
IF "Tag_1" = 1
THEN "Tag_Value" := 10;
ELSIF "Tag_2" = 1
ELSIF "Tag_3" = 1
ELSE "Tag_Value" := 0;
END_IF;
操作数值
Tag_1 1 0 0 0
Tag_2 0 1 0 0
Tag_3 0 0 1 0
Tag_Value 10 20 30 0
- 168 -
CASE：创建多路分支 (S7-1200, S7-1500)
CASE：创建多路分支
说明
使用“创建多路分支”指令，可以根据数字表达式的值执行多个指令序列中的一个。
表达式的值必须为整数。执行该指令时，会将表达式的值与多个常数的值进行比较。如果表达式的值等
于某个常数的值，则将执行紧跟在该常数后编写的指令。常数可以为以下值：
• 整数（例如，5）
• 整数的范围（例如，15..20）
• 由整数和范围组成的枚举（例如，10、11、15..20）
语法
“创建多路分支”指令的语法如下所示：
SCL
CASE <表达式> OF
<常数 1>: <指令 1>
<常数 2>: <指令 2>
<常数 X>: <指令 X>; // X >=3
ELSE <指令 0>;
END_CASE;
<表达式> 整数 I、Q、M、D、L 与设定的常数值进行比较的值。
作为指令序列执行条件的常数值。常数可以为以
下值：
• 整数（例如，5）
<常数> 整数 I、Q、M、D、L
• 整数的范围（例如，15..20）
• 由整数和范围组成的枚举（例如，10、11、
15..20）
当表达式的值等于某个常数值时，将执行的各种指
<Instruction> - 令。如果不满足条件，则执行 ELSE 后编写的指
令。如果两个值不相等，则执行这些指令。
如果表达式的值等于第一个常数（<常数 1>）的值，则将执行紧跟在该常数后编写的指令（<指令 1>）。
程序将从 END_CASE 后继续执行。
如果表达式的值不等于第一个常数（<常数 1>）的值，则会将该值与下一个设定的常数值进行比较。以
这种方式执行 CASE 指令直至比较的值相等为止。如果表达式的值与所有设定的常数值均不相等，则将
执行 ELSE 后编写的指令（<指令 0>）。ELSE 是一个可选的语法部分，可以省略。
- 169 -
CASE：创建多路分支 (S7-1200, S7-1500)
此外，CASE 指令也可通过使用 CASE 替换一个指令块来进行嵌套。END_CASE 表示 CASE 指令结

束。
示例
SCL
CASE "Tag_Value" OF
0 :
"Tag_1" := 1;
1,3,5 :
"Tag_2" :=1;
6..10 :
"Tag_3" := 1;
16,17,20..25 :
"Tag_4" := 1;
ELSE "Tag_5" := 1;
END_CASE;
操作数值
16,17, 20, 21,
Tag_Value 0 1, 3 , 5 6, 7, 8, 9, 10 2
22, 23, 24, 25
Tag_1 1 - - - -
Tag_2 - 1 - - -
Tag_3 - - 1 - -
Tag_4 - - - 1 -
Tag_5 - - - - 1
1: 操作数将设置为信号状态“1”。
-：操作数的信号状态将保持不变。
- 170 -
FOR：在计数循环中执行 (S7-1200, S7-1500)
FOR：在计数循环中执行
说明
使用“在计数循环中执行”指令，重复执行程序循环，直至运行变量不在指定的取值范围内。
也可以嵌套程序循环。在程序循环内，可以编写包含其它运行变量的其它程序循环。
通过指令“复查循环条件”(CONTINUE)，可以终止当前连续运行的程序循环。通过指令“立即退出循环”
(EXIT) 终止整个循环的执行。有关本主题的更多信息，请参见“另请参见”。
FOR 语句的限制
编写不会导致死循环的“安全”FOR 语句时，请遵循以下规则和限制：
规则
FOR ii := Start TO End BY Step DO
如果... ... 则说明
start < end end < (PMAX step) 运行变量 ii 在正方向上运行
start > end AND step < O end < (PMAX step) 运行变量 ii 在负方向上运行
限制
各种数据类型的限制不同：
数据类型 PMAX NMAX

类型 SINT 的 ii 127 -128
类型 INT 的 ii 32767 -32768
类型 DINT 的 ii 2147483647 -2147483648
类型 LINT 的 ii 9223372036854775807 -9223372036854775808
语法
“在计数循环中执行”指令的语法如下所示：
SCL
FOR<执行变量> := <起始值> TO<结束值> BY<增量> DO<指令>
END_FOR;
参数
下表列出了指令“在计数循环中执行”的参数：
- 171 -
FOR：在计数循环中执行 (S7-1200, S7-1500)
S7-1200 S7-1500
执行循环时会计算其值的操作数。执
SINT, INT, SINT, INT, I、Q、M、D、
<执行变量> 行变量的数据类型将确定其它参数的
DINT DINT, LINT L
数据类型。
SINT, INT, SINT, INT, I、Q、M、D、表达式，在执行变量首次执行循环时，
<起始值>
DINT DINT, LINT L 将分配表达式的值。
表达式，在运行程序最后一次循环时会
定义表达式的值。在每个循环后都会
检查运行变量的值：
• 未达到结束值：
SINT, INT, SINT, INT, I、Q、M、D、执行符合 DO 的指令
<结束值>
DINT DINT, LINT L • 达到结束值：
最后执行一次 FOR 循环
• 超出结束值：
完成 FOR 循环
执行该指令期间，不允许更改结束值。
执行变量在每次循环后都会递增（正增
量）或递减（负增量）其值的表达式。
<Incre‐ SINT, INT, SINT, INT, I、Q、M、D、可以选择指定增量的大小。如果未指
ment> DINT DINT, LINT L 定增量，则在每次循环后执行变量的值
加 1。
执行该指令期间，不允许更改增量。
只有运行变量的值在取值范围内，每次
<指令> - - 循环都就会执行的指令。取值范围由
起始值和结束值定义。
示例
SCL
FOR i := 2 TO 8 BY 2
DO "a_array[i] := "Tag_Value"*"b_array[i]";
END_FOR;
“Tag_Value”操作数乘以“b_array”ARRAY 变量的元素 (2, 4, 6, 8)。并将计算结果读入到“a_array”AR‐
RAY 变量的元素 (2, 4, 6, 8) 中。
- 172 -
WHILE：满足条件时执行 (S7-1200, S7-1500)
WHILE：满足条件时执行
说明
使用“满足条件时执行”指令可以重复执行程序循环，直至不满足执行条件为止。该条件是结果为布尔值
（TRUE 或 FALSE）的表达式。可以将逻辑表达式或比较表达式作为条件。
语法
“满足条件时执行”指令的语法如下所示：
SCL
WHILE <条件> DO <指令>
END_WHILE;
WHILE 指令的语法如下所示：
<条件> BOOL I、Q、M、D、L 表达式，每次执行循环之前都需要进行求值。
在满足条件时，要执行的指令。如果不满足条件，
<指令> -
则程序将从 END_WHILE 后继续执行。
示例
SCL
WHILE
"Tag_Value1" <> "Tag_Value2"
DO "Tag_Result"
:= "Tag_Input";
END_WHILE;
只要“Tag_Value1”和“Tag_Value2”操作数的值不匹配，“Tag_Input”操作数的值就会分配给“Tag_Result”
操作数。
- 173 -
REPEAT：不满足条件时执行 (S7-1200, S7-1500)
REPEAT：不满足条件时执行
说明
使用“不满足条件时执行”指令可以重复执行程序循环，直至不满足执行条件为止。该条件是结果为布尔
值（TRUE 或 FALSE）的表达式。可以将逻辑表达式或比较表达式作为条件。
即使满足终止条件，此指令也只执行一次。
语法
“不满足条件时执行”指令的语法如下所示：
SCL
REPEAT <指令>
UNTIL <Condition>END_REPEAT;
REPEAT 指令的语法如下所示：
在设定条件的值为 FALSE 时执行的指令。即使
<指令> -
满足终止条件，此指令也只执行一次。
表达式，每次执行循环之后都需要进行求值。如
果表达式的值为 FALSE，则将再次执行程序循
<条件> BOOL I、Q、M、D、L
环。如果表达式的值为 TRUE，则程序循环将从
END_REPEAT 后继续执行。
示例
SCL
REPEAT "Tag_Result"
:= "Tag_Value";
UNTIL "Tag_Error"
END_REPEAT;
只要“Tag_Error”操作数值的信号状态为“0”，就会将“Tag_Value”操作数的值分配给“Tag_Result”操作数。
- 174 -
CONTINUE：复查循环条件 (S7-1200, S7-1500)
CONTINUE：复查循环条件
说明
使用“复查循环条件”指令，可以结束 FOR、WHILE 或 REPEAT 循环的当前程序运行。
执行该指令后，将再次计算继续执行程序循环的条件。该指令将影响其所在的程序循环。
语法
“复查循环条件”指令的语法如下所示：
SCL
CONTINUE;
示例
SCL
FOR i
:= 1 TO 15 BY 2 DO
IF (i < 5)THEN
CONTINUE;
END_IF;
"DB10".Test[i] := 1;
END_FOR;
如果满足条件 i < 5，则不执行后续的值分配（“DB10”.Test[i] := 1）。运行变量 (i) 以增量“2”递增，然后
检查其当前值是否在设定的取值范围内。如果执行变量在取值范围内，则将再次计算 IF 的条件。
如果不满足条件 i < 5，则执行后续的值分配（“DB10”.Test[i] := 1）并开始一个新循环。在这种情况下，
执行变量也会以增量“2”进行递增并接受检查。
- 175 -
EXIT：立即退出循环 (S7-1200, S7-1500)
EXIT：立即退出循环
说明
使用“立即退出循环”指令，可以随时取消 FOR、WHILE 或 REPEAT 循环的执行，而无需考虑是否满足
条件。在循环结束（END_FOR、END_WHILE 或 END_REPEAT）后继续执行程序。
该指令将影响其所在的程序循环。
语法
“立即退出循环”指令的语法如下所示：
SCL
EXIT;
示例
SCL
FOR i := 15 TO 1 BY -2 DO
IF (i < 5)
THEN EXIT;
END_IF;
"DB10".Test[i] := 1;
END_FOR;
如果满足条件 i < 5，则将取消循环执行。程序将从 END_FOR 后继续执行。
如果不满足条件 i < 5，则执行后续的值分配（“DB10”.Test[i] := 1）并开始一个新循环。将运行变量 (i)
以 2 进行递减，并进行检查该变量的当前值是否在程序中设定的取值范围之内。如果执行变量 (i) 在取
值范围内，则将再次计算 IF 的条件。
- 176 -
GOTO：跳转 (S7-1200, S7-1500)
GOTO：跳转
说明
使用“跳转”指令，可以从标注为跳转标签的指定点开始继续执行程序。
跳转标签和“跳转”指令必须在同一个块中。在一个块中，跳转标签的名称只能指定一次。每个跳转标签
可以是多个跳转指令的目标。
不允许从“外部”跳转到程序循环内，但允许从循环内跳转到“外部”。
语法
“跳转”指令的语法如下所示：
SCL
GOTO <跳转标签>
...
<跳转标签>: <指令>
GOTO 指令的语法如下所示：
参数数据类型说明
<跳转标签> - 跳转标签，将跳转到该标签处
<指令> - 跳转后执行的指令。
示例
SCL
CASE "Tag_Value" OF
1 : GOTO MyLABEL1;
2 : GOTO MyLABEL2;
3 : GOTO MyLABEL3;
ELSE GOTO MyLABEL4;
END_CASE;
MyLABEL1: "Tag_1" := 1;
根据“Tag_Value”操作数的值，程序将从对应的跳转标签标识点开始继续执行。例如，如果“Tag_Value”
操作数的值为 2，则程序将从跳转标签“MyLABEL2”开始继续执行。在这种情况下，将跳过“MyLABEL1”
跳转标签所标识的程序行。
- 177 -
RETURN：退出块 (S7-1200, S7-1500)
RETURN：退出块
说明
使用“退出块”指令，可以终止当前处理块中的程序执行，并在调用块中继续执行。
如果该指令出现在块结尾处，则可以跳过。
语法
“退出块”指令的语法如下所示：
SCL
RETURN;
示例
SCL
IF "Tag_Error" <>0 THEN RETURN;
END_IF;
如果“Tag_Error”操作数的信号状态不为 0，则将终止当前处理块中的程序执行。
- 178 -
(*...*)：插入注释段 (S7-1200, S7-1500)
(*...*)：插入注释段
说明
可以通过“插入注释段”指令添加一个注释段。括号内“(*...*)”的文本将处理为一段注释。
语法
“插入注释段”指令的语法如下所示：
SCL
(*...*)
示例
SCL
(*这是一条注释信息。*)
- 179 -
运行时控制 (S7-1200, S7-1500)
运行时控制
• ENDIS_PW：限制和启用密码合法性 (S7-1200, S7-1500)
• RE_TRIGR：重置周期监视时间 (S7-1200, S7-1500)
• STP：退出程序 (S7-1200, S7-1500)
• GET_ERROR：获取本地错误信息 (S7-1200, S7-1500)
• GET_ERR_ID：获取本地错误 ID (S7-1200, S7-1500)
• INIT_RD：初始化所有保留数据 (S7-1500)
• WAIT：组态延时时间 (S7-1500)
• RUNTIME：测量程序运行时间 (S7-1200, S7-1500)
- 180 -
ENDIS_PW：限制和启用密码合法性 (S7-1200, S7-1500)
ENDIS_PW：限制和启用密码合法性
说明
可以使用“限制和启用密码合法性”指令指定是否可以为 CPU 组态密码。甚至在密码正确的情况下，也可
以阻止正常连接。
当调用该指令且 REQ 参数具有信号状态“0”时，在输出参数处仅显示当前设置状态。如果更改了输入参
数，这些更改将不会传送到输出参数。
如果调用该指令且 REQ 参数具有信号状态“1”，则信号状态可从输入参数（F_PWD、FULL_PWD、
R_PWD、HMI_PWD）处应用。FALSE 表示不允许按密码的合法性；TRUE 表示可以使用密码。
可单独允许或禁止密码的禁用和启用。例如，可以禁止使用除故障安全密码之外的其它所有密码。这
样，可以限制一个小型用户组的访问选项。无论 REQ 参数的值如何，输出参数（F_PWD_ON、
FULL_PWD_ON、R_PWD_ON、HMI_PWD_ON）将始终显示密码使用的当前状态。
未组态的密码必须在输入中具有 TRUE 信号状态，并在输出中返回 TRUE 信号状态。只能为 F-CPU 组
态故障安全密码，因此在标准 CPU 中必须始终与 TRUE 信号状态互连。如果指令返回错误，调用将无
效，即先前的锁定仍然有效。
在下列条件中，可再次启用已禁用的密码：
• CPU 被重置为出厂设置。
• S7-1500 CPU 的前面板显示一个对话框，在该对话框中可浏览相应的菜单，以便再次启用密码。
• 调用“限制和启用密码合法性”指令时，所需密码的输入参数具有信号状态“1”。
• 将操作模式开关切换到 STOP 位置。当开关设置回 RUN 时，将会重新设置对密码合法性的限制。
• 将一个空存储卡（传输卡或程序卡）插入 S7-1200 CPU。
• 将 POWER OFF 切换到 POWER ON 会禁用 S7-1200 CPU 中的保护。必须在程序中再次调用“限
制和启用密码合法性”指令（例如在启动 OB 中）。
说明
如果 HMI 密码未启用，“限制和启用密码合法性”指令将禁止从 HMI 系统访问。
说明
现有的合法连接仍将保留其访问权限，不可使用“限制和启用密码合法性”指令对其进行限制。
操作 S7-1500 CPU 时防止意外锁定

在 CPU 的前面板上可进行此设置，CPU 将保存最新的设置。
为防止意外锁定，通过将 S7-1500 CPU 的模式开关设置为 STOP 模式可禁用保护。将模式转换器设置
为 RUN 将再次自动启用保护，无需再次调用“限制和启用密码合法性”或在前面板上执行其它操作。
操作 S7-1200 CPU 时防止意外锁定

由于 S7-1200 CPU 没有操作模式开关，因此使用 POWER OFF/POWER ON 禁用保护。所以我们建议
用户在自己的程序中使用某些程序序列来防止意外锁定。
为此需要使用循环中断 OB 或主 OB (OB 1) 中的定时器编写一个时间控制。在从 POWER OFF 切换到
POWER ON 后，用户可以选择相对快速地在相应 OB（例如 OB 1 或 OB 35）中调用“限制和启用密码
合法性”指令，并禁用相关的保护。在启动 OB (OB 100) 中调用指令，以使指令处于非活动状态且密码
合法性无限制的时间周期相对较短。此步骤可提供最大可能的保护，以防止未授权的访问。
- 181 -
如果意外锁定，则可以跳过启动 OB 中的调用（例如，通过查询输入参数）并在锁定重新激活前设置时
间（例如 10 秒到 1 分钟）来建立到 CPU 的连接。
如果在程序代码中未设置定时器并且被锁定，则向 CPU 中插入一个空的传输卡或程序卡。空的传输卡
或程序卡将删除 CPU 的内部装载存储器。随后必须将用户程序从 STEP 7 重新下载到 CPU 中。
操作 S7-1200 CPU 时忘记密码的步骤

如果在操作有密码保护的 S7-1200 CPU 时忘记密码，则可使用一个空的传输卡或程序卡删除密码保护
的程序。空的传输卡或程序卡将删除 CPU 的内部装载存储器。然后在 CPU 中从 STEP 7 Basic 加载
一个新的用户程序。
警告
插入空的传输卡
在运行过程在 CPU 中插入一个传输卡时，CPU 将转入 STOP 模式。如果操作状态不稳定，则控制器
操作可能失败，从而导致控制器所控制的设备运行失控。这样可能会引起自动化系统异常操作，进而
导致严重的人员伤亡和/或财产损失。
取出传输卡后，传输卡的内容仍在内部装载存储器中。请确保此时该卡不包含任何程序。
警告
插入空的程序卡
当运行过程中在 CPU 中插入程序卡时，CPU 将转入 STOP 模式。如果操作状态不稳定，则控制器操
作可能失败，从而导致控制器所控制的设备运行失控。这样可能会引起自动化系统异常操作，进而导
致严重的人员伤亡和/或财产损失。
请确保程序卡为空。内部装载存储器将复制到空的程序卡。取出先前的空程序卡后，内部装载存储器
将为空。
在 CPU 转入 RUN 模式之前，必须移除传输卡或程序卡。
密码使用对操作模式的影响
下表列出通过“限制和启用密码合法性”指令使用密码对操作模式的影响以及相应的用户操作。
动作通过该指令进行密码保护
操作模式变化后的基本状态
• 操作模式切换为 STOP 未激活
• 手动复位内存（PG、交换机、MC 的变更（运动控
制））（无限制）
• 复位为工厂设置
• S7-1200-CPU：
锁定被禁用，必须再次在程序中调用指令
（例如在启动 OB 中）。
执行 POWER ON 后的基本状态 • S7-1500 CPU：
启用（如果在 POWER OFF 之前激活了锁
定）。不允许使用密码的选项为保持型选
项。
操作模式从 RUN/STARTUP/HOLD 转换到 STOP（因激活
终止该指令、发生错误或通信）或 STOP 转换到
STARTUP/RUN/HOLD 密码仍不可使用。
- 182 -
语法
“限制和启用密码合法性”指令的语法如下所示：
SCL
ENDIS_PW(REQ := <操作数>,
F_PWD := <操作数>,
FULL_PWD := <操作数>,
R_PWD := <操作数>,
HMI_PWD := <操作数>,
F_PWD_ON => <操作数>,
FULL_PWD_ON => <操作数>,
R_PWD_ON => <操作数>,
HMI_PWD_ON => <操作数>)
参数
下表列出了“限制和启用密码合法性”指令的参数：
当 REQ 参数的信号状态为
REQ Input BOOL I、Q、M、D、L “0”时，将查询密码的当前设置
信号状态。
读/写访问权（包括故障安全）
• F_PWD = "0"：不允许使用
F_PWD Input BOOL I、Q、M、D、L 密码
• F_PWD = "1"：允许使用密
码
读/写访问权
• FULL_PWD = "0"：不允许
FULL_PWD Input BOOL I、Q、M、D、L 使用密码
• FULL_PWD = "1"：允许使
用密码
读访问权
• R_PWD = "0"：不允许使
R_PWD Input BOOL I、Q、M、D、L 用密码
• R_PWD = "1"：允许使用
密码
HMI 访问权
• HMI_PWD = "0"：不允许
HMI_PWD Input BOOL I、Q、M、D、L 使用密码
• HMI_PWD = "1"：允许使
用密码
读/写访问权状态（包括故障安
F_PWD_ON Output BOOL I、Q、M、D、L
全）
- 183 -
• F_PWD_ON = "0"：不允许

使用密码
• F_PWD_ON = "1"：允许使
用密码
读/写访问权的状态
FULL_PWD_
• FULL_PWD_ON = "0"：不
Output BOOL I、Q、M、D、L 允许使用密码
ON
• FULL_PWD_ON = "1"：允
许使用密码
读访问权的状态
• R_PWD_ON = "0"：不允
R_PWD_ON Output BOOL I、Q、M、D、L 许使用密码
• R_PWD_ON = "1"：允许
使用密码
HMI 访问权的状态
HMI_PWD_O
• HMI_PWD_ON = "0"：不
Output BOOL I、Q、M、D、L 允许使用密码
N
• HMI_PWD_ON = "1"：允
许使用密码
函数值 (RET_VAL) WORD I、Q、M、D、L 错误信息
RET_VAL 参数
(W#16#...)
0000 无错误
8090 不支持“限制和启用密码合法性”指令。
80D0 未组态故障安全密码。使用标准 CPU 时，信号状态必须为 TRUE。
80D1 未组态读/写访问
80D2 未组态读访问
80D3 未组态 HMI 访问
请参见”。
示例
SCL
"Tag_Result" := ENDIS_PW(REQ := 0,
F_PWD := 0,
FULL_PWD := 0,
R_PWD := 1,
- 184 -
HMI_PWD := 0,
F_PWD_ON => "Status_F_PWD",
FULL_PWD_ON => "Sta-
tus_FULL_PWD",
R_PWD_ON => "Status_R_PWD",
HMI_PWD_ON => "Sta-
tus_HMI_PWD");
操作数数据类型值
REQ BOOL 0
F_PWD BOOL 0
FULL_PWD BOOL 0
R_PWD BOOL 1
HMI_PWD BOOL 0
Status_F_PWD BOOL 0
Status_FULL_PWD BOOL 0
Status_R_PWD BOOL 1
Status_HMI_PWD BOOL 0
因为操作数“REQ”的信号状态为“0”，所以将执行该指令。操作数 R_PWD 的信号状态为“1”，这表示在
输入分配的密码后允许进行读访问。 R_PWD_ON 状态操作数的信号状态也为“1”，因此表示 R_PWD 操
作数将激活。
- 185 -
RE_TRIGR：重置周期监视时间 (S7-1200, S7-1500)
RE_TRIGR：重置周期监视时间
说明
可以使用“重置周期监视时间”指令重置 CPU 的最大循环时间。根据 CPU 组态中所设置的时间，重新启
动周期监视时间。
可以在所有块中调用指令“重置周期监视时间”，而无需考虑优先级。
如果在具有较高优先级的块中调用此指令（例如，硬件中断、诊断中断或周期性中断），则不会执行此
指令。
指令“重置周期监视时间”完全在时间范围内执行（最大程序循环的 10 次），而不考虑调用次数。过期
后，程序循环将无法再延长。
语法
“重置周期监视时间”指令的语法如下所示：
SCL
RE_TRIGR()
参数
“重置周期监视时间”指令不带任何参数且不提供错误信息。
- 186 -
STP：退出程序 (S7-1200, S7-1500)
STP：退出程序
说明
使用“退出程序”指令，可将 CPU 设置为 STOP 模式，从而终止程序执行。是否从 RUN 模式切换到
STOP 模式，则取决于 CPU 的组态。
语法
“退出程序”指令的语法如下所示：
SCL
STP()
- 187 -
GET_ERROR：获取本地错误信息 (S7-1200, S7-1500)
GET_ERROR：获取本地错误信息
说明
可以使用“获取本地错误信息”指令查询块内发生的错误。该错误通常为访问错误。如果处理块的过程
中系统报告了一个错误，则将生成上一次执行该指令后执行该块时所发生第一个错误的详细信息。
错误信息只能保存在“ErrorStruct”系统数据类型的操作数中。 “ErrorStruct”系统数据类型将指定存储错
误相关信息的具体结构。可使用其它指令评估该结构并编写相应的响应。如果块中存在多处错误，则在
更正了第一个错误后仅输出该指令中下一个错误的错误信息。
说明
只有在存在错误信息时才能更改 <操作数>。可以通过以下方式在处理错误之后将操作数设置回“0”：
• 在块接口的“Temp”部分声明操作数。
• 在调用指令之前将操作数重置为“0”。
有关该指令的执行和其它故障排除方式的示例，请参见“另请参见”。
说明
“获取本地错误信息”指令支持在块内进行本地错误处理。将“获取本地错误信息”插入某个块的程序代
码中时，如果发生错误，则将忽略所有预定义的系统响应。
语法
“获取本地错误信息”指令的语法如下所示：
SCL
GET_ERROR(<操作数>)
参数
下表列出了“获取本地错误信息”指令的参数：
<操作数> ErrorStruct D、L 有关已发生错误的信息
数据类型“ErrorStruct”
下表列出了“ErrorStruct”数据类型的结构：
结构组件数据类型说明
ERROR_ID WORD 错误 ID
显示块调用期间是否出错。
FLAGS BYTE 16#01: 块调用过程中发生错误
16#00: 块调用过程中无错误
REACTION BYTE 默认响应：
- 188 -
0: 忽略（写入错误），
1: 以替代值“0”继续（读取错误），
2: 跳过指令（系统错误）
CODE_ADDRESS CREF 有关块地址和类型的信息
出错块的类型：
1: OB
BLOCK_TYPE BYTE
2: FC
3: FB
CB_NUMBER UINT 代码块的编号
OFFSET UDINT 对内部存储器的引用
MODE BYTE 有关操作数地址的信息
OPERAND_NUMBER UINT 机器指令的操作数编号
POINTER_NUMBER_LOCATION UINT (A) 内部指针
SLOT_NUMBER_SCOPE UINT (B) 内部存储器中的存储区
DATA_ADDRESS NREF 有关操作数地址的信息
(C) 存储区：
L： 16#40 – 4E、86、87、8E、8F、
C0 – CE
I： 16#81
AREA BYTE Q： 16#82
M： 16#83
DB： 16#84、85、8A、8B
超出数据类型 DINT 可直接编辑变量
的范围： 16#04
DB_NUMBER UINT (D) 数据块编号
OFFSET UDINT (E) 操作数的相对地址
结构组件“ERROR_ID”
下表列出了结构组件“ERROR_ID”中可能输出的值：
ID* ID* 说明
（十六进制）（十进制）
0 0 无错误
2503 9475 指针无效
2520 9504 STRING 无效
2522 9506 读取错误：操作数超出有效范围
2523 9507 写入错误：操作数超出有效范围
2524 9508 读取错误：操作数无效
2525 9509 写入错误：操作数无效
2528 9512 读取错误：数据对齐
- 189 -
2529 9513 写入错误：数据对齐

252C 9516 指针无效
2530 9520 写入错误：数据块
2533 9523 使用了无效指针
2538 9528 访问错误： DB 不存在
2539 9529 访问错误：使用了错误 DB
253A 9530 全局数据块不存在
253C 9532 故障信息或函数不存在
253D 9533 系统函数不存在
253E 9534 故障信息或函数块不存在
253F 9535 系统块不存在
2575 9589 程序嵌套深度出错
2576 9590 本地数据分配出错
2577 9591 未选择块属性“通过寄存器传递参数”。
25A0 9632 TP 中发生内部错误
25A1 9633 变量为写保护
25A2 9634 变量的数值无效
2942 10562 读取错误： Input
2943 10563 写入错误： Output
请参见”。
示例
SCL
LABEL: #TagOut := #Field[#index] * REAL#40.5;
GET_ERROR(#Error);
IF #Error.REACTION = 1 THEN
GOTO LABEL;
;
END_IF;
访问“#Field[#index]”变量时出错。尽管读取/访问发生错误，#TagOut 操作数仍返回信号状态“1”，并使
用值“0.0”执行乘法。如果出现这种错误情况，我们建议您在执行乘法之后设定“获取本地错误信息”指令
以获取错误。 “获取本地错误信息”指令提供的错误信息将通过比较进行评估。如果“#Error.REACTION”
结构组件的值为“1”，则表示出现读取/访问错误，程序执行将再次从跳转标签 LABEL 处开始。
- 190 -
GET_ERR_ID：获取本地错误 ID (S7-1200, S7-1500)
GET_ERR_ID：获取本地错误 ID
说明
可以使用“获取本地错误 ID”指令查询块内发生的错误。该错误通常为访问错误。如果在上一次执行该
指令后块执行过程中系统报告块执行错误，则该指令将输出所发生第一个错误的错误 ID。
错误 ID 只能保存在 WORD 数据类型的操作数中。如果块中存在多处错误，则在更正了第一个错误后仅
输出该指令中下一个错误的错误 ID。
说明
只有在存在错误信息时才能更改 <操作数>。可以通过以下方式在处理错误之后将操作数设置回“0”：
• 在块接口的“Temp”部分声明操作数。
• 在调用指令之前将操作数重置为“0”。
如果存在错误信息，则只能设置“获取本地错误 ID”指令的输出。即使不满足其中的某个条件，剩余的程

序执行不受“获取本地错误 ID”指令的影响。
有关该指令的执行和其它故障排除方式的示例，请参见“另请参见”。
说明
“获取本地错误 ID”指令支持在块内进行本地错误处理。在将“获取本地错误 ID”指令插入块的程序代
码中时，如果发生错误，则将忽略任何预定义的系统响应。
语法
“获取本地错误 ID”指令的语法如下所示：
SCL
GET_ERR_ID()
参数
下表列出了“获取本地错误 ID”指令的参数：
函数值 WORD D、L 错误 ID
错误 ID
下表列出了可输出的值：
ID* ID* 说明
（十六进制）（十进制）
0 0 无错误
2503 9475 指针无效
2520 9504 STRING 无效
- 191 -
2522 9506 读取错误：操作数超出有效范围

2523 9507 写入错误：操作数超出有效范围
2524 9508 读取错误：操作数无效
2525 9509 写入错误：操作数无效
2528 9512 读取错误：数据对齐
2529 9513 写入错误：数据对齐
252C 9516 指针无效
2530 9520 写入错误：数据块
2533 9523 使用了无效指针
253A 9530 全局数据块不存在
253C 9532 故障信息或函数不存在
253D 9533 系统函数不存在
253E 9534 故障信息或函数块不存在
253F 9535 系统块不存在
2575 9589 程序嵌套深度出错
2576 9590 本地数据分配出错
2577 9591 未选择块属性“通过寄存器传递参数”。
25A0 9632 TP 中发生内部错误
25A1 9633 变量为写保护
25A2 9634 变量的数值无效
2942 10562 读取错误： Input
2943 10563 写入错误： Output
请参见”。
示例
SCL
#TagOut := #Field[#index] * REAL#40.5;
#TagID := GET_ERR_ID();
IF #TagID = 16#2522 THEN

MOVE_BLK(IN := #TagArrayIn[0],
COUNT := 1,
OUT => #TagArrayOut[1]);
- 192 -
END_IF;
访问“#Field[#index]”变量时出错。尽管读取/访问发生错误，#TagOut 操作数仍返回信号状态“1”，并使
用值“0.0”执行乘法。如果出现这种错误情况，我们建议您在执行乘法之后设定“获取本地错误 ID”指令以
获取错误。 “获取本地错误 ID”指令提供的错误 ID 将通过比较进行评估。如果 #TagID 操作数返回 ID
16#2522，则表示有读取/访问错误，并且 #TagArrayIn[0] 操作数的值“100.0”被写入到 #TagArrayOut[1]
操作数。
- 193 -
INIT_RD：初始化所有保留数据 (S7-1500)
INIT_RD：初始化所有保留数据
说明
“初始化所有保留数据”指令用于同时复位所有数据块、位存储器以及 SIMATIC 定时器和计数器中的保持
性数据。由于该指令的执行时间超出程序周期的持续时间，因此只能在启动 OB 中执行。
语法
“初始化所有保留数据”指令的语法如下所示：
SCL
INIT_RD(<操作数>)
参数
下表列出了“初始化所有保留数据”指令的参数：
如果输入“REQ”的信号状态
<操作数> Input BOOL I、Q、M、D、L 为“1”，将复位所有保持性数
据。
错误信息：
函数值 (RET_VAL) INT I、Q、M、D、L 如果指令执行期间出错，则在
参数 RET_VAL 中输出错误
代码。
RET_VAL 参数
(W#16#...)
0000 无错误
80B5 由于该指令不在启动 OB 中进行编程，因此无法执行。
常见错误信
另请参见："GET_ERR_ID：获取本地错误 ID
息
请参见”。
示例
- 194 -
INIT_RD：初始化所有保留数据 (S7-1500)
SCL
"Tag_Result" := INIT_RD("Tag_REQ");
若操作数“Tag_REQ”的信号状态为“1”，则执行该指令。将复位所有数据块、位存储器以及 SIMATIC 定
时器和计数器中的全部保持性数据。
- 195 -
WAIT：组态延时时间 (S7-1500)
WAIT：组态延时时间
说明
可使用“组态延时时间”指令，将程序的执行过程暂停一段特定的时间。在该指令的参数 WT 中时间段的
单位为微秒。
可以组态的延时为 -32768 到 32767 微秒 (μs)。允许的最短延时时间取决于相应 CPU 并且与“组态延时
时间”指令的执行时间一致。
更高优先级的事件可中断该指令的执行。
“组态延时时间”指令不返回错误信息。
语法
“组态延时时间”指令的语法如下所示：
SCL
WAIT(WT := <操作数>)
WT Input INT 延时时间的单位为微秒 (μs)
P
- 196 -
RUNTIME：测量程序运行时间 (S7-1200, S7-1500)
RUNTIME：测量程序运行时间
说明
“测量程序运行时间”指令用于测量整个程序、单个块或命令序列的运行时间。
如果要测量整个程序的运行时间，请在 OB1 中调用指令“测量程序运行时间”。第一次调用时开始测量运
行时间，在第二次调用后输出 RET_VAL 将返回程序的运行时间。测量的运行时间包括程序执行过程中
可能运行的所有 CPU 进程，例如，由较高级别事件或通信引起的中断。指令“测量程序运行时间”读取
CPU 内部计数器中的内容并将该值写入 in/out 参数中。该指令根据内部计数器的频率计算当前程序运
行时间并将其写入输出 RET_VAL 中。
如果要测量单个块或单个命令序列的运行时间，则需要三个单独的程序段。在程序的单个程序段中，调
用指令“测量程序运行时间”。首次调用该指令即可设置运行时间测量的起始点。然后在下一个程序段
中调用所需的程序块或命令序列。在另一个程序段中，第二次调用“测量程序运行时间”指令并将相同的
存储器分配给 in/out 参数，与在第一次调用该指令时所做的一样。第三个程序段中的“测量程序运行时
间”指令将读取内部 CPU 计数器，并根据内部计数器中的频率计算该程序块或命令序列的当前运行时间，
然后再写入输出 RET_VAL 中。
以下情况适用于固件版本低于 V4.1 的 S7-1200 CPU：测量程序运行时间”指令使用内部高频计数器来
计算时间。如果计数器溢出（每分钟最多发生一次），指令将返回值 <= 0.0。忽略这些运行时间值。
说明
由于命令序列中的指令序列会在程序的优化编译期间发生变化，因而无法确切地确定命令序列的运行
时间。
语法
“测量程序运行时间”指令的语法如下所示：
SCL
RUNTIME(<操作数>)
<操作数> InOut LREAL I、Q、M、D、L 保存测量运行时间的起始点。
函数值返回测得的运行时间（单位为
LREAL I、Q、M、D、L
秒）
示例
以下示例说明了该指令基于程序块的运行时间的工作原理：
SCL
"Tag_Result" := RUNTIME("Tag_Memory");
"Best_before_date_DB" ();
- 197 -
RUNTIME：测量程序运行时间 (S7-1200, S7-1500)
"Tag_Result" := RUNTIME("Tag_Memory");
通过第一次调用该指令来设置运行时间测量的起始点，然后将其作为该指令第二次调用的引用缓存到
“TagMemory”操作数中。
然后调用“Best_before_date”程序块 FB1。
处理完程序块 FB1 后，将再次执行该指令。第二次调用该指令将计算出该程序块的运行时间，然后将
结果写入输出“Tag_Result”中。
- 198 -
字逻辑运算 (S7-1200, S7-1500)
字逻辑运算
• DECO：解码 (S7-1200, S7-1500)
• ENCO：编码 (S7-1200, S7-1500)
• SEL：选择 (S7-1200, S7-1500)
• MUX：多路复用 (S7-1200, S7-1500)
• DEMUX：多路分用 (S7-1200, S7-1500)
- 199 -
DECO：解码 (S7-1200, S7-1500)
DECO：解码
说明
使用“解码”指令，在输出值中将输入值所指定的位置位。
“解码”指令读取参数 IN 的值，并设置输出值中的某个位，该位位置与读取的值一致。输出值中的其它位
以零填充。如果参数 IN 的值大于 31，则执行以 32 为模的指令。
语法
“解码”指令的语法如下所示：
SCL
DECO(IN := <表达式>)
DECO_WORD(IN := <表达式>)
IN Input UINT 输出值中待置位位的位置。
P
1. 可以使用“_”明确指定指令
的数据类型。
2. 如果未明确指定数据类型，
位字符串
_<数据类型> - 将由使用的变量或类型编
默认： DWORD
码的常数来确定。
3. 如果既未明确指定数据类
型，也未指定定义的变量或
类型编码的常数，则使用默
认数据类型。
函数值位字符串当前输出值
P
示例
SCL
"Tag_Result" := DECO(IN := "Tag_Value");
"Tag_Result2" := DECO_BYTE(IN := "Tag_Value2");
下图将通过具体的操作数值对该指令的工作原理进行说明：
- 200 -
DECO：解码 (S7-1200, S7-1500)
该指令从“Tag_Value”操作数的值中读取数值“3”，并将第三个位设置为“Tag_Result”操作数的值。
- 201 -
ENCO：编码 (S7-1200, S7-1500)
ENCO：编码
说明
使用“编码”指令读取输入值中设置的最小值位的位号，并作为结果返回。
语法
“编码”指令的语法如下所示：
SCL
ENCO(IN := <表达式>)
IN Input 位字符串 I、Q、M、D、L、P 输入值
待读取输入值中位
函数值 INT I、Q、M、D、L、P
的位号。
示例
SCL
"Tag_Result" := ENCO(IN := "Tag_Value");
下图将通过具体的操作数值对该指令的工作原理进行说明：
该指令读取操作数“Tag_Value”的最小值置位位，并将该位的位置“3”写入操作数“Tag_Result”中。
- 202 -
SEL：选择 (S7-1200, S7-1500)
SEL：选择
说明
“选择”指令将根据一个开关参数（G 参数）选择参数 IN0 或 IN1 中的一个，并将所选参数中的内容作为
结果返回。如果参数 G 的信号状态为“0”，则移动参数 IN0 的值。当参数 G 的信号状态为“1”时，将移
动参数 IN1 的值，并返回为函数值。
只有当所有参数的变量均为同一种数据类型等级时，才能执行该指令。
语法
“选择”指令的语法如下所示：
SCL
SEL(G:= <表达式>,
IN0 := <表达式>,
IN1 := <表达式>)
S7-1200 S7-1500
I、Q、M、D、
G Input BOOL BOOL 开关
L
浮点数、定时器、 I、Q、M、D、
IN0 Input 字符串、DATE、第一个输入值
字符串、TOD、 L、P
TOD、LTOD、
DATE、DT
DT、LDT
IN1 Input 字符串、DATE、第二个输入值
TOD、LTOD、
DATE、DT
DT、LDT
函数值字符串、DATE、指令的结果
TOD、LTOD、
DATE、DT
DT、LDT
示例
- 203 -
SEL：选择 (S7-1200, S7-1500)
SCL
"Tag_Result" := SEL(G := "Tag_Value",
IN0 := "Tag_0",
IN1 := "Tag_1");
操作数值
Tag_Value 0 1
Tag_0 W#16#0000 W#16#4C
Tag_1 W#16#FFFF D#16#5E
Tag_Result W#16#0000 D#16#5E
- 204 -
MUX：多路复用 (S7-1200, S7-1500)
MUX：多路复用
说明
“多路复用”指令将复制一个所选的输入参数值并将其发出。使用参数 K 可以确定要移动其值的输入参
数的编号。编号从 IN0 开始，每次新增输入后将连续递增。最多可声明 32 个输入。
输入所允许数据类型为数值型数据类型和时间型数据类型。所有分配有参数的变量都必须为相同的数
据类型。
如果满足以下任何条件，则函数值无效：
• 执行该指令期间出错。
• 参数 K 的输入超出了可用输入。如果不使用输入 INELSE，在这种情况下输入 IN0 的值将分配给函数
值，ENO 使能输出设置为“0”。
语法
“多路复用”指令的语法如下所示：
SCL
MUX(K:= <表达式>,
IN0 := <表达式>,
IN1 := <表达式>,
INELSE := <表达式>)
参数
下表列出了“多路复用”指令的参数：
S7-1200 S7-1500
指定要传送内容的参
数。
I、Q、M、D、 • 如果 K = 0，则参数
K Input 整数整数
L、P IN0
• 如果 K = 1，则参数
IN1，依此类推
二进制数、整
数、浮点数、
定时器、
浮点数、字符串、
STRING、 I、Q、M、D、
IN0 Input TOD、LTOD、第一个输入值
CHAR、 L、P
DATE、定时器、
WCHAR、
DT、LDT
TOD、DATE、
DT
二进制数、整二进制数、整数、
I、Q、M、D、
IN1 Input 数、浮点数、浮点数、字符串、第二个输入值
L、P
定时器、 TOD、LTOD、
- 205 -
MUX：多路复用 (S7-1200, S7-1500)
STRING、
CHAR、
DATE、定时器、
WCHAR、
DT、LDT
TOD、DATE、
DT
二进制数、整
数、浮点数、
定时器、
STRING、 I、Q、M、D、
INn Input TOD、LTOD、可选的输入值
CHAR、 L、P
DATE、定时器、
WCHAR、
DT、LDT
TOD、DATE、
DT
二进制数、整
数、浮点数、
定时器、
STRING、 I、Q、M、D、指定 K <> n 时要复制
INELSE Input TOD、LTOD、
CHAR、 L、P 的值。
DATE、定时器、
WCHAR、
DT、LDT
TOD、DATE、
DT
二进制数、整
数、浮点数、
定时器、
函数值 STRING、 I、Q、M、D、
TOD、LTOD、指令的结果
CHAR、 L、P
DATE、定时器、
WCHAR、
DT、LDT
TOD、DATE、
DT
示例
SCL
"Tag_Result" := MUX(K := "Tag_Number",
IN0 := "Tag_1",
IN1 := "Tag_2",
INELSE := "Tag_3");
操作数值
Tag_Number 1 4
Tag_1 DW#16#00000000 DW#16#00000000
Tag_2 DW#16#003E4A7D DW#16#003E4A7D
Tag_3 DW#16#FFFF0000 DW#16#FFFF0000
- 206 -
MUX：多路复用 (S7-1200, S7-1500)
Tag_Result DW#16#003E4A7D DW#16#FFFF0000
- 207 -
DEMUX：多路分用 (S7-1200, S7-1500)
DEMUX：多路分用
说明
使用“多路分用”指令，将输入参数 IN 的值传送到所选的输出参数。输入参数的选择与参数值 K 无关。
K 参数指定要将输入参数 IN 的值传送到的输出参数的编号。其它输出参数则保持不变。编号从 OUT0
开始，对于每个新输出，此编号连续递增。可以最多声明 32 个输出参数。
如果参数 K 的值大于输出参数的值，则将使能输出 ENO 的值设置为“0”，并将输入参数 IN 的值传输到
输出参数 OUTELSE 中。
如果满足以下任何条件，则函数值无效：
• 参数 K 的值大于可用输出数。
• 执行该指令期间出错。
语法
“多路分用”指令的语法如下所示：
SCL
DEMUX(K:= <表达式>,
IN := <Expression>,
OUT0 := <操作数>,
OUT1 := <操作数>,
OUTELSE := <操作数>)
参数
下表列出了指令“多路分用”的参数：
S7-1200 S7-1500
指定要将输入
值 (IN) 复制到
的输出。
• 如果 K = 0，
I、Q、M、D、则复制参数
K Input 整数整数
L、P OUT0
• 如果 K = 1，
则复制参数
OUT1，依此
类推
数、浮点数、定数、浮点数、 I、Q、M、D、
IN Input 输入值
时器、STRING、字符串、定时 L、P
CHAR、器、TOD、
- 208 -
DEMUX：多路分用 (S7-1200, S7-1500)
LTOD、
WCHAR、TOD、
DATE、DT、
DATE、DT
LDT
二进制数、整
二进制数、整
数、浮点数、
数、浮点数、定
字符串、定时
时器、STRING、 I、Q、M、D、
OUT0 Output 器、TOD、第一个输出
CHAR、 L、P
LTOD、
WCHAR、TOD、
DATE、DT、
DATE、DT
LDT
二进制数、整
二进制数、整
数、浮点数、
字符串、定时
OUT1 Output 器、TOD、第二个输出
CHAR、 L、P
LTOD、
WCHAR、TOD、
DATE、DT、
DATE、DT
LDT
二进制数、整
二进制数、整
数、浮点数、
字符串、定时
OUTn Output 器、TOD、可选输出
CHAR、 L、P
LTOD、
WCHAR、TOD、
DATE、DT、
DATE、DT
LDT
二进制数、整
二进制数、整
数、浮点数、
字符串、定时当 K > n 时，输
OUTELSE Output 器、TOD、入 IN 的值要复
CHAR、 L、P
LTOD、制到的输出。
WCHAR、TOD、
DATE、DT、
DATE、DT
LDT
有关可用数据类型的更多信息，请参见“另请参见”。
示例
SCL
DEMUX(K := "Tag_Number",
IN := "Tag_Value",
OUT0 := "Tag_1",
OUT1 := "Tag_2",
OUTELSE := "Tag_3");
执行程序段之前，“多路分用”指令的输入值
参数操作数值
K Tag_Number 2 4
- 209 -
DEMUX：多路分用 (S7-1200, S7-1500)
IN Tag_Value DW#16#FFFFFFFF DW#16#003E4A7D

执行程序段之后，“多路分用”指令的输出值
参数操作数值
OUT0 Tag_1 不变不变
OUT1 Tag_2 DW#16#FFFFFFFF 不变
OUTELSE Tag_3 不变 DW#16#003E4A7D
- 210 -
移位和循环 (S7-1200, S7-1500)
移位和循环
• SHR：右移 (S7-1200, S7-1500)
• SHL：左移 (S7-1200, S7-1500)
• ROR：循环右移 (S7-1200, S7-1500)
• ROL：循环左移 (S7-1200, S7-1500)
- 211 -
SHR：右移 (S7-1200, S7-1500)
SHR：右移
说明
使用“右移”指令，可以将参数 IN 的内容逐位向右移动，并将结果作为函数值返回。参数 N 用于指定应
将特定值移位的位数。
如果参数 N 的值为“0”，则将参数 IN 的值作为结果。
如果参数 N 的值大于可用位数，则参数 IN 的值将向右移动该位数个位置。
操作数左边由于移位而空出的各个位将用零进行填充。
下图说明了如何将整型操作数的内容向右移动 4 位：
语法
“右移”指令的语法如下所示：
SCL
SHR(IN := <操作数>,
N := <操作数>)
参数
下表列出了“右移”指令的参数：
- 212 -
SHR：右移 (S7-1200, S7-1500)
S7-1200 S7-1500
IN Input I、Q、M、D、L 要移位的值
数数
USINT,
USINT,
UINT, 对值 (IN) 进行移
N Input UINT, I、Q、M、D、L
UDINT, 位的位数
UDINT
ULINT
函数值 I、Q、M、D、L 指令的结果
数数
示例
SCL
"Tag_Result" := SHR(IN := "Tag_Value",
N := "Tag_Number");
参数操作数值
IN Tag_Value 0011 1111 1010 1111
N Tag_Number 3
函数值 Tag_Result 0000 0111 1111 010 1
将“Tag_Value”操作数的内容向右移动 3 位。该指令的结果作为函数值在“Tag_Result”操作数中返回。
- 213 -
SHL：左移 (S7-1200, S7-1500)
SHL：左移
说明
使用“左移”指令，可以将参数 IN 的内容逐位向左移动，并将结果作为函数值返回。参数 N 用于指定应
将特定值移位的位数。
如果参数 N 的值为“0”，则将参数 IN 的值作为结果。
如果参数 N 的值大于位数，则参数 IN 的值将向左移动可用位数个位置。
结果值中因移位而空出的位将用 0 填充。
下图显示了如何将 WORD 数据类型操作数的内容向左移动 6 位：
语法
“左移”指令的语法如下所示：
SCL
SHL(IN := <操作数>,
N := <操作数>)
参数
下表列出了“左移”指令的参数：
- 214 -
SHL：左移 (S7-1200, S7-1500)
S7-1200 S7-1500
IN Input I、Q、M、D、L 要移位的值
数数
USINT,
USINT,
UINT, 对值 (IN) 进行移
UDINT, 位的位数
UDINT
ULINT
数数
示例
SCL
"Tag_Result" := SHL(IN := "Tag_Value",
N := "Tag_Number");
参数操作数值
IN Tag_Value 0011 1111 1010 1111
N Tag_Number 4
函数值 Tag_Result 1111 1010 1111 0000
将“Tag_Value”操作数的值将向左移动 4 位。该指令的结果作为函数值在“Tag_Result”操作数中返回。
- 215 -
ROR：循环右移 (S7-1200, S7-1500)
ROR：循环右移
说明
使用“循环右移”指令，将参数 IN 的内容逐位向右循环移位，并将结果赋值给指定的操作数。参数 N 用
于指定应将特定值循环移位的位数。用移出的位填充因循环移位而空出的位。
如果参数 N 的值为“0”，则将输入 IN 的值作为结果。
如果参数 N 的值大于可用位数，则输入 IN 中的操作数值将循环移动指定位数个位。
下图显示了如何将 DWORD 数据类型操作数的内容向右循环移动 3 位：
语法
“循环右移”指令的语法如下所示：
SCL
ROR(IN := <操作数>,
N := <操作数>)
参数
下表列出了“循环右移”指令的参数：
S7-1200 S7-1500
IN Input I、Q、M、D、L 要循环移位的值
数数
- 216 -
ROR：循环右移 (S7-1200, S7-1500)
USINT,
USINT,
UINT, 要将值进行 (IN)
UDINT, 循环移位的位数
UDINT
ULINT
数数
示例
SCL
"Tag_Result" := ROR(IN := "Tag_Value",
N := "Tag_Number");
参数操作数值
IN Tag_Value 0000 1111 1001 0101
N Tag_Number 5
函数值 Tag_Result 1010 1000 0111 1100
将“Tag_Value”操作数的内容将向右循环移动 5 位。该指令的结果作为函数值在“Tag_Result”操作数中
返回。
- 217 -
ROL：循环左移 (S7-1200, S7-1500)
ROL：循环左移
说明
使用“循环左移”指令，可以将参数 IN 的内容逐循环左移，并将结果作为函数值返回。参数 N 用于指定
应将特定值循环移位的位数。用移出的位填充因循环移位而空出的位。
如果参数 N 的值为“0”，则将输入 IN 的值作为结果。
如果参数 N 的值大于可用位数，则输入 IN 中的操作数值将循环移动指定位数个位。
下图显示了如何将 DWORD 数据类型操作数的内容向左循环移动 3 位：
语法
“循环左移”指令的语法如下所示：
SCL
ROL(IN := <操作数>,
N := <操作数>)
参数
下表列出了“循环左移”指令的参数：
S7-1200 S7-1500
IN Input I、Q、M、D、L 要循环移位的值
数数
- 218 -
ROL：循环左移 (S7-1200, S7-1500)
USINT,
USINT,
UINT, 要将值进行 (IN)
UDINT, 循环移位的位数
UDINT
ULINT
数数
示例
SCL
"Tag_Result" := ROL(IN := "Tag_Value",
N := "Tag_Number");
参数操作数值
IN Tag_Value 1010 1000 1111 0110
N Tag_Number 5
函数值 Tag_Result 0001 1110 1101 0101
将“Tag_Value”操作数的内容将向左循环移动 5 位。该指令的结果作为函数值在“Tag_Result”操作数中
返回。
- 219 -
传统 (S7-1500)
传统
• DRUM：执行顺控程序 (S7-1500)
• DCAT：离散控制定时器报警 (S7-1500)
• MCAT：电机控制定时器报警 (S7-1500)
• IMC：比较输入位与掩码位 (S7-1500)
• SMC：比较扫描矩阵 (S7-1500)
• LEAD_LAG：提前和滞后算法 (S7-1500)
• SEG：创建 7 段显示的位模式 (S7-1500)
• BCDCPL：求十进制补码 (S7-1500)
• BITSUM：统计置位位数量 (S7-1500)
- 220 -
DRUM：执行顺控程序 (S7-1500)
DRUM：执行顺控程序
说明
通过“执行顺控程序”指令，可以将相应步的 OUT_VAL 参数的已设定值分配给已设定的输出位（OUT1
到 OUT16）和输出字 (OUT_WORD)。因此，当指令仍处于某特定步时，该步必须满足参数 S_MASK
中设定的使能掩码条件。如果该步的事件为真且为当前步设定的时间已用完，或者参数 JOG 的值从“0”
变为“1”，则该指令进入下一步。如果参数 RESET 的信号状态变为“1”，将复位该指令。当前步因此等
同于预设步 (DSP)。
每步所耗用的时间由预设时基 (DTBP) 与每步预设计数值 (S_PRESET) 的乘积确定。启动新步时，会将
此计算值加载到参数 DCC 中，该参数包含当前步的剩余时间。例如，参数 DTBP 的值为 2，且第一个
步的预设值为“100”(100 ms)，则参数 DCC 的值为“200”(200 ms)。
可使用时间值和/或事件对程序步进行编程。具有一个事件位且时间值为“0”的步，在该事件位的信号状
态为“1”时立即进入下一步。仅用时间值编程的步将立即开始计时。具有事件位且时间值大于“0”的步，
在该事件位的信号状态为“1”时开始计时。信号状态为“1”时，初始化事件位。
当顺控程序位于最后一个编程步 (LST_STEP) 且该步的时间用完时，会将参数 Q 的信号状态置位为“1”；
否则复位为“0”。置位参数 Q 时，该指令将停留在该步，直至参数复位。
在可组态掩码 (S_MASK) 中，可以选择输出字 (OUT_WORD) 中的各个位并通过输出值 (OUT_VAL) 置
位或复位输出位（OUT1 到 OUT16）。如果可组态掩码的某个位的信号状态为“1”，则将置位值
OUT_VAL 或复位相应位。如果可组态掩码的某个位的信号状态为“0”，相应位则保持不变。在信号状态
为“1”时，将初始化所有 16 个步中可组态掩码的所有位。
参数 OUT1 的输出位对应输出字 (OUT_WORD) 的最低有效位。参数 OUT16 的输出位对应输出字
(OUT_WORD) 的最高有效位。
语法
“执行顺控程序”指令的语法如下所示：
SCL
<实例>(RESET:= <操作数>,
JOG := <操作数>,
DRUM_EN := <操作数>,
LST_STEP := <操作数>,
EVENT1 - 16 := <操作数>,
OUT1 - 16 := <操作数>,
Q => <操作数>,
OUT_WORD => <操作数>,
ERR_CODE => <操作数>)
- 221 -
参数
下表列出了“执行顺控程序”指令的参数：
RESET Input BOOL I、Q、M、D、L 信号状态“1”表示复位状态。
当信号状态从“0”变为“1”时，
JOG Input BOOL I、Q、M、D、L
该指令将进入下一步。
信号状态“1”允许顺控程序按
DRUM_EN Input BOOL I、Q、M、D、L
照事件和时间条件提前执行。
LST_STEP Input BYTE I、Q、M、D、L 最后一个编程步的编号。
EVENT(i), 事件位 (i)；
Input BOOL I、Q、M、D、L
1 ≤ i ≤ 16 初始信号状态为“1”。
OUT(j),
Output BOOL I、Q、M、D、L 输出位 (j)
1 ≤ j ≤ 16
信号状态“1”表示最后一步的
Q Output BOOL I、Q、M、D、L
时间已用完。
I、Q、M、D、L、顺控程序写入输出值的目标
OUT_WORD Output WORD
P 字地址。
ERR_CODE Output WORD 错误信息
P
JOG_HIS Static BOOL I、Q、M、D、L 参数 JOG 的历史位
信号状态“1”表示最后一步的
EOD Static BOOL I、Q、M、D、L
时间已用完。
DSP Static BYTE 顺控程序的预设步
P
DSC Static BYTE 顺控程序的当前步
P
DCC Static DWORD 顺控程序的当前计数值
P
DTBP Static WORD 顺控程序的预设时基
P
PrevTime Static TIME I、Q、M、D、L 上一次的系统时间
每个步 [1 到 16] 的预置计数
ARRAY[1..16] of
S_PRESET Static I、Q、M、D、L 值，其中 1 个时钟脉冲 = 1
WORD
ms。
ARRAY[1..16, 每个步 [1 到 16，0 到 15] 的
OUT_VAL Static I、Q、M、D、L
0..15] of BOOL 输出值。
每个步 [1 到 16，0 到 15] 的
ARRAY[1..16,
S_MASK Static I、Q、M、D、L 可组态掩码。初始信号状态
0..15] of BOOL
为“1”。
ERR_CODE 参数
下表列出了 ERR_CODE 参数值的含义：
- 222 -
ERR_COD 说明
E*
W#16#000
无错误
0
W#16#000
参数 LST_STEP 的值小于 1 或大于 16。
B
W#16#000
参数 DSC 的值小于 1 或大于参数 LST_STEP 的值。
C
W#16#000
参数 DSP 的值小于 1 或大于参数 LST_STEP 的值。
D
请参见”。
示例
在以下示例中，该指令从步 1 前进到步 2。根据为步 2 组态的掩码和参数 OUT_VAL 的值，设置输出位
（OUT1 到 OUT16）和输出字 (OUT_WORD)。
说明
可以初始化数据块中的静态参数。
SCL
"DRUM_DB"(RESET := "Tag_Reset"
JOG := "Tag_Input_Jog"
DRUM_EN := "Tag_Input_DrumEN"
LST_STEP := "Tag_Number_LastStep"
EVENT1 := "MyTag_Event_1"
OUT1 => "MyTag_Output_1"
- 223 -

Q => "Tag_Output_Q"
OUT_WORD => "Tag_OutputWord"
ERR_CODE => "Tag_ErrorCode");
下表将通过具体的值对该指令的工作原理进行说明：
执行前
在本例中，使用以下值来初始化输入参数：
参数操作数地址值
RESET Tag_Reset M0.0 FALSE
JOG Tag_Input_JOG M0.1 FALSE
DRUM_EN Tag_Input_DrumEN M0.2 TRUE
LST_STEP Tag_Number_LastStep MB1 B#16#08
EVENT2 MyTag_Event_2 M20.0 FALSE
以下各值保存在该指令的背景数据块“DRUM_DB”中：
参数地址值
JOG_HIS DBX12.0 FALSE
EOD DBX12.1 FALSE
DSP DBB13 W#16#0001
DSC DBB14 W#16#0001
- 224 -
DCC DBD16 DW#16#0000000A

DTBP DBW20 W#16#0001
S_PRESET[1] DBW26 W#16#0064
S_PRESET[2] DBW28 W#16#00C8
OUT_VAL[1,0] DBX58.0 TRUE
OUT_VAL[2,0] DBX60.0 FALSE
S_MASK[2,0] DBX92.0 FALSE
S_MASK[2,1] DBX92.1 TRUE
- 225 -

执行该指令之前，将输出参数设置为以下各值：
Q Tag_Output_Q M6.0 FALSE
OUTWORD Tag_OutputWord MW8 W#16#FFFF
OUT1 MyTag_Output_1 M4.0 TRUE
执行后
执行该指令之后，将以下各值写入输出参数：
- 226 -
OUT2 MyTag_Output_2 M4.1 FALSE

Q Tag_Output_Q M6.0 FALSE
OUTWORD Tag_OutputWord MW8 W#16#4321
ERR_CODE Tag_ErrorCode MW10 W#16#0000
该指令执行后，其背景数据块“DRUM_DB”中的以下值会发生变化：
参数地址值
JOG_HIS DBX12.0 FALSE
EOD DBX12.1 FALSE
DSC DBB14 W#16#0002
DCC DBD16 DW#16#000000C8
- 227 -
DCAT：离散控制定时器报警 (S7-1500)
DCAT：离散控制定时器报警
说明
“离散控制定时器报警”指令用于从参数 CMD 发出打开或关闭命令的时刻开始计时。计时过程一直持续
到超出了预设时间 (PT) 或收到此信息为止：即在规定时间内已打开或关闭（O_FB 或 C_FB）设备。如
果在收到有关设备打开或关闭的信息之前就超出了预设时间，将激活相应的报警。如果命令输入的信号
状态在超出预设时间前发生变化，则重新计时。
“离散控制定时器报警”指令对各种输入条件的反应如下：
• 参数 CMD 的信号状态从“0”变为“1”时，对参数 Q、CMD_HIS、ET（仅当 ET < PT 时）、OA 和 CA
的信号状态有如下影响：
o 参数 Q 和 CMD_HIS 置位为“1”。
o 参数 ET、OA 和 CA 复位为“0”。
• 参数 CMD 的信号状态从“1”变为“0”时，参数 Q、ET（仅当 ET < PT 时）、OA、CA 和 CMD_HIS 将
复位为“0”。
• 如果参数 CMD 和 CMD_HIS 的信号状态均为“1”，且参数 O_FB 的信号状态设置为“0”，则将上次执行
该指令以来的时间差 (ms) 加到参数 ET 的值中。如果参数 ET 的值大于参数 PT 的值，则将参数 OA
的信号状态置位为“1”。如果参数 ET 的值不大于参数 PT 的值，则将参数 OA 的信号状态复位为“0”。
将参数 CMD_HIS 的值设置为参数 CMD 的值。
• 如果参数 CMD、CMD_HIS 和 O_FB 的信号状态置位为“1”且参数 C_FB 的值为“0”，则将参数 OA 的
信号状态设置为“0”。将参数 ET 的值设置为参数 PT 的值。如果参数 O_FB 的信号状态变为“0”，则
将在下次执行指令时设置报警。将参数 CMD_HIS 的值设置为参数 CMD 的值。
• 如果参数 CMD、CMD_HIS 和 C_FB 的值为“0”，则将上次执行该指令以来的时间差 (ms) 加到参数 ET
的值中。如果参数 ET 的值大于参数 PT 的值，则将参数 CA 的信号状态置位为“1”。如果不大于参
数 PT 的值，则参数 CA 的信号状态为“0”。将参数 CMD_HIS 的值设置为参数 CMD 的值。
• 如果参数 CMD、CMD_HIS 和 O_FB 的信号状态为“0”且参数 C_FB 设置为“1”，则将参数 CA 设置为
“0”。将参数 ET 的值设置为参数 PT 的值。如果参数 C_FB 的信号状态变为“0”，则在下次执行指令
时设置报警。将参数 CMD_HIS 的值设置为参数 CMD 的值。
• 如果参数 O_FB 和 C_FB 的信号状态均为“1”，则将两个报警输出的信号状态都置位为“1”。
“离散控制定时器报警”指令不提供错误信息。
语法
“离散控制定时器报警”指令的语法如下所示：
SCL
<实例>(CMD:= <操作数>,
O_FB := <操作数>,
C_FB := <操作数>,
Q => <操作数>,
OA => <操作数>,
- 228 -
CA => <操作数>)
参数
下表列出了该指令的参数：
信号状态“0”表示“关闭 (close)”命
令。
CMD Input BOOL I、Q、M、D、L
信号状态“1”表示“打开 (open)”命
令。
O_FB Input BOOL I、Q、M、D、L 打开时的反馈输入
C_FB Input BOOL I、Q、M、D、L 关闭时的反馈输入
Q Output BOOL I、Q、M、D、L 显示参数 CMD 的状态
OA Output BOOL I、Q、M、D、L 打开时的报警输出
CA Output BOOL I、Q、M、D、L 关闭时的报警输出
当前已用时间，其中 1 次计数 = 1
ET Static DINT D、L
ms。
预设的时间值，其中 1 次计数 = 1
PT Static DINT D、L
ms。
PREV_TIME Static DWORD D、L 上一次的系统时间
CMD_HIS Static BOOL D、L CMD 历史位
在程序中调用指令时，不显示静态参数。这些静态参数保存在指令实例中。
示例
在以下示例中，参数 CMD 从“0”变为“1”。执行该指令后，参数 Q 将置位为“1”，而两个报警输出 OA 和
CA 的信号状态为“0”。背景数据块的参数 CMD_HIS 的信号状态将置位为“1”，同时将参数 ET 复位为
“0”。
说明
SCL
"DCAT_DB"(CMD := "Tag_Input_CMD",
O_FB := "Tag_Input_O_FB",
C_FB := "Tag_Input_C_FB",
Q => "Tag_Output_Q",
OA => "Tag_Output_OA",
CA => "Tag_Output_CA");
执行前
- 229 -
在本示例中，输入和输出参数可使用以下各值：
参数操作数值
CMD Tag_Input_CMD TRUE
O_FB Tag_Input_O_FB FALSE
C_FB Tag_Input_C_FB FALSE
Q Tag_Output_Q FALSE
OA Tag_Output_OA FALSE
CA Tag_Output_CA FALSE
以下各值保存在该指令的背景数据块“DCAT_DB”中：
参数地址值
ET DBD4 L#12
PT DBD8 L#222
CMD_HIS DBX16.0 FALSE
执行后
参数操作数值
Q Tag_Output_Q TRUE
以下各值保存在该指令的背景数据块“DCAT_DB”中：
参数地址值
ET DBD4 L#0
CMD_HIS DBX16.0 TRUE
- 230 -
MCAT：电机控制定时器报警 (S7-1500)
MCAT：电机控制定时器报警
说明
“电机控制定时器报警”指令用于从开启命令输入（打开或关闭）时开始计时。计时过程一直持续到超出
了预设时间，或相关反馈输入提示设备已在规定时间内执行了要求的操作为止。如果在收到反馈前就超
出了预设时间，则触发相应的报警。
执行“电机控制定时器报警”指令
下表列出了“电机控制定时器报警”指令对各种输入条件的反应：
输入参数输出参数
O_ C_ S_
O_ C_ O_ C_ O_ C_
ET CM CM CM OO CO OA CA ET Q 状态
HIS HIS FB FB HIS HIS
D D D
X 1 1 X X X X X 0 0 1 1 PT 0 0 0 报警
X X X X X X 1 1 0 0 1 1 PT 0 0 0 报警
X X X X X 1 X X 0 0 0 0 X 0 0 1 停止
X X X 1 1 X X X 0 0 0 0 X 0 0 1 停止
X 0 X 1 0 0 X X 1 0 0 0 0 1 0 1 开始打开
<P
1 0 X 0 0 0 X 1 0 0 0 INC 1 0 1 打开
T
X 1 0 X 0 0 1 0 0 0 0 0 PT 1 0 1 已打开
>= 打开的报
1 0 X 0 0 0 X 0 0 1 0 PT 1 0 0
PT 警
X X 0 0 1 0 X X 0 1 0 0 0 0 1 1 开始关闭
<P
0 1 0 X 0 X 0 0 1 0 0 INC 0 1 1 关闭
T
X 0 1 0 X 0 0 1 0 0 0 0 PT 0 1 1 已关闭
>= 关闭的报
0 1 0 X 0 X 0 0 0 0 1 PT 0 1 0
PT 警
X 0 0 0 0 0 X X 0 0 0 0 X 0 0 1 已停止
符号说明：
INC 将上次处理 FB 以来的时间差 (ms) 加到 ET 中
PT 将 PT 的值设置为与 ET 的相同
X 无法使用
<PT ET < PT
>=PT ET >= PT
- 231 -
如果输入参数 O_HIS and C_HIS 的信号状态均为“1”，则立即将这两个输入参数的信号状态置位为

“0”。此时，将使用上述表格 (X) 中的最后一行。由于无法确定输入参数 O_HIS 和 C_HIS 的信号状态
是否都为 1，因此将通过以下方式设置输出参数：
OO = FALSE
CO = FALSE
OA = FALSE
CA = FALSE
ET = PT
Q = TRUE
语法
“电机控制定时器报警”指令的语法如下所示：
SCL
<实例>(O_CMD:= <操作数>,
C_CMD := <操作数>,
S_CMD := <操作数>,
O_FB := <操作数>,
C_FB := <操作数>,
00 => <操作数>,
C0 => <操作数>,
OA => <操作数>,
CA => <操作数>,
Q => <操作数>)
参数
下表列出了“电机控制定时器报警”指令的参数：
O_CMD Input BOOL I、Q、M、D、L “打开”命令输入
C_CMD Input BOOL I、Q、M、D、L “关闭”命令输入
S_CMD Input BOOL I、Q、M、D、L “停止”命令输入
O_FB Input BOOL I、Q、M、D、L 打开时的反馈输入
C_FB Input BOOL I、Q、M、D、L 关闭时的反馈输入
OO Output BOOL I、Q、M、D、L “打开”输出
CO Output BOOL I、Q、M、D、L “关闭”输出
OA Output BOOL I、Q、M、D、L 打开时的报警输出
CA Output BOOL I、Q、M、D、L 关闭时的报警输出
- 232 -
Q Output BOOL I、Q、M、D、L 信号状态“0”表示错误状态。

当前已用时间，其中 1 次计
ET Static DINT D、L
数 = 1 ms
预设的时间值，其中 1 次计
PT Static DINT D、L
数 = 1 ms
PREV_TIME Static DWORD D、L 上一次的系统时间
O_HIS Static BOOL D、L “打开”历史位
C_HIS Static BOOL D、L “关闭”历史位
示例
说明
SCL
"MCAT_DB"(O_CMD := "Tag_Iput_O_CMD",
C_CMD := "Tag_Input_C_CMD",
S_CMD := "Tag_Input_S_CMD",
O_FB := "Tag_Input_O_FB",
C_FB := "Tag_Input_C_FB",
OO => "Tag_OutputOpen",
CO => "Tag_OutputClosed",
OA => "Tag_Output_OA",
CA => "Tag_Output_CA",
Q => "Tag_Output_Q");
执行前
在本示例中，输入和输出参数可使用以下各值：
参数操作数值
O_CMD Tag_Input_O_CMD TRUE
C_CMD Tag_Input_C_CMD FALSE
S_CMD Tag_Input_S_CMD FALSE
O_FB Tag_Input_O_FB FALSE
C_FB Tag_Input_C_FB FALSE
OO Tag_OutputOpen FALSE
- 233 -
CO Tag_OutputClosed FALSE
Q Tag_Output_Q FALSE
以下各值保存在该指令的背景数据块“MCAT_DB”中：
参数地址值
ET DBD4 L#2
PT DBD8 L#22
O_HIS DBX16.0 TRUE
C_HIS DBX16.1 FALSE
执行后
参数操作数值
OO Tag_OutputOpen TRUE
CO Tag_OutputClosed FALSE
Q Tag_Output_Q TRUE
以下各值保存在该指令的背景数据块“MCAT_DB”中：
参数地址值
ET DBD4 L#0
O_HIS DBX16.0 TRUE
CMD_HIS DBX16.1 FALSE
- 234 -
IMC：比较输入位与掩码位 (S7-1500)
IMC：比较输入位与掩码位
说明
“比较输入位与掩码位”指令可以将最多 16 个已编程输入位（IN_BIT0 到 IN_BIT15）的信号状态与相应
掩码位进行比较。可编程多达 16 个带掩码的步。将参数 IN_BIT0 的值与掩码 CMP_VAL[x,0] 的值相
比较，其中“x”代表步号。在参数 CMP_STEP 中指定用于比较的掩码步号。所有编程值均以相同方式进
行比较。未编程输入位或未编程掩码位的默认信号状态为 FALSE。
如果在比较期间找到匹配值，参数 OUT 的信号状态置为“1”。否则将参数 OUT 置为“0”。
如果参数 CMP_STEP 的值大于 15，则不执行该指令。并在参数 ERR_CODE 中输出错误信息。
语法
“比较输入位与掩码位”指令的语法如下所示：
SCL
<实例>.IN_BIT0 - 15 := <操作数>,
CMP_STEP := <操作数>,
OUT => <操作数>,
参数
下表列出了“比较输入位与掩码位”指令的参数：
IN_BIT0 Input BOOL I、Q、M、D、L 比较输入位 0 与掩码位 0。
- 235 -
IMC：比较输入位与掩码位 (S7-1500)

CMP_STEP Input BYTE 用于比较的掩码步号。
P
信号状态“1”表示已找到一个匹配值。
OUT Output BOOL I、Q、M、D、L
信号状态“0”表示未找到匹配值。
ERR_COD I、Q、M、D、L、
Output WORD 错误信息
E P
比较掩码 [0 到 15，0 到 15]：下标的
ARRAY OF
CMP_VAL Static I、Q、M、D、L 第一个编号为步号，第二个编号为掩
WORD
码的位号。
ERR_CODE 参数
(W#16#...)
0000 无错误
000A 参数 CMP_STEP 的值大于 15。
请参见”。
- 236 -
SMC：比较扫描矩阵 (S7-1500)
SMC：比较扫描矩阵
说明
“比较扫描矩阵”指令可将最多 16 个已编程输入位（IN_BIT0 到 IN_BIT15）的信号状态与各步比较掩码
的相应位进行比较。处理从步 1 开始并继续，直到最后一个编程步 (LAST) 或直到找到匹配值。将参
数 IN_BIT0 的输入位将与掩码 CMP_VAL[x,0] 的值相比较，其中“x”代表步号。所有编程值均以相同方
式进行比较。如果找到匹配值，则将参数 OUT 的信号状态设置为“1”，并将匹配掩码的步号写入参数
OUT_STEP。未编程输入位或未编程掩码位的默认信号状态为 FALSE。如果多个步具有匹配掩码，则
参数 OUT_STEP 仅指示找到的第一个步。如果没有找到匹配值，则将参数 OUT 的信号状态置为“0”。
在这种情况下，参数 OUT_STEP 的值比参数 LAST 的值大“1”。
语法
“比较扫描矩阵”指令的语法如下所示：
SCL
<实例>.IN_BIT0 - 15 := <操作数>,
OUT => <操作数>,
OUT_STEP => <操作数>,
语法
下表列出了“比较扫描矩阵”指令的参数：
- 237 -
SMC：比较扫描矩阵 (S7-1500)

信号状态“1”表示已找到一个匹配值。
OUT Output BOOL I、Q、M、D、L
信号状态“0”表示未找到匹配值。
包含具有匹配掩码的步号，如果未找
OUT_STEP Output BYTE 到相匹配的掩码，则是比参数 LAST
P
的值大“1”的步号。
ERR_COD I、Q、M、D、L、
Output WORD 错误信息
E P
I、Q、M、D、L、指定为获得匹配掩码而将扫描的最后
LAST Static BYTE
P 一步的步号。
比较掩码 [0 到 15，0 到 15]：下标的
ARRAY OF
CMP_VAL Static I、Q、M、D、L 第一个编号为步号，第二个编号为掩
WORD
码的位号。
ERR_CODE 参数
(W#16#...)
0000 无错误
000E 参数 LAST 的值大于 15。
请参见”。
- 238 -
LEAD_LAG：提前和滞后算法 (S7-1500)
LEAD_LAG：提前和滞后算法
说明
“提前和滞后算法”指令用于通过模拟量变量处理信号。 GAIN 参数的增益值必须大于零。使用以下等式
计算“提前和滞后算法”指令的结果：
仅当在固定的程序周期中运行指令“提前和滞后算法”时，才生成正确的结果。参数 LD_TIME、LG_TIME
和 SAMPLE_T 中必须指定相同的运算单元。计算 LG_TIME > 4 + SAMPLE_T 时，该指令与以下函数
类似：
OUT = GAIN * ((1 + LD_TIME * s) / (1 + LG_TIME * s)) * IN
当参数 GAIN 的值小于或等于零时，将不进行计算，并在参数 ERR_CODE 中输出错误信息。
“提前和滞后算法”指令可与回路一起用作动态前馈控制中的补偿器。该指令由两项操作组成。 “Lead”操
作将输出 OUT 的相位进行移位，使得输出提前于输入。相反，“Lag”操作对输出进行移位，使得输出滞
后于输入。由于“Lag”操作相当于积分，因此可用作噪声抑制器或低通滤波器。 “Lead”操作相当于微分，
因此可用作高通滤波器。同时使用两个指令（“Lead”和“Lag”），将导致在较低频率时输出的相位滞后于
输入，而在较高频率时输出的相位提前于输入。这意味着“提前和滞后算法”指令可用作带通滤波器。
语法
“提前和滞后算法”指令的语法如下所示：
SCL
<实例>(IN:= <操作数>,
SAMPLE_T := <操作数>,
OUT => <操作数>,
下表列出了该指令的参数：
待处理的当前采样
时间（周期）输入
IN Input REAL I、Q、M、D、L、P 值。
IN 参数中也可以指
定常数。
SAMPLE_T Input INT I、Q、M、D、L、P 采样时间
- 239 -
SAMPLE_T 参数中
也可以指定常数。
OUT Output REAL I、Q、M、D、L 指令的结果
ERR_CODE Output WORD I、Q、M、D、L 错误信息
提前时间的单位与
LD_TIME Static REAL I、Q、M、D、L、P
采样时间的相同。
滞后时间的时间单
LG_TIME Static REAL I、Q、M、D、L、P 位与与采样时间的
相同
%/% 的增益（稳态
GAIN Static REAL I、Q、M、D、L、P 下输出变化与输入
变化的比率）。
PREV_IN Static REAL I、Q、M、D、L、P 上一次输入
PREV_OUT Static REAL I、Q、M、D、L、P 上一次输出
ERR_CODE 参数
(W#16#...)
0000 无错误
0009 参数 GAIN 的值小于或等于 0。
请参见”。
示例
说明
SCL
"LEAD_LAG_DB"(IN := "Tag_Input",
SAMPLE_T := "Tag_Input_SAMPLE_T",
OUT => "Tag_Output_Result",
ERR_CODE => "Tag_ErrorCode");
执行前
在本例中，输入参数使用以下值：
- 240 -
参数操作数值
IN Tag_Input 2.0
SAMPLE_T Tag_Input_SAMPLE_T 10
以下各值保存在该指令的背景数据块“LEAD_LAG_DB”中：
参数地址值
LD_TIME DBD12 2.0
LG_TIME DBD16 2.0
GAIN DBD20 1.0
PREV_IN DBD24 6.0
PREV_OUT DBD28 6.0
执行后
参数操作数值
OUT Tag_Output_Result 2.0
以下各值保存在该指令的背景数据块“LEAD_LAD_DB”中：
参数操作数值
PREV_IN DBD24 2.0
PREV_OUT DBD28 2.0
- 241 -
SEG：创建 7 段显示的位模式 (S7-1500)
SEG：创建 7 段显示的位模式
说明
“创建 7 段显示的位模式”指令用于将所指定源字 (IN) 的四个十六进制数都转换为 7 段显示的等价位模
式。指令的结果在参数 OUT 中以双字形式输出。
十六进制数字和 7 段（a、b、c、d、e、f、g）分配存在以下关系：
输入数字段分配显示
7 段显示
（二进制） ‑gfedcba （十六进制）
0000 00111111 0
0001 00000110 1
0010 01011011 2
0011 01001111 3
0100 01100110 4
0101 01101101 5
0110 01111101 6
0111 00000111 7
1000 01111111 8
1001 01100111 9
1010 01110111 A
1011 01111100 B
1100 00111001 C
1101 01011110 D
1110 01111001 E
1111 01110001 F
语法
“创建 7 段显示的位模式”指令的语法如下所示：
SCL
SEG(IN := <操作数>,
OUT => <操作数>)
参数
下表列出了“创建 7 段显示的位模式”指令的参数：
- 242 -
SEG：创建 7 段显示的位模式 (S7-1500)
以四个十六进制数
IN Input WORD I、Q、M、D、L、P
字表示的源字
OUT Output DWORD I、Q、M、D、L、P 7 段显示的位模式
函数值 VOID 函数值为空
示例
SCL
SEG(IN := "Tag_Input",
OUT => "Tag_Output");
参数操作数值
十六进制二进制
IN Tag_Input W#16#1234 0001 0010 0011 0100
00000110 01011011 01001111
OUT Tag_Output DW16#065B4F66 01100110
显示： 1234
- 243 -
BCDCPL：求十进制补码 (S7-1500)
BCDCPL：求十进制补码
说明
“求十进制补码”指令用于计算操作数中所指定 7 位 BCD 数的十进制补码。该指令使用以下数学公式进
行计算：
10000000（BCD 编码）
– 7 位 BCD 值
----------------------------------------
十进制补码（BCD 编码）
语法
“求十进制补码”指令的语法如下所示：
SCL
BCDCPL(<操作数>)
参数
下表列出了“求十进制补码”指令的参数：
<操作数> Input 位字符串 I、Q、M、D、L、P 7 位 BCD 数
函数值 DWORD I、Q、M、D、L、P 指令的结果
示例
SCL
"Tag_Result" := BCDCPL("Tag_Input");
下表使用具体的值说明了该指令的工作方式：
操作数值*
Tag_Input DW#16#01234567
Tag_Result DW#16#08765433
请参见”。
- 244 -
BITSUM：统计置位位数量 (S7-1500)
BITSUM：统计置位位数量
说明
可以使用“统计置位位数量”指令统计信号状态被置位为“1”的操作数的位数。
语法
“统计置位位数量”指令的语法如下所示：
SCL
BITSUM(<操作数>)
参数
下表列出了“统计置位位数量”指令的参数：
要统计其置位位数
<操作数> Input DWORD I、Q、M、D、L、P
量的操作数
函数值 INT I、Q、M、D、L、P 指令的结果
示例
SCL
"Tag_Result" := BITSUM("Tag_Input");
下表使用具体的值说明了该指令的工作方式：
操作数值*
Tag_Input DW#16#12345678
Tag_Result W#16#000D（13 位）
请参见”。
- 245 -

西门子S7-1200 SCL编程指令手册

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

西门子S7-1200 SCL编程指令手册

Uploaded by

Copyright:

Available Formats

SCL (S7-1200, S7-1500)

每次调用“生成脉冲”指令，都会为其分配一个 IEC 定时器用于存储指令数据。

在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 定时器将存储在自身数

每次调用“接通延时”指令，必须将其分配给存储指令数据的 IEC 定时器。

在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 定时器将存储在自身数

每次调用“关断延时”指令，必须将其分配给存储指令数据的 IEC 定时器。

• 声明为块中“Static”程序段内类型为 TOF_TIME 的局部变量（例如，#MyTOF_TIMER）

• 声明为块中“Static”部分的 TOF_TIME 或 TOF_LTIME 类型的局部变量（例如，#MyTOF_TIMER）

在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 定时器将存储在自身数

IF "TON_DB".ET < T#25s THEN

可以将在程序中声明的 IEC 定时器赋给“加载持续时间”指令。

IF "TON_DB".ET < T#10s AND #preset = true THEN

以下给出了如何构造时间单元的一个示例： 另请参见“L： 加载定时器值”。

以下给出了如何构造时间单元的一个示例： 另请参见“L： 加载定时器值”。

以下给出了如何构造时间单元的一个示例： 另请参见“L： 加载定时器值”。

以下给出了如何构造时间单元的一个示例： 另请参见“L： 加载定时器值”。

以下给出了如何构造时间单元的一个示例： 另请参见“L： 加载定时器值”。

每次调用“加计数”指令，都会为其分配一个 IEC 计数器用于存储指令数据。 IEC 计数器是一种具有以下

系统数据类型 IEC_<Counter> 的数据块（共享 局部变量

系统数据类型 IEC_<Counter> 的数据块（共享 局部变量

可以按如下方式声明 IEC 计数器：

在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 计数器将存储在自身数

如果在函数块中使用“优化的块访问”(optimized block access) 设置 IEC 计数器作为本地变量（多重背

系统数据类型为 IEC_counter 的数据块（全局 DB）

每次调用“减计数”指令，都会为其分配一个 IEC 计数器用于存储指令数据。 IEC 计数器是一种具有以下

系统数据类型 IEC_<Counter> 的数据块（共享 局部变量

系统数据类型 IEC_<Counter> 的数据块（共享 局部变量

可以按如下方式声明 IEC 计数器：

• 声明为块中“Static”部分的 CTD_<Data type> 类型的局部变量（例如 #MyCTD_COUNTER）

在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 计数器将存储在自身数

如果在函数块中使用“优化的块访问”(optimized block access) 设置 IEC 计数器作为本地变量（多重背

系统数据类型为 IEC_counter 的数据块（全局 DB）

每次调用“加减计数”指令，都会为其分配一个 IEC 计数器用来存储指令数据。 IEC 计数器是一种具有以

系统数据类型 IEC_<Counter> 的数据块（共享 局部变量

系统数据类型 IEC_<Counter> 的数据块（共享 局部变量

可以按如下方式声明 IEC 计数器：

• 声明为块中“Static”部分的 CTUD_<Data type> 类型的局部变量（例如 #MyCTUD_COUNTER）

在程序中插入该指令时，将打开“调用选项”(Call options) 对话框，可以指定 IEC 计数器将存储在自身数

系统数据类型为 IEC_counter 的数据块（全局 DB）

Q Output BOOL I、Q、M、D、L 计数器状态

TypeOf：检查 VARIANT 变量的数据类型

TypeOfElements：检查 VARIANT 变量的 ARRAY 元素的数据

#Tag_RetVal := Deserialize(SRC_ARRAY := "Buf-

IF #Label = 'arti' THEN

PLC 数据类型的名称 名称 数据类型

#Tag_RetVal := Serialize(SRC_VARIABLE := #Label,

#Tag_RetVal := Serialize(SRC_VARIABLE := "Source".Ar-

PLC 数据类型的名称 名称 数据类型

如果参数 DEST 或参数 AR‐

8482 参数 DEST_INDEX 的值超出了 VARIANT 的限值。

如果满足以下条件，则输出 OUT 的值无效：

可以使用“不可中断的存储区移动”指令移动最多 16 KB 大小的数据。 注意：CPU 对此有特定限制。

如果满足以下条件，则输出 OUT 的值无效：

可以使用“不可中断的存储区移动”指令移动最多 16 KB 大小的数据。 注意：CPU 对此有特定限制。

8282 INDEX 参数的值超出 ARRAY 的上限。

8282 INDEX 参数的值超出 ARRAY 的上限。

ERROR Output INT I、Q、M、D、L 如果指令执行期间出错，则在

ERROR Output INT I、Q、M、D、L 如果指令执行期间出错，则在

BYTEOFF‐ I、Q、M、D、 待写入的地址

如果要将存储位写入输入、输出或位存储区，则必须将参数 DBNUMBER 的值设置为“0”，否则指令将

DBNUM‐ DINT, 如果 AREA = DB，则为目的存储区

VariantGet：读出 VARIANT 变量值

VariantPut：写入 VARIANT 变量值

CountOfElements：获取 ARRAY 元素的数量

以下给出了如何构造时间单元的一个示例：另请参见“L：加载定时器值”。

以下给出了如何构造时间单元的一个示例：另请参见“L：加载定时器值”。

以下给出了如何构造时间单元的一个示例：另请参见“L：加载定时器值”。

以下给出了如何构造时间单元的一个示例：另请参见“L：加载定时器值”。

以下给出了如何构造时间单元的一个示例：另请参见“L：加载定时器值”。

系统数据类型 IEC_<Counter> 的数据块（共享局部变量

系统数据类型 IEC_<Counter> 的数据块（共享局部变量

系统数据类型 IEC_<Counter> 的数据块（共享局部变量

系统数据类型 IEC_<Counter> 的数据块（共享局部变量

系统数据类型 IEC_<Counter> 的数据块（共享局部变量

系统数据类型 IEC_<Counter> 的数据块（共享局部变量

PLC 数据类型的名称名称数据类型

PLC 数据类型的名称名称数据类型

可以使用“不可中断的存储区移动”指令移动最多 16 KB 大小的数据。注意：CPU 对此有特定限制。

可以使用“不可中断的存储区移动”指令移动最多 16 KB 大小的数据。注意：CPU 对此有特定限制。

BYTEOFF‐ I、Q、M、D、待写入的地址

示例：使用存储器字 MW14 到 MW20 中的内容预设置 MW100 到 MW118 中的内容。

在 IF 指令内可以嵌套任意多个 ELSIF 和 THEN 组合。可以选择对 ELSE 分支进行编程。

• F_PWD_ON = "0"：不允许

2529 9513 写入错误：数据对齐

如果存在错误信息，则只能设置“获取本地错误 ID”指令的输出。即使不满足其中的某个条件，剩余的程

2522 9506 读取错误：操作数超出有效范围