瓦良格功能块开发预备知识

数据类型介绍:

为了方便开发，瓦良格功能块包含许多数据类型，数据类型明细如下： INT UINT DINT LINT SINT UDINT USINT ULINT UINT WORD DWORD LWORD REAL LREAL TIME BYTE STRING WSTRING BOOL 下面将逐个介绍各个数据类型的的意义。

1,INT 整型：

数据类型 INT（整数）是编程中常用的一种数据类型，用于表示整数值。INT（整数）类型使用补码（Two's Complement）表示法来表示正负数。具体来说，INT类型的最高位（即最左边的一位）用于表示正负，0 表示正数，1 表示负数。 例如，在32位的INT类型中，第31位（从0开始计数）是符号位。其余的31位用于表示数值的大小。以下是一些关于INT数据类型的其他关键点：

1. 范围：INT类型的范围取决于具体的编程语言和系统架构。例如，在许多编程语言中，标准的32位INT类型可以表示从 -2,147,483,648 到 2,147,483,647 之间的整数。
2. 存储：INT类型通常占用4个字节（32位）的存储空间
3. 用途：INT类型广泛用于需要整数值的场景，如计数、索引、循环控制等。
4. 操作：可以对INT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。
5. 溢出：由于INT类型的范围有限，当计算结果超出其表示范围时会发生溢出，导致结果不正确。因此，在编程时需要注意防止溢出。

2,UINT 无符号整型：

1. 范围：UINT类型的范围从0开始，最大值取决于具体的位数。例如，32位的UINT类型可以表示从0到4,294,967,295之间的整数。
2. 存储：UINT类型通常占用4个字节（32位）的存储空间，但也有其他变种，如短无符号整型（unsigned short int）和长无符号整型（unsigned long int），它们占用的存储空间可能不同。
3. 用途：UINT类型广泛用于需要非负整数值的场景，如计数、内存地址、位掩码等。
4. 操作：可以对UINT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。
5. 溢出：由于UINT类型的范围有限，当计算结果超出其表示范围时会发生溢出，导致结果不正确。因此，在编程时需要注意防止溢出。

3,DINT 双整型：

1. 范围：DINT类型的范围从-2,147,483,648到2,147,483,647。
2. 存储：DINT类型占用4个字节（32位）的存储空间。
3. 符号位：DINT类型使用补码（Two's Complement）表示法，最高位（第31位）用于表示正负，0表示正数，1表示负数。
4. 用途：DINT类型广泛用于需要较大整数值的场景，如计数器、定时器、数学运算等。
5. 操作：可以对DINT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等

4,LINT 长整型：

范围：LINT类型的范围从-9,223,372,036,854,775,808到9,223,372,036,854,775,807 存储：LINT类型占用8个字节（64位）的存储空间。 符号位：LINT类型使用补码（Two's Complement）表示法，最高位（第63位）用于表示正负，0表示正数，1表示负数。 用途：LINT类型广泛用于需要非常大整数值的场景，如高精度计数、时间戳、大数据计算等。 操作：可以对LINT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。

5,SINT 短整型：

范围：SINT类型的范围从即从-128到127。 存储：SINT类型占用1个字节（8位）的存储空间。 符号位：SINT类型使用补码（Two's Complement）表示法，最高位（第7位）用于表示正负，0表示正数，1表示负数。 用途：SINT类型广泛用于需要较小整数值的场景，如简单计数、状态标志、低级别硬件控制等。 操作：可以对SINT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。

6,UDINT

范围：UDINT类型的范围从从0到4,294,967,295。 存储：UDINT类型占用4个字节（32位）的存储空间。 符号位：由于是无符号整数，UDINT类型不使用符号位，所有位都用于表示数值。 用途：UDINT类型广泛用于需要较大正整数值的场景，如计数器、时间戳、内存地址、大数据计算等。 操作：可以对UDINT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。

7,USINT

范围：USINT类型的范围从0到255。 存储：USINT类型占用1个字节（8位）的存储空间。 符号位：由于是无符号整数，USINT类型不使用符号位，所有位都用于表示数值。 用途：USINT类型广泛用于需要较小正整数值的场景，如简单计数、状态标志、低级别硬件控制等。 操作：可以对USINT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算

8,ULINT

范围：ULINT类型的范围从0到18,446,744,073,709,551,615。 存储：ULINT类型占用8个字节（64位）的存储空间。 符号位：由于是无符号整数，ULINT类型不使用符号位，所有位都用于表示数值。 用途：ULINT类型广泛用于需要非常大正整数值的场景，如高精度计数、大数据处理、时间戳、内存地址等。 操作：可以对ULINT类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。

9,WORD

范围：WORD类型的范围是从0到65,535。 存储：WORD类型占用2个字节（16位）的存储空间。 符号位：由于是无符号整数，WORD类型不使用符号位，所有位都用于表示数值。 用途：WORD类型广泛用于需要中等范围正整数值的场景，如硬件寄存器、网络协议、图像处理等。 操作：可以对WORD类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。

10,DWORD

范围：DWORD 类型的范围是从 0 到 4,294,967,295。 存储：DWORD 类型占用 4 个字节（32 位）的存储空间。 符号位：由于是无符号整数，DWORD 类型不使用符号位，所有位都用于表示数值。 用途：DWORD 类型广泛用于需要较大范围正整数值的场景，如操作系统中的内存地址、文件大小、计时器等。 操作：可以对 DWORD 类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等。

11,LWORD

范围：LWORD类型的范围是从0到18,446,744,073,709,551,615。 存储：LWORD类型占用8个字节（64位）的存储空间。 符号位：由于是无符号整数，LWORD类型不使用符号位，所有位都用于表示数值。 用途：LWORD类型广泛用于需要非常大范围正整数值的场景，如大数据处理、加密算法、科学计算等。 操作：可以对LWORD类型进行各种数学和逻辑操作，如加减乘除、取模、位运算等

12,REAL

范围：REAL 类型的范围非常广泛，可以表示非常小的数（接近于零）到非常大的数。 存储：REAL 类型通常占用 4 个字节（32 位）的存储空间，但具体大小可能因编程语言和实现而异。 精度：REAL 类型可以表示小数部分，因此适用于需要精确表示小数的场景，如科学计算、工程计算等。 用途：REAL 类型广泛用于需要表示非整数值的场景，如物理模拟、金融计算、图形处理等。 操作：可以对 REAL 类型进行各种数学操作，如加减乘除、取模、幂运算等。

13.LREAL

范围：LREAL类型的范围非常广泛，可以表示非常小的数（接近于零）到非常大的数。 存储：LREAL类型占用8个字节（64位）的存储空间。 精度：LREAL类型可以表示小数部分，因此适用于需要高精度表示小数的场景，如科学计算、工程计算等。 用途：LREAL类型广泛用于需要表示非整数值且要求高精度的场景，如物理模拟、金融计算、图形处理等。 操作：可以对LREAL类型进行各种数学操作，如加减乘除、取模、幂运算等。

14,TIME

范围：TIME 类型的值范围从 -838:59:59 到 838:59:59，可以表示超过24小时的时间间隔。 存储：TIME 类型占用 3 个字节的存储空间，如果包含小数秒部分，则根据小数秒精度的位数需要额外的字节。 精度：TIME 类型可以包含小数秒部分，精度最高可达微秒（6位小数）。 用途：TIME 类型广泛用于需要表示一天中的具体时间或时间间隔的场景，如数据库中的时间戳、事件调度等。 操作：可以对 TIME 类型进行各种时间操作，如加减时间、比较时间、提取小时、分钟、秒等。

15,BYTE

范围：BYTE 类型的值范围是 0 到 255。它表示一个 8 位的无符号整数。 存储：BYTE 类型占用 1 个字节（8 位）的存储空间。 用途：BYTE 类型广泛用于需要存储小整数值的场景，如标志位、颜色值（如 RGB 颜色的每个分量）、字符编码等。 操作：可以对 BYTE 类型进行各种整数操作，如加减乘除、位运算、比较等。

16,STRING

STRING 数据类型的一些关键点： 范围：STRING 类型可以包含任意长度的字符序列，具体长度限制取决于编程语言或数据库系统的实现。 存储：STRING 类型的存储空间取决于字符串的长度和编码方式（如 ASCII、UTF-8 等）。 用途：STRING 类型广泛用于存储和处理文本数据，如姓名、地址、描述性文本等。 操作：可以对 STRING 类型进行各种操作，如连接、截取、查找、替换、比较等。

17,WSTRING

范围：WSTRING 类型可以包含任意长度的宽字符序列，具体长度限制取决于编程语言或数据库系统的实现。 存储：WSTRING 类型的存储空间取决于字符串的长度和编码方式（如 UTF-16、UTF-32 等）。每个宽字符通常占用 2 或 4 个字节。 用途：WSTRING 类型广泛用于存储和处理多字节字符集的文本数据，如国际化应用中的多语言支持。 操作：可以对 WSTRING 类型进行各种操作，如连接、截取、查找、替换、比较

18,WSTRING

范围：WSTRING 类型可以包含任意长度的宽字符序列，具体长度限制取决于编程语言或数据库系统的实现。 存储：WSTRING 类型的存储空间取决于字符串的长度和编码方式（如 UTF-16、UTF-32 等）。每个宽字符通常占用 2 或 4 个字节。 用途：WSTRING 类型广泛用于存储和处理多字节字符集的文本数据，如国际化应用中的多语言支持。 操作：可以对 WSTRING 类型进行各种操作，如连接、截取、查找、替换、比较等。

19,BOOL

范围：BOOL 类型只有两个可能的值：true（真）和 false（假）。 存储：BOOL 类型通常占用 1 个字节的存储空间，但具体实现可能因编程语言和系统而异 用途：BOOL 类型广泛用于条件判断和逻辑运算，如控制程序流程、标志状态等。 操作：可以对 BOOL 类型进行逻辑操作，如与（AND）、或（OR）、非（NOT）等

ANY: 可以是任何数据类型，包括基础类型和复合类型。

ANY_NUM: 可以是任何数值类型，包括：

SINT，INT，DINT，LINT，USINT，UINT，UDINT，ULINT，REAL，LREAL

ANY_INT: 可以是任何整数类型，包括：

BYTE，WORD，DWORD，LWORD，SINT，INT，DINT，LINT，USINT，UINT，UDINT，ULINT

ANY_REAL: 可以是任何实数类型，包括：REAL，LREAL

ANY_BIT: 可以是任何位类型，包括：

BOOL，BYTE，WORD，DWORD，LWORD

ANY_STRING: 可以是任何字符串类型，包括：STRING，WSTRING

ANY_DATE: 可以是任何日期和时间类型，包括：

DATE,TIME

ANY_ELEMENTARY: 可以是任何基本类型，包括：

BOOL,BYTE,WORD,DWORD,LWORD,SINT,INT,DINT,LINT,USINT,UINT,UDINT,ULINT,REAL,LREAL,STRING,WSTRING,DATE,TIME,TIME_OF_DAY,DATE_AND_TIME

ANY_MAGNITUDE: 可以是任何带符号或无符号的数值类型，包括：

SINT,INT,DINT,LINT,USINT,UINT,UDINT,ULINT,REAL,LREAL

ANY_UNSIGNED: 可以是任何无符号整数类型，包括：

BYTE,WORD,DWORD,LWORD,USINT,UINT,UDINT,ULINT

START 启动功能块

用于在PLC程序起始时发送一个初始事件

COLD:发送冷启动事件

WARM:发送热启动事件

STOP:需要时发送停止事件

默认使用时PLC会自动在开机时发送一个冷启动事件

F_ADD_DT_TIME 时间间隔加法功能块

F_ADD_DT_TIME 是时间加法功能块用于向 DATE_AND_TIME 类型的日期和时间

TIME 类型的时间间隔。 详解如下：

REQ: 这是输入事件触发函数块的操作。当这个事件被触发（或接收到信号） 时，功能块将开始执行操作。

IN1: 这是输入参数，需要接收一个DATE_AND_TIME 类型的值。这应该是你要基于的原始日期和时间

IN2：: 这是另一个输入参数，接收一个 TIME 类型的值。这是你要添加到 IN1 的时间间隔。

CNF: 这是一种输出事件。当功能块的操作完成时，它将触发这个事件（或发送一个信号）以表明操作已完成。

OUT：: 这是输出参数，会产生一个新的 DATE_AND_TIME 类型的值，是把 IN2： 的时间间隔添加到 IN1 的日期和时间之后的结果。

因此，简单的说，你可以用这个功能块在一个已经知道的日期时间IN1，基础上添加一个时间间隔IN2，得到一个新的日期时间OUT。IN1 为DATE_AND_TIME 类型，它表示一个绝对的日期和时间，包括年、月、日、小时、分钟、秒和毫秒IN2为TIME 类型，OUT为DATE_AND_TIME 类型， 当 REQ 触发后，将IN1 与IN2相加，

F_ADD_TOD_TIME 时间加法功能块

F_ADD_TOD_TIME 是一天中的时间加法功能块，用于将一个DATE_AND_TIME 类型的时间和一个TIME 类型的时间间隔相加，输出结果也是一个DATE_AND_TIME 类型的时间。这个功能块常常用于计算某个时间点加上某个时间间隔以后的时间。 下面是F_ADD_DT_TIME 功能块各个参数的详细解释：

REQ: 这是一个输入事件，当这个事件被触发时，功能块开始执行计算操作。

IN1: 这是一个TIME_OF_DAY 类型的输入参数，代表一个时间点。

IN2: 这是一个 TIME 类型的输入参数，代表一个时间间隔。

CNF: 这是一个输出事件，当功能块计算完成后，这个事件会被触发，标示计算操作已经完成。

OUT: 这是一个TIME_OF_DAYE 类型的输出参数，它的值是计算操作的结果， 即 IN1 代表的时间点加上

IN2： 代表的时间间隔的时间。

例如，你可以使用这个功能块来计算 3 小时后的DATE_AND_TIME 类型表示）输入到 IN1，将 3 小时（用 TIME 类型表示）输入到 IN2， 然后触发REQ 事件。当 CNF 事件被触发时，OUT 参数的值就是 3 小时后的具体时间。IN1 为TIME_OF_DAY 类型包含小时、分钟、秒和毫秒

具体时间。你需要将当前时间（用

IN2： 为TIME 类型

OUT： 为 TIME_OF_DAY 类型

F_DIVTIME 时间除法功能块

F_DIVTIME"是一个功能块，主要用于将 TIME 类型的时间间隔除以一个数值型参数ANY_NUM。其特定元素的解释如下：

REQ：这是输入事件，当此事件被激发时，功能块开始执行除法运算。IN1：这是一个TIME 类型的输入参数，表示一个时间间隔。

IN2：这是一个 ANY_NUM 类型的输入参数，表示一个数值。

CNF：这是一个输出事件，当功能块完成除法运算后，此事件将被触发，表示计算操作已完成。

OUT：这是一个 TIME 类型的输出参数，表示IN1 除以 IN2： 的运算结果。

所以，用这个功能块可以在一个已知的时间间隔（IN1）基础上，除以一个数值(IN2)， 得到一个新的时间间隔(OUT)。

F_MULTIME 时间乘法功能块

"F_MULTIME" 是一个功能块，用于将时间数乘以一个数值。以下是该功能块每个部分的具体解释：

REQ：这是输入事件，当触发此事件时，该功能块会开始执行相应的乘法运算。IN1 和IN2：这是输入参数，其中 IN1 是时间（TIME）类型，IN2： 是任意数值（ANY_NUM）类型。这两个值将被用于乘法运算。

OUT:这是输出参数，类型为时间 TIME，其值是 IN1 和 IN2： 的乘积。

例如，如果你设置的 IN1 为 2 小时，IN2设置为 3，并触发了REQ 事件，那么该功能块将计算 2 小时乘以 3，结果为 6 小时，然后将这个结果赋值给OUT，之后触发CNF 事件，表示计算已经完成。

F_SUB_DATE_DATE 日期时间差值计算功能块

"F_SUB_DATE_DATE"是一个功能块，其主要功能是计算两个日期之间的时间差。以下是各个参数的详细说明：

REQ：这是输入事件，当该事件被触发时，功能块会开始计算日期之间的时间差。

IN1, IN2：它们是日期类型（DATE）的输入参数，即需要计算时间差的两个日期。

CNF：这是输出事件，一旦计算完成，该事件就会被触发。

OUT：这是时间（TIME）类型的输出参数，其值为 IN1 和 IN2： 之间的时间差。

例如，如果你设置了 IN1 的值为 2024 年 12 月 31 日，IN2： 的值为 2024 年 12 月 1 日，然后触发了 REQ 事件，功能块将计算从 2024 年 12 月 1 日到 2024 年 12 月 31 日的时间差，然后将结果赋值给OUT，并触发CNF 事件以表示计算已完成。

F_SUB_DT_DT 时间差值计算功能块

"F_SUB_DT_DT" 是一个功能块，其主要任务是计算两个日期及时间值之间的差，即间隔时间。以下是各部分的具体解释：

REQ：这是输入事件，当该事件被触发时，功能块开始计算两个日期及时间值之间的差。

IN1和IN2：它们是日期和时间（DATE_AND_TIME）类型的输入参数，这两个值将用于计算时间差。

CNF：这是输出事件，计算完成时，该事件将被触发。

OUT：这是一个时间（TIME）类型的输出参数，其值为 IN1 和 IN2： 之间的时间差。

比如说，如果你将 IN1 设置为 2024 年 05 月 15 日 03:03:39，IN2： 设置为 2024 年 05 月14日 03:03:39，并触发 REQ 事件，那么这个功能块将计算这两个时间点之间的时间差，并将结果保存在 OUT 中，然后触发CNF 事件表明时间差的计算完成。

F_SUB_DT_TIME 时间减法功能块

"F_SUB_DT_TIME"是一个功能块，其主要功能是从一个特定的日期和时间值中减去一个时间值。以下是各个部分的具体解释：

REQ：这是输入事件，当该事件被触发时，功能块开始从日期和时间值中减去时间值。IN1：它是日期和时间（DATE_AND_TIME）类型的输入参数， 表示需要从中减去时间的日期和时间。

IN2：它是时间（TIME）类型的输入参数，表示需要被减去的时间的长度。

CNF：这是输出事件，一旦计算完成，该事件就会被触发。

OUT：这是日期和时间（DATE_AND_TIME）类型的输出参数，其值为 IN1 减去IN2： 后的结果。

例如，如果你将IN1 设置为 2024 年 05 月 15 日 03:05:20，IN2：设置为 1 小时，并触发REQ事件，那么这个功能块将从 2024 年 05 月 15 日 03:05:20 减去 1 小时，然后将结果保存在OUT中，并触发CNF 事件以表示计算已完成。

F_CONCAT_DATE_TOD 时间拼接功能块

"F_CONCAT_DATE_TOD"是一个功能块，主要功能是将日期（DATE）与一天中的时间

（TIME_OF_DAY）拼接成日期与时间（DATE_AND_TIME）。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN1：这是一个日期（DATE）类型的输入参数。

IN2：这是一天中的时间（TIME_OF_DAY）类型的输入参数。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个日期与时间（DATE_AND_TIME）类型的输出参数，表示拼接后的结果。

举例来说，如果你的输入 IN1 是 2024 年 5 月 15 日，输入 IN2： 是早上 5 点 26 分 38秒，然后触发了REQ 事件，那么该功能块将会将日期与一天中的时间拼接起来，结果为 2024 年 5 月 15 日早上 5 点 26 分 38 秒，这个值会被存储在 OUT 参数中，并触发CNF 事件表示操作已完成。这种拼接操作在需要处理与日期和时间相关的问题时非常有用。

F_SUB_TOD_TOD 时间差计算功能块

"F_SUB_TOD_TOD"是一个功能块，用于计算一天中的两个时间点之间的时间差。以下是参数和事件的具体解释：

REQ：这是输入事件，在该事件被触发时，功能块开始执行计算操作。

IN1、IN2：这两个参数都是一天中的时间（TIME_OF_DAY）类型，表示要进行比较的两个时间点。

IN1 是开始时间，

IN2： 是结束时间。

CNF：这是输出事件，当计算完成，这个事件会被触发。

OUT：这是时间（TIME）类型的输出参数，表示 IN1 和 IN2： 之间的时间差。

例如，如果你将IN1 设为上午 10:00，将 IN2： 设为下午 2:00，并触发REQ 事件，那么这个功能块就会计算两个时间点之间的时间差，结果是 4 个小时，然后存入OUT 参数，并触发 CNF 事件表示计算操作已完成。

F_SUB_TOD_TIME 时间减少功能块

"F_SUB_TOD_TIME"是一个功能块，它的主要任务是从一个特定的一天中的时间（TIME_OF_DAY）减去一个时间（TIME）。以下是各部分的具体解释：

REQ：这是输入事件，当该事件被触发时，功能块开始执行计算。

IN1：它是一天中的时间（TIME_OF_DAY）类型的输入参数，表示需要从中减去时间的一天中的时间。

IN2：它是时间（TIME）类型的输入参数，表示需要被减去的时间段。

CNF：这是输出事件，当计算完成时，这个事件会被触发。

OUT：这是一天中的时间（TIME_OF_DAY）类型的输出参数，表示 IN1 减去IN2： 后的结果。

例如，如果你将IN1 设置为 13:30（一天中的 13 小时 30 分钟），IN2： 设置为 1 小时，并触发了REQ 事件，那么这个功能块会从 13:30 减去 1 小时，然后将结果保存在OUT中，并触发 CNF 事件来表示计算已完成。

F_DIV 触发运算功能块

F_DIV，它的作用是执行除法运算。功能块的输入包括：

REQ：这是一个输入事件，当触发时，功能块开始执行除法运算。

IN1 和 IN2：这是两个数值输入，代表除法运算的被除数和除数。功能块的输出包括：

CNF：这是一个输出事件，当除法运算完成后触发。

OUT：这是一个数值输出，代表除法运算的结果。

因此，当REQ 事件被触发时，功能块会将 IN1 除以IN2，然后将结果输出到OUT，并触发 CNF 事件。这是一个非常基础但是在许多情况下都非常有用的功能块，可以用于各种需要进行除法运算的场景。

IN1，IN2,OUT：的参数类型为 ANY_NUM,它支持：INT

UINT：无符号整数类型REAL，实数类型LREAL，长实数类型LINT

ULINT：无符号长整数类型 SINT：短整数类型 USINT：无符号短整数类型 DINT：双整数类型 UDINT：无符号双整数类型

F_EXP 指数计算功能块

F_EXP 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的指数值。这个功能块特别适用于需要进行指数运算的场合。以下是对 F_EXP 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算指数的数值。

OUT：这是一个输出参数，表示计算后的指数运算结果。

F_EXP 功能块通常用于复杂的数学计算，例如在自动化控制系统中，当我们需要根据某个变量的增长率来预测未来的值时，可以使用 F_EXP 来进行计算。它可以帮助提高系统的准确性和效率。

F_EXPT 幂运算功能块

"F_EXPT"是一个功能块，用于进行幂运算，即加权运算。它接受两个实数(ANY_REAL)作为输入参数，然后将第一个参数的值计算为第二个参数的幂，输出的结果也是实数。以下是各个元素的具体解释：

REQ：这是输入事件。当这个事件被触发时，功能块开始执行幂运算。IN1 和IN2：这是两个实数类型的输入参数。

IN1：是底数，

IN2：是指数。

CNF：这是输出事件。当功能块的操作完成时，它会触发这个事件，表示运算已完成。OUT：这是一个实数类型的输出参数，它的值是将 IN1 的值计算为 IN2： 的幂的结果。

简单来说，如果你设置 IN1 为 2，IN2：为 3，然后触发 REQ 事件，该功能块将计算 2 的 3 次幂的结果，结果为 8，然后将 8 赋给 OUT，并触发 CNF 事件以表示计算任务已完成

F_MOD 取模运算功能块

F_MOD是一个功能块，它的作用是执行取模运算。功能块的输入包括：

REQ：这是一个输入事件，当触发时，功能块开始执行取模运算。

IN1：这是一个 ANY_INT 类型的输入，代表被除数。

IN2：这是一个 ANY_INT 类型的输入，代表除数。功能块的输出包括：

CNF：这是一个输出事件，当取模运算完成后触发。

OUT：这是一个 ANY_NUM 类型的输出，代表取模运算的结果。

因此，当REQ 事件被触发时，功能块会将 IN1 的值除以 IN2： 的值，然后将余数输出到OUT，并触发CNF 事件。这是一个在需要进行取模运算的场景中非常有用的功能块。

F_MOVE 数据移动功能块

F_MOVE是一个功能块，它的作用是进行数据移动。功能块的输入包括：

REQ：这是一个输入事件，当触发时，功能块开始执行数据移动操作。

IN：这是一个 ANY 类型的输入，代表需要移动的数据。功能块的输出包括：

CNF：这是一个输入事件，当数据移动操作完成后触发。

OUT：这是一个 ANY 类型的输入，代表移动后的数据。

因此，当REQ 事件被触发时，功能块会将 IN 的数据移动到 OUT，并触发 CNF 事件。这是一个在需要进行数据移动的场景中非常有用的功能块。

F_MUL 乘法运算功能块

F_MUL 是一个功能块，其主要功能是实现两个数的乘法运算。以下是各个参数的详细说明：

REQ：这是输入事件，当该事件被触发时，功能块会开始进行乘法运算

IN1, IN2：它们是两个任意数值类型（ANY_NUM）的输入参数，这两个值将用于进行乘法运算。

CNF：这是输出事件，一旦乘法运算完成，该事件就会被触发。

OUT：这是任意数值类型的输出参数，其值为 IN1 和 IN2： 的乘法运算结果。

例如，如果你设置了 IN1 的值为 4，IN2 的值为 5，然后触发了 REQ 事件，该功能块将计算 4 乘以 5 得到 20，然后将 20 赋值给 OUT，并触发 CNF 事件以表示乘法运算已完成。

F_SUB 减法计算功能块

"F_SUB"是一个功能块，它的主要功能是执行两个数值的减法运算。这是各部分的具体解释：

REQ：这是触发输入事件。当这个事件被触发时，功能块开始执行减法运算。

IN1, IN2：这是两个可以表示任何数量级(ANY_MAGNITUDE)的输入参数。这两个数将被用于减法运算，即 IN1 减去 IN2：。

CNF：这是触发输出事件。一旦减法运算完成，这个事件将被触发。

OUT：这是表示任何数量级（ANY_MAGNITUDE）的输出参数，它的值是 IN1 和 IN2： 的差。

举例来说，如果你设置 IN1 的值为 10，IN2： 的值为 5，然后触发 REQ 事件，那么这个功能块将计算 10 减 5 等于 5，然后将 OUT 的值设置为 5，并触发 CNF 事件以表示减法运算已完成。

F_TRUNC 取整计算功能块

"F_TRUNC" 是一个功能块，用于将任意实数（ANY_REAL）取整。以下是具体的解读： REQ: 这是输入事件，当该事件被触发时，功能块开始执行操作。

IN: 这是任意实数（ANY_REAL）类型的输入参数，表示需要被取整的值。CNF: 这是输出事件，当取整操作完成，这个事件会被触发。

OUT：这是任意整数（ANY_INT）类型的输出参数，表示对输入实数取整后的结果。举个例子，如果你将 IN 设为 5.7，并触发REQ 事件，那么该功能块会将 5.7 取整，结果为 5，存入 OUT参数，并触发CNF 事件表示操作已完成。

为了保证数据的正确性，在使用功能块后必须要接一下INT2INT功能块

F_ABS 绝对值计算功能块

F_ABS 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的绝对值。这个功能块特别适用于需要处理正数和负数数值，但只关注其大小而不关注符号的场合。以下是对 F_ABS 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算绝对值的数值。

OUT：这是一个输出参数，表示计算后的绝对值结果。

F_ABS 功能块通常用于数值处理，例如在控制系统中处理传感器读数的偏差，或者在计算过程中需要忽略符号的情况。它可以帮助简化程序的逻辑并提高数值处理的效率。

F_ACOS 余弦计算功能块

F_ACOS 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的反余弦值。这个功能块特别适用于需要根据已知的余弦值来确定角度的场合。以下是对 F_ACOS 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算反余弦的数值。该值的范围应在 -1 到 1 之间。

OUT：这是一个输出参数，表示计算后的角度值，单位为弧度。

F_ACOS 功能块通常用于三角函数的计算，例如在机器人学或者运动控制中，当我们知道某个向量的方向余弦时，可以使用 F_ACOS 来计算出对应的角度。它可以帮助提高系统的准确性和效率。

F_ASIN 反正弦计算功能块

F_ASIN 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的反正弦值。这个功能块特别适用于需要根据已知的正弦值来确定角度的场合。以下是对 F_ASIN 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算反正弦的数值。该值的范围应在 -1 到 1 之间。

OUT：这是一个输出参数，表示计算后的角度值，单位为弧度。

F_ASIN 功能块通常用于三角函数的计算，例如在机器人学或者运动控制中，当我们知道某个向量的方向正弦时，可以使用 F_ASIN 来计算出对应的角度。它可以帮助提高系统的准确性和效率。

F_ATAN 反正切计算功能块

F_ATAN 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的反正切值。这个功能块特别适用于需要根据已知的正切值来确定角度的场合。以下是对 F_ATAN 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算反正切的数值。

OUT：这是一个输出参数，表示计算后的角度值，单位为弧度。

F_ATAN 功能块通常用于三角函数的计算，例如在机器人学或者运动控制中，当我们知道某个向量在X-Y平面上的斜率时，可以使用 F_ATAN 来计算出对应的角度。它可以帮助提高系统的准确性和效率。

F_LN 自然对数计算功能块

F_LN 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的自然对数。这个功能块特别适用于需要进行对数运算的场合。以下是对 F_LN 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算自然对数的数值。

OUT：这是一个输出参数，表示计算后的自然对数结果。

F_LN 功能块通常用于复杂的数学计算，例如在过程控制或数据分析中，当我们需要根据某个变量的变化率来进行分析时，可以使用 F_LN 来进行计算。它可以帮助提高系统的准确性和效率。

F_LOG 数学对数计算功能块

F_LOG 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的对数值。这个功能块特别适用于需要进行对数运算的场合。以下是对 F_LOG 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算对数的数值。

OUT：这是一个输出参数，表示计算后的对数结果。

F_LOG 功能块通常用于复杂的数学计算，例如在工业自动化或数据处理中，当我们需要根据某个变量的变化来进行分析或预测时，可以使用 F_LOG 来进行计算。它可以帮助提高系统的准确性和效率。

F_SIN 正弦计算功能块

F_SIN 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的正弦值。这个功能块特别适用于需要进行三角函数运算的场合。以下是对 F_SIN 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算正弦的角度值。

OUT：这是一个输出参数，表示计算后的正弦运算结果。

F_SIN 功能块通常用于复杂的数学计算，例如在自动化控制系统中，当我们需要根据角度变化来控制机械运动时，可以使用 F_SIN 来进行计算。它可以帮助提高系统的准确性和效率。

F_COS 余弦计算功能块

F_COS 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的余弦值。这个功能块特别适用于需要根据已知的角度来确定余弦值的场合。以下是对 F_COS 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算余弦的角度值，单位为弧度。

OUT：这是一个输出参数，表示计算后的余弦值。

F_COS 功能块通常用于三角函数的计算，例如在机器人学或者运动控制中，当我们知道某个角度时，可以使用 F_COS 来计算出对应的余弦值。它可以帮助提高系统的准确性和效率。

F_SQRT 平方根计算功能块

F_SQRT 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于计算数值的平方根。这个功能块特别适用于需要进行平方根运算的场合。以下是对 F_SQRT 功能块的详细介绍：

IN：这是一个输入参数，表示需要计算平方根的数值。

OUT：这是一个输出参数，表示计算后的平方根结果。

F_SQRT 功能块通常用于复杂的数学计算，例如在工业自动化或数据处理中，当我们需要根据某个变量的幅度来进行分析或预测时，可以使用 F_SQRT 来进行计算。它可以帮助提高系统的准确性和效率。

F_TAN 正切计算功能块

F_TAN 是一个功能块，用于计算正切值。这个功能块特别适用于需要进行三角函数运算的场合。以下是对 F_TAN 功能块的详细介绍。

IN：这是一个输入参数，表示需要计算正切的角度值。

OUT：这是一个输出参数，表示计算后的正切运算结果。

F_TAN 功能块通常用于复杂的数学计算，例如在自动化控制系统中，当我们需要根据角度变化来控制机械运动时，可以使用 F_TAN 来进行计算。它可以帮助提高系统的准确性和效率。

F_ADD 加法功能块

F_ADD 是一个功能块，用于执行加法运算。它接受两个输入并输出它们的和。以下是它的主要参数：

IN1 和 IN2：两个输入数据，类型为任意数值类型（如整数、浮点数等）。

OUT：输出数据，表示 IN1 和 IN2 的和。

当接收到输入事件时，F_ADD 会将 IN1 和 IN2 相加，并将结果输出到 OUT

F_AND 逻辑与功能块

"F_AND"是一个功能块，用于执行逻辑与（AND）操作。这是每个部分的具体含义： REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN1：这是一个布尔值（ANY_BIT）类型的输入参数，表示需要进行逻辑与操作的第一个值。

IN2：这是一个布尔值（ANY_BIT）类型的输入参数，表示需要进行逻辑与操作的第二个值。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个布尔值（ANY_BIT）类型的输出参数，表示逻辑与操作的结果。

举个例子，假设你设置 IN1 为真TRUE（真和IN2： 为FLASE（假），并触发 REQ 事件，那么该功能块会执行逻辑与操作，结果为FLASE（假），存储在 OUT： 参数中，并触发CNF事件表示操作已完成。这是因为在逻辑与操作中，只有当两个参数都为真时，结果才为真。

F_NOT 非门功能块

"F_NOT"是一个功能块，用于执行逻辑非（NOT）操作。以下是每部分的具体含义： REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN：这是一个布尔值（ANY_BIT）类型的输入参数，表示需要进行逻辑非操作的值。CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个布尔值（ANY_BIT）类型的输出参数，表示逻辑非操作的结果。

举个例子，假设你设置 IN 为真TRUE（真并且触发了 REQ 事件，那么这个功能块将执行逻辑非操作，结果为FLASE（假），存储在 OUT 参数中，并且触发CNF 事件表示操作已完成。这是因为在逻辑非操作中，输入为真的结果是假，输入为假的结果是真。

F_OR与或操作功能块

"F_OR"是一个功能块，用于执行逻辑或（OR）操作。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN1：这是一个任意位（ANY_BIT）类型的输入参数，表示进行逻辑或操作的第一个值。

IN2：这是一个任意位（ANY_BIT）类型的输入参数，表示进行逻辑或操作的第二个值。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个任意位（ANY_BIT）类型的输出参数，表示逻辑或操作的结果。

例如，如果你将IN1 设为真TRUE（真，IN2： 设为FLASE（假），并触发了 REQ 事件，那么该功能块将执行逻辑或操作，结果为真TRUE真，存储在 OUT 参数中，并触发CNF事件表示操作已完成。这是因为在逻辑或操作中，只要有一个输入参数为真，结果就是真。

F_XOR 异或功能块

"F_XOR"是一个功能块，用于执行异或（XOR）操作。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN1：这是第一个任意位（ANY_BIT）类型的输入参数。

IN2：这是第二个任意位（ANY_BIT）类型的输入参数。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个任意位（ANY_BIT）类型的输出参数，表示异或操作的结果。

异或操作是一种基础的二进制运算，其规则是相同为 0，不同为 1。举例来说，如果你的输入 IN1 是 1010，输入 IN2： 是 0110，然后触发了 REQ 事件，那么该功能块将会执行异或操作，结果为 1100，这个值会被存储在 OUT 参数中，并触发CNF 事件表示操作已完成。此类操作常见于一些数据交换、错误检测和密码学中。

F_ROL 左旋操作功能块

"F_ROL"是一个功能块，用于执行逻辑左旋（ROL）操作。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN：这是一个任意位（ANY_BIT）类型的输入参数，表示需要进行逻辑左旋操作的值。N：这是一个任意整数（ANY_INT）类型的输入参数，表示旋转的数量。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个任意位（ANY_BIT）类型的输出参数，表示逻辑左旋操作的结果。

例如，如果你的输入是二进制的 101011，N 为 2，然后触发了REQ 事件，那么该功能块将会将位值向左移动两位，结果为 101110，存储在 OUT： 参数中，并触发CNF 事件表示操作已完成。如果左旋移位导致某些位值超了范围，那么这些位值将从右侧回绕过来。在此例子中，从左侧移的两位数字 01 将从右侧回绕到输入值的开始，形成最终的 101110。这种操作经常现在加密和数据压缩算法中。

F_ROR 右旋操作功能块

"F_ROR"是一个功能块，用于执行逻辑右旋（ROR）操作。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN：这是一个任意位（ANY_BIT）类型的输入参数，表示需要进行逻辑右旋操作的值。N这是一个任意整数（ANY_INT）类型的输入参数，表示旋转的数量。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个任意位（ANY_BIT）类型的输出参数，表示逻辑右旋操作的结果。

例如，如果你的输入是二进制的 101011，N 为 2，然后触发了REQ 事件，那么该功能块将会将位值向右移动两位，结果为 111010，存储在 OUT： 参数中，并触发CNF 事件表示操作已完成。如果右旋移位导致某些位值超了范围，那么这些位值将从左侧回绕过来。在此例子中，从右侧移的两位数字 11 将从左侧回绕到输入值的开始，形成最终的 111010。这种操作经常用于加密和数据压缩算法中。

F_SHR 逻辑左移功能块

"F_SHR"是一个功能块，用于执行逻辑右移（SHR）操作。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN：这是一个任意位（ANY_BIT）类型的输入参数，表示需要进行逻辑右移操作的值。N：这是一个任意整数（ANY_INT）类型的输入参数，表示移位的数量。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个任意位（ANY_BIT）类型的输出参数，表示逻辑右移操作的结果。

例如，如果你的输入是二进制的 101011，N 为 2，然后触发了REQ 事件，那么该功能块将会将位值向右移动两位，结果为 001010，存储在 OUT： 参数中，并触发CNF 事件表示操作已完成。如果右移操作导致某些位值超了范围，那么这些位值将被丢弃， 右侧位置将被填充为 0。在此例子中，从右侧移的两位数字 11 将被丢弃，右侧将被添加两个 0，形成最终的 001010。这种操作经常被用于数值倍增或减半等计算中。

F_SHL 逻辑左移功能块

"F_SHL" 是一个功能块，用于执行逻辑左移（SHL）操作。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN：这是一个任意位（ANY_BIT）类型的输入参数，表示需要进行逻辑左移操作的值。N：这是一个任意整数（ANY_INT）类型的输入参数，表示移位的数量。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个任意位（ANY_BIT）类型的输出参数，表示逻辑左移操作的结果。

例如，如果你的输入是二进制的 101011，N 为 2，然后触发了REQ 事件，那么该功能块将会将位值向左移动两位，结果为 101100，存储在 OUT： 参数中，并触发CNF 事件表示操作已完成。如果左移操作导致某些位值超了范围，那么这些位值将被丢弃， 而左侧位置将被填充为 0。在此例子中，从左侧移的两位数字 10 将被丢弃，左侧将被添加两个 0，形成最终的 101100。这种操作经常被用于数值倍增或减半等计算中。

F_CONCAT 字符串拼接功能块

"F_CONCAT"是一个功能块，用于将两个字符串进行拼接。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始执行操作。

IN1：这是第一个字符串（ANY_STRING）类型的输入参数。

IN2：这是第二个字符串（ANY_STRING）类型的输入参数。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个字符串（ANY_STRING）类型的输出参数，表示拼接后的结果。

举例来说，如果你的输入 IN1 是"Hello "，输入 IN2 是"World"，然后触发了 REQ 事件，那么该功能块将会拼接两个字符串，结果为"Hello World"，这个值会被存储在OUT参数中，并触发 CNF 事件表示操作已完成。

F_DELETE 字符串删除功能块

"F_DELETE"是一个功能块，主要用于删除字符串中的一部分内容。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始进行操作。

IN：这是一个字符串（ANY_STRING）类型的输入参数，即需要进行操作的原始字符串。

L：这是一个整数（ANY_INT）类型的输入参数，表示从字符串的哪个位置开始删除。

P：这是一个整数（ANY_INT）类型的输入参数，表示删除的字符数量。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个字符串（ANY_STRING）类型的输出参数，表示操作完成后的结果字符串。

举个例子，如果你的输入 IN 是"Hello World"，输入L 为 7，输入 P 为 5，然后触发了REQ 事件，那么该功能块将会执行删除操作，结果为"Hello "，这个值会被存储在OUT参数中，并触发CNF 事件表示操作已完成。

F_FIND 字符串查找功能块

"F_FIND"是一个功能块，主要用于在一个字符串（IN1）中找到另一个字符串（IN2：）的位置。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始进行操作。

IN1：这是一个字符串（ANY_STRING）类型的输入参数，即需要进行搜索的原始字符串。

IN2：这是一个字符串（ANY_STRING）类型的输入参数，表示需要搜索的目标字符或字符串。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个整数（ANY_INT）类型的输出参数，表示目标字符串在原始字符串中的位置，如果未找到则返回-1。

例如，如果你的输入 IN1 为"Hello World"，输入 IN2： 为"World"，然后触发了 REQ 事件，那么该功能块将在原始字符串中搜索目标字符串，找到后返回目标字符串的位置，结果为 6，这个值会被存储在

OUT 参数中，并触发CNF 事件表示操作已完成。如果搜索的目标字符串在原始字符串中未找到，结果将会是-1。

F_INSERT 字符串插入功能块

"F_INSERT"是一个功能块，主要用于在指定位置插入一段文本到原始字符串中。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始进行操作。

IN1：这是一个字符串（ANY_STRING）类型的输入参数，即需要进行操作的原始字符串。

IN2：这是一个字符串（ANY_STRING）类型的输入参数，表示需要插入的字符串。

P：这是一个整数类型（ANY_INT）的输入参数，标识在原始字符串的哪个位置插入字符串。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个字符串（ANY_STRING)类型的输出参数，表示操作完成后的结果字符串。

举个例子，如果你的输入 IN1 为"Hello ", 输入IN2： 为"World", 输入 P 为 6，并触发了REQ 事件，那么该功能块将会在原始字符串第 6 个位置插入"World", 结果为"Hello World"，这个值会被存储在 OUT 参数中，并触发CNF 事件表示操作已完成。

F_LEFT 左取字符功能块

"F_LEFT"是一个功能块，主要用于获取字符串从左边开始的特定长度的子串。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始进行操作。

IN：这是一个字符串（ANY_STRING）类型的输入参数，表示需要进行操作的原始字符串。

L：这是一个整数（ANY_INT）类型的输入参数，表示从左开始需要获取的字符数量。CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个字符串（ANY_STRING）类型的输出参数，表示操作完成后的结果字符串。

例如，如果你的输入 IN 是"Hello World"，输入L 为 5，然后触发了REQ 事件，那么该功能块将会执行获取子串的操作，从左往右获取5个字符结果为"Hello"，这个值会被存储在 OUT 参数中，并触发CNF 事件表示操作已完成。

F_LEN 字符串长度计算功能块

"F_LEN"是一个功能块，主要用于计算输入的字符串（IN）的长度。以下是每个部分的具体含义：

REQ：输入事件，当该事件被触发时，功能块开始运行。

IN：此为字符串（ANY_STRING）类型的输入参数，表示要计算长度的原始字符串。

CNF：输出事件，当计算完成并有一个结果可以输出时，会触发此事件。

OUT：此为整数（ANY_INT）类型的输出参数，表示计算后的字符串长度。

例如，如果你的输入 IN 是"Hello World"并且触发了REQ 事件，那么该功能块将会计算并返回字符串的长度，结果为 11，这个值会被存入 OUT 参数，并且会触发CNF 事件表示计算操作已完成。

F_MID 指定位置取字符串功能块

"F_MID"是一个功能块，主要用于获取字符串中从指定位置开始的特定长度的子串。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始进行操作。

IN：这是一个字符串（ANY_STRING）类型的输入参数，表示需要进行操作的原始字符串。

L：这是一个整数（ANY_INT）类型的输入参数，表示从特定位置开始需要获取的字符

数量。

P：这是一个整数（ANY_INT）类型的输入参数，标识了在原始字符串中开始获取子串的位置。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个字符串（ANY_STRING）类型的输出参数，表示操作完成后的结果字符串。

例如，如果你的输入为 IN= "Hello World", L= 5, P= 7，并触发了 REQ 事件，那么该功能块将会从第 7 个字符开始获取长度为 5 的子串，结果为 "World"。这个结果将会被存储在 OUT 参数中，并会触发 CNF 事件表示操作已完成。

F_REPLACE 字符串替换功能块

"F_REPLACE"是一个功能块，主要用于将输入字符串（IN1）中从指定位置（P）开始的指定长度（L）的子字符串替换为另一个字符串（IN2：）。这是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始运行。

IN1：这是一个字符串（ANY_STRING）的输入参数，表示需要操作的原始字符串。

IN2：这是一个字符串（ANY_STRING）的输入参数，表示要用来替换的字符串。

L：这是一个整数（ANY_INT）的输入参数，表示在原始字符串中要被替换的子字符串的长度。

P：这是一个整数（ANY_INT）的输入参数，表示在原始字符串中开始替换操作的位置。

CNF：这是输出事件，当操作完成时，会触发这个事件。

OUT：这是一个字符串（ANY_STRING）的输出参数，它存储了替换操作后得到的新字符串。

例如，如果你的输入是 IN1= "Hello World", IN2：= "Everyone", L= 5, P= 7，并且触发了REQ 事件，那么功能块将会在原始字符串的第 7 个字符开始，替换长度为 5 的子串为"Everyone"，替换后的结果是 "Hello Everyone"。这个结果会被存储在 OUT： 参数中，并且会触发CNF 事件表示操作已完成。

F_RIGHT 右取字符功能块

"F_RIGHT"是一个功能块，主要用来从字符串（IN）的右侧获取指定长度（L）的字符。这是每部分的具体含义：

REQ：输入事件，当该事件被触发时，功能块开始运行。

IN：这是一个字符串类型（ANY_STRING）的输入参数，代表要操作的原始字符串。L：这是一个整数类型（ANY_INT）的输入参数，代表从字符串右侧开始需要获取的字符数量。

CNF：输出事件，当操作完成并产生结果时，该事件会被触发。

OUT：这是一个字符串类型（ANY_STRING）的输出参数，代表操作完成后得到的结果。

举个例子，如果你的输入参数是 IN="Hello World", L=5 并且触发了 REQ 事件。那么该功能块会从原始字符串的右侧开始，获取长度为 5 的字符。这个结果 "World" 会被存储在 OUT： 参数中，并且触发 CNF 事件，表示操作已完成。

F_EQ 等于运算功能块

"F_EQ"是一个功能块，主要用于比较两个基本元素（ANY_ELEMENTARY）是否相等。以下是每个部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始进行操作。

IN1、IN2：这是需要比较的两个基本元素，可以是数字、字符串或布尔值等。

CNF：这是输出事件，当操作完成时，该事件会被触发。

OUT：这是一个布尔值（BOOL），表示比较的结果。如果 IN1 和IN2： 相等，则结果为真TRUE（真；如果不相等，则结果为FLASE（假）。

例如，如果你的输入为 IN1= "Apple", IN2：= "Apple"，并触发了 REQ 事件，那么该功能块将会比较这两个字符串是否相等。因为两个字符串相等，所以结果为真TRUE（真，这个结果将会被存储在 OUT 参数中，并会触发 CNF 事件表示操作已完成。

F_GE 大于等于运算功能块

"F_GE"是一个功能块，主要用于比较两个基本元素（ANY_ELEMENTARY）中的第一个元素是否大于或等于第二个元素。以下是各部分的具体含义：

REQ：这是输入事件。当该事件被触发时，功能块开始运行。

IN1、IN2：这是要进行比较的两个基本元素，它们可以是数字、字符串或者布尔值。CNF：这是输出事件，一旦操作结束，该事件就会被触发。

OUT：这是一个布尔值（BOOL），表示比较的结果。如果 IN1 大于或等于IN2：，那么结果为真TRUE（真；否则，结果为FLASE（假）。

例如，如果你的输入是 IN1=7, IN2：=5，并触发了 REQ 事件，那么这个功能块就会进行比较。由于 7 大于 5，所以结果为真TRUE，这将被存储在 OUT 参数中，并触发CNF事件表示操作已完成。

F_GT 大于运算功能块

"F_GT"是一个功能块，主要用来比较两个基本元素（ANY_ELEMENTARY）中的第一个元素是否大于第二个元素。以下是每个部分的具体含义：

REQ：输入事件，当触发此事件时，功能块开始进行操作。

IN1、IN2：这是两个需进行比较的基本元素，可以是数字、字符串或者布尔值。

CNF：输出事件，当操作完成时，该事件会被触发。

OUT：这是一个布尔值（BOOL），表示比较的结果。如果 IN1 大于 IN2：，那么结果为真

TRUE（真；否则，结果为FLASE（假）。

例如，如果你的输入为 IN1 = 5, IN2 = 3，并且触发了 REQ 事件，那么该功能块将比较这两个数字。由于 5 大于 3，因此结果为真TRUE（真，这个结果将会被存储在 OUT 参数中，并会触发 CNF 事件，表示操作已完成。

F_LE 相等功能块

"F_LE"是一个功能块，主要用于比较两个基本元素（ANY_ELEMENTARY）中第一个元素是否小于或等于第二个元素。以下是各部分的具体含义：

REQ：这是输入事件，当该事件被触发时，功能块开始进行操作。

IN1、IN2：这是要进行比较的两个基本元素。它们可以是数字、字符串或布尔值等。CNF：这是输出事件。当操作完成时，该事件会被触发。

OUT：这是一个布尔值（BOOL），表示比较的结果。如果 IN1 小于或等于IN2：，那么结果为真TRUE（真；否则结果为FLASE（假）。

举例来说，如果你的输入是 IN1=3, IN2：=5，并触发了 REQ 事件，那么这个功能块就会进行比较。由于 3 小于 5，所以结果为真TRUE（真，这将会被存储在 OUT 参数中，并触发 CNF 事件以表示操作已完成。

F_LT 小于运算功能块

"F_LT"是一个功能块，主要用来比较两个基本元素（ANY_ELEMENTARY）中的第一个元素是否小于第二个元素。以下是每个部分的具体含义：

REQ：输入事件，当触发此事件时，功能块开始进行操作。

IN1、IN2：这是两个要进行比较的基本元素，可以是数字、字符串，或者布尔值。CNF：输出事件，当操作完成时，它会被触发。

OUT：这是一个布尔值（BOOL），表示比较的结果。如果 IN1 小于 IN2：，那么结果为真

TRUE（真；否则，结果为FLASE（假）。

例如，如果你输入的是 IN1= 3，IN2：= 5，并触发了 REQ 事件，那么该功能块将开始比较这两个数字。由于 3 小于 5，所以结果为真TRUE（真。这个结果将被存储在 OUT参数中，并且会触发 CNF 事件来表示操作已完成。

F_NE 不等运算功能块

"F_NE"是一个功能块，它主要用来比较两个基本元素（ANY_ELEMENTARY）是否不相等。以下是其各部分的详细解释：

REQ：输入事件，当这个事件被触发时，功能块开始工作。

IN1、IN2：这是两个要进行比较的基本元素，可以是数字、字符串或布尔值。

CNF：输出事件，当比较操作完成时触发。

OUT：这是一个布尔值（BOOL），显示比较结果。如果 IN1 不等于 IN2：，则结果为真

TRUE（真；否则结果为FLASE（假）。

举个例子，如果你输入的是 IN1= 5, IN2：= 3，并触发了 REQ 事件，那么功能块就会开始比较这两个数字。由于 5 不等于 3，因此结果为真TRUE真。这个结果将存储在 OUT参数中，并会触发 CNF 事件表示操作已完成。

F_LIMIT 数值范围限制功能块

F_LIMIT 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于限制数值的范围。这个功能块特别适用于需要对数值进行范围限制的场合。以下是对 F_LIMIT 功能块的详细介绍：

IN：这是一个输入参数，表示需要进行范围限制的原始数值。

MIN：这是一个输入参数，表示允许的最小值。

MX：这是一个输入参数，表示允许的最大值。

OUT：这是一个输出参数，表示经过范围限制后的结果数值。

F_LIMIT 功能块通常用于确保数值在特定的操作范围内，例如在自动化控制系统中，当我们需要确保温度、压力或其他测量值不超过安全限制时，可以使用 F_LIMIT 来进行控制。它可以帮助防止系统超出安全运行条件，从而提高系统的安全性和可靠性。

F_MAX 取最大值功能块

F_MAX 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于找出多个数值中的最大值。这个功能块特别适用于需要比较数值并选出最大值的场合。以下是对 F_MAX 功能块的详细介绍：

IN1, IN2：, ..., INx：这些是输入参数，表示需要进行比较的数值。

OUT：这是一个输出参数，表示所有输入数值中的最大值。

F_MAX 功能块通常用于各种应用场景，例如在工业自动化中，当我们需要从多个传感器读数中找出最大值以进行进一步处理时，可以使用 F_MAX 来进行计算。它可以帮助提高系统的响应性和效率。

F_MIN 取最小值功能块

F_MIN 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于找出多个数值中的最小值。这个功能块特别适用于需要比较数值并选出最小值的场合。以下是对 F_MIN 功能块的详细介绍：

IN1, IN2：, ..., INx：这些是输入参数，表示需要进行比较的数值。

OUT：这是一个输出参数，表示所有输入数值中的最小值。

F_MIN 功能块通常用于各种应用场景，例如在工业自动化中，当我们需要从多个传感器读数中找出最小值以进行进一步处理时，可以使用 F_MIN 来进行计算。它可以帮助提高系统的决策质量和精确性。

F_BYTE_BCD_TO_USINT

"F_BYTE_BCD_TO_USINT"是一种功能块，用于将字节（BYTE）中的二进制编码十进制

（BCD）数字转换为无符号短整数（USINT）。以下是各部分的具体含义：

REQ：这是输入事件，当它被触发时，功能块开始执行。

IN：字节（BYTE），需要转换的二进制编码十进制数。

CNF：这是输出事件，当转换完成时，它被触发。

OUT：这是输出的无符号短整数（USINT）。

例如，如果你的输入是 IN=0x12（在二进制编码十进制中，这表示 12）并且触发了REQ 事件，那么这个功能块就会进行转换。转换结果为十进制数的 12，存储在OUT参数中，并触发CNF事件以表示操作已完成。

F_DWORD_BCD_TO_UDINT

"F_DWORD_BCD_TO_UDINT" 是一种功能块，用于将双字（DWORD）中的二进制编码十进制（BCD）数字转换为无符号双字整数（UDINT）。以下是各部分的具体含义：

REQ：这是输入事件，当它被触发时，功能块开始执行。

IN：双字（DWORD），需要转换的二进制编码十进制数。

CNF：这是输出事件，当转换完成时，它被触发。

OUT：这是输出的无符号双字整数（UDINT）。

例如，如果你的输入是 IN=0x12345678（在二进制编码十进制中，这表示 12345678） 并且触发了 REQ 事件，那么这个功能块就会进行转换。转换结果为十进制数的12345678，存储在 OUT 参数中，并触发 CNF 事件以表示操作已完成。

F_LWORD_BCD_TO_ULINT

"F_LWORD_BCD_TO_ULINT"是一个功能块，用于将长字（LWORD）中的二进制编码的十进制（BCD）数字转换为无符号长整形（ULINT）。以下是各部分的具体含义：

REQ: 这是输入事件，当它被触发时，功能块开始执行。

IN: 长字（LWORD），需要转换的二进制编码十进制数字。

CNF: 这是输出事件，当转换完成时，它被触发。

OUT： 这是输出的无符号长整型（ULINT）。

举一个例子，如果你的输入是 IN=0x1234567890123456（在二进制编码十进制中，这表示 1234567890123456）并且触发了 REQ 事件，然后这个功能块就会进行转换。转换结果为十进制数的 1234567890123456，存储在 OUT 参数中，并触发 CNF 事件以表示转换操作已完成。

F_UDINT_TO_BCD_DWORD

"F_UDINT_TO_BCD_DWORD"是一个功能块，用于将无符号双字（UDINT）转换为双字

（DWORD）中的二进制编码十进制（BCD）数字。以下是各部分的具体含义：

REQ：这是输入事件，当它被触发时，功能块开始执行。

IN：无符号双字（UDINT），需要转换的数值。

CNF：这是输出事件，当转换完成时，它被触发。

OUT：这是输出的二进制编码十进制（BCD）双字（DWORD）。

例如，如果你的输入是 IN=987654321（一个无符号双字整数）并且触发了 REQ 事件，然后这个功能块就会进行转换。转换结果为 BCD 的 987654321，存储在 OUT 参数中，并触发 CNF 事件以表示转换操作已完成。

F_UINT_TO_BCD_WORD

"F_UINT_TO_BCD_WORD"是一个功能块，用于将无符号整数（UINT）转换为字

（WORD）中的二进制编码十进制（BCD）数字。以下是各部分的具体含义：

REQ：这是输入事件，当它被触发时，功能块开始执行。

IN：无符号整数（UINT），需要转换的数值。

CNF：这是输出事件，当转换完成时，它被触发。

OUT：这是输出的二进制编码十进制（BCD）字（WORD）。

举一个例子，如果你的输入是 IN=12345（一个无符号整数）并且触发了 REQ 事件， 然后这个功能块就会进行转换。转换结果为 BCD 的 12345，存储在 OUT： 参数中，并触发 CNF 事件以表示转换操作已完成。

F_ULINT_TO_BCD_LWORD

"F_ULINT_TO_BCD_LWORD"是一个功能块，用于将无符号长整型（ULINT）转换为长字（LWORD）中的二进制编码十进制（BCD）数字。以下是各部分的具体含义：

REQ：输入事件，一旦触发，函数块就开始执行。

IN：无符号长整型（ULINT）数据，这是要被转换的数值。

CNF：输出事件，当转换完成时会被触发。

OUT：长字（LWORD）中的二进制编码十进制（BCD）数字，这是转换的结果。 例如，如果你的输入是 IN=1234567890123456（无符号长整型数值），并且触发了 REQ 事件，功能块就会进行转换操作。转换后的结果会是一个 BCD 编码的1234567890123456，这将被存储在out参数中，并触发 CNF 事件以表示转换操作已完成。

F_USINT_TO_BCD_BYTE

"F_USINT_TO_BCD_BYTE"是一个功能块，用于将无符号短整型（USINT）转换为字节

（BYTE）中的二进制编码十进制（BCD）数字。以下是各部分的具体含义：

REQ：这是输入事件，一旦它被触发，该功能块就开始执行。

IN：这是无符号短整型（USINT），需要被转换的数值。

CNF：这是输出事件，当转换完成时，它将被触发。

OUT：这是转换后的二进制编码十进制（BCD）字节（BYTE）。

比如，如果你设置了 IN=123（一个无符号短整数）并触发了 REQ 事件，该功能块就会开始转换。转换结果是BCD 的 123，存储在 OUT 参数中，并触发 CNF 事件表示

转换已完成。

F_WORD_BCD_TO_UINT

"F_WORD_BCD_TO_UINT"是一个功能块，它的功能是将字（WORD）中的二进制编码十进制（BCD）转换为无符号整型（UINT）。以下是它的各部分的具体含义：

REQ：输入事件，当它被触发时，这个功能块就开始执行。

IN：字（WORD）中的二进制编码十进制（BCD），它是被转换的数值。

CNF：输出事件，当转换完成时，它会被触发。

OUT：转换后的无符号整型（UINT）。

如，如果你的输入设置为 IN=12345（BCD 字）并且触发了 REQ 事件，那么这个功能块就会开始转换。转换后的结果是UINT 的 12345，被保存在 OUT 参数中，并且会触发 CNF 事件，告知你转换已经完成。

F_BOOL_TO_BYTE 布尔型转比特型功能块

"F_BOOL_TO_BYTE"是一个功能块，它的功能是将布尔值（BOOL）转换为字节

（BYTE）。以下是各部分的具体含义：

REQ：这是一个输入事件，功能块在接收到这个事件后开始执行。IN：这是一个布尔值（BOOL），是要进行转换的值。

CNF：这是一个输出事件，功能块在转换完成后会触发这个事件。OUT：这是转换后的字节（BYTE）。

例如，如果你将IN设为布尔值真（TURE）并触发了REQ事件，那么功能块就会开始转换。转换后的结果是字节 1，存储在OUT参数中，并触发CNF事件表示转换已完成。

F_BOOL_TO_DINT 布尔型转双整型功能块

"F_BOOL_TO_DINT"是一个功能块，它将布尔值（BOOL）转换为双字整数（DINT）。下面是各部分的具体含义：

REQ：输入事件，一旦被触发，功能块就开始执行。

IN：布尔值（BOOL），这是需转换的输入值。

CNF：输出事件，当转换完成时，它会被触发。

OUT：转换后的双字整数（DINT）。

举例来说，假设你设定了 IN设为布尔值TRUE并触发了REQ 事件，那么该功能块就开始执行转换动作。转换结果是DINT的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_DWORD 布尔型转双字型功能块

"F_BOOL_TO_DWORD" 是一个功能块，它的作用是将布尔值（BOOL）转换为双字

（DWORD）。以下是各部分的具体含义：

REQ：输入事件，功能块在接收到这个事件后开始执行。

IN：布尔值（BOOL），是转换过程的输入值。

CNF：输出事件，当转换完成时，功能块会触发这个事件，表示完成状态。

OUT：转换后的双字（DWORD）。

举例来说，假设你设定了 IN设为布尔值TRUE并触发了REQ 事件，那么该功能块就开始执行转换动作。转换结果是DWORD的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_INT 布尔型转整型功能块

"F_BOOL_TO_INT"是一种功能块，用于将布尔值（BOOL）转换为整数（INT）。各部分的含义如下：

REQ：输入事件。一旦该事件被触发，此功能块开始执行操作。

IN：布尔值（BOOL），这是需要进行转换的输入值。

CNF：输出事件。一旦转换完成，此事件被触发。

OUT：这是转换结果的整数（INT）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是INT的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_LINT 布尔型转长整型功能块

"F_BOOL_TO_LINT" 是一个功能块，它将布尔值（BOOL）转换为长整数（LINT）。以下是每个部分的具体含义：

REQ：输入事件。当此事件被触发时，功能块开始执行操作。

IN：布尔值（BOOL），这是待转换的输入值。

CNF：输出事件。当转换完成时，此事件会被触发。

OUT：转换后的长整数（LINT）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是LINT的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_SINT 布尔型转双整型功能块

"F_BOOL_TO_SINT" 是一个功能块，它的作用是将布尔值（BOOL）转换为短整数

（SINT）。以下是各部分的具体含义：

REQ：输入事件，功能块在接收到这个事件后开始执行。

IN：布尔值（BOOL），是转换过程的输入值。

CNF：输出事件，当转换完成时，功能块会触发这个事件，表示完成状态。

OUT：转换后的短整数（SINT）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是SINT的1，相对应的对应若为FLASE（假）则是0，会被保存在 OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_STRING 布尔型转字符串型功能块

"F_BOOL_TO_STRING" 是一个功能块，它的主要功能是将布尔值（BOOL）转换为字符串（STRING）。这里各部分的具体含义如下：

REQ：输入事件。当此事件被触发时，功能块开始执行操作。

IN：布尔值（BOOL）。这是待转换的输入值。

CNF：输出事件。当转换完成后，此事件会被触发。

OUT：转换后的字符串（STRING）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是STRING的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_UDINT 布尔型转无符号双整型功能块

"F_BOOL_TO_UDINT" 是一个功能块，它的功能是将布尔值（BOOL）转换为无符号双整数（UDINT，Unsigned Double INTeger）。以下是各部分的具体含义：

REQ：输入事件，功能块在接收到这个事件后开始执行操作。

IN：布尔值（BOOL），是转换操作的输入值。

CNF：输出事件，当转换完成后，功能块会触发这个事件表示完成状态。

OUT：转换后的无符号双整数（UDINT）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是UDINT的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_UINT 布尔型转无符号整型功能块

"F_BOOL_TO_UINT" 是一个功能块，它的主要功能是将布尔值（BOOL）转换为无符号整数（UINT，Unsigned INTeger）。以下是各部分的具体含义：

REQ：输入事件。当接收到此事件时，功能块开始执行操作。

IN：布尔值（BOOL）。这是要转换的输入值。

CNF：输出事件。当转换完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的无符号整数（UINT）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是UINT的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_ULINT 布尔型转无符号长整型功能块

"F_BOOL_TO_ULINT" 是一个功能块，它的主要功能是将布尔值（BOOL）转换为无符号长整型（ULINT，Unsigned Long INTeger）。以下是各部分的详细含义：

REQ：输入事件。当此事件被触发时，功能块开始执行操作。

IN：布尔值（BOOL）。这是要进行转换的输入值。

CNF：输出事件。当转换完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的无符号长整型（ULINT）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果ULINT的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_USINT 布尔型转无符号短整型功能块

"F_BOOL_TO_USINT" 是一个功能块，它的主要功能是将布尔值（BOOL）转换为无符号短整数（USINT，Unsigned Short INTeger）。以下是各部分的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行操作。

IN：布尔值（BOOL）。这是要进行转换的输入值。

CNF：输出事件。当转换任务完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的无符号短整数（USINT）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是USINT的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_WORD 布尔型转字型功能块

"F_BOOL_TO_WORD" 是一个功能块，其主要功能是将布尔值（BOOL）转换为字

（WORD）。以下是各部分的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行操作。

IN：布尔值（BOOL）。这是要进行转换的输入值。

CNF：输出事件。当转换完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的字（WORD）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ 事件，那么该功能块就开始执行转换动作。转换结果是WORD的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_WSTRING 布尔型转宽字符串型功能块

"F_BOOL_TO_WSTRING" 是一个功能块，其主要功能是将布尔值（BOOL）转换为宽字符串（WSTRING）。以下是每个部分的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行操作。

IN：布尔值（BOOL）。这是要进行转换的输入值。

CNF：输出事件。当转换完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的宽字符串（WSTRING）。

举例来说，假设你设定了IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是WSTRING的1，相对应的对应若为FLASE（假）则是0，会被保存在 OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BOOL_TO_LWORD 布尔型转长字型功能块

"F_BOOL_TO_LWORD" 是一个功能块，其主要功能在于将布尔值（BOOL）转换为长字

（LWORD，Long WORD）。以下是各部分的详细解释：

REQ：输入事件。当此事件被激活，功能块开始执行操作。

IN：布尔值（BOOL）。这是要进行转换的输入值。

CNF：输出事件。当转换完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的长字（LWORD）。

举例来说，假设你设定了 IN设为布尔值TRUE并触发了REQ事件，那么该功能块就开始执行转换动作。转换结果是LWORD的1，相对应的对应若为FLASE（假）则是0，会被保存在OUT参数中并且CNF事件会被触发，告知你转换已完成。

F_BYTE_TO_DINT 比特型转双整型功能块

"F_BYTE_TO_DINT" 是一个功能块，其主要功能是将字节（BYTE）转换为双整型（DINT，Double INT）。以下是这个功能块各部分的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行操作。

IN：字节（BYTE）。这是要转换的输入值。

CNF：输出事件。当转换完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的双整型（DINT）。

例如，如果你将输入IN设置为35（BYTE）并触发 REQ 事件，那么功能块开始执行转换操作。当转换完成后，结果（DINT 类型的 35）会被存储在OUT参数中，并触发CNF 事件以表示操作已完成。其中，双整型可以存储更大范围的整数值。

F_BYTE_TO_DWORD 比特型转双字型功能块

"F_BYTE_TO_DWORD" 是一个功能块，它的主要作用是将字节（BYTE）转换为双字

（DWORD，Double WORD）。以下是各部分的详细解释：

REQ：输入事件，当此事件被激活后，功能块开始执行转换操作。

IN：字节（BYTE）类型的输入值，是进行转换的源数据。

CNF：输出事件，当转换完成后，这个事件会被触发表示状态完成。

OUT：转换后的双字（DWORD）类型的输出值。

举个例子，如果你将输入IN 设为 8（BYTE）并触发REQ 事件，那此功能块就会开始执行转换。当转换完成，结果（也就是 DWORD 类型的 8）会存储在OUT参数中，并触发CNF事件，表示转换已完成。双字类型可以存储的整数范围比单纯的字节类型更大。

F_BYTE_TO_INT 比特型转整型功能块

"F_BYTE_TO_INT" 是一个功能块，其主要任务是将字节（BYTE）转换为整型（INT）。以下是对每部分的详细解释：

REQ：输入事件。当此事件被激活，功能块开始执行操作。

IN：字节（BYTE）。这是要进行转换的输入值。

CNF：输出事件。当转换完成后，功能块会触发此事件以表示完成状态。

OUT：转换后的整型（INT）。

例如，如果你将输入IN设为72（字节）并触发 REQ 事件，那么功能块就会开始执行操作。当转换完成后，结果（即整型的 72）会被存储在OUT参数中，并会触发CNF事件以示转换已完成。整型可以存储的数值范围比字节大。

F_BYTE_TO_LINT 比特型转长整型功能块

"F_BYTE_TO_LINT" 是一个功能块，其主要功能是将字节（BYTE）转换为长整形数

（LINT，Long INT）。下面是每部分的详细解释：

REQ：输入事件。当此事件被触发，功能块开始执行转换操作。

IN：字节（BYTE）。这是需要进行转换的输入值。

CNF：输出事件。当转换工作完成后，此事件会被触发来表示完成状态。

OUT：转换后的长整形数（LINT）。

例如，如果你将输入IN设为 150（字节）并触发 REQ 事件，那么该功能块就会开始执行转换操作。当转换完成后，结果（即长整形数的 150）将会被存储在OUT参数中， 并触发CNF事件以表示转换工作已完成。长整形数可以存储的数值范围更大。

F_BYTE_TO_LWORD 比特型转长字型功能块

"F_BYTE_TO_LWORD" 是一种功能块，主要用于将字节（BYTE）转换为长字

（LWORD，Long WORD）。以下是每部分的详细解释：

REQ：输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：字节（BYTE），要进行转换的输入值。

CNF：输出事件，功能块在完成转换操作后触发此事件，以表示完成状态。

OUT：转换后的长字（LWORD）。

举个例子，如果你将输入IN设为 200（字节）并触发REQ事件，功能块就会开始执行转换操作。当转换完成，结果（即长字形式的 200）将存储在OUT参数中，并触发CNF事件，以表示转换已完成。长字类型可以存储的数字范围要大于字节类型。

F_BYTE_TO_SINT 比特型转短整型功能块

"F_BYTE_TO_SINT" 是一种功能块，它的主要任务是将字节（BYTE）类型转换为短整数

（SINT，Short INT）。以下是对每个部分的详细解释：

REQ：输入事件。功能块在此事件被触发时开始执行转换操作。

IN：字节（BYTE）。这是需要转换的输入值。

CNF：输出事件。在转换操作完成后，此事件会被触发以表示完成状态。OUT：转换后的短整数（SINT）。

例如，如果将输入IN设置为 100（字节）并触发REQ事件，功能块就会开始执行转换操作。一旦转换完成，结果（即短整数形式的 100）将被存储在OUT参数中，并触发CNF 事件以表示转换已完成。请注意，短整数的存储范围要小于字节。

F_BYTE_TO_STRING 比特型转字符串型功能块

"F_BYTE_TO_STRING" 是一种功能块，它的主要工作是将字节（BYTE）类型转换为字符串（STRING）。以下是每部分的详细解释：

REQ：输入事件，当此事件被触发时，功能块开始执行转换操作。IN：字节（BYTE），需要进行转换的输入值。

CNF：输出事件，功能块在转换完毕后会触发此事件，表示完成状态。OUT：转换后的字符串（STRING）。

举个例子，如果你将输入 IN 设置为 65（字节）并触发 REQ 事件，那么该功能块将开始执行转换操作。当转换完成后，结果（即字符"A"，对应于 ASCII 码 65 的字符串）将被存储在OUT参数中，然后触发 CNF 事件以表示转换操作已完成。请注意，字符串可以存储比字节更丰富的数据，如字符和字母。

F_BYTE_TO_UDINT 比特型转无符号双整型功能块

"F_BYTE_TO_UDINT" 是一种功能块，它的主要工作是将字节（BYTE）类型转换为无符号双字（UDINT，Unsigned Double INT）。以下是每部分的详细解释：

REQ：输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：字节（BYTE），需要进行转换的输入值。

CNF：输出事件，功能块在完成转换后会触发此事件，表示完成状态。

OUT：转换后的无符号双字（UDINT）。

举例来说，如果你把输入IN设为 250（字节）并触发 REQ 事件，该功能块就会开始执行转换工作。当转换完成后，结果（即无符号双字形式的 250）将被存储在OUT中， 并触发 CNF 事件以显示转换已完成。无符号双字比字节能存储的数值范围大得多。

F_BYTE_TO_UINT 比特型转无符号整型功能块

F_BYTE_TO_UINT 是一个功能块，是在实时可编程逻辑控制（PLC）编程中使用的。其主要目的是将字节（Byte）类型数据转换为无符号整数（UINT）类型数

据。具体地，这个功能块的参数功能如下：

REQ：这是输入事件接口。当这个接口接收到一个事件时，功能块开始执行操作。

IN：这是输入接口，应接收一个 Byte 类型的值。

CNF：这是输出事件接口，当功能块成功地执行完操作后，它将发生一个事件。

OUT：这是输出接口。当功能块成功地执行完操作后，这个接口将输出一个UINT 类型的值，这个值是将输入的Byte 值转换成的UINT 值。

例如，假设你有一个 Byte 值 b，并且你需要将这个值转换为无符号整数。你可以通过输入事件REQ 来触发功能块，然后把 b 传入到 IN 接口。然后，功能块将开始执行操作，并将转换后的UINT 值输出到OUT接口。转换完成后，CNF 事件将被触发。

F_BYTE_TO_ULINT 比特型转无符号长整型功能块

F_BYTE_TO_ULINT 是一个功能块，它用于实时的可编程逻辑控制器（PLC）编

程。其主要目的是将字节（Byte）类型数据转换为无符号长整数（ULINT）类型数据。具体地，这个功能块的各个参数的功能如下：

REQ：这是输入事件接口。当这个接口接收到一个事件时，功能块开始执行操作。

IN：这是输入接口，应接收一个 Byte 类型的值。

CNF：这是输出事件接口，当功能块成功地执行完操作后，它将发生一个事件。

OUT：这是输出接口。当功能块成功地执行完操作后，它将输出一个ULINT 类型的值，即将输入的Byte 值转换成ULINT 值。

例如，如果你有一个 Byte 值 b，你需要将其转换为无符号长整数。你可以通过使用输入事件 REQ 来触发功能块，然后将 b 传入到 IN 接口。然后，功能块启动并进行转换操作，并将转换后的 ULINT 值输出到OUT： 接口。转换完成后，CNF 事件将被触发。

F_BYTE_TO_USINT 比特型转无符号短整型功能块

F_BYTE_TO_USINT 是一个功能块，用于实时可编程逻辑控制器（PLC）编程。这个功能块的主要目标是将字节（Byte）类型的数据转换为无符号小整数（USINT）类型的数据。功能块的各个参数具有以下功能：

REQ：这是输入事件接口。当这个接口接收到一个事件时，该功能块开始执行操作。

IN：这是输入接口，它应接收一个 Byte 类型的值。

CNF：这是输出事件接口，当功能块成功完成其操作后，它将发生一个事件。

OUT：这是输出接口。当功能块成功完成操作后，它将输出一个 USINT 类型的值，该值是由输入的 Byte 值转换得到的。

例如，如果你有一个 Byte 值 b，并且你想把它转换成一个无符号的小整数。你可以通过激活输入事件 REQ 来触发功能块，然后把 b 传给 IN 接口。然后，该功能块将开始执行操作，并将转换后的 USINT 值输出到 OUT接口。当转换完成后，CNF 事件将被触发。

F_BYTE_TO_WORD 比特型转字型功能块

F_BYTE_TO_WORD 是一个功能块，常用于实时可编程逻辑控制器（PLC）编程。此功能块的主要目标是将字节（Byte）类型的数据转换为字（WORD）类型的数 据。针对这个功能块的各项参数，他们的功能如下：

REQ：这是输入事件接口。当这个接口接收到一个事件时，该功能块开始执行操作。

IN：这是输入接口，它将接收一个 Byte 类型的值。

CNF：这个输出事件接口，当功能块成功完成其操作之后，它将触发一个事件。

OUT：这是输出接口。当功能块成功完成操作后，将输出一个 WORD 类型的值，即将输入的 Byte 值转换得到的值。

例如，如果你有一个 Byte 值 b，而你希望将这个值转换为一个字（Word）。你可以通过激发输入事件REQ 来触发此功能块，然后向 IN 接口输入 b。然后，功能块开始执行操作，并将转换得到的 WORD 值发送到OUT接口。转换完成后，CNF 事件将被触发。

F_BYTE_TO_WSTRING 比特型转宽字符串型功能块

F_BYTE_TO_WSTRING 是一个功能块，这个功能块在实时可编程逻辑控制器

（PLC）编程中用来将字节（Byte）类型的数据转换为宽字符串（WSTRING）类型的数据。

以下是功能块各参数的详细解释：

REQ：这是输入事件接口。当接收到一个事件时，功能块开始执行。

IN：这是输入接口，应接收一个 Byte 类型的值。

CNF：这是输出事件接口，在功能块成功完成其操作后，它会触发一个事件。

OUT：这是输出接口。功能块成功完成操作后，它会输出一个 WSTRING（宽字符串） 类型的值，即将输入的 Byte 值转换成的值。

例如，如果你有一个 Byte 值 b，并希望将其转换为一个宽字符串。你可以通过触发REQ 输入事件来激活功能块，然后将 b 传入 IN 接口。然后，功能块开始执行并将转换得到的 WSTRING 值输出到 OUT接口。转换完成后，CNF 事件将被触发。

F_DINT_TO_BYTE 双整型转比特型功能块

F_DINT_TO_BYTE 是一个功能块，主要用于实时可编程逻辑控制器（PLC） 编程。这个功能块的主要目的是将双整型数（DINT）转换为字节（BYTE）。这些参数的功能如下：

REQ：这是一个输入事件接口。当这个接口接收到一个事件时，这个功能块就会开始运行。

IN：这是一个输入接口，它接收一个双整数类型（DINT）的值。

CNF：当功能块成功完成它的运算后，这个输出事件接口会触发一个事件。

OUT：这是一个输出接口。当这个功能块成功地执行了它的任务之后，它将会输出一个字节（BYTE）类型的值。

例如，如果你有一个双整数值 d，你想要将它转换为一个字节值。你可以通过触发REQ 输入事件来激活这个功能块，然后将 d 传递给 IN 接口。然后，功能块就会开始工作，并且将转换后的字节值输出到 OUT接口。当转换完成之后，CNF 事件就会被触发。

F_DINT_TO_DWORD 双整型转双字数型功能块

F_DINT_TO_DWORD 是一个功能块，主要用于实时可编程逻辑控制器

（PLC）编程。这个功能块的主要目的是将双整型数（DINT）转换为双字（DWORD）。这些参数的功能如下：

REQ：这是一个输入事件接口。当这个接口接收到一个事件时，这个功能块就会开始运行。

IN：这是一个输入接口，它接收一个双整数类型（DINT）的值。

CNF：当功能块成功完成它的运算后，这个输出事件接口会触发一个事件。

OUT：这是一个输出接口。当这个功能块成功地执行了它的任务之后，它将会输出一个双字（DWORD）类型的值。

例如，如果你有一个双整数值 d，你想要将它转换为一个双字值。你可以通过触发REQ 输入事件来激活这个功能块，然后将 d 传递给 IN 接口。然后，功能块就会开始工作，并且将转换后的双字值输出到 OUT 接口。当转换完成之后，CNF 事件就会被触发。

F_DINT_TO_INT 双整型转整型功能块

F_DINT_TO_INT 是一个功能块，主要用途是在实时可编程逻辑控制器（PLC） 编程中将双整型（DINT）转化为整型（INT）。下面是功能块各参数的具体解释：

REQ：这是输入事件接口。当接收到一个事件时，功能块开始执行。

IN：这是输入接口，应接收一个 DINT（双整型）类型的值。

CNF：这是输出事件接口，在功能块成功完成其操作后，它会发生一个事件。

OUT：这是输出接口。功能块成功完成操作后，它会输出一个 INT（整型）类型的值， 即将输入的 DINT 值转换得到的值。

例如，如果你有一个 DINT 值 d，并希望将其转换为 INT 类型。你可以通过触发 REQ 输入事件来激活功能块，然后将d 传入 IN 接口。然后，功能块开始执行并将转换得到的INT 值输出到 OUT接口。转换完成后，CNF 事件将被触发。

F_DINT_TO_LINT 双整型转长整型功能块

F_DINT_TO_LINT 是一个功能块，它在实时可编程逻辑控制器（PLC）编程中被用来将双整型（DINT）转换为长整型（LINT）。以下是功能块各项参数的详细解析：

REQ：这是一个输入事件接口，只有当接收到一个事件，功能块才开始运行。

IN：这是一个输入接口，它用来接收一个双整型（DINT）的值。

CNF：这是一个输出事件接口，当功能块成功完成操作后，它就会发送一个事件。

OUT：这是一个输出接口，功能块成功执行操作后，它会输出一个长整形（LINT）的值（这个值就是将输入的 DINT 值进行转换得到的）。

比如，你有一个双整型值 d，你想把它转换成一个长整型。你可以通过触发 REQ 输入事件使功能块开始工作，然后把 d 传给 IN 接口。然后，功能块开始运行，并把转换成长整型的值输出到 OUT 接口。当转换完成，CNF 事件就会触发。

F_DINT_TO_LREAL 双整型转长实数型功能块

"F_DINT_TO_LREAL"是一个功能块，主要用于实时可编程逻辑控制器（PLC）编程。它的主要作用是将双整型数（DINT）转换为长实数型（LREAL）。以下是对功能块各参数的详细解释：

REQ：这是输入事件接口。当接收到一个事件，该功能块就开始运行。

IN：这是输入接口，用于接收一个双整型（DINT）值。

CNF：这是输出事件接口。当该功能块成功执行其操作后，它将发生一个事件。

OUT：这是输出接口。该功能块成功执行操作后，将输出一个长实数型（LREAL）值。

例如，如果你有一个双整型值d，并且你需要将其转换为长实数型。你可以通过在 REQ 输入事件接口触发事件，以激活此功能块，并将 d 传递给 IN 接口。然后，该功能块开始运行并将转化后的长实数型值输出到OUT 接口。转换完成后，CNF 事件将被触发。

F_DINT_TO_LWORD 双整型转长字型功能块

"F_DINT_TO_LWORD"是一个功能块，主要用于实时可编程逻辑控制器（PLC）编程中。它的作用是将双整型(DINT)转换为长字型(LWORD)。以下是对这个功能块各参数的详细解释：

REQ：是输入事件接口。当接收到一个事件，该功能块就开始运行。

IN：是输入接口，它接收一个双整型(DINT)类型的值。

CNF：输出事件接口。在功能块成功完成其操作后，它会发生一个事件。

OUT：是输出接口。功能块成功执行操作后，将产生一个长字型（LWORD）类型的值。

例如，假设你有一个双整型值d，你希望将其转换为长字型。你可以通过触发 REQ 输入事件来激活功能块，并将 d 送入 IN 接口。然后，该功能块开始运行，并将结果作为长字型值输出到 OUT 接口。上述转换完成后，CNF 事件就会被触发。

F_DINT_TO_REAL 双整型转实数型功能块

"F_DINT_TO_REAL"是一个功能块，它在实时可编程逻辑控制器（PLC）编程中用来将双整型（DINT）转换为实数型（REAL）。以下是功能块参数的详细解释：

REQ：这是一个输入事件接口。只有接收到事件时，功能块才开始运行。

IN：这是一个输入接口。它接收一个双整型（DINT）类型的值。

CNF：这是一个输出事件接口。一旦功能块成功完成操作，它将发生一个事件。

OUT：这是一个输出接口。功能块成功执行操作后，它将输出一个实数型（REAL）的值。

例如，如果你有一个双整型值d，并且你希望将它转换为实数型。你可以通过在REQ

输入事件上触发一个事件来激活功能块，并将 d 交给 IN 接口。然后，该功能块开始运行，并将结果作为实数型值输出到OUT 接口。转换完成后，CNF 事件被触发。

F_DINT_TO_SINT 双整型转短整型功能块

"F_DINT_TO_SINT"是一个功能块，主要用于实时可编程逻辑控制器（PLC）编程中。它的功能是将双整型(DINT)值转换为短整型(SINT)值。以下是对功能块参数的详细解释：

REQ：这是一个输入事件接口。只有当接收到一个事件时，该功能块才开始运行。

IN：这是输入接口，它接收一个双整型(DINT)类型的值。

CNF：这是输出事件接口。一旦该功能块成功执行操作，它就会发生一个事件。

OUT：这是输出接口。当功能块成功执行操作后，它会输出一个短整型(SINT)类型的值。

例如，如果你有一个双整型值d，你想将其转换为短整型。你可以通过在REQ 输入事件接口触发一个事件来激活该功能块，并将d 发送到 IN 接口。然后，功能块会开始运行并将结果作为短整型值输出到 OUT接口。一旦转换完成，CNF 事件就会被触发。

F_DINT_TO_STRING 双整型转字符串型功能块

"F_DINT_TO_STRING"是一个功能块，主要用于实时可编程逻辑控制器（PLC）编程中。它的作用是将双整型(DINT)值转换为字符串(STRING)。以下是对功能块各参数的详细解释：

REQ：是输入事件接口。当接收到一个事件，该功能块就开始运行。

IN：是输入接口，它接收一个双整型(DINT)类型的值。

CNF：输出事件接口。在功能块成功完成其操作后，它会发生一个事件。

OUT：是输出接口。功能块成功执行操作后，将产生一个字符串(STRING)类型的值。

例如，假设你有一个双整型值d，你希望将其转换为字符串。你可以通过触发 REQ 输入事件来激活功能块，并将 d 送入 IN 接口。然后，该功能块开始运行，并将结果作为字符串值输出到 OUT 接口。上述转换完成后，CNF 事件就会被触发。

F_DINT_TO_UDINT 双整型转无符号双整型功能块

"F_DINT_TO_UDINT"是一个功能块，常用于实时可编程逻辑控制器（PLC）编程中。主要功能是将双整型(DINT)数据转换为无符号双整型(UDINT)数据。各个参数的详细解释如下：

REQ：这是输入事件接口。一旦接收到事件，这个功能块就开始执行。

IN：这是输入接口，接收一个双整型(DINT)类型的值。

CNF：这是输出事件接口。当功能块成功完成其操作时，它会发生一个事件。

OUT：这是输出接口。当功能块成功执行操作时，它会输出一个无符号双整型(UDINT) 类型的值。

假设你有一个双整型值d，并且你希望将它转换为无符号双整型。你可以通过 REQ 输入事件接口触发一个事件，激活这个功能块，并将d 送入 IN 接口。然后，该功能块开始执行并将结果作为无符号双整型值输出到 OUT 接口。当转换完成后，CNF 事件被触发。

F_DINT_TO_UINT 双整型转无符号整型功能块

"F_DINT_TO_UINT"是一个功能块，通常用于实时可编程逻辑控制器（PLC）编程中。它的主要功能是将双整型（DINT）数据转换为无符号整型（UINT）数据。以下是对各个参数的详细解释：

REQ：这是输入事件接口。只有在接收到事件时，该功能块才开始工作。

IN：这是输入接口，接收一个双整型（DINT）类型的值。

CNF：这是输出事件接口。当功能块成功完成其操作时，它将发生一个事件。

OUT：这是输出接口。功能块成功执行操作后，会输出一个无符号整型（UINT）类型的值。

例如，如果你有一个双整型值d，并且你想要将它转换为无符号整型。可以通过在 REQ 输入事件接口触发一个事件来激活此功能块，并将d 传递到 IN 接口。然后，功能块开始运行，并将结果作为无符号整型值输出到OUT 接口。一旦转换完成，CNF 事件将被触发。

F_DINT_TO_ULINT 双整型转无符号长整型功能块

"F_DINT_TO_ULINT"是一个功能块，常见于实时可编程逻辑控制器（PLC）编程中。它的功能是将双整型(DINT)数据转换为无符号长整型(ULINT)数据。以下是对各参数的详细解释：

REQ：这是输入事件接口。只有当接收到事件时，该功能块才开始运行。IN：这是输入接口，用于接收一个双整型(DINT)类型的值。

CNF：这是输出事件接口。如果对应的功能块操作成功完成，那么会有一个事件被触发。

OUT：这是输出接口，功能块会在成功完成操作后，输出一个无符号长整型(ULINT)类型的值。

例如，你有一个双整型值d，并且你想要将它转换成无符号长整型。这时，你可以在REQ 输入事件接口触发一个事件来激活这个功能块，并将 d 送入 IN 接口。然后，功能块开始运行，并把结果作为无符号长整型值传到OUT 接口。完成转换后，CNF 事件就会被触发。

F_DINT_TO_USINT 双整型转无符号短整型功能块

"F_DINT_TO_USINT"是一个功能块，通常应用于实时可编程逻辑控制器（PLC）编程中。这个功能块的主要任务是将双整型（DINT）数据转换为无符号短整型（USINT） 数据。以下是各个参数的详细解释：

REQ：这是输入事件接口。只有在接收到一个事件时，这个功能块才会开始执行。

IN：这是输入接口，用于接收一个双整型（DINT）类型的值。

CNF：这是一个输出事件接口。当功能块成功完成操作时，它会发生一个事件。

OUT：这是输出接口。功能块在成功完成操作后，会输出一个无符号短整型（USINT） 值。

例如，如果你有一个双整型值d，并希望将它转换为无符号短整型，你可以在 REQ 输入事件接口中发起一个事件，激活这个功能块，并将 d 送入 IN 接口。然后，功能块开始执行，并将结果作为无符号短整型值输出到 OUT 接口。当转换完成后，CNF 事件将被触发。

F_DINT_TO_WORD 双整型转字型功能块

"F_DINT_TO_WORD"是一个功能块，它在实时可编程逻辑控制器（PLC）编程中使用。它的目标是将一个双整数型（DINT）值转换为字型（WORD）值。以下是对各个参数的详细解释：

REQ：这是输入事件接口。只有当接收到事件时，该功能块才开始执行。

IN：这是输入接口，用于接收一个双整型(DINT）的值。

CNF：这是输出事件接口。当功能块成功完成其操作时，该事件将被触发。

OUT：这是输出接口。功能块成功完成操作后，将输出一个字型（WORD）的值。

例如，如果你有一个双整型值d，并希望将其转换为字型。你可以通过在REQ 输入事件接口中生成一个事件来激活该功能块，并将 d 传递到 IN 接口。然后，功能块开始执行，并将结果作为字型值输出到 OUT 接口。一旦转换完成，CNF 事件将被触发。

F_DINT_TO_WSTRING 双整型转宽字符串型功能块

"F_DINT_TO_WSTRING"是一个功能块，通常应用于实时可编程逻辑控制器（PLC）编程中。其主要作用是将双整型（DINT）数据转换为宽字符型字符串（WSTRING）。以下是各个参数的详细解释：

REQ：输入事件接口。只有在接收到一个事件时，这个功能块才会开始执行。

IN：输入接口，用于接收一个双整型（DINT）类型的值。

CNF：输出事件接口。当功能块成功完成操作时，它会发生一个事件。

OUT：输出接口。功能块在成功完成操作后，会输出一个宽字符型字符串

（WSTRING）的值。

例如，如果你有一个双整型值d，并希望将它转换为宽字符型字符串，你可以在REQ 输入事件接口中触发一个事件，从而启动这个功能块，并把d 送入 IN 接口。然后，功能块就会开始执行，并将结果作为宽字符型字符串的值输出到 OUT 接口。当转换完成后，CNF 事件将被触发。

F_DT_TO_DATE 日期时间型转日期型功能块

"F_DT_TO_DATE"是一个功能块，通常在实时可编程逻辑控制器(PLC)编程中使用。这个功能块的主要作用是将日期和时间（DATE_AND_TIME）转换为日期（DATE）。以下是每个参数的详细解释：

REQ：输入事件接口。只有在接收到一个事件时，这个功能块才开始执行。

IN：输入接口，用于接收一个日期和时间（DATE_AND_TIME）的值。

CNF：输出事件接口。当这个功能块成功完成了操作，就会触发这个事件。

OUT：输出接口。在功能块成功执行操作后，它将输出一个日期（DATE）的值。

例如，如果你有一个日期和时间的值 dt，并希望将它转换为一个日期。你可以在 REQ 输入事件接口中发起一个事件，触发这个功能块，并将dt 送入IN 接口。然后，功能块将开始执行，并将结果作为一个日期值输出至OUT 接口。当转换完成后，CNF 事件将被触发。

F_DT_TO_TOD 日期时间型转时间型功能块

"F_DT_TO_TOD"是一个功能块，通常在实时可编程逻辑控制器（PLC）编程中使用。这个功能块的主要目标是将日期和时间（DATE_AND_TIME）转换为一天中的时间（TIME_OF_DAY）。以下是各参数的详细解释：

REQ：输入事件接口。只有在接收到事件时，这个功能块才开始执行。

IN：输入接口，用于接收一个日期和时间（DATE_AND_TIME）的值。

CNF：输出事件接口。当功能块成功完成操作后，这个事件会被触发。

OUT：输出接口。完成操作后，功能块会输出一个一天中的时间（TIME_OF_DAY）的值。

举例来说，如果你有一个日期和时间的值 dt，并希望将它转换为一天中的时间。你可以在REQ 输入事件接口中发起一个事件来触发这个功能块，并将dt 送到IN 接口。然后，功能块会开始执行，并将结果作为一天中的时间的值输出到OUT 接口。一旦转换完成，CNF 事件就会被触发。

F_TIME_IN_MS_TO_LINT 毫秒时间型转长整型功能块

F_TIME_IN_MS_TO_LINT 是一个功能块。这个功能块的主要目标是将 TIME（时间）类型的值，以毫秒为单位，转换为 LINT（长整型）类型的值。以下是对每个参数的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行并开始将通过 IN 接口接收的时间类型数据转换为长整型数据。

IN：输入接口。与输入时间类型数据相关的部分。

CNF：输出事件。当时间类型的数据成功转换为长整型数据时，此事件将被触发。

OUT：输出接口。这是已经转换为长整型数据的输出部分。

简单来说，当REQ 事件被触发时，功能块 "F_TIME_IN_MS_TO_LINT" 就开始运行，并将从 IN 接口输入的时间类型数据转换为长整型数据。一旦数据转换成功，转换后的数据就会通过 OUT 接口输出，并触发CNF 事件。

F_TIME_IN_MS_TO_LREAL 毫秒时间型转长实数型功能块

F_TIME_IN_MS_TO_LREAL 是一个功能块。这个功能块的主要目标是将 TIME（时间）类型的值，以毫秒为单位，转换为 LREAL（双精度浮点型）类型的值。以下是对每个参数的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行并开始将通过 IN 接口接收的时间类型数据转换为双精度浮点型数据。

IN：输入接口。与输入时间类型数据相关的部分。

CNF：输出事件。当时间类型的数据成功转换为双精度浮点型数据时，此事件将被触发。

OUT：输出接口。这是已经转换为双精度浮点型数据的输出部分。

简单来说，当 REQ 事件被触发时，功能块 F_TIME_IN_MS_TO_LREAL 就开始运行，并将从 IN 接口输入的时间类型数据转换为双精度浮点型数据。一旦数据转换成功，转换后的数据就会通过 OUT 接口输出，并触发 CNF 事件。

F_TIME_IN_MS_TO_ULINT 毫秒时间型转无符号长整型功能块

F_TIME_IN_MS_TO_ULINT 是一个功能块。这个功能块的主要目标是将 TIME（时间）类型的值，以毫秒为单位，转换为 ULINT（无符号长整型）类型的值。以下是对每个参数的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行并开始将通过 IN 接口接收的时间类型数据转换为无符号长整型数据。

IN：输入接口。与输入时间类型数据相关的部分。

CNF：输出事件。当时间类型的数据成功转换为无符号长整型数据时，此事件将被触发。

OUT：输出接口。这是已经转换为无符号长整型数据的输出部分。

简单来说，当 REQ 事件被触发时，功能块 F_TIME_IN_MS_TO_ULINT 就开始运行，并将从 IN 接口输入的时间类型数据转换为无符号长整型数据。一旦数据转换成功，转换后的数据就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块通常用于需要精确整数计算的应用场景，比如在工业自动化过程中进行精确的时间测量或者数据转换。ULINT 类型的数据范围是从 0 到 18,446,744,073,709,551,615

F_TIME_IN_NS_TO_LINT 纳秒时间型转长整型功能块

F_TIME_IN_NS_TO_LINT 是一个功能块，它将时间值（以纳秒为单位）转换为长整型（LINT）数值。这个功能块对于需要在纳秒级别进行时间测量和处理的应用场景非常有用。

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以纳秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整型（LINT）数值。

简单来说，当REQ事件被触发时，F_TIME_IN_NS_TO_LINT功能块就开始运行，并将从IN接口输入的纳秒时间值转换为LINT数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。

F_TIME_IN_NS_TO_LREAL 纳秒时间型转长实数型功能块

F_TIME_IN_NS_TO_LREAL 是一个功能块，它将时间值（以纳秒为单位）转换为长实数（LREAL）数值。这个功能块对于需要在纳秒级别进行时间测量和处理的应用场景非常有用。

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以纳秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长实数（LREAL）数值。

简单来说，当REQ事件被触发时，F_TIME_IN_NS_TO_LREAL功能块就开始运行，并将从IN接口输入的纳秒时间值转换为LREAL数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。LREAL类型的数据范围可以非常广泛，允许表示非常大或非常小的数值，适用于高精度计算

F_TIME_IN_NS_TO_ULINT 纳秒时间型转无符号长整型功能块

F_TIME_IN_NS_TO_ULINT 是一个功能块，它的作用是将时间值（以纳秒为单位）转换为无符号长整型（ULINT）数值。这个功能块特别适用于需要处理高精度时间数据的工业自动化应用。下面是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以纳秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号长整型（ULINT）数值。

简单来说，当REQ事件被触发时，F_TIME_IN_NS_TO_ULINT 功能块就开始运行，并将从IN接口输入的纳秒时间值转换为 ULINT 数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。ULINT 类型的数据范围非常广泛，能够表示非常大的数值，适合于需要高计数范围的应用场景。

F_TIME_IN_US_TO_LINT 微秒时间型转长整型功能块

F_TIME_IN_US_TO_LINT 是一个功能块，它的作用是将时间值（以微秒为单位）转换为长整型（LINT）数值。这个功能块适用于需要处理精确到微秒的时间数据的工业自动化应用。下面是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以微秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整型（LINT）数值。

简单来说，当REQ事件被触发时，F_TIME_IN_US_TO_LINT 功能块就开始运行，并将从IN接口输入的微秒时间值转换为 LINT 数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。LINT 类型的数据范围非常广泛，能够表示非常大的数值，适合于需要高计数范围的应用场景。

F_TIME_IN_US_TO_LREAL 微秒时间型转长实数型功能块

F_TIME_IN_US_TO_LREAL是一个功能块，它的作用是将时间值（以微秒为单位）转换为长实数（LREAL）数值。这个功能块适用于需要处理精确到微秒的时间数据的工业自动化应用。下面是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以微秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长实数（LREAL）数值。

简单来说，当REQ事件被触发时，F_TIME_IN_US_TO_LREAL 功能块就开始运行，并将从IN接口输入的微秒时间值转换为 LREAL 数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。LREAL 类型的数据范围非常广泛，能够表示非常大的数值，适合于需要高计数范围的应用场景。

F_TIME_IN_US_TO_ULINT 微秒时间型转无符号长整型功能块

F_TIME_IN_US_TO_ULINT 是一个功能块，它的作用是将时间值（以微秒为单位）转换为无符号长整型（ULINT）数值。这个功能块适用于需要处理精确到微秒的时间数据的工业自动化应用。下面是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以微秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号长整型（ULINT）数值。

简单来说，当 REQ 事件被触发时，F_TIME_IN_US_TO_ULINT 功能块就开始运行，并将从 IN 接口输入的微秒时间值转换为 ULINT 数值。一旦转换完成，转换后的数值就会通过 OUT 接口输出，并触发 CNF 事件。ULINT 类型的数据范围非常广泛，能够表示非常大的正数值，适合于需要高计数范围的应用场景。

F_TIME_IN_S_TO_LINT 秒时间型转长整型功能块

F_TIME_IN_S_TO_LINT 是一个功能块，用于将时间值（以秒为单位）转换为长整型（LINT）数值。这个功能块适用于需要以秒为单位处理时间数据的工业自动化应用。以下是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整型（LINT）数值。

简单来说，当REQ事件被触发时，216.F_TIME_IN_S_TO_LINT 功能块就开始运行，并将从IN接口输入的秒时间值转换为 LINT 数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。LINT 类型的数据范围可以表示非常大的负数到非常大的正数，适合于需要大范围整数计数的应用场景。

F_TIME_IN_S_TO_LREAL 秒时间型转长实数型功能块

F_TIME_IN_S_TO_LREAL 是一个功能块，它的作用是将时间值（以秒为单位）转换为长实数（LREAL）数值。这个功能块适用于需要处理精确到秒的时间数据的工业自动化应用。下面是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长实数（LREAL）数值。

简单来说，当REQ事件被触发时，F_TIME_IN_S_TO_LREAL 功能块就开始运行，并将从IN接口输入的秒时间值转换为 LREAL 数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。LREAL 类型的数据范围可以表示非常大或非常小的数值，适合于需要高精度浮点数的应用场景。

F_TIME_IN_S_TO_ULINT 秒时间型转无符号长整型功能块

F_TIME_IN_S_TO_ULINT 是一个功能块，它的作用是将时间值（以秒为单位）转换为无符号长整型（ULINT）数值。这个功能块适用于需要处理精确到秒的时间数据的工业自动化应用。下面是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值（以秒为单位）。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号长整型（ULINT）数值。

简单来说，当REQ事件被触发时，F_TIME_IN_S_TO_ULINT 功能块就开始运行，并将从IN接口输入的秒时间值转换为 ULINT 数值。一旦转换完成，转换后的数值就会通过OUT接口输出，并触发CNF事件。ULINT 类型的数据范围非常广泛，能够表示非常大的数值，适合于需要高计数范围的应用场景。

F_TIME_TO_STRING 时间型转字符串型功能块

F_TIME_TO_STRING 是一个功能块，它用于将时间数据转换为字符串格式。这个功能块非常有用，因为它允许程序员将时间值以可读的文本形式显示或记录。以下是对 F_TIME_TO_STRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字符串格式的时间值。

简单来说，当 REQ 事件被触发时，F_TIME_TO_STRING 功能块就开始运行，并将从 IN 接口输入的时间值转换为字符串格式。一旦转换完成，转换后的字符串就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在需要将时间显示在人机界面（HMI）或者需要将时间记录在日志文件中时非常有用。

F_TIME_TO_WSTRING 时间型转宽字符串型功能块

F_TIME_TO_WSTRING 是一个功能块，它用于将时间值转换为宽字符串（WSTRING）格式。这个功能块对于需要将时间数据以宽字符集格式显示或记录的应用来说非常有用。下面是对这个功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的时间值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串格式的时间值。

简单来说，当 REQ 事件被触发时，F_TIME_TO_WSTRING 功能块就开始运行，并将从 IN 接口输入的时间值转换为宽字符串格式。一旦转换完成，转换后的字符串就会通过 OUT 接口输出，并触发 CNF 事件。

宽字符串（WSTRING）是一种数据类型，它能够存储更大范围的字符，比如 Unicode 字符，这使得它能够表示多种语言的字符。这在全球化的应用中非常重要，因为它允许程序在不同的语言环境中以正确的字符显示时间。

F_DWORD_TO_BYTE 双字型转比特型功能块

"F_DWORD_TO_BYTE"是一个功能块，通常用于实时可编程逻辑控制器（PLC）编程 中。这个功能块的主要功能是将双字（DWORD）转换为字节（BYTE）。以下是各个参数的详细解释：

REQ：输入事件接口。只有在接收到一个事件时，这个功能块才会开始执行。

IN：输入接口，这里应该输入一个双字（DWORD）值。

CNF：输出事件接口。当功能块成功完成操作时，会发生一个事件。

OUT：输出接口。完成操作后，功能块会输出一个字节（BYTE）的值。

例如，如果你有一个双字值 dw，并希望将它转换为字节。你可以在 REQ 输入事件接口中触发一个事件，使得这个功能块开始执行，并将 dw 输入到 IN 接口。然后，功能块就会开始执行，并将结果作为字节的值输出到OUT接口。当转换完成后，将触发CNF 事件。

F_DWORD_TO_DINT 字型转短整型功能块

"F_DWORD_TO_DINT"是一个功能块，通常在实时可编程逻辑控制器（PLC）编程中使用。这个功能块的主要任务是将双字（DWORD）转换为双整数（DINT）。以下是对参数的详细解释： REQ：输入事件接口。只有在接收到一个事件的信号时，这个功能块才会开始执行。IN：输入接口，接收一个双字（DWORD）的值。 CNF：输出事件接口。当功能块成功完成转换后，会触发这个事件。
OUT：输出接口。在功能块成功执行转换后，会输出一个双整数（DINT）的值。 例如，如果你有一个双字（DWORD）的值 dw，并希望将其转换为双整数（DINT）。你可以在 REQ 输入事件接口中触发一个事件，开始执行这个功能块，并将 dw 送入 IN 接口。然后，功能块将开始执行，并将结果作为一个双整数的值输出至OUT： 接口。当转换完成后，CNF 事件将被触发。

F_DWORD_TO_INT 双字型转整型功能块

"F_DWORD_TO_INT"是一个功能块，通常在实时可编程逻辑控制器（PLC）编程中使 用。它的主要功能是将双字（DWORD）转换为整数（INT）。以下是各个参数的详细解释：

REQ：输入事件接口。这个功能块只有在接收到事件时才会开始执行。IN：输入接口，接收一个双字（DWORD）值。

CNF：输出事件接口。当功能块完成执行后，这个事件将会被触发。OUT：输出接口，功能块执行结束后，它将输出一个整数（INT）值。

例如，假设你有一个双字（DWORD）的值'dw'，并希望将它转换为一个整数（INT）。你可以在REQ 输入事件接口中触发一个事件已启动功能块，并将'dw'输入到 IN 接口。接着，功能块就会开始运算，并将整数的结

果输出到 OUT接口。一旦转换完成，功能块就会触发 CNF 事件。

F_DWORD_TO_LINT 双字型转长整型功能块

"F_DWORD_TO_LINT"是一个功能块。这个功能块主要用于将双字（DWORD）转换为长整数（LINT）。以下是对每个参数的详细解释：

REQ：输入事件接口。这个功能块会在接收到事件后开始执行。IN：输入接口，接收一个双字（DWORD）值。

CNF：输出事件接口。功能块成功完成后，会触发这个事件。 OUT：输出接口。功能块执行结束后，会以长整数（LINT）的形式输出结果。

比方说，如果你有一个双字（DWORD）的值'dw'，并希望将其转换为一个长整（LINT）。你可以在 REQ 输入事件接口中触发一个事件来启动这个功能模块，并将'dw'输入到 IN 接口。然后，功能块将开始运行，并将

长整数的结果输出到OUT 接口。一旦转换完成，CNF 事件将被触发。

F_DWORD_TO_LWORD 双字型转长子型功能块

"F_DWORD_TO_LWORD"是一个功能块。这个功能块的主要任务是将双字（DWORD）转换为长字（LWORD）。以下是对参数的详细解释：

REQ: 输入事件接口。只有在接收到一个事件的信号时，这个功能块才会开始执行

IN: 输入接口，接收一个双字（DWORD）的值。

CNF: 输出事件接口。当功能块成功完成转换后，会触发这个事件。

OUT：: 输出接口。在功能块成功执行转换后，会输出一个长字（LWORD）的值。

举个例子，假设你有一个双字（DWORD）的值 dw，并希望将其转换为长字（LWORD）。你可以在 REQ 输入事件接口中触发一个事件，来开始执行这个功能块，并将 dw 送入 IN 接口。然后，功能块开始执行，并将结

果作为一个长字（LWORD）的值输出至OUT接口。当转换完成后，CNF 事件将被触发。

F_DWORD_TO_REAL 双字型转实数型功能块

"F_DWORD_TO_REAL"是一个功能块。该功能模块的主要任务是将双字（DWORD）转换为实数（REAL）。以下是各个参数的详细解释：

REQ：输入事件接口。只有在接收到相应的事件后，这个功能模块才会开始执行。IN：输入接口，接收一个双字（DWORD）的值。

CNF：输出事件接口。当功能块完成执行后，会触发这个事件。

OUT：输出接口。功能块完成执行后，会输出一个实数（REAL）的值。

例如，你有一个双字（DWORD）的值 'dw'，并希望将其转换为实数（REAL）。你可以在 REQ 输入事件接口触发一个事件来启动这个功能模块，并将 'dw' 输入到 IN 接口。然后，功能模块开始运行，并将实数的结

果输出到 OUT 接口。一旦转换完成， CNF 事件将被触发。

F_DWORD_TO_SINT 双字型转短整型功能块

"F_DWORD_TO_SINT"是一个功能块，通常用于实时可编程逻辑控制器

（PLC）的编程。这个功能块的主要任务是将双字（DWORD）转换成称为短整数（SINT）的数据类型。下面是对参数的详细解释：

REQ：输入事件接口。这个功能块在收到此事件信号后开始执行。IN：这是输入接口，接收一个双字（DWORD）的值。

CNF：输出事件接口。功能块在成功完成转换后会触发这个事件。

OUT：这是输出接口，在功能块成功执行转换后，会输出一个短整数（SINT）的值。

例如，如果你有一个双字（DWORD）的值“dw”，并想将其转换为短整数（SINT）。你可以在 REQ 输入事件接口触发一个事件，开始执行这个功能块，并将“dw”送到 IN 接口。然后，功能块开始执行，并将结果作为一个短整数（SINT）的值输出到OUT 接口。当转换完成后，CNF 事件将被触发。

F_DWORD_TO_STRING 双字型转字符串型功能块

"F_DWORD_TO_STRING"是一个功能块。它的核心任务是将双字（DWORD）转换为字符串（STRING）。以下是对其参数的详细解释：

REQ：是输入事件，当这个事件被触发时，功能块才会开始执行。

IN： 是输入接口，接收一个双字（DWORD）数据。

CNF： 输出事件，当功能块完成转换操作后，会触发这个事件。

OUT：是输出接口，功能块执行结束后，会输出一个字符串（STRING）。

比如，你有一个双字（DWORD）的值'dw'，你想把它转换成字符串。那么，你需要在REQ 事件输入接口触发一个事件，开始执行功能块，并在 IN 接口输入'dw'。接下来， 功能块会开始执行，并把执行结果作为字符串（STRING）输出到 OUT 接口。当转换完成后，CNF 事件会被触发。

F_DWORD_TO_UDINT 双字型转无符号双整型功能块

"F_DWORD_TO_UDINT"是一个功能块。主要功能是将 DWORD（双字）转换为UDINT（无符号双整数）。各参数的详细解释如下：

REQ：输入事件。这个功能模块在接收到该事件信号后才开始执行。

IN：该输入接口接受一个双字（DWORD）数值。

CNF：输出事件。功能模块在成功完成转换后会触发此事件。

OUT：该输出接口在功能模块成功执行转换后输出一个无符号双整数（UDINT）。

举例来说，如果你有一个DWORD 数值 'dw'，并希望将其转换为UDINT。你可以在REQ 输入事件处触发一个事件，开始执行这个功能模块，并将'dw'输入到 IN 接口。然后，功能模块开始执行，并将结果作为UDINT 数值在 OUT 接口处输出。当转换完成， CNF 事件将被触发。

F_DWORD_TO_UINT 双字型转无符号整型功能块

"F_DWORD_TO_UINT"是一个功能块，它的主要任务是把DWORD（双字）转换为UINT（无符号整数）。参数的具体描述如下：

REQ：是一个输入事件，当这个事件被触发后，该功能模块会开始执行。

IN：是一个输入接口，它接收一个双字（DWORD）类型的数据。

CNF：一旦功能模块完成转换操作，CNF 这个输出事件就会被触发。

OUT： 是一个输出接口，当功能模块执行完成后，它会输出一个UINT（无符号整数）类型的数据。

举例来说，假如你有一个DWORD 类型的值'dw'，你想要把它转化成UINT 类型。那么你需要在REQ 事件输入接口处触发一个事件，然后该功能模块就开始工作，并且在 IN 接口输入'dw'。接下来，该功能模块开始执行，并且把转换结果作为UINT 类型的数据，输出到 OUT 接口。当转换完成，CNF 这个事件就会被触发。

F_DWORD_TO_ULINT 双字型转无符号长整型功能块

"F_DWORD_TO_ULINT"是一个功能块。该功能模块用于将DWORD（双字）转换为ULINT（无符号长整数）。各参数的详细解释如下：

REQ：输入事件。此功能模块在接收到此事件信号后开始执行。

CNF：输出事件。功能模块完成转换后会触发此事件。

OUT：在功能模块完成执行转换后，该输出接口输出一个无符号长整数（ULINT）。

举例来说，如果你有一个DWORD 数值'dw'，你希望将其转换为一个 ULINT。你只需要在 REQ 输入事件处触发一个事件来开始执行此功能模块，并将'dw'输入到 IN 接口。然后，功能模块会开始执行，并在 OUT 接口处输出一个 ULINT 结果。或者，在转换完成后，CNF 事件将被触发。

F_DWORD_TO_USINT 双字型转无符号短整型功能块

"F_DWORD_TO_USINT"是一个功能块，主要任务是将DWORD（双字）类型的数据转换为 USINT（无符号短整型）类型的数据。这些参数具体表示：

REQ：输入事件。当该事件被触发后，功能模块会开始执行。

IN：输入接口，它接收一个 DWORD（双字）类型的数值。

CNF：输出事件。该功能模块在完成转换过程后会触发该事件。

OUT：输出接口，功能模块执行完成后，会输出一个 USINT（无符号短整型）类型的数值。

举例来说，假设你有一个DWORD 类型的数据'dw'，你希望将其转换为USINT 类型。你需要在REQ 事件输入接口处触发一个事件，然后功能模块就会开始执行，并在 IN 接口输入'dw'。接着，功能模块开始执行，并在 OUT 接口处输出一个USINT 类型的结

果。当转换完成后，CNF 事件将会被触发。

F_DWORD_TO_WORD 双字型转字型功能块

"F_DWORD_TO_WORD"是一个功能块， 它的主要任务是将DWORD（双字）类型的数值转换为 WORD（字）类型的数值。以下是参数的具体说明：

REQ：输入事件。当这个事件被触发后，该功能模块开始执行。

IN：输入接口，它接收一个 DWORD（双字）类型的数据。

CNF：输出事件。一旦功能模块完成转换操作，就会触发此事件。

OUT：输出接口，当功能模块执行完成后，它会输出一个 WORD（字）类型的数据。

例如，如果你有一个 DWORD 类型的值'dw'，你想要将它转换成 WORD 类型。你需要在 REQ 事件输入接口处触发一个事件，然后该功能模块开始执行，并在 IN 接口输入'dw'。功能模块开始执行，并将转换结果作为 WORD 类型的数据输出到OUT 接口。当转换完成后，CNF 事件就会被触发。

F_DWORD_TO_WSTRING 双字型转宽字符串型功能块

"F_DWORD_TO_WSTRING" 是一个功能块，主要为了将 DWORD（32 位无符号整数） 类型的数据转换为 WSTRING （宽字符串） 类型的数据。参数的含义如下：

REQ：输入事件。当这个事件触发时，该功能模块会开始执行转换操作。

IN：输入接口，接受一个 DWORD 类型的值。

CNF：输出事件。当转换操作完成后，该事件将被触发。

OUT：输出接口，当功能模块执行完毕后，它会输出转换后的 WSTRING 类型的值。

举一个例子来讲，假设你有一个 DWORD 类型的值'dw'，你想把它转变为 WSTRING 类型。你需要在REQ 输入事件上触发一个事件来启动功能模块，并在 IN 输入接口上输入'dw'。然后，功能模块开始执行转换，并在 OUT 输出接口上输出一个 WSTRING 类型的结果。当转换完成后，将触发CNF 输出事件。

F_INT_TO_BYTE 整型转比特型功能块

"F_INT_TO_BYTE" 是一个功能块。它的主要作用是将 INT（整型）类型的数据转换成 BYTE（字节型）类型的数据。下面是参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行。

IN：输入接口，接收一个 INT（整型）类型的值。

CNF：输出事件。一旦功能模块完成转换操作，就会触发此事件。

OUT：输出接口，功能模块执行完成后会输出一个 BYTE（字节型）类型的值。例如，如果你有一个 INT 类型的值 'i'，你想要将它转换为 BYTE 类型。你需要在

REQ 事件输入接口处触发一个事件，然后功能模块开始执行，并在 IN 接口输入 'i'。然后，功能模块开始执行，将转换结果输出为 BYTE 类型的数据到 OUT 接口。完成转换后，将触发 CNF 事件。

F_INT_TO_DINT 整型转双整型功能块

"F_INT_TO_DINT"是一个功能块，其主要任务是将 INT（整型）类型的数据转换为 DINT（双整型）类型的数据。以下是参数的详细说明：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，这里接收一个 INT（整型）类型的数据。

CNF：输出事件。一旦功能模块完成转换操作，它会触发这个事件。

OUT：输出接口，功能模块在执行完操作后，会输出一个 DINT（双整型）类型的数据。

例如，你有一个INT 类型的数值'i'，你想要将这个数值转换为DINT 类型。你需要在REQ 输入事件的位置上触发一个事件，然后这个功能模块开始执行，并且在 IN 接口输入'i'。功能模块开始运行，并将结果作为DINT 类型的数值输出在 OUT 接口。完成转换后会触发CNF 事件。

F_INT_TO_REAL 整型转实数型功能块

"F_INT_TO_REAL" 是一个功能块。它的主要作用是将 INT（整数）类型的数据转换为 REAL（实数）类型的数据。下面是各个参数的详细解释：

REQ：是一个输入事件，当它被触发时，功能模块开始执行转换操作。

IN：是一个输入接口，它接收一个 INT 类型的数据。

CNF：是一个输出事件，在功能模块完成转换后，它将被触发。

OUT：是一个输出接口，功能模块完成转换后会输出一个 REAL 类型的数据。

举个例子，假设你有一个 INT 类型的值 '1'，你希望将其转换为 REAL 类型。首先在REQ 输入事件上触发一个事件使功能模块开始执行，并在 IN 接口输入 '1' 后，功能模块开始执行转换操作，并在完成后在 OUT 接口输出一个 REAL 类型的值。一旦转换完成，CNF 事件就会被触发。

F_INT_TO_LREAL 整型转长实数型功能块

"F_INT_TO_LREAL"是一个功能块。该模块的主要功能是将INT（整数）类型的数据转换为 LREAL（长实数）类型的数据。不同参数的意义如下：

REQ: 输入事件，当收到此事件时，功能模块开始执行转换过程。

IN: 输入端口，接受INT 类型的数据输入。

CNF: 输出事件，当功能模块完成转换处理后，会触发此事件。

OUT：: 输出端口，功能模块完成转换后，会输出 LREAL 类型的数据。

举例说明，假如你有一个 INT 类型的数据'1'，想要转换为 LREAL 类型。首先，在 REQ 输入事件上触发一个事件，然后功能模块开始进行转换操作，在 IN 端口输入'1'。功能模块开始执行，并在 OUT 端口输出转换后的LREAL 类型数据。转换完成后，CNF 事件便会被触发。

F_INT_TO_LWORD 整型转长字型功能块

"F_INT_TO_LWORD"是一个功能块，用于将 INT（整数）类型的数据转换为 LWORD（长字，64 位无符号整数）类型数据。以下是它各个参数的详细解释：

REQ：这是输入事件。当此事件触发时，功能模块开始执行转换操作。

IN：这是输入接口，需要接收一个 INT 类型的值。

CNF：这是输出事件。当功能模块完成转换操作后，该事件将被触发。

OUT：这是输出接口，功能模块执行完成后，会输出一个 LWORD 类型的值。

例如，你有一个INT 类型的值'1'，你想把它转换为 LWORD 类型的值。首先，你需要在REQ 输入事件上触发一个事件，让功能模块开始执行，并在 IN 接口输入'1'。然后，功能模块开始执行并在 OUT 输出接口上输出一个 LWORD 类型的值。完成转换后，CNF 事件会被触发。

F_INT_TO_SINT 整型转短整型功能块

"F_INT_TO_SINT"是一个功能块。它的主要作用是把 INT（整数）类型的数据转换成 SINT（短整型）类型的数据。以下是每个参数的详细解释：

REQ：这是一个输入事件。当它被触发时，功能模块开始执行其转换过程。

IN：这是一个输入端口，它接收一个 INT 类型的值。

CNF：这是一个输出事件。当功能模块完成其转换后，它将被触发。

OUT：这是一个输出端口，功能模块在完成转换后会在这个端口上输出一个 SINT 类型的值。

例如，如果你有一个 INT 类型的值 '1'，你想把它转为 SINT 类型。首先，你在 REQ 输入事件上触发一个事件来启动功能模块，并在 IN 端口上输入 '1'，然后功能模块开始执行转换，结束时在 OUT 端口上输出一个 SINT 类型的值，CNF 事件随后会被触发。

F_INT_TO_STRING 整型转字符串型功能块

"F_INT_TO_STRING"是一个功能块。它的主要作用是将 INT(整数)类型的数据转换为 STRING(字符串)类型的数据。下面是各个参数的详细解释：

REQ：这是一个输入事件。当它被触发时，功能模块开始执行转换操作。

IN：这是一个输入接口，它需要接收一个 INT 类型的数据。

CNF：这是一个输出事件。当功能模块完成转换后，该事件将被触发。

OUT：这是一个输出接口，功能模块完成数据转换后，会在此接口输出一个 STRING 类型的数据。

例如，假设你有一个 INT 类型的值 '1'，你希望将其转换为 STRING 类型。首先在 REQ 输入事件上触发一个事件使功能模块开始执行，并在 IN 接口输入 '1'。然后，功能模块开始执行转换操作并在完成后在 OUT 接口输出一个 STRING 类型的值。当转换完成时，CNF 事件将被触发。

F_INT_TO_UDINT 整型转无符号双整型功能块

"F_INT_TO_UDINT" 是一个功能块。它的主要功能是将 INT（整数）类型的数据转换为 UDINT（无符号双字整数）类型的数据。各个参数的详细解释如下：

REQ：输入事件。当它被触发时，功能模块开始执行转换操作。

IN：输入接口，接收一个INT类型的数据。

CNF：输出事件。当功能模块完成转换后，此事件将被触发。 OUT：输出接口，功能模块完成转换后会在此接口输出一个 UDINT 类型的数据。

举个例子，如果你有一个INT 类型的值 '1'，你想把它转换为 UDINT 类型。你首先在REQ 输入事件上触发一个事件让功能模块开始执行，并在 IN 接口输入 '1'。接着，功能模块开始执行转换操作，并在完成后在 OUT 接口输出一个 UDINT 类型的值。一旦转换完成，CNF 事件就会被触发。

F_INT_TO_UINT 整型转无符号整型功能块

"F_INT_TO_UINT"是一个功能块。主要作用是将 INT（有符号整数）类型的数据转换为 UINT（无符号整数）类型的数据。各参数的详细说明如下：

REQ：这是一个输入事件。当其被触发时，功能模块开始执行其转换过程。

IN：这是接收一个INT 类型值的输入端口。

CNF：输出事件。当功能模块完成转换操作时，该事件会被触发。

OUT：输出接口。当转换完成时，功能模块会在此接口输出一个UINT 类型的数据。举个例子，如果你有一个 INT 类型的值，你想把它转换为UINT 类型。你首先在 REQ 输入事件上触发一个事件，使功能模块开始执行。然后，你在 IN 接口输入一个 INT 类

型的值。功能模块在执行转换操作，并在完成后触发CNF 事件，输出接口OUT 则会输

一个 UINT 类型的数据。

F_INT_TO_ULINT 整型转无符号长整型功能块

"F_INT_TO_ULINT"是一个功能块。这个模块的主要任务是将 INT（有符号整数）类型的数据转换为 ULINT（无符号长整数）类型的数据。下面是对各个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，接收一个 INT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，此事件将被触发。

OUT：输出接口，转换完成后，功能模块会在这里输出一个ULINT 类型的数据。

比方说，你有一个 INT 类型的值并想要将其转换为ULINT 类型。首先，在REQ 输入事件上触发一个事件，使功能模块开始执行。然后在 IN 接口输入一个INT 类型的数据。模块开始转换操作，并在完成后在OUT 接口输出一个 ULINT 类型的数据，同时触发CNF 输出事件。

F_INT_TO_LINT 整型转长整型型功能块

"F_INT_TO_LINT" 是一个功能块。它的主要功能是将 INT（整数）类型的数据转换为 LINT（长整型）类型的数据。以下是参数的详细解释：

REQ：输入事件，当此事件被触发时，功能模块开始执行转换操作。

IN：输入接口，接收一个 INT 类型的值。

CNF：输出事件，功能模块完成转换后会触发。

OUT：输出接口，功能模块完成转换后会输出一个 LINT 类型的值。

例如，假设你有一个 INT 类型的值 '1'，你想将其转换为 LINT 类型。首先，你需要在REQ 输入事件上触发一个事件，然后功能模块开始执行。在 IN 接口输入 '1' 后，功能模块开始执行转换操作，并在完成后在 OUT 接口输出一个 LINT 类型的值。一旦转换完成，CNF 事件就会被触发。

F_INT_TO_DWORD 整型转双字型功能块

"F_INT_TO_DWORD" 是一个功能块，用于将 INT（整数）类型的数据转换为 DWORD（双字，32 位无符号整数）类型的数据。以下是参数的详细说明：

REQ：输入事件。当此事件被触发时，功能模块开始执行转换操作。

IN：输入接口，需要接收一个 INT 类型的值。

CNF：输出事件。功能模块完成转换操作后会触发此事件。

OUT：输出接口，功能模块执行完成后会输出一个 DWORD 类型的值。

例如，你有一个 INT 类型的值 '1'，你想将其转换为 DWORD 类型。你需要在 REQ 输入事件上触发一个事件，然后功能模块开始执行，并在 IN 接口输入 '1'。功能模块开始操作，并在 OUT 输出接口上输出一个 DWORD 类型的值。完成转换后，会触发CNF 事件。

F_INT_TO_USINT 整型转无符号短整型功能块

"F_INT_TO_USINT"是一个功能块。它的主要任务是将 INT（有符号整数）类型的数据转换为 USINT（无符号短整数）类型的数据。以下是针对各个参数的详细说明：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，接收一个INT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，此事件将被触发。

OUT：输出接口，转换完成后，功能模块会在此处输出一个USINT 类型的数据。

例如，如果你有一个 INT 类型的值，你想把它转换为 USINT 类型。首先，在 REQ 输入事件上触发一个事件，功能模块开始执行。然后在 IN 接口上输入 INT 类型的数据。功能模块开始进行转换操作，并在完成后在 OUT 接口上输出一个 USINT 类型的数据，并触发 CNF 输出事件。

F_INT_TO_WORD 整型转宽字型功能块

"F_INT_TO_WORD" 是一个功能块。这个模块的主要任务是将 INT（有符号整数）类型的数据转换成 WORD（16 位无符号整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。一旦这个事件被触发，功能模块就开始执行转换操作。

IN：输入接口，它接收一个 INT 类型的数据。

CNF：输出事件。一旦功能模块完成了转换操作，这个事件就会被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个 WORD 类型数据的地方。

简而言之，如果你有一个 INT 类型的值，你可以通过在 REQ 输入事件上触发一个事件来开始转换操作，然后在 IN 接口上输入你的 INT 数据。功能模块会开始执行转换操作，并在完成后在 OUT 接口上输出一个 WORD 类型的数据，并触发 CNF 输出事件。

F_INT_TO_WSTRING 整型转宽字符串型功能块

"F_INT_TO_WSTRING"是一个功能块。这个模块的主要任务是将 INT（有符号整数）类型的数据转换为 WSTRING（宽字符串） 类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 INT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个 WSTRING 类型数据的地方。

简单来说，如果你有一个 INT 类型的值并希望将其转换为 WSTRING 类型，你可以通过在 REQ 输入事件上触发一个事件来开始转换操作，然后在 IN 接口上输入你的 INT 数据。功能模块会开始执行转换操作，当完成后，它会在OUT 接口上输出一个WSTRING 类型的数据，并触发CNF 输出事件。

F_UDINT_TO_BYTE 无符号双整型转比特型功能块

F_UDINT_TO_BYTE 是一个功能块。它是用来将 UDINT（无符号双字）类型的数据转换为 BYTE（字节）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 BYTE 类型的数据。

总结来说，功能块 F_UDINT_TO_BYTE 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 BYTE 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_DINT 无符号双整型转双整型功能块

F_UDINT_TO_DINT 是一个功能块。它是用来将 UDINT（无符号双字）类型的数据转换为 DINT（双字）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 DINT 类型的数据。

总结来说，功能块 F_UDINT_TO_DINT 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 DINT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_DWORD 无符号双整型转双字型功能块

F_UDINT_TO_DWORD 是一个功能块。它是用来将 UDINT（无符号双字）类型的数据转换为 DWORD（双字）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发.

OUT：输出接口。输出转换后的 DWORD 类型的数据。

总结来说，功能块 F_UDINT_TO_DWORD 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 DWORD 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_INT 无符号双整型转整型功能块

F_UDINT_TO_INT 是一个功能块。它是用来将 UDINT（无符号双字）类型的数据转换为 INT（整数）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 INT 类型的数据。

总结来说，功能块 F_UDINT_TO_INT 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 INT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_LINT 无符号双整型转长整型功能块

F_UDINT_TO_LINT 是一个功能块。它是用来将 UDINT（无符号双字）类型的数据转换为 LINT（长整数）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 LINT 类型的数据。

总结来说，功能块 F_UDINT_TO_LINT 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 LINT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_LREAL 无符号双整型转长实数型功能块

F_UDINT_TO_LREAL 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 LREAL（长实数）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 LREAL 类型的数据。

总结来说，功能块 F_UDINT_TO_LREAL 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 LREAL 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_LWORD 无符号双整型转长字型功能块

F_UDINT_TO_LWORD 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 LWORD（长字）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 LWORD 类型的数据。

总结来说，功能块 F_UDINT_TO_LWORD 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 LWORD 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_REAL 无符号双整型转实数型功能块

F_UDINT_TO_REAL 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 REAL（实数）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 REAL 类型的数据。

总结来说，功能块 F_UDINT_TO_REAL 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 REAL 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_SINT 无符号双整型转短整型功能块

F_UDINT_TO_SINT 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 SINT（有符号字节）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 SINT 类型的数据。

总结来说，功能块 F_UDINT_TO_SINT 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 SINT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_STRING 无符号双整型转字符串型功能块

F_UDINT_TO_STRING 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 STRING（字符串）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 STRING 类型的数据。

总结来说，功能块 F_UDINT_TO_STRING 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 STRING 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_UINT 无符号双整型转无符号整型功能块

F_UDINT_TO_UINT 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 UINT（无符号字）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 UINT 类型的数据。

总结来说，功能块 F_UDINT_TO_UINT 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 UINT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_ULINT 无符号双整型转无符号长整型功能块

F_UDINT_TO_ULINT 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 ULINT（无符号长整型）类型的数据。以下是它的各个参数的解释.

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 ULINT 类型的数据。

总结来说，功能块 F_UDINT_TO_ULINT 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 ULINT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_USINT 无符号双整型转无符号短整型功能块

F_UDINT_TO_USINT 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 USINT（无符号字节）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 USINT 类型的数据。

总结来说，功能块 F_UDINT_TO_USINT 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 USINT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_WORD 无符号双整型转字型功能块

F_UDINT_TO_WORD 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 WORD（字）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 WORD 类型的数据。

总结来说，功能块 F_UDINT_TO_WORD 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 WORD 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_UDINT_TO_WSTRING 无符号双整型转宽字符串型功能块

F_UDINT_TO_WSTRING 是一个功能块。它用于将 UDINT（无符号双字）类型的数据转换为 WSTRING（宽字符串）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作并开始将 IN 输入接口的 UDINT 类型数据转换。

IN：输入接口。接收一个 UDINT 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 WSTRING 类型的数据。

总结来说，功能块 F_UDINT_TO_WSTRING 在 REQ 事件触发后开始运行，将 IN 接口接收到的 UDINT 类型数据转换为 WSTRING 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_LINT_TO_BYTE 长整型转比特型功能块

"F_LINT_TO_BYTE"是一个功能块。这个模块的主要任务是将 LINT（长整数）类型的数据转换为 BYTE（字节）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个 BYTE 类型数据的地方。

简单来说，如果你有一个 LINT 类型的值并希望将其转换为 BYTE 类型，你可以通过在REQ 输入事件上触发一个事件来开始转换操作，然后在 IN 接口上输入你的 LINT 数据。功能模块会开始执行转换操作，当完成后，它会在OUT 接口上输出一个 BYTE 类型的数据，并触发CNF 输出事件。

F_LINT_TO_DINT 长整数型转双整型功能块

"F_LINT_TO_DINT"是一个功能块。其主要任务是将 LINT（长整数）类型的数据转换为DINT（双字长整数）类型的数据。以下是对每个参数的详细解释：

REQ: 输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN: 输入接口，它接收一个 LINT 类型的数据。

CNF: 输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：: 输出接口，这是功能模块在完成转换操作后输出一个 DINT 类型数据的地方。

简单来说，如果你有一个 LINT 类型的值并希望将其转换为 DINT 类型，你可以通过在REQ 输入事件上触发一个事件来开始转换操作，然后在 IN 接口上输入你的 LINT 数据。功能模块会开始执行转换操作，当完成后，它会在OUT 接口上输出一个DINT 类型的数据，并在CNF 输出事件上触发一个事件。

F_LINT _TO_DWORD 长整数型转双字型功能块

"F_LINT_TO_DWORD"是一个功能块。其主要任务是将 LINT（长整数）类型的数据转换为DWORD（双字长无符号整数）类型的数据。以下是对每个参数的详细解释：

REQ: 输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN: 输入接口，它接收一个 LINT 类型的数据。

CNF: 输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：: 输出接口，这是功能模块在完成转换操作后输出一个 DWORD 类型数据的地方。

简单来说，如果你有一个 LINT 类型的值并希望将其转换为 DWORD 类型，你可以通过在 REQ 输入事件上触发一个事件来开始转换操作，然后在 IN 接口上输入你的 LINT 数据。功能模块会开始执行转换操作，当完成后，它会在OUT接口上输出一个DWORD 类型的数据，并在CNF 输出事件上触发一个事件。

F_LINT_TO_INT 长整数型转整型功能块

"F_LINT_TO_INT"是一个功能块。这个模块主要的功能就是将 LINT（长整数）类型的数据转换成 INT（整数）类型的数据。下面是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个 INT 类型数据的地方。

用简单的话来说，如果你有一个 LINT 类型的值，并想将它转换成 INT 类型，你可以在REQ 输入事件上触发一个事件来开始转换操作，然后在 IN 接口上输入你的 LINT 数

据。然后功能模块会开始执行转换操作，当完成后，它会在OUT 接口上输出一个 INT 类型的数据，并在CNF 输出事件上触发一个事件。

F_LINT_TO_LREAL 长整数型转长实数型功能块

"F_LINT_TO_LREAL"是一个功能块。其主要任务是将 LINT（长整数）类型的数据转换为 LREAL（长实数或者说双精度浮点）类型的数据。以下是对每个参数的详细解释：

REQ: 输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN: 输入接口，它接收一个 LINT 类型的数据。

CNF: 输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：: 输出接口，这是功能模块在完成转换操作后输出一个 LREAL 类型数据的地方。

简单来说，如果你有一个 LINT 类型的值并希望将其转换为 LREAL 类型，你可以通过在REQ 输入事件上触发一个事件来开始转换操作，然后在 IN 接口上输入你的 LINT 数据。功能模块会开始执行转换操作，当完成后，它会在OUT 接口上输出一个 LREAL 类型的数据，并在CNF 输出事件上触发一个事件。

F_LINT_TO_LWORD 长整数型转长字型功能块

"F_LINT_TO_LWORD"是一个功能块。其主要作用是将 LINT（长整数）类型的数据转换为 LWORD（长字长无符号整数）类型的数据。以下是对每个参数的详细解释：

REQ: 输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN: 输入接口，它接收一个 LINT 类型的数据。

CNF: 输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：: 输出接口，这是功能模块在完成转换操作后输出一个 LWORD 类型数据的地方。

简单来说，F_LINT_TO_LWORD 的功能模块接收一个 LINT 类型的值，并通过 REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个 LWORD 类型的数据并在 CNF 输出事件触发一个事件。

F_LINT_TO_REAL 长整数型转实数型功能块

"F_LINT_TO_REAL"是一个功能块。这个模块主要的功能就是将 LINT（长整数）类型的数据转换成 REAL（实数）类型的数据。下面是对每个参数的详细解释：

REQ：输入事件。当这个事件触发时，功能模块开始执行转换操作。

IN：输入接口，接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件被触发。

OUT：输出接口，功能模块在完成转换后在此输出一个REAL 类型的数据。

所以，如果你有一个 LINT 类型的值并想将它转换成REAL 类型，你可以在REQ 输入事件上触发一个事件来启动这个转换操作，然后在 IN 接口上输入你的 LINT 类型的值。功能模块会进行转换操作，并在完成后在 OUT 接口上输出一个 REAL 类型的数据，并且在CNF 输出事件上触发一个事件。

F_LINT_TO_SINT 长整数型转短整型功能块

"F_LINT_TO_SINT"是一个功能模块。这个模块主要的功能是将 LINT（长整数）类型的数据转换成 SINT（小型短整数）类型的数据。下面是对这个功能模块的参数的详细解释：

REQ：输入事件。当这个事件触发时，功能模块开始执行转换操作。

IN：输入接口，接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换后，这个事件会被触发。

OUT：输出接口，功能模块在完成转换操作后在这里输出一个 SINT 类型的数据。

简单来说，如果你有一个 LINT 类型的值，并且你希望将其转换为 SINT 类型，你可以在 REQ 输入事件上触发一个事件来启动转换操作，然后在 IN 接口上输入你的 LINT 数据。当转换完成后，功能模块会在OUT 接口上输出一个 SINT 类型的结果，并在 CNF 输出事件上触发一个事件。

F_LINT_TO_STRING 长整数型转字符串型功能块

"F_LINT_TO_STRING"是一个功能块。这个模块主要的功能是将 LINT（长整数）类型的数据转换成 STRING（字符串）类型的数据。以下是对每个参数的详细解释： REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。 OUT：输出接口，这是功能模块在完成转换操作后输出一个 STRING 类型数据的地方。

简单来说，F_LINT_TO_STRING 的功能模块接收一个 LINT 类型的值，并通过 REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个STRING 类型的数据，并在CNF 输出事件触发一个事件。

F_LINT_TO_UDINT 长整数型转无符号双整型功能块

"F_LINT_TO_UDINT"是一个功能模块。这个模块的主要功能是将 LINT（长整数）类型的数据转换为 UDINT（无符号的双字整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。 OUT：输出接口，这是功能模块在完成转换操作后输出一个UDINT 类型数据的地方。

简单来说，F_LINT_TO_UDINT 的功能模块接收一个 LINT 类型的值，并通过REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个UDINT 类型的数据，并在CNF 输出事件触发一个事件。

F_LINT_TO_UINT 长整数型转无符号整型功能块

"F_LINT_TO_UINT"是一个功能模块。这个模块的主要功能是将 LINT（长整数）类型的数据转换为 UINT（无符号短整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个UINT 类型数据的地方

简单来说，F_LINT_TO_UINT 的功能模块接收一个 LINT 类型的值，并通过 REQ 输入事件触发转换操作。当转换完成后，功能模块在 OUT 接口输出一个UINT 类型的数据， 并在CNF 输出事件触发一个事件。

F_LINT_TO_ULINT 长整数型转无符号长整型功能块

"F_LINT_TO_ULINT"是一个功能模块。这个模块的主要功能是将 LINT（长整数）类型的数据转换为 ULINT（无符号长整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。 OUT：输出接口，这是功能模块在完成转换操作后输出一个ULINT 类型数据的地方。

简单来说，F_LINT_TO_ULINT 的功能模块接收一个 LINT 类型的值，并通过REQ 输入事件触发转换操作。当转换完成后，功能模块在 OUT 接口输出一个ULINT 类型的数据， 并在CNF 输出事件触发一个事件。

F_LINT_TO_USINT 长整数型转无符号短整型功能块

"F_LINT_TO_USINT"是一个功能模块。这个模块的主要功能是将 LINT（长整数）类型的数据转换为 USINT（无符号小整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。 OUT：输出接口，这是功能模块在完成转换操作后输出一个USINT 类型数据的地方。

简单来说，F_LINT_TO_USINT 的功能模块接收一个 LINT 类型的值，并通过REQ 输入事件触发转换操作。当转换完成后，功能模块在 OUT 接口输出一个USINT 类型的数据， 并在CNF 输出事件触发一个事件。

F_LINT_TO_WORD 长整数型转字型功能块

"F_LINT_TO_WORD"是一个功能模块。这个模块的主要功能是将 LINT（长整数）类型的数据转换为 WORD（字）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。 OUT：输出接口，这是功能模块在完成转换操作后输出一个 WORD 类型数据的地方。

简单来说，F_LINT_TO_WORD 的功能模块接收一个 LINT 类型的值，并通过REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个WORD 类型的数据，并在CNF 输出事件触发一个事件。

F_LINT_TO_WSTRING 长整数型转长字符串型功能块

"F_LINT_TO_WSTRING"是一个功能模块。这个模块的主要功能是将 LINT（长整数）类型的数据转换为WSTRING（宽字符串）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LINT 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个 WSTRING 类型数据的地方。

简单来说，F_LINT_TO_WSTRING 的功能模块接收一个 LINT 类型的值，并通过 REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个 WSTRING 类型的数据，并在CNF 输出事件触发一个事件。

F_REAL_TO_DINT 实数型转双整型功能块

"F_REAL_TO_DINT"是一个功能块。其主要作用是将 REAL（实数）类型的数据转换为DINT（双整数）类型的数据。以下是这个功能块的参数说明：

REQ：输入事件。在此事件被触发时，功能块开始工作，开始将输入接口 IN 的 REAL 类型数据进行转换。

IN：输入接口。这是一个接收REAL 类型数据的接口。

CNF：输出事件。当数据转换完成后，将会触发此事件。

OUT：输出接口。用于输出转换成DINT 类型后的数据。

所以，总的来说，当 REQ 事件触发后，F_REAL_TO_DINT 功能块会开始工作，并将 IN 输入接口的 REAL 类型数据转换为 DINT 类型，一旦转换完成，将会触发CNF 事件，并通过OUT 输出接口输出转换后的数据。

F_REAL_TO_DWORD 实数型转双字型功能块

"F_REAL_TO_DWORD"是一个功能块。它的主要作用是将REAL（实数）类型的数据转换为 DWORD（双字）类型的数据。以下是此功能块的参数说明：

REQ：输入事件。当触发了这个事件后，功能块开始工作，并开始将输入接口 IN 的REAL 类型数据进行转换。

IN：输入接口。这是一个接收REAL 类型数据的接口。

CNF：输出事件。当数据转换完成时，这个事件会被触发。

OUT：输出接口。这是一个输出转换后的 DWORD 类型数据的接口。

总的来说，当触发REQ 事件后，F_REAL_TO_DWORD 功能块开始工作，将IN 输入接口的REAL 类型数据转化成 DWORD 类型，转换完成后，会触发CNF 事件，并通过OUT 输出接口输出转换后的数据。

F_REAL_TO_INT 实数型转整型功能块

"F_REAL_TO_INT"是一个功能块。它将 REAL（实数）类型数据转换为 INT（整数）类型数据。此功能块的参数解释如下：

REQ：输入事件。当此事件被触发时，功能块开始执行，开始将输入接口 IN 的 REAL 类型数据进行转换。

IN：输入接口。这是一个接受REAL 类型数据的接口。

CNF：输出事件。数据转换完成后，此事件被触发。

OUT：输出接口。这是输出转换后的 INT 类型数据的接口。

总的来说，当REQ 事件触发后，功能块F_REAL_TO_INT 开始运行，将IN 输入接口的REAL 类型数据转换为 INT 类型。一旦完成转换，便会触发 CNF 事件，并通过OUT输出接口输出转换后的数据。

F_REAL_TO_LINT 实数型转长整型功能块

"F_REAL_TO_LINT"是一个功能块。它的主要功能是将 REAL（实数）类型的数据转换为 LINT（长整数）类型的数据。以下是对这个功能块参数的解释：

REQ：输入事件。当这个事件被触发时，功能块开始工作，并开始将输入接口 IN 的REAL 类型数据进行转换。

IN：输入接口。这个接口接收REAL类型的数据。

CNF：输出事件。这个事件会在数据转换完成后被触发。

OUT：输出接口。这个接口输出转换后的LINT 类型数据。

简单来说，当REQ 事件被触发后，F_REAL_TO_LINT 功能块开始运行，将IN 输入接口接收的 REAL 类型数据转换为 LINT 类型的数据。转换完成后，会触发 CNF 事件，并通过 OUT 输出接口输出转换后的数据。

F_REAL_TO_LREAL 实数型转长实数型功能块

"F_REAL_TO_LREAL"是一个功能块。该功能块用于将REAL（实数）类型的数据转换为 LREAL（长实数）类型的数据。下面是关于这个功能块参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作，并开始将输入接口 IN 的 REAL 类型数据进行转换。

IN：输入接口。这是一个接收REAL类型数据的接口。

CNF：输出事件。当数据转换完成时，这个事件会被触发。

OUT：输出接口。这是一个输出转换后的 LREAL 类型数据的接口。

总的来说，当REQ 事件被触发后，F_REAL_TO_LREAL 功能块开始工作，将 IN 输入接口的REAL 类型数据转化为 LREAL 类型，转换完成后，会触发 CNF 事件，并通过OUT 输出接口输出转换后的数据。

F_REAL_TO_SINT 实数型转双整型功能块

"F_REAL_TO_SINT"是一个功能块。它的主要功能是将REAL（实数）类型的数据转换为 SINT（短整数）类型的数据。以下是对这个功能块各参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始执行，并开始将输入接口 IN 的REAL 类型数据进行转换。

IN：输入接口。这是一个接收REAL 类型数据的接口。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。该接口会输出转换后的 SINT 类型数据。

因此，当REQ 事件触发后，F_REAL_TO_SINT 功能块开始运行，将 IN 输入接口接收的REAL 类型数据转换为 SINT 类型的数据。数据转换完成后，将触发CNF 事件，并通过OUT 输出接口输出转换后的数据。

F_REAL_TO_STRING 实数型转字符串型功能块

"F_REAL_TO_STRING"是一个功能块。主要功能是将 REAL（实数）类型的数据转换为 STRING（字符串）类型的数据。下面是对这个功能块参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并将输入接口 IN 的 REAL 类型数据进行转换。

IN：输入接口。这是一个接收REAL类型数据的接口。

CNF：输出事件。一旦数据转换完成，这个事件将被触发。

OUT：输出接口。这是一个输出转换后的 STRING 类型数据的接口。

概括来说，当REQ 事件被触发后，F_REAL_TO_STRING 功能块开始运行，将接收自 IN 输入接口的 REAL 类型数据转换为 STRING 类型。完成转换后，将通过OUT 输出接口输出转换后的数据，并触发 CNF 事件。

F_REAL_TO_UDINT 实数型转无符号双整型功能块

"F_REAL_TO_UDINT"是一个功能块。它的作用是将 REAL（实数）类型的数据转换为UDINT（无符号双整型）类型的数据。以下是

关于这个功能块的参数解释：

REQ：输入事件。当此事件被触发，功能块开始工作，并对输入接口 IN 的REAL 数据进行转换。

IN：输入接口。这个接口接收REAL 类型的数据。

CNF：输出事件。当数据转换完成后，此事件被触发。

OUT：输出接口。这个接口输出转换后的 UDINT 类型的数据。

总的来说，当REQ 事件被触发时，F_REAL_TO_UDINT 功能块开始工作，把从 IN 接口接收的 REAL 类型数据转换为 UDINT 类型的数据。转换完成后，通过 OUT 接口输出转换后的数据，并触发 CNF 事件。

F_REAL_TO_UINT 实数型转无无符号整型功能块

"F_REAL_TO_UINT"是一个功能块。它被用来将 REAL（实数）类型的数据转换为UINT（无符号整型）类型的数据。下面是关于这个功能块各参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作，并开始对输入接口 IN 的REAL 类型数据进行转换。

IN：输入接口。这是一个接收REAL 类型数据的接口。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。这个接口将输出转换后的UINT 类型数据。

总结一下，当REQ 事件被触发时，F_REAL_TO_UINT 功能块开始运行，将IN 输入接口接收的 REAL 类型数据转换为 UINT 类型的数据。数据转换完成后，将触发CNF 事件， 并通过 OUT 输出接口输出转换后的数据。

F_REAL_TO_ULINT 实数型转无符号长整型功能块

"F_REAL_TO_ULINT"是一个功能块。主要作用是将 REAL（实数）类型的数据转换为ULINT（无符号长整型）类型的数据。这里是功能块参数的解释：

REQ：输入事件。当这个事件被触发，功能块开始转换从输入接口 IN 接收的 REAL 类型数据。

IN：输入接口。此接口接收REAL类型的数据。

CNF：输出事件。数据转换完成后，这个事件将被触发。

OUT：输出接口。此接口输出转换完成后的ULINT 类型数据。

总体来说，当REQ 事件被触发时，F_REAL_TO_ULINT 功能块开始运行，将从 IN 输入接口接收的 REAL 类型数据转换为 ULINT 类型的数据。数据转换完成后，将通过 OUT 输出接口输出转换后的数据，并触发 CNF 事件。

F_REAL_TO_USINT 实数型转无符号短整型功能块

"F_REAL_TO_USINT"是一个功能块，即函数

块。其主要作用是将 REAL（实数）类型的数据转换为 USINT（无符号小整型）类型的数据。下面是对这个功能块参数的解析：

REQ：输入事件。这个事件翻译为"请求"或"要求"。当此事件被触发，也即当有一个请求发生，函数块就开始对输入接口 IN 的REAL 数据进行转换操作。

IN：输入接口。这个接口接受REAL 类型的数据。

CNF：输出事件。这个事件意味着"确认"或"完成"。当 REAL 数据被转换为USINT 数据后，这个事件就会被触发，表示转换操作已经完成。

OUT：输出接口。这个接口输出转换完成后的 USINT 类型的数据。

简单来说，当REQ 事件被触发，即有一个转换请求时，F_REAL_TO_USINT 函数块就开始工作，将 IN 口接收的REAL 类型的数据转换为 USINT 类型。转换完成后，通过 OUT 口输出结果，并触发 CNF 事件以表示转换完成。

F_REAL_TO_WSTRING 实数型转宽字符串型功能块

"F_REAL_TO_WSTRING"是一个功能块。它用于将REAL（实数）类型的数据转换为 WSTRING（宽字符串）类型的数据。以下对每个参数的解释：

REQ：输入事件。这个事件被触发时，功能块开始从输入接口 IN 的 REAL 类型数据开始工作并转换成WSTRING 类型。

IN：输入接口。这个接口接收REAL 类型的数据。

CNF：输出事件。当数据转换完成后，这个事件将被触发。

OUT：输出接口。这个接口输出转换后的 WSTRING 类型的数据。

简而言之，当REQ 事件被触发，功能块F_REAL_TO_WSTRING 开始运行，并将来自输入接口 IN 的REAL 类型数据转换为WSTRING 类型的数据。数据转换完成后，会通过输出接口 OUT 输出数据，并触发CNF 事件。

F_LREAL_TO_DINT 长实数型转双整型功能块

"F_LREAL_TO_DINT"是一个功能模块。这个模块的主要功能是将 LREAL（长实数）类型的数据转换为DINT（双整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LREAL 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。 OUT：输出接口，这是功能模块在完成转换操作后输出一个DINT 类型数据的地方。

简单来说，F_LREAL_TO_DINT 的功能模块接收一个 LREAL 类型的值，并通过REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个DINT 类型的数

据，并在CNF 输出事件触发一个事件。

F_LREAL_TO_INT 长实数型转整型功能块

"F_LREAL_TO_INT"是一个功能模块。这个模块的主要功能是将 LREAL（长实数）类型的数据转换为 INT（整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LREAL 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个 INT 类型数据的地方。简单来说，F_LREAL_TO_INT 的功能模块接收一个 LREAL 类型的值，并通过REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个INT 类型的数据， 并在CNF 输出事件触发一个事件。

F_LREAL_TO_LINT 长实数型转长整型功能块

"F_LREAL_TO_LINT"是一个功能模块。这个模块的主要功能是将 LREAL（长实数）类型的数据转换为 LINT（长整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LREAL 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。 OUT：输出接口，这是功能模块在完成转换操作后输出一个 LINT 类型数据的地方。

简单来说，F_LREAL_TO_LINT 的功能模块接收一个 LREAL 类型的值，并通过REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个LINT 类型的数据，并在CNF 输出事件触发一个事件。

F_LREAL_TO_LWORD 长实数型转长字型功能块

"F_LREAL_TO_LWORD"是一个功能模块。这个模块的主要功能是将 LREAL（长实数）类型的数据转换为 LWORD（长字）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当这个事件被触发时，功能模块开始执行转换操作。

IN：输入接口，它接收一个 LREAL 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，这个事件将被触发。

OUT：输出接口，这是功能模块在完成转换操作后输出一个 LWORD 类型数据的地方。

简单来说，F_LREAL_TO_LWORD 的功能模块接收一个 LREAL 类型的值，并通过 REQ 输入事件触发转换操作。当转换完成后，功能模块在OUT 接口输出一个 LWORD 类型的数据，并在 CNF 输出事件触发一个事件。

F_LREAL_TO_REAL 长实数型转实数型功能块

"F_LREAL_TO_REAL"是一个功能块。它的主要功能是将 LREAL（长实数）类型的数据转换为REAL（实数）类型的数据。以下是参数的详细解释：

REQ：输入事件。当此事件被触发时，功能模块开始执行转换操作。

IN：数据输入，接收 LREAL 类型的数据。

CNF：输出事件。当功能模块完成转换操作后，此事件将被触发。

OUT：数据输出，转换操作完成后输出 REAL 类型的数据。

简单来说，F_LREAL_TO_REAL 功能模块接收一个 LREAL 类型的值，并通过REQ 输入事件触发转换操作。操作完成后，通过 OUT 接口输出一个REAL 类型的数据，并通过CNF 输出事件向用户发完成信号。

F_LREAL_TO_SINT 长实数型转短整型功能块

"F_LREAL_TO_SINT"是一个功能块。它的主要任务是将 LREAL（长实数）类型的数据转换为 SINT（短整数）类型的数据。以下是这些参数的详细解释：

REQ：输入事件。当此事件被触发时，功能模块开始进行转换操作。

IN：输入接口，这是传入 LREAL 类型数据的位置。

CNF：输出事件。完成转换操作后，将触发此事件。

OUT：输出接口，这是功能模块在完成转换操作后输出 SINT 类型数据的位置。

总的来说，F_LREAL_TO_SINT 功能模块接收一个 LREAL 类型的值，并通过REQ 输入事件触发一个转换操作。完成转换后，功能模块在OUT 接口输出一个 SINT 类型的数据，并通过 CNF 输出事件产生一个信号。

F_LREAL_TO_STRING 长实数型转字符串型功能块

"F_LREAL_TO_STRING"是一个功能块。它的主要功能是将 LREAL（长实数）类型的数据转换为 STRING（字符串）类型的数据。以下是这些参数的详细解释：

REQ：输入事件。当此事件被触发时，转换操作开始运行。

IN：输入接口，接收一个LREAL类型的数据。

CNF：输出事件。完成转换操作后，将触发此事件。

OUT：输出接口，完成转换操作后输出 STRING 类型的数据。

总的来说，F_LREAL_TO_STRING 功能模块是在接收到一个 LREAL 类型的值后，通过REQ 输入事件触发转换操作。转换完成后，通过OUT 接口输出一个STRING 类型的数据，并且通过CNF 输出事件产生一个完成的信号。

F_LREAL_TO_UDINT 长实数型转无符号双整型功能块

"F_LREAL_TO_UDINT"是一个功能模块。其主要作用是将 LREAL 类型（长实数）的数据转换为 UDINT（无符号双字整数）类型的数据。下面是对参数的详细解释：

REQ：输入事件。触发此事件会开始转换操作。

IN：输入接口，接收LREAL类型的数据。

CNF：输出事件。完成转换操作后，会触发此事件。

OUT：输出接口，完成转换后输出的是UDINT 类型的数据。

总的来说，F_LREAL_TO_UDINT 功能模块接收一个LREAL 类型的值，通过REQ 输入事件触发转换操作。操作完成后，通过 OUT 接口输出一个UDINT 类型的数据，并通过CNF 输出事件转换完成的信号。

F_LREAL_TO_UINT 长实数型转无符号整型功能块

"F_LREAL_TO_UINT"是一个功能模块。它将 LREAL（长实数）类型的数据转换为 UINT

（无符号整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。当此事件被触发时，会对 IN 接口的 LREAL 类型数据执行转换操作。IN：输入接口，接收 LREAL 类型的数据。

CNF：输出事件。完成转换操作后，会触发此事件。

OUT：输出接口，转换完成后的 UINT 类型数据将从这里输出。

总的来说，此功能模块在收到REQ 触发事件后，将IN 接口的 LREAL 类型数据转换为UINT 类型的数据，并从OUT 接口输出，然后触发CNF 输出事件来表示转换操作已经完成。

F_LREAL_TO_ULINT 长实数型转无符号整型功能块

"F_LREAL_TO_ULINT" 是一个功能模块。该模块的主要功能是将 LREAL 类型（长实数） 的数据转换为ULINT 类型（无符号长整数）的数据。以下是参数的详细解释： REQ：输入事件。当此事件被触发，模块会开始将输入接口 IN 的 LREAL 类型数据执行转换操作。

IN：这是输入接口。它接收一个 LREAL 类型的数据。

CNF：输出事件。当转换操作完成后，它被触发。

OUT：这是输出接口。转换完成后的 ULINT 类型数据将从这里输出。

所以说，F_LREAL_TO_ULINT 模块在 REQ 输入事件被触发后，接收到 IN 接口的 LREAL 类型数据，进行转换操作，然后通过 OUT 接口输出转为ULINT 类型的数据，并通过CNF 输出事件来表示转换操作已完成。

F_LREAL_TO_USINT 长实数型转无符号短整型功能块

"F_LREAL_TO_USINT"是一个功能模块。它的主要功能是将 LREAL（长实数）类型的数据转换成USINT（无符号短整数）类型的数据。以下是关于模块中各个参数的详解：

REQ：输入事件。当该事件被触发时，会开始对 IN 接口输入的 LREAL 类型的数据执行转换操作。

IN：输入接口。接收一个LREAL类型的数据。

CNF：输出事件。当转换操作完成后，该事件将被触发。

OUT：输出接口。在转换完成后，转换得到的 USINT 类型的数据会从这个接口输出。总的来说，F_LREAL_TO_USINT 模块在REQ 输入事件被触发后，将 IN 接口的LREAL 类型数据进行转换，然后通过 OUT 接口输出 USINT 类型的数据，并通过CNF输出事件

F_LREAL_TO_WSTRING 长实数型转宽字符串型功能块

"F_LREAL_TO_WSTRING"是一个功能模块。其主要作用是将 LREAL（长实数）类型的数据转换成 WSTRING（宽字符串）类型的数据。这是对每个参数的详细解释：

REQ：输入事件。当此事件被触发后，将开始对接口 IN 的 LREAL 类型数据进行转换。

IN：输入接口，它接收一个 LREAL 类型的数据。

CNF：输出事件。转换完成后，会触发此事件。

OUT：输出接口。转换后的 WSTRING 类型数据将从此接口输出。

这意味着：在REQ 输入事件被触发后，"F_LREAL_TO_WSTRING"模块将接口 IN 的LREAL 类型数据转换为 WSTRING 类型，并通过接口OUT 输出，同时通过CNF 输出事件表示转换完成。

F_LWORD_TO_BYTE 长字型转比特型功能块

"F_LWORD_TO_BYTE"是一个功能模块。它的主要功能是将 LWORD（长字）类型的数据转换成 BYTE（字节）类型的数据。下面是对各个参数的详细说明：

REQ：输入事件。当这个事件被触发时，模块开始对输入接口 IN 的 LWORD 类型数据执行转换操作。

IN：这是输入接口，其接收一个 LWORD 类型的数据。

CNF：输出事件。转换完成后，这个事件被触发。

OUT：这是输出接口。转换完成后，BYTE 类型数据将从这个接口输出。

所以，当REQ 输入事件被触发后，F_LWORD_TO_REAL 模块将接受到的IN 接口的LWORD 类型数据进行转换，并通过OUT 接口输出转换后的 REAL 类型数据，然后通过CNF 输出事件表示该转换操作已完成。

F_LWORD_TO_DINT 长字型转双整型功能块

"F_LWORD_TO_DINT"是一个功能块。主要用于将 LWORD（长字）类型的数据转换为DINT（双字整数）类型的数据。为了方便理解，这里是对于里面的每个参数的解释：

REQ：这是输入事件。它在被触发后，功能块开始运行，将输入的 LWORD 类型的数据进行转换。

IN： 输入端口。它接受一个 LWORD 类型的数据。

CNF：输出事件。是在转换完成后触发的事件。

OUT：输出端口。在转换完成后，转换得到的 DINT 类型的数据会通过这个端口输出。

总结一下，当REQ 事件被触发后，F_LWORD_TO_DINT 功能块会开始工作，在接收到IN 端口的数据后进行转换，完成转换后通过OUT 端口输出 DINT 类型的数据，并触发CNF 事件表示转换完成。

F_LWORD_TO_DWORD 长字型转双字型功能块

"F_LWORD_TO_DWORD"是一个功能块。它的主要功能是将 LWORD（长字）类型的数据转换为DWORD（双字）类型的数据。以下是各个参数的解释：

REQ：是输入事件。一旦此事件被触发，功能块开始转换接口 IN 中的 LWORD 类型的数据。

IN：是个输入接口，用于接收一个 LWORD 类型的数据。

CNF：输出事件。显示数据转换已完成。

OUT：: 输出接口，用于输出转换后的DWORD 类型的数据。

综上，REQ 事件触发后，F_LWORD_TO_DWORD 功能块接收 IN 接口的 LWORD 数据， 完成转换后，通过OUT 接口输出 DWORD 类型的数据，并通过 CNF 事件标识转换完成。

F_LWORD_TO_INT 长字型转整型功能块

"F_LWORD_TO_INT"是一个功能块。这个功能块的主要功能是将 LWORD（长字）类型的数据转换为 INT（整数）类型的数据。针对参数的详细解释如下：

REQ：这是输入事件。在此事件触发后，功能块将开始将输入接口 IN 的 LWORD 类型数据进行转换。

IN：这是输入接口，用于接收 LWORD 类型的数据。

CNF：这是输出事件，当数据转换完成后，该事件被触发。

OUT：这是输出接口，数据转换完成后，转换的 INT 类型数据将从这个接口输出。

总的来说，REQ 事件在被触发后，F_LWORD_TO_INT 功能块将开始接收 IN 接口的数据并进行转换，转换完成后，会触发CNF 事件，并通过 OUT 接口输出 INT 类型的数据。

F_LWORD_TO_LINT 长字型转长整型功能块

"F_LWORD_TO_LINT"是一个功能块。它的主要功能是将 LWORD（长字）类型的数据转换为 LINT（长整数）类型的数据。以下是每个参数的简要解释：

REQ：输入事件。一旦此事件被触发，功能块就开始工作，转换 IN 输入接口的LWORD 类型数据。

IN：输入接口，用于接收一个 LWORD 类型的数据。

CNF：输出事件。一旦数据转换完成，它就会被触发。

OUT：输出接口，用于输出转换后的 LINT 类型数据。

总的来说，当REQ 事件被触发后，F_LWORD_TO_LINT 功能块就开始工作，接收 IN 接口的数据进行转换，完成后通过 OUT 接口输出 LINT 类型的数据，并触发CNF 事件表明转换完成。

F_LWORD_TO_LREAL 长字型转实数型功能块

"F_LWORD_TO_LREAL"是一个功能块。它的主要功能是将 LWORD（长字）类型的数据转换为 LREAL（长实数）类型的数据。以下是每个参数的简要解释：

REQ：输入事件。当此事件被触发时，功能块开始工作，转换 IN 输入接口中的LWORD 类型的数据。

IN：输入接口，用于接收一个 LWORD 类型的数据。

CNF：输出事件。完成数据转换后，该事件将被触发。

OUT：输出接口，用于输出转换后的 LREAL 类型的数据。

总结来讲，当REQ 事件被触发后，F_LWORD_TO_LREAL 功能块开始接收IN 接口中的数据进行转换，转换完成后，会触发 CNF 事件，并通过OUT 接口输出 LREAL 类型的数据。

F_LWORD_TO_SINT 长字型转短整型功能块

"F_LWORD_TO_SINT"是一个功能块。它的主要目的是将 LWORD（长字）数据类型转换成 SINT（短整数）数据类型。每个参数的具体解释如下：

REQ：这是输入事件。当此事件被触发时，功能块开始转换 IN 输入接口的LWORD 类

型数据。

IN：这是输入接口，用于接收LWORD类型的数据。

CNF：这是输出事件。一旦数据转换完成，此事件将被触发。

OUT：这是输出接口，用于输出转换后的 SINT 类型数据。

简而言之，当REQ 事件被触发后，F_LWORD_TO_SINT 功能块开始接收IN 接口的数据并进行转换，转换完成后，将通过OUT 接口输出 SINT 类型数据，并触发CNF 事件表示转换完成。

F_LWORD_TO_STRING 长字型转字符串型功能块

"F_LWORD_TO_STRING"是一个功能块。其主要功能是将 LWORD（长字）类型的数据转换为 STRING（字符串）类型的数据。以下为其参数的解释：

REQ：输入事件。当此事件被触发时，功能块开始工作，开始转换 IN 输入接口中的LWORD 类型数据。

IN：输入接口，用于接收一个 LWORD 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口，用于输出转换后的 STRING 类型数据。

总的来说，当REQ 事件被触发后，F_LWORD_TO_STRING 功能块开始接收来自 IN 接口的 LWORD 类型数据并进行转换，转换完成后会触发 CNF 事件，并通过OUT 接口输出 转换后的 STRING 类型数据。

F_LWORD_TO_UDINT 长字型转无符号双整型功能块

"F_LWORD_TO_UDINT"是一个功能块。它的主要作用是将 LWORD（长字）类型的数据转换为 UDINT（无符号双字整数）类型的数据。以下是各个参数的解释：

REQ：输入事件。当此事件触发时，功能块开始工作，开始转换 IN 输入接口的LWORD 类型数据。

IN：输入接口。用于接收一个 LWORD 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。用于输出转换后的 UDINT 类型的数据。

总而言之，当REQ 事件触发后，F_LWORD_TO_UDINT 功能块开始接收IN 接口的LWORD 类型数据并进行转换，完成后会触发CNF 事件，并通过 OUT 接口输出转换后的 UDINT 类型数据。

F_LWORD_TO_UINT 长字型转无符号整型功能块

"F_LWORD_TO_UINT"是一个功能块。它被用于将 LWORD（长字）类型的数据转换为 UINT（无符号整数）类型的数据。下面是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 LWORD 类型数据转换。

IN：输入接口。接收一个 LWORD 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 UINT 类型的数据。

总的来说，功能块 F_LWORD_TO_UINT 在 REQ 事件触发后开始工作，将 IN 接口接收到的 LWORD 类型数据转换为UINT 类型，并在完成转换后触发 CNF 事件，通过 OUT 接口输出转换后的数据。

F_LWORD_TO_ULINT 长字型转无符号长整型功能块

"F_LWORD_TO_ULINT"是一个功能块。它是用来将 LWORD（长字）类型的数据转换为 ULINT（无符号长整数）类型的数据。以下是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 LWORD 类型数据转换。

IN：输入接口。接收一个 LWORD 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 ULINT 类型的数据。

总结来说，功能块 F_LWORD_TO_ULINT 在REQ 事件触发后开始运行，将IN 接口接收到的 LWORD 类型数据转换为ULINT 类型，并在完成转换后触发CNF 事件，通过OUT 接口输出转换后的数据。

F_LWORD_TO_USINT 长字型转无符号整型功能块

"F_LWORD_TO_USINT"是一个功能块。它用于将 LWORD（长字）类型的数据转换为 USINT（无符号小整数）类型的数据。以下是这个功能块参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 LWORD 类型数据转换。

IN：输入接口。接收一个 LWORD 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 USINT 类型的数据。

总的来说，功能块 F_LWORD_TO_USINT 在 REQ 事件触发后开始工作，它将 IN 输入接口接收到的 LWORD 类型数据转换为USINT 类型，一旦转换完成，它将触发CNF 事件，并通过 OUT 输出接口输出转换后的数据。

F_LWORD_TO_WORD 长字型转字型功能块

"F_LWORD_TO_WORD"是一个功能块。它被用于将 LWORD（长字）类型的数据转换为 WORD（字）类型的数据。下面是它的各个参数的解释：

REQ：输入事件。当此事件被触发，功能块开始工作并开始将 IN 输入接口的 LWORD

类型数据转换。

IN：输入接口。接收一个 LWORD 类型的数据。

CNF：输出事件。数据转换完成后，此事件将被触发。

OUT：输出接口。输出转换后的 WORD 类型的数据。

总的来说，功能块 F_LWORD_TO_WORD 在REQ 事件触发后开始工作，将 IN 接口接收到的 LWORD 类型数据转换为 WORD 类型，并在完成转换后触发CNF 事件，通过OUT 接口输出转换后的数据。

F_LWORD_TO_WSTRING 长字型转长字符串型功能块

"F_LWORD_TO_WSTRING"是一个功能块。这个功能块被用来将 LWORD（长字）类型的数据转换为 WSTRING（宽字符串）类型的数据。以下是它的参数的解释：

REQ：输入事件。当此项被触发时，功能块开始工作并开始进行输入接口 IN 的LWORD 类型数据的转换。

IN：输入接口。这是一个接收LWORD类型数据的接口。

CNF：输出事件。当数据转换完成后，这个事件会被触发。

OUT：输出接口。这是一个输出转换后的 WSTRING 类型数据的接口。

总的来说，当REQ 事件触发后，功能块F_LWORD_TO_WSTRING 开始运行，将 IN 输入接口的 LWORD 类型数据转换成 WSTRING 类型，一旦转换完成，就会触发CNF 事件，并通过 OUT 输出接口输出转换后的数据。

F_SINT_TO_BYTE 短整型转比特型功能块

"F_SINT_TO_BYTE"是一个功能块。这个功能块的作用是把 SINT（有符号短整型）类型的数据转换为 BYTE（字节）类型的数据。各个参数的含义如下：

REQ：输入事件。这个事件被触发时，功能块就会开始将输入接口 IN 的 SINT 类型数据转换成 BYTE 类型。

IN：输入接口。接收 SINT 类型的数据。

CNF：输出事件。一旦数据转换完成，这个事件就会被触发。

OUT：输出接口。输出转换完成后的 BYTE 类型数据。

总结一下，当REQ 事件被触发时，F_SINT_TO_BYTE 功能块开始运行，再将从 IN 输入接口接收的 SINT 类型数据转换成 BYTE 类型数据。数据转换完成，并通过 OUT 输出接口输出转换好的数据后，就会触发CNF 事件。

F_SINT_TO_DINT 短整型转双整型功能块

"F_SINT_TO_DINT"是一个功能块。这个功能块的主要功能是将 SINT（有符号短整型）类型的数据转换为 DINT（双字长整型）类型的数据。让我们简单解析一下这些参数的含义：

REQ：输入事件。当此事件被触发，即有一个执行请求时，功能块就开始执行，将输入接入 IN 接收到的 SINT 类型数据转换成DINT 类型的数据。

IN：输入接口。用于接收 SINT 类型的数据。

CNF：输出事件。这是一个确认事件，当数据转换完成后，这个事件将会被触发，表示转换操作已完成。

OUT：输出接口。这个接口用于输出转换完成后的DINT 类型的数据。

所以总的来说，当REQ 事件被触发，即有一个请求时，F_SINT_TO_DINT 功能块就会工作，将输入接口IN 接收到的 SINT 类型数据转换成 DINT 类型的数据。当数据转换完成后，通过OUT 接口输出，并触发 CNF 事件，告知用户数据转换已完成。

F_SINT_TO_DWORD 短整型转双字型型功能块

"F_SINT_TO_DWORD"是一个功能块。这个功能块的主要作用是将 SINT（有符号整数）类型的数据转换为 DWORD（双字长无符号整数）类型的数据。具体参数的说明如下：

REQ：输入事件。当此事件被触发时， 功能块就会开始将输入接口 IN 的 SINT 类型数据转换为DWORD 类型数据。

IN：输入接口。这个接口接收类型为 SINT 的数据。

CNF：输出事件。当数据转换完成后，这个事件将被触发。

OUT：输出接口。这个接口用于输出转换后的 DWORD 类型数据。

总结一下，当REQ 事件被触发时，F_SINT_TO_DWORD 功能块开始运行，将输入接口IN 接收的 SINT 类型数据转换为 DWORD 类型数据。当数据转换完成后，通过 OUT 接口输出转换后的数据，并触发CNF 事件。

F_SINT_TO_INT 短整型转整型功能块

"F_SINT_TO_INT" 是一个功能块。此功能块的目的是将 SINT（有符号整数）类型的数据转换为 INT（整型）类型的数据。该功能块参数的具体含义如下：

REQ：输入事件。当这个事件被触发时，功能块开始转换操作，将从输入接口 IN 接收到的 SINT 类型的数据转换为 INT 类型数据。

IN：输入接口。此接口用于接收 SINT 类型的数据。

CNF：输出事件。在数据转换完成后会触发此事件。

OUT：输出接口。用于输出转换完成后的 INT 类型数据。

综上，当 REQ 事件被触发时，F_SINT_TO_INT 功能块会开始运行，开始将 IN 接口输入的 SINT 数据转换为 INT 数据。当数据转换完成后，将转换结果通过 OUT接口输入，并触发 CNF 事件。

F_SINT_TO_LINT 短整型转长整型功能块

"F_SINT_TO_LINT"是一个在可编程逻辑控制器（PLC）编程中使用的功能块。它的主要任务是将 SINT（有符号整数）类型的数据转换为 LINT（长整型）类型的数据。这些参数的解释如下：

REQ: 输入事件。当此事件得到触发，功能块将开始把输入接口 IN 的 SINT 类型数据转换为 LINT 类型数据。

IN: 输入接口。这个接口接收 SINT 类型的数据。

CNF: 输出事件。当数据转换完成后，这个事件将被触发。

OUT：: 输出接口。这个接口用于输出转换完成后的 LINT 类型数据。

总的来说，当REQ 事件被触发时，F_SINT_TO_LINT 功能块会开始工作，把输入接口 IN 接收到的 SINT 类型数据转换为 LINT 类型数据。一旦数据转换完成，就会触发CNF 事件并通过OUT 接口输出转换后的数据。

F_SINT_TO_LREAL 短整型转长实数型功能块

"F_SINT_TO_LREAL"是一个功能块。该功能块的作用是将 SINT（有符号整数）类型的数据转换为 LREAL（长实数）类型的数据。下面是各参数的具体含义：

REQ：输入事件。当此事件被触发时，功能块开始转换操作，将从输入接口 IN 接收到的 SINT 类型的数据转换为 LREAL 类型数据。

IN：输入接口。此接口用于接收 SINT 类型的数据。

CNF：输出事件。在数据成功转换为 LREAL 类型后，将触发该事件。

OUT：输出接口。在数据转换完成后，该接口将输出转换后的 LREAL 类型数据。

总的来说，当触发REQ 事件时，F_SINT_TO_LREAL 功能块开始运行，将 IN 接口输入的 SINT 数据转换为 LREAL 数据。数据转换完成后，通过 OUT 接口输出转换后的数据，并触发 CNF 事件。

F_SINT_TO_LWORD 短整型转长字型功能块

"F_SINT_TO_LWORD"是一个功能块。其主要作用是将 SINT（有符号整数）类型的数据转换为 LWORD（长字）类型的数据。下面是各个参数的具体含义：

REQ: 输入事件。当这个事件被触发时，功能块开始执行，将从 IN 接口接收到的 SINT 类型数据转换为 LWORD 类型数据。

IN: 输入接口。这是输入要被转换的 SINT 类型数据的地方。

CNF: 输出事件。当数据成功转换为 LWORD 类型后，将触发这个事件。

OUT：: 输出接口。这是输出已转换为 LWORD 类型数据的地方。

因此，总结来说，当 REQ 事件被触发时，F_SINT_TO_LWORD 功能块开始运行，将 IN 接口输入的 SINT 数据转换为 LWORD 数据。转换完成后，通过 OUT 接口输出转换后的数据，并触发CNF 事件。

F_SINT_TO_REAL 短整型转实数型功能块

"F_SINT_TO_REAL"是一个功能块。它用于将SINT（有符号整数）类型的数据转换为 REAL（实数）类型的数据。以下是每个参数的详细说明：

REQ：输入事件。当这个事件被触发时，功能块开始将输入接口 IN 中的 SINT 类型数据转换为 REAL 类型数据。

IN：输入接口。此接口用于接收 SINT 类型的数据。

CNF：输出事件。当数据转换完成后，此事件会被触发。

OUT：输出接口。输出已转换为 REAL 类型的数据。

总的来说，当REQ 事件被触发时，F_SINT_TO_REAL 功能块开始工作，将IN 接口的SINT 类型数据转换为REAL 类型的数据。当数据转换完成后，CNF 事件会被触发，同时 OUT 接口将输出转换后的 REAL 数据。

F_SINT_TO_STRING 短整型转字符串型功能块

"F_SINT_TO_STRING"是一个功能块。这个功能块用来将 SINT（有符号整数）类型的数据转换为 STRING（字符串）类型的数据。以下是参数的具体含义：

REQ：输入事件。当这个事件被触发时，功能块开始运行，将从 IN 接口接收到的 SINT 类型数据转换为 STRING 类型数据。

IN：输入接口。这是输入 SINT 类型数据的接口。

CNF：输出事件。当数据成功转换为 STRING 类型后，这个事件会被触发。

OUT：输出接口。这是输出转换后的 STRING 类型数据的接口。

因此，当REQ 事件被触发时，F_SINT_TO_STRING 功能块开始运行，它将IN 接口输入的 SINT 数据转换为 STRING 数据。之后，OUT 接口将会输出转换成 STRING 类型的数据，并触发 CNF 事件。

F_SINT_TO_UDINT 短整型转无符号双整型功能块

"F_SINT_TO_UDINT"是一个功能块。这个功能块的作用是将 SINT（有符号整数）类型的数据转换为 UDINT（无符号双整数）类型的数据。以下是各参数的具体说明：

REQ：输入事件。当这个事件被激活时，功能块会开始执行，将从 IN 接口接收到的SINT 类型数据转换为UDINT 类型数据。

IN：输入接口。这个接口是输入SINT 类型数据的地方。

CNF：输出事件。当数据成功转换为 UDINT 类型后，这个事件会被激发。

OUT：输出接口。这个是输出已经转换为 UDINT 类型数据的地方。

总而言之，当REQ 事件被激活时，F_SINT_TO_UDINT 功能块开始运行，将IN 接口输入的 SINT 数据转换为UDINT 数据。在转换完成后，通过OUT 接口输出转换后的数据，并激发 CNF 事件。

F_SINT_TO_UINT 短整型转无符号整型功能块

"F_SINT_TO_UINT"是一个功能块。这个功能块用来将 SINT（有符号整数）类型的数据转换为 UINT（无符号整数）类型的数据。以下是各参数的详细说明：

REQ：输入事件。当这个事件被触发时，功能块开始将输入接口 IN 中的 SINT 类型数据转换为 UINT 类型数据。

IN：输入接口。这是输入 SINT 类型数据的地方。

CNF：输出事件。当数据成功转换为 UINT 类型后，这个事件会被触发。

OUT：输出接口。这是输出转换后的 UINT 类型数据的地方。

综上所述，当REQ 事件被触发时，F_SINT_TO_UINT 功能块开始运行，将从 IN 接口接收到的 SINT 数据转换为 UINT 类型的数据。在完成转换后，通过 OUT 接口输出转换后的 UINT 类型数据，并触发 CNF 事件。

F_SINT_TO_ULINT 短整型转无符号长整型功能块

"F_SINT_TO_ULINT"是一个功能块。这个功能块的作用是将 SINT（有符号整数） 类型的数据转换为 ULINT（无符号长整数） 类型的数据。下面是对各参数的具体解释：

REQ：输入事件。当这个事件被激活时，功能块会开始执行，并从 IN 接口接收 SINT 类型的数据进行转换。

IN：输入接口。这是一个接收 SINT 类型数据的口。

CNF：输出事件。当 SINT 数据成功转为 ULINT 类型数据后，此事件就会被触发。

OUT：输出接口。转化为 ULINT 类型后的数据将通过此接口输出。

所以，当 REQ 事件被触发时，F_SINT_TO_ULINT 功能块就会开始执行，它会将 IN 接口输入的 SINT 类型数据转换为 ULINT 类型数据。在转换完成后，OUT 会输出转换后的 ULINT 类型数据，并触发 CNF 事件。

F_SINT_TO_USINT 短整型转无符号短整型功能块

"F_SINT_TO_USINT"是一个功能块。该功能块的目的是将 SINT（有符号整数）类型的数据转换为 USINT（无符号小整数）类型的数据。以下是对各参数的详细解释：

REQ: 输入事件。当此事件被激发，该功能块开始执行，将从 IN 接口收到的 SINT 类型数据转换为 USINT 类型数据。

IN: 输入接口。这是输入SINT 类型数据的地方。

CNF: 输出事件。当数据成功转换为USINT 类型以后，该事件会被激活。

OUT：输出接口。这是输出转换后的USINT 类型数据的地方。

总结起来，一旦REQ 事件被激活，F_SINT_TO_USINT 功能块开始运行，将在 IN 接口输入的 SINT 数据转换为USINT 数据。当转换完成后，数据通过OUT 接口输出，并且触发了CNF 事件。

F_SINT_TO_WORD 短整型转字型功能块

"F_SINT_TO_WORD"是一个功能块。此功能块的作用是将 SINT（有符号整数）数据类型转换为 WORD（字）数据类型。以下是各参数的具体解释：

REQ：输入事件。当该事件被激活时，功能块开始执行，将 SINT 类型的数据从 IN 接口输入进行转换。

IN：输入接口这是一个用来输入 SINT 类型数据的接口。

CNF：输出事件这个事件当 SINT 类型的数据被成功转换成 WORD 类型的数据后会被

触发。

OUT：输出接口。转换成WORD 类型后的数据会从这个接口输出。

总结来说，一旦REQ 事件被触发，F_SINT_TO_WORD 功能代码就会开始将在 IN 接口端输入的 SINT 类型数据转换为 WORD 类型数据。在完成转换后，将会输出转换后的WORD 类型数据，并触发CNF 事件。

F_SINT_TO_WSTRING 短整型转宽字符串型功能块

"F_SINT_TO_WSTRING" 是一个功能块。该功能块的主要作用是将 SINT（有符号整数）类型的数据转换为 WSTRING（宽字符串）类型的数据。下面是对各参数的具体解释：

REQ：输入事件。一旦这个事件被触发，功能块就开始起作用，从 IN 接口接收 SINT 类型的数据进行转换。

IN：输入接口。这是一个接收 SINT 类型数据的接口。

CNF：输出事件。当 SINT 数据被成功转换为 WSTRING 类型数据后，这个事件就会被触发。

OUT：输出接口。转化后的 WSTRING 类型数据将通过此接口输出。

所以，当 REQ 事件被触发时，F_SINT_TO_WSTRING 功能块就会开始运行，它会将IN 接口输入的 SINT 类型数据转换为 WSTRING 类型数据。一旦转换完成，OUT 会输出转换后的 WSTRING 类型数据，并且 CNF 事件会被触发。

F_STRING_TO_BOOL 字符串型转布尔型功能块

"F_STRING_TO_BOOL"是一个功能块。这个功能块的主要任务是将 STRING（字符串）类型的数据转化为 BOOL（逻辑布尔）类型的数据。以下是对各参数的详细解释：

REQ：输入事件。一旦此事件被激发，该功能块开始执行，从 IN 接口接收到的STRING 类型数据开始转为 BOOL 类型数据。

IN：输入接口。它作为插入STRING 类型数据的地方。

CNF：输出事件。当数据成功转化为 BOOL 类型后，此事件会被触发。OUT：输出接口。这是输出转换后的 BOOL 类型数据的地方。

总的来说，REQ 事件被触发后，功能块 F_STRING_TO_BOOL 开始运行，将在 IN 接口输入的 STRING 类型数据转化为 BOOL 类型数据。一旦转换完成，数据通过OUT 接口输出，并触发了 CNF 事件。

F_STRING_TO_BYTE 字符串型转比特型功能块

"F_STRING_TO_BYTE" 是一个功能块。函数功能是将 STRING（字符串） 类型数据转换为 BYTE（字节） 类型数据。以下是各参数的具体含义：

REQ：输入事件。在该事件激活时，功能块开始执行，将从 IN 接口输入的 STRING 类型数据进行转换。

IN：输入接口。这是用于输入 STRING 类型数据的接口。

CNF：输出事件。这个事件在 STRING 数据成功转换为 BYTE 数据后被触发。

OUT：输出接口。转换成 BYTE 类型后的数据将从这个接口输出。

综上所述，REQ 事件被触发的时候，F_STRING_TO_BYTE 功能块开始运行，开始将 IN 接口中输入的 STRING 类型数据转换成 BYTE 类型数据。一旦完成了转换，通过 OUT 输出 BYTE 类型数据，并激活 CNF 事件。

F_STRING_TO_DINT 字符串型转双整型功能块

"F_STRING_TO_DINT" 是一个功能块。他的作用是将 STRING（字符串）类型的数据转换为 DINT（双字整数）类型的数据。以下是对各参数的详细解释：

REQ：输入事件。刚开始时此事件将被激活，并且功能块开始运行，接着，从 IN 接口接收的 STRING 类型数据被准备转换为 DINT 类型数据。

IN：输入接口。这是一个接受 STRING 类型数据的接口。

CNF：输出事件。一旦 STRING 类型的数据成功转换为 DINT 类型的数据，此事件就会被激活。

OUT：输出接口。这是一个输出转换后的 DINT 类型数据的接口。

总的来说，一旦 REQ 事件被触发，F_STRING_TO_DINT 功能块就会开始运算，并将从IN 接口接收的 STRING 类型数据转换为 DINT 类型数据。转换完毕后，OUT 将输出 转换后的 DINT 类型数据，并触发 CNF 事件。

F_STRING_TO_DWORD 字符串型转双字型功能块

"F_STRING_TO_DWORD"是一个功能块。这个功能模块的主要作用是将 STRING（字符串） 类型的数据转换为 DWORD（双字， 32 位无符号整数）类型的数据。以下是其参数的解释：

REQ：输入事件。一旦该事件被触发，功能块开始执行，并开始将 IN 接口接收的STRING 类型数据转换为 DWORD 类型数据。

IN：输入接口。这是输入 STRING 类型数据的地方。

CNF：输出事件。当 STRING 类型的数据成功转换为 DWORD 类型数据时，该事件被激发。

总的来说，一旦 REQ 事件激活，功能块 F_STRING_TO_DWORD 开始运行，并将从IN 接口输入的 STRING 类型数据转换为 DWORD 类型数据。转换完成后，数据通过OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_INT 字符串型转整型功能块

"F_STRING_TO_INT"是一个功能块它的主要作用是将 STRING（字符串）类型的输入转换为 INT（整数）类型的输出。该功能块的各个参数具有以下含义：

REQ：输入事件。激活该事件时，此功能块会开始运行，并开始将从 IN 接口输入的STRING 数据转换为 INT 数据。

IN：输入接口。这是输入 STRING 类型数据的地方。

CNF：输出事件。当 STRING 数据成功转换为 INT 数据时，此事件被触发。

OUT：输出接口。转换为 INT 类型的数据将通过此接口输出。

因此，一旦 REQ 事件被触发，F_STRING_TO_INT 功能块便会执行，开始将 IN 接口输入的 STRING 类型数据转换为 INT 类型数据。一旦转换完成，转换后的数据就会通过 OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_LINT 字符串型转长整型功能块

"F_STRING_TO_LINT" 是一个功能块。其主要功能是将 STRING（字符串）类型的数据转换为 LINT（长整数）类型的数据。以下是其参数的详细解释：

REQ：输入事件。一旦该事件被触发，功能块开始执行，并开始将从 IN 接口接收到的STRING 类型数据转换为 LINT 类型数据。

IN：输入接口。这是输入 STRING 类型数据的地方。

CNF：输出事件。当 STRING 类型的数据成功转换为 LINT 类型数据时，该事件将被触发。

OUT：输出接口。这是输出已转换为 LINT 类型数据的地方。

概括来说，一旦 REQ 事件被激活，F_STRING_TO_LINT 功能块就开始工作，将从 IN 接口输入的 STRING 类型数据转换为 LINT 类型数据。转换完成后，数据通过 OUT 接口输出，同时触发 CNF 事件。

F_STRING_TO_LREAL 字符串型转长实数型功能块

"F_STRING_TO_LREAL" 是一个功能块。它的核心功能是把 STRING（字符串）类型的数据转换成为 LREAL（长实数，即双精度浮点数）类型的数据。这个功能块的各项参数分别代表以下含义：

REQ：输入事件。这是一个触发器，一旦被触发，功能块就开始执行，同时将由 IN 接口输入的 STRING 类型数据转换为 LREAL 类型数据。

IN：输入接口。它用于输入 STRING 类型的数据。

CNF：输出事件。当 STRING 类型的数据成功转换成 LREAL 类型数据时，就会触发这个事件。

OUT：输出接口。这是输出转换后的 LREAL 类型数据的地方。

总的来说，REQ 事件被触发后，F_STRING_TO_LREAL 功能块就启动运行，并开始把从IN 接口输入的 STRING 类型数据转换为 LREAL 类型数据。转换完成后，LREAL 类型的数据通过 OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_LWORD 字符串型转长字数型功能块

"F_STRING_TO_LWORD" 是一个功能块。它主要用于将 STRING（字符串）类型的数据转换为 LWORD（长字，64 位无符号整数）类型的数据。以下是其参数的详细解释：

REQ：输入事件。当该事件被触发时，功能块开始执行，并开始将从 IN 接口收到的STRING 类型数据转换为 LWORD 类型数据。

IN：输入接口。用于输入 STRING 类型的数据。

CNF：输出事件。当 STRING 类型的数据成功转换为 LWORD 类型数据时，该事件被触发。

OUT：输出接口。用于输出已转换为 LWORD 类型的数据。

简而言之，只要 REQ 事件被激活，F_STRING_TO_LWORD 功能块就开始工作，将 IN 接口接收的 STRING 类型数据转换为 LWORD 类型数据。转换完成后，数据通过OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_REAL 字符串型转实数型功能块

"F_STRING_TO_REAL" 是一个功能块。其主要作用是将 STRING（字符串）类型的数据转换为 REAL（浮点数）类型的数据。该功能块的各参数具体含义如下：

REQ：输入事件。当该事件被激活时，功能块会开始执行，并且从 IN 接口接收STRING 类型数据转换为 REAL 类型数据的操作也会开始。

IN：输入接口。用于输入 STRING 类型的数据。

CNF：输出事件。当 STRING 类型的数据成功转换为 REAL 类型数据时，该事件会被触发。

OUT：输出接口。将已转换为 REAL 类型的数据输出。

总的来说，一旦 REQ 事件被激活，“F_STRING_TO_REAL” 功能块就会启动，援助将从IN 接口接收的 STRING 类型数据转换为 REAL 类型数据的工作。一旦数据的转换完成，那么数据会通过 OUT 接口进行输出，并触发 CNF 事件。

F_STRING_TO_SINT 字符串型转短整型功能块

"F_STRING_TO_SINT" 是一个功能块。它的主要功能是将 STRING（字符串）类型的数据转换为 SINT（有符号短整数）类型的数据。以下是对每个参数的详细解释：

REQ：输入事件。一旦该事件被触发，功能块就开始执行，并开始将从 IN 接口接收的STRING 类型数据转换为 SINT 类型数据。

IN：输入接口。它被用来输入 STRING 类型的数据。

CNF：输出事件。当 STRING 类型的数据被成功转换为 SINT 类型数据时，该事件被触发。

OUT：输出接口。它被用来输出已经转换为 SINT 类型的数据。

总的来说，REQ 事件被触发后，F_STRING_TO_SINT 功能块就开始运行，将通过 IN 接口输入的 STRING 类型的数据转换为 SINT 类型的数据。数据转换完成后，它会通过 OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_TIME 字符串型转时间型功能块

"F_STRING_TO_TIME" 是一个功能块。它的主要功能是将 STRING（字符串）类型的数据转换为 TIME（时间）类型的数据。以下是各个参数的详细解析：

REQ：输入事件。一旦该事件被触发，功能块就开始执行，并开始将从 IN 接口传入的STRING 类型数据转换为 TIME 类型数据。

IN：输入接口。用来输入 STRING 类型的数据。

CNF：输出事件。当 STRING 类型的数据被成功转换为 TIME 类型数据时，该事件被触发。

OUT：输出接口。用来输出已转换为 TIME 类型的数据。

总的来说，REQ 事件被触发后，F_STRING_TO_TIME 功能块就开始运行，将 IN 接口传入的 STRING 类型数据转换为 TIME 类型数据。转换完成后，转换成的数据会通过OUT 接口输出，同时触发 CNF 事件。

F_STRING_TO_UDINT 字符串型转无符号双整型型功能块

"F_STRING_TO_UDINT" 是一个功能块。这个功能块的主要任务是将 STRING（字符串）类型的数据转换为 UDINT（无符号双字整数）类型的数据。下面是各个参数的具体含义：

REQ：输入事件。一旦这个事件被激活，功能块就开始运行，并开始把从 IN 接口接收的 STRING 类型的数据转换为 UDINT 类型的数据。

IN：输入接口。这里是输入 STRING 类型数据的地方。

OUT：输出接口。这里会输出已转换为 UDINT 类型的数据。CNF：输出事件。当 STRING 类型的数据成功地转换为 UDINT 类型的数据后，这个事件就会被触发。

总的来说，一旦 REQ 事件被激活，功能块 "F_STRING_TO_UDINT" 会启动，并开始把通过 IN 接口输入的 STRING 类型数据转换为 UDINT 类型数据。如果数据转换成功，数据会通过 OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_UINT 字符串型转无符号整型功能块

"F_STRING_TO_UINT" 是一个功能块。它的主要任务是将 STRING（字符串）类型的数据转换为 UINT（无符号整数）类型的数据。下面是对各个参数的详细解释：

REQ：输入事件。当该事件被触发时，功能块开始运行，并开始将来自 IN 接口的STRING 类型数据转换为 UINT 类型数据。

IN：输入接口。这是用于输入 STRING 类型数据的地方。

CNF：输出事件。当 STRING 类型的数据成功转换为 UINT 类型数据时，该事件会被触发。

OUT：输出接口。这里会输出已转换为 UINT 类型的数据。

总的来说，一旦 REQ 事件被触发，功能块 "F_STRING_TO_UINT" 就开始运行，并开始把经由 IN 接口输入的 STRING 类型数据转换为 UINT 类型数据。一旦数据转换成功，通过 OUT 接口输出，并且触发 CNF 事件。

F_STRING_TO_ULINT 字符串型转无符号长整型功能块

"F_STRING_TO_ULINT" 是一个功能块。这个功能块的主要任务是将 STRING（字符串）类型的数据转换为 ULINT（无符号长整型）类型的数据。下面是对各个参数的详细解释：

REQ：输入事件。当该事件被触发时，功能块开始运行，并开始将来自 IN 接口的STRING 类型数据转换为 ULINT 类型数据。

IN：输入接口。这是用于输入 STRING 类型数据的地方。

CNF：输出事件。当 STRING 类型的数据成功转换为 ULINT 类型数据时，该事件会被触发。

OUT：输出接口。这里会输出已转换为 ULINT 类型的数据。

简单来说，一旦 REQ 事件被激活，功能块 "F_STRING_TO_ULINT" 就开始运行，并开始将通过 IN 接口输入的 STRING 类型数据转换为 ULINT 类型数据。数据转换完成后，就会通过 OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_USINT 字符串型转无符号短整型功能块

"F_STRING_TO_USINT"是一个功能块。这个功能块的主要目标是将 STRING（字符串）类型的值转换为 USINT（无符号短整数）类型的值。以下是对每个参数的详细解释：

REQ: 输入事件。一旦该事件被触发，功能模块就开始运行并将从 IN 接口的 STRING 类型的数据转换为USINT 类型的数据。

IN: 输入接口。这是输入 STRING 类型数据的地方。

CNF: 输出事件。当 STRING 类型的数据成功地转换为 USINT 类型的数据时，该事件将被触发。

OUT：: 输出接口。这是输出已转换为USINT 类型数据的地方。

总的来说，一旦 REQ 事件被触发，功能块 "F_STRING_TO_USINT" 就会激活，并开始

将从 IN 接口输入的 STRING 类型数据转换为 USINT 类型数据。当数据转换成功时，转换后的数据将通过 OUT 接口输出，并触发 CNF 事件。

F_STRING_TO_WORD 字符串型转字型功能块

"F_STRING_TO_WORD"是一个功能块。这个功能块的主要目标是将 STRING（字符串）类型的值转换为 WORD（字）类型的值。以下是对每个参数的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行并开始将通过 IN 接口接收的字符串类型数据转换为字类型数据。

IN：输入接口。与输入字符串类型数据相关的部分。

CNF：输出事件。当字符串类型的数据成功转换为字类型数据时，此事件将被触发。

OUT：输出接口。这是已经转换为字类型数据的输出部分。

简单来说，当REQ 事件被触发时，功能块 "F_STRING_TO_WORD" 就开始运行，并将从 IN 接口输入的字符串类型数据转换为字类型数据。一旦数据转换成功，转换后的数据就会通过 OUT 接口输出，并触发CNF 事件。

F_STRING_TO_WSTRING 字符串型转长字符串型功能块

"F_STRING_TO_WSTRING"是一个功能块。这个功能块的主要目标是将 STRING（字符串）类型的数据转换为 WSTRING（宽字符字符串）类型的数据。下面是对每个参数的详细解释：

REQ：输入事件。当此事件被触发时，功能块开始执行并开始将 IN 接口的字符串类型数据转换为宽字符字符串类型数据。

IN：输入接口。这是输入字符串类型数据的地方。

CNF：输出事件。当字符串类型的数据成功转换为宽字符字符串类型数据时，此事件将被触发。

OUT：输出接口。这是已经转换为宽字符字符串类型数据的输出部分。

综上所述，一旦 REQ 事件被触发，"F_STRING_TO_WSTRING" 功能块就开始运行，并开始将通过 IN 接口输入的字符串类型数据转换为宽字符字符串类型数据。当数据转换成功时，转换后的数据将通过 OUT 接口输出，并触发 CNF 事件。

F_UINT_TO_BYTE 无符号整型转比特型功能块

F_UINT_TO_BYTE 是一个功能块，它用于将无符号整数（UINT）转换为字节（BYTE）格式。这个功能块在需要将较大的无符号整数值转换为更小的数据类型以节省空间或符合特定硬件要求时非常有用。以下是对 F_UINT_TO_BYTE 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字节（BYTE）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_BYTE 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 BYTE 格式。一旦转换完成，转换后的 BYTE 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_UINT_TO_DINT 无符号整型转双整型功能块

F_UINT_TO_DINT 是一个功能块，它用于将无符号整数（UINT）转换为双整数（DINT）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_DINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双整数（DINT）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_DINT 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 DINT 格式。一旦转换完成，转换后的 DINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数据类型转换时非常有用，特别是在处理数字信号或进行数值运算时

F_UINT_TO_DWORD 无符号整型转双字型功能块

F_UINT_TO_DWORD 是一个功能块，它用于将无符号整数（UINT）转换为双字（DWORD）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_DWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双字（DWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_DWORD 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 DWORD 格式。一旦转换完成，转换后的 DWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数据类型转换时非常有用，特别是在处理数字信号或进行数值运算时。

F_UINT_TO_INT 无符号整型转整型功能块

F_UINT_TO_INT 是一个功能块，它用于将无符号整数（UINT）转换为整数（INT）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_INT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的整数（INT）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_INT 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 INT 格式。一旦转换完成，转换后的 INT 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数据类型转换时非常有用，特别是在处理数字信号或进行数值运算时。

F_UINT_TO_LINT 无符号整型转长整型功能块

F_UINT_TO_LINT 是一个功能块，它用于将无符号整数（UINT）转换为长整数（LINT）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_LINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整数（LINT）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_LINT 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 LINT 格式。一旦转换完成，转换后的 LINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_UINT_TO_LREAL 无符号整型转长实数型功能块

F_UINT_TO_LREAL 是一个功能块，它用于将无符号整数（UINT）转换为长实数（LREAL）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_LREAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长实数（LREAL）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_LREAL 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 LREAL 格式。一旦转换完成，转换后的 LREAL 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数据类型转换时非常有用，特别是在处理数字信号或进行数值运算时。

F_UINT_TO_LWORD 无符号整型转长字型功能块

F_UINT_TO_LWORD 是一个功能块，它用于将无符号整数（UINT）转换为长字（LWORD）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_LWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长字（LWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_LWORD 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 LWORD 格式。一旦转换完成，转换后的 LWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数据类型转换时非常有用，特别是在处理数字信号或进行数值运算时。

F_UINT_TO_REAL 无符号整型转实数型功能块

F_UINT_TO_REAL 是一个功能块，它用于将无符号整数（UINT）转换为实数（REAL）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_REAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的实数（REAL）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_REAL 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 REAL 格式。一旦转换完成，转换后的 REAL 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数据类型转换时非常有用，特别是在处理数字信号或进行数值运算时。

F_UINT_TO_SINT 无符号整型转短整型功能块

F_UINT_TO_SINT 是一个功能块，它用于将无符号整数（UINT）转换为短整数（SINT）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_SINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的短整数（SINT）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_SINT 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 SINT 格式。一旦转换完成，转换后的 SINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数据类型转换时非常有用，特别是在处理数字信号或进行数值运算时。

F_UINT_TO_STRING 无符号整型转字符串型功能块

F_UINT_TO_STRING 是一个功能块，它用于将无符号整数（UINT）转换为字符串（STRING）格式。这个功能块在需要将数字数据转换为可读文本格式时非常有用。以下是对 F_UINT_TO_STRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字符串（STRING）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_STRING 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 STRING 格式。一旦转换完成，转换后的 STRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

这个功能块在进行数字到文本的转换时非常有用，特别是在需要显示或记录数字数据为文本信息时。

F_UINT_TO_UDINT 无符号整型转无符号双整型功能块

F_UINT_TO_UDINT 是一个功能块，它用于将无符号整数（UINT）转换为双字无符号整数（UDINT）格式。这个功能块在需要将较小的数据类型转换为较大的数据类型以进行进一步处理或计算时非常有用。以下是对 F_UINT_TO_UDINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双字无符号整数（UDINT）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_UDINT 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 UDINT 格式。一旦转换完成，转换后的 UDINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_UINT_TO_ULINT 无符号整型转长整型功能块

F_UINT_TO_ULINT 是一个功能块，它用于将无符号整数（UINT）转换为宽字符串（ULINT）格式。这个功能块在需要将数值转换为可显示或存储为文本的宽字符串格式时非常有用。以下是对 F_UINT_TO_ULINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串（ULINT）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_ULINT 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 WSTRING 格式。一旦转换完成，转换后的 WSTRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_UINT_TO_USINT 无符号整型转无符号短整型型功能块

F_UINT_TO_USINT 是一个功能块，它用于将无符号整数（UINT）转换为单字节无符号整数（USINT）格式。这个功能块在需要将较小的数据类型转换为较小的数据类型以便于处理更小范围的数值时非常有用。以下是对 F_UINT_TO_USINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的单字节无符号整数（USINT）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_USINT 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 USINT 格式。一旦转换完成，转换后的 USINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_UINT_TO_WORD 无符号整型转字型功能块

F_UINT_TO_WORD 是一个功能块，它用于将无符号整数（UINT）转换为字（WORD）格式。这个功能块在需要将较小的数据类型转换为相同大小的数据类型以便于处理特定范围的数值时非常有用。以下是对 F_UINT_TO_WORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字（WORD）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_WORD 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 WORD 格式。一旦转换完成，转换后的 WORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_UINT_TO_WSTRING 无符号整型转宽字符串型功能块

F_UINT_TO_WSTRING 是一个功能块，它用于将无符号整数（UINT）转换为宽字符串（WSTRING）格式。这个功能块在需要将数值转换为可显示或存储为文本的宽字符串格式时非常有用。以下是对 F_UINT_TO_WSTRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号整数（UINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串（WSTRING）格式的值。

简单来说，当 REQ 事件被触发时，F_UINT_TO_WSTRING 功能块就开始运行，并将从 IN 接口输入的 UINT 值转换为 WSTRING 格式。一旦转换完成，转换后的 WSTRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_BYTE 无符号长整型转比特型功能块

F_ULINT_TO_BYTE 是一个功能块，它用于将无符号长整（ULINT）转换为字节（BYTE）格式。这个功能块在需要将较大的数据类型转换为较小的数据类型以便于处理特定范围的数值时非常有用。以下是对 F_ULINT_TO_BYTE 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字节（BYTE）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_BYTE 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 BYTE 格式。一旦转换完成，转换后的 BYTE 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_DINT 无符号长整型转双整型功能块

F_ULINT_TO_DINT 是一个功能块，它用于将无符号长整数（ULINT）转换为双整数（DINT）格式。这个功能块在需要将大范围的数值转换为更常用的数据类型时非常有用。以下是对 F_ULINT_TO_DINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双整数（DINT）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_DINT 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 DINT 格式。一旦转换完成，转换后的 DINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_DWORD 无符号长整型转双字型型功能块

F_ULINT_TO_DWORD 是一个功能块，它用于将无符号长整数（ULINT）转换为双字（DWORD）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_DWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双字（DWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_DWORD 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 DWORD 格式。一旦转换完成，转换后的 DWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_INT 无符号长整型转整型功能块

F_ULINT_TO_INT 是一个功能块，它用于将无符号长整数（ULINT）转换为整数（INT）格式。这个功能块在需要将大范围的数值转换为更常用的数据类型时非常有用。以下是对 F_ULINT_TO_INT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的整数（INT）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_INT 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 INT 格式。一旦转换完成，转换后的 INT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_LINT 无符号长整型转长整型功能块

F_ULINT_TO_LINT 是一个功能块，它用于将无符号长整数（ULINT）转换为长整数（LINT）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_LINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整数（LINT）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_LINT 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 LINT 格式。一旦转换完成，转换后的 LINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_LREAL 无符号长整型转长实数型功能块

F_ULINT_TO_LREAL 是一个功能块，它用于将无符号长整数（ULINT）转换为长实数（LREAL）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_LREAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长实数（LREAL）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_LREAL 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 LREAL 格式。一旦转换完成，转换后的 LREAL 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_LWORD 无符号长整型转长字型型功能块

F_ULINT_TO_LWORD 是一个功能块，它用于将无符号长整数（ULINT）转换为长字（LWORD）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_LWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长字（LWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_LWORD 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 LWORD 格式。一旦转换完成，转换后的 LWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_REAL 无符号长整型转实数型功能块

F_ULINT_TO_REAL 是一个功能块，它用于将无符号长整数（ULINT）转换为实数（REAL）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_REAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的实数（REAL）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_REAL 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 REAL 格式。一旦转换完成，转换后的 REAL 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_SINT 无符号长整型转短整型功能块

F_ULINT_TO_SINT 是一个功能块，它用于将无符号长整数（ULINT）转换为短整数（SINT）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_SINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的短整数（SINT）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_SINT 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 SINT 格式。一旦转换完成，转换后的 SINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_STRING 无符号长整型转字符串型功能块

F_ULINT_TO_STRING 是一个功能块，它用于将无符号长整数（ULINT）转换为字符串（STRING）格式。这个功能块在需要将数值转换为文本格式以便显示或记录时非常有用。以下是对 F_ULINT_TO_STRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字符串（STRING）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_STRING 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 STRING 格式。一旦转换完成，转换后的 STRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_UDINT 无符号长整型转无符号宽整型功能块

F_ULINT_TO_UDINT 是一个功能块，它用于将无符号长整数（ULINT）转换为无符号双整数（UDINT）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_UDINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号双整数（UDINT）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_UDINT 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 UDINT 格式。一旦转换完成，转换后的 UDINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_UINT 无符号长整型转无符号宽整型功能块

F_ULINT_TO_UINT 是一个功能块，它用于将无符号长整数（ULINT）转换为无符号整数（UINT）格式。这个功能块在需要将大范围的数值转换为适用于特定应用的数据类型时非常有用。以下是对 F_ULINT_TO_UINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号双整数（UINT）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_UINT 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 UINT 格式。一旦转换完成，转换后的 UINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_USINT 无符号长整型转无符号短整型功能块

F_ULINT_TO_USINT 是一个功能块，它用于将无符号长整数（ULINT）转换为无符号短整数（USINT）格式。这个功能块在需要将大范围的数值转换为较小范围的数据类型时非常有用。以下是对 F_ULINT_TO_USINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号短整数（USINT）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_USINT 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 USINT 格式。一旦转换完成，转换后的 USINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_ULINT_TO_WORD 无符号长整型转字型功能块

F_ULINT_TO_WORD 是一个功能块，它用于将无符号长整数（ULINT）转换为 WORD 数据类型。这个功能块在需要将大范围的数值转换为较小范围的数据类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。

以下是对 F_ULINT_TO_WORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的 WORD 格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_WORD 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 WORD 格式。一旦转换完成，转换后的 WORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 ULINT 的范围比 WORD 大得多，因此在转换过程中可能会发生数据截断，导致精度损失。在使用此功能块时，确保理解其对您的应用程序可能产生的影响。

F_ULINT_TO_WSTRING 无符号长整型转宽字符串型功能块

F_ULINT_TO_WSTRING 是一个功能块，它用于将无符号长整数（ULINT）转换为宽字符串（WSTRING）格式。这个功能块在需要将大范围的数值转换为可表示为文本的数据类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。

以下是对 F_ULINT_TO_WSTRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号长整数（ULINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串（WSTRING）格式的值。

简单来说，当 REQ 事件被触发时，F_ULINT_TO_WSTRING 功能块就开始运行，并将从 IN 接口输入的 ULINT 值转换为 WSTRING 格式。一旦转换完成，转换后的 WSTRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 ULINT 的范围比 WSTRING 大得多，因此在转换过程中可能会发生数据截断，导致精度损失。在使用此功能块时，确保理解其对您的应用程序可能产生的影响。

F_USINT_TO_BYTE 无符号短整型转比特型功能块

F_USINT_TO_BYTE 是一个功能块，它用于将无符号短整（USINT）转换为字节（BYTE）格式。这个功能块在需要将较小范围的数值转换为字节数据类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。

以下是对 F_USINT_TO_BYTE 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字节（BYTE）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_BYTE 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 BYTE 格式。一旦转换完成，转换后的 BYTE 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 USINT 和 BYTE 的范围相同，转换过程中通常不会发生数据截断或精度损失。在使用此功能块时，可以预期转换结果的准确性。

F_USINT_TO_DINT 无符号短整型转双整型功能块

F_USINT_TO_DINT 是一个功能块，它用于将无符号短整数（USINT）转换为双整数（DINT）格式。这个功能块在需要将较小范围的数值转换为更大范围的整数类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。

以下是对 F_USINT_TO_DINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双整数（DINT）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_DINT 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 DINT 格式。一旦转换完成，转换后的 DINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 USINT 的范围小于 DINT，转换过程中不会发生数据截断或精度损失。在使用此功能块时，可以预期转换结果的准确性。

F_USINT_TO_DWORD 无符号短整型转双字型型功能块

F_USINT_TO_DWORD 是一个功能块，它用于将无符号短整数（USINT）转换为双字（DWORD）格式。这个功能块在需要将较小范围的数值转换为更大范围的数据类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。

以下是对 F_USINT_TO_DWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双字（DWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_DWORD 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 DWORD 格式。一旦转换完成，转换后的 DWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 USINT 的范围小于 DWORD，转换过程中不会发生数据截断或精度损失。在使用此功能块时，可以预期转换结果的准确性。

F_USINT_TO_INT 无符号短整型转整型型功能块

F_USINT_TO_INT 是一个功能块，它用于将无符号短整数（USINT）转换为整数（INT）格式。这个功能块在需要将较小范围的数值转换为更大范围的整数类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。以下是对 F_USINT_TO_INT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的整数（INT）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_INT 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 INT 格式。一旦转换完成，转换后的 INT 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 USINT 的范围小于 INT，转换过程中不会发生数据截断或精度损失。在使用此功能块时，可以预期转换结果的准确性。

F_USINT_TO_LINT 无符号短整型转长整型功能块

F_USINT_TO_LINT 是一个功能块，它用于将无符号短整数（USINT）转换为长整数（LINT）格式。这个功能块在需要将较小范围的数值转换为更大范围的数据类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。以下是对 F_USINT_TO_LINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整数（LINT）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_LINT 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 LINT 格式。一旦转换完成，转换后的 LINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 USINT 的范围小于 LINT，转换过程中不会发生数据截断或精度损失。在使用此功能块时，可以预期转换结果的准确性。

F_USINT_TO_LREAL 无符号短整型转长实数型功能块

F_USINT_TO_LREAL 是一个功能块，它用于将无符号短整数（USINT）转换为长实数（LREAL）格式。这个功能块在需要将较小范围的数值转换为更大范围的实数类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。以下是对 F_USINT_TO_LREAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长实数（LREAL）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_LREAL 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 LREAL 格式。一旦转换完成，转换后的 LREAL 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 USINT 的范围小于 LREAL，转换过程中不会发生数据截断或精度损失。在使用此功能块时，可以预期转换结果的准确性。

F_USINT_TO_LWORD 无符号短整型转长字型功能块

F_USINT_TO_LWORD 是一个功能块，它用于将无符号短整数（USINT）转换为长字（LWORD）格式。这个功能块在需要将较小范围的数值转换为更大范围的数据类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。以下是对 F_USINT_TO_LWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长字（LWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_LWORD 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 LWORD 格式。一旦转换完成，转换后的 LWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

请注意，由于 USINT 的范围小于 LWORD，转换过程中不会发生数据截断或精度损失。在使用此功能块时，可以预期转换结果的准确性。

F_USINT_TO_REAL 无符号短整型转实数型功能块

F_USINT_TO_REAL 是一个功能块，它用于将无符号短整数（USINT）转换为实数（REAL）格式。这个功能块在需要将较小范围的数值转换为更大范围的实数类型时非常有用，特别是在 PLC 编程中处理数字信号或进行数值运算时。以下是对 F_USINT_TO_REAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的实数（REAL）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_REAL 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 REAL 格式。一旦转换完成，转换后的 REAL 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_USINT_TO_UINT 无符号短整型转无符号整型功能块

F_USINT_TO_UINT 是一个功能块，它用于将无符号短整数（USINT）转换为宽字符串（UINT）。在 PLC 编程中，当需要将数字数据转换为可显示的文本格式时，这个功能块非常有用。以下是对 F_USINT_TO_UINT功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串（UINT）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_UINT 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 UINT 格式。一旦转换完成，转换后的 UINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_USINT_TO_STRING 无符号短整型转字符串型功能块

F_USINT_TO_STRING 是一个功能块，它用于将无符号短整数（USINT）转换为字符串（STRING）。这个功能块在需要将数值转换为可显示或存储为文本格式的字符串时非常有用，特别是在 PLC 编程中处理数字信号或进行数据记录时。以下是对 F_USINT_TO_STRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字符串（STRING）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_STRING 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 STRING 格式。一旦转换完成，转换后的 STRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_USINT_TO_UDINT 无符号短整型转无符号双整型功能块

F_USINT_TO_UDINT 是一个功能块，它用于将无符号短整数（USINT）转换为无符号双整数（UDINT）。在 PLC 编程中，这个功能块非常有用，尤其是在处理需要更大范围数值的场合。以下是对 F_USINT_TO_UDINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号双整数（UDINT）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_UDINT 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 UDINT 格式。一旦转换完成，转换后的 UDINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_USINT_TO_WORD 无符号短整型转字型功能块

F_USINT_TO_WORD 是一个功能块，它用于将无符号短整数（USINT）转换为字（WORD）。在 PLC 编程中，这个功能块非常有用，尤其是在处理数字信号转换时。以下是对 F_USINT_TO_WORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字（WORD）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_WORD 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 WORD 格式。一旦转换完成，转换后的 WORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_USINT_TO_WSTRING 无符号短整型转宽字符串型功能块

F_USINT_TO_WSTRING 是一个功能块，它用于将无符号短整数（USINT）转换为宽字符串（WSTRING）。在 PLC 编程中，当需要将数字数据转换为可显示的文本格式时，这个功能块非常有用。以下是对 F_USINT_TO_WSTRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的无符号短整数（USINT）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串（WSTRING）格式的值。

简单来说，当 REQ 事件被触发时，F_USINT_TO_WSTRING 功能块就开始运行，并将从 IN 接口输入的 USINT 值转换为 WSTRING 格式。一旦转换完成，转换后的 WSTRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_BYTE 字型转比特型功能块

F_WORD_TO_BYTE 是一个功能块，它用于将字（WORD）数据类型转换为字节（BYTE）。这在 PLC 编程中很有用，特别是当你需要将一个较大的数据类型转换为一个较小的数据类型以节省空间或符合特定硬件要求时。以下是对 F_WORD_TO_BYTE 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字节（BYTE）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_BYTE 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 BYTE 格式。一旦转换完成，转换后的 BYTE 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_DINT 字型转双整型功能块

F_WORD_TO_DINT 是一个功能块，它用于将字（WORD）数据类型转换为双整数（DINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将较小的数据类型转换为较大的数据类型以进行进一步处理时。以下是对 F_WORD_TO_DINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双整数（DINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_DINT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 DINT 格式。一旦转换完成，转换后的 DINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_DWORD 字型转双字型功能块

F_WORD_TO_DWORD 是一个功能块，用于将字（WORD）数据类型转换为双字（DWORD）。这在 PLC 编程中非常有用，尤其是当你需要将一个较小的数据类型转换为一个较大的数据类型以便进行数值处理或满足特定的应用需求时。

以下是对 F_WORD_TO_DWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双字（DWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_DWORD 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 DWORD 格式。一旦转换完成，转换后的 DWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_INT 字型转整型功能块

F_WORD_TO_INT 是一个功能块，它用于将字（WORD）数据类型转换为整数（INT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将较小的数据类型转换为较大的数据类型以进行进一步处理时。以下是对 F_WORD_TO_INT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的整数（INT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_INT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 INT 格式。一旦转换完成，转换后的 INT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_LINT 字型转长整型功能块

F_WORD_TO_LINT 是一个功能块，它用于将字（WORD）数据类型转换为长整数（LINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将较小的数据类型转换为较大的数据类型以进行进一步处理时。以下是对 F_WORD_TO_LINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整数（LINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_LINT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 LINT 格式。一旦转换完成，转换后的 LINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_LWORD 字型转长字型功能块

F_WORD_TO_LWORD 是一个功能块，它用于将字（WORD）数据类型转换为长字（LWORD）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将较小的数据类型转换为较大的数据类型以进行进一步处理时。以下是对 F_WORD_TO_LWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长字（LWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_LWORD 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 LWORD 格式。一旦转换完成，转换后的 LWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_SINT 字型转短整型功能块

F_WORD_TO_SINT 是一个功能块，它用于将字（WORD）数据类型转换为短整数（SINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将较小的数据类型转换为较大的数据类型以进行进一步处理时。以下是对 F_WORD_TO_SINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的短整数（SINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_SINT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 SINT 格式。一旦转换完成，转换后的 SINT 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WORD_TO_UDINT 字型转无符号双整型型功能块

F_WORD_TO_UDINT 是一个功能块，它用于将字（WORD）数据类型转换为双字（UDINT）数据类型。在 PLC 编程中，这个功能块非常有用，尤其是在需要将较小的数据类型转换为较大的数据类型以处理更大数值或进行进一步计算时。

以下是对 F_WORD_TO_UDINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双字（UDINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_UDINT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 UDINT 格式。一旦转换完成，转换后的 UDINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换确保了数据的完整性和准确性，特别是在进行数学运算或数据处理时

F_WORD_TO_ULINT 字型转无符号长整型功能块

F_WORD_TO_ULINT 是一个功能块，它用于将字（WORD）数据类型转换为无符号长整型（ULINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要处理大范围数值或进行高精度计算时。

以下是对 F_WORD_TO_ULINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号长整型（ULINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_ULINT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 ULINT 格式。一旦转换完成，转换后的 ULINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从较小的数值范围扩展到更大的数值范围，确保数据处理的准确性和可靠性。

F_WORD_TO_USINT 字型转无符号短整型功能块

F_WORD_TO_USINT 是一个功能块，它用于将字（WORD）数据类型转换为无符号短整型（USINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要处理较小的数值范围或进行简单计算时。

以下是对 F_WORD_TO_USINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号短整型（USINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_USINT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 USINT 格式。一旦转换完成，转换后的 USINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从较大的数值范围缩小到较小的数值范围，确保数据处理的准确性和可靠性。

F_WORD_TO_WSTRING 字型转宽字符串型功能块

F_WORD_TO_WSTRING 是一个功能块，它用于将字（WORD）数据类型转换为宽字符串（WSTRING）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将数字数据转换为可读文本或进行字符串操作时。

以下是对 F_WORD_TO_WSTRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串（WSTRING）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_WSTRING 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 WSTRING 格式。一旦转换完成，转换后的 WSTRING 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从数值格式转换为字符串格式，便于显示和进一步处理。

F_WORD_TO_UINT 字型转无符号整型功能块

F_WORD_TO_UINT 是一个功能块，它用于将字（WORD）数据类型转换为无符号整型（UINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将数字数据转换为可读文本或进行字符串操作时。

以下是对 F_WORD_TO_UINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的宽字符串（UINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_UINT 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 UINT 格式。一旦转换完成，转换后的 UINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从数值格式转换为字符串格式，便于显示和进一步处理。

F_WORD_TO_STRING 字型转字符串型功能块

F_WORD_TO_STRING 是一个功能块，它用于将字（WORD）数据类型转换为字符串（STRING）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将数字数据转换为可读文本格式以进行显示或记录时。

以下是对 F_WORD_TO_STRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的字（WORD）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字符串（STRING）格式的值。

简单来说，当 REQ 事件被触发时，F_WORD_TO_STRING 功能块就开始运行，并将从 IN 接口输入的 WORD 值转换为 STRING 格式。一旦转换完成，转换后的 STRING 值就会通过 OUT 接口输出，并触发 CNF 事件。

F_WSTRING_TO_BOOL 宽字符串转布尔型功能块

F_WSTRING_TO_BOOL 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为布尔值（BOOL）。在 PLC 编程中，这个功能块非常有用，尤其是在需要根据字符串内容决定逻辑控制流程时。

以下是对 F_WSTRING_TO_BOOL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的布尔值（BOOL）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_BOOL 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 BOOL 格式。一旦转换完成，转换后的 BOOL 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为布尔值，便于进行条件判断和逻辑操作。

F_WSTRING_TO_BYTE 宽字符串转比特型功能块

F_WSTRING_TO_BYTE 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为字节（BYTE）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_BYTE 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的字节（BYTE）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_BYTE 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 BYTE 格式。一旦转换完成，转换后的 BYTE 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为字节格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_DINT 宽字符串转双整数功能块

F_WSTRING_TO_DINT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为双整数（DINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_DINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双整数（DINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_DINT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 DINT 格式。一旦转换完成，转换后的 DINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为双整数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_DWORD 宽字符串转双字型功能块

F_WSTRING_TO_DWORD 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为双字（DWORD）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_DWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的双字（DWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_DWORD 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 DWORD 格式。一旦转换完成，转换后的 DWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为双字格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_INT 宽字符串转整数功能块

F_WSTRING_TO_INT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为整数（INT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_INT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的整数（INT）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_INT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 INT 格式。一旦转换完成，转换后的 INT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为整数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_LINT 宽字符串转长整型数功能块

F_WSTRING_TO_LINT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为长整数（LINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_LINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长整数（LINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_LINT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 LINT 格式。一旦转换完成，转换后的 LINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为长整数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_LREAL 宽字符串转长实数型功能块

F_WSTRING_TO_LREAL 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为长实数（LREAL）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_LREAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长实数（LREAL）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_LREAL 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 LREAL 格式。一旦转换完成，转换后的 LREAL 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为长实数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_LWORD 宽字符串转长字型功能块

F_WSTRING_TO_LWORD 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为长字（LWORD）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_LWORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的长字（LWORD）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_LWORD 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 LWORD 格式。一旦转换完成，转换后的 LWORD 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为长字格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_REAL 宽字符串转实数型功能块

F_WSTRING_TO_REAL 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为实数（REAL）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_REAL 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的实数（REAL）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_REAL 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 REAL 格式。一旦转换完成，转换后的 REAL 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为实数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_SINT 宽字符串转短整数功能块

F_WSTRING_TO_SINT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为短整数（SINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_SINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的短整数（SINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_SINT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 SINT 格式。一旦转换完成，转换后的 SINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为短整数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_STRING 宽字符串转标准字符串功能块

F_WSTRING_TO_STRING 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为标准字符串（STRING）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的字符串数据时。

以下是对 F_WSTRING_TO_STRING 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的标准字符串（STRING）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_STRING 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 STRING 格式。一旦转换完成，转换后的 STRING 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从宽字符串格式转换为标准字符串格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_TIME 宽字符串转时间型功能块

F_WSTRING_TO_TIME 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为时间（TIME）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的时间数据时。

以下是对 F_WSTRING_TO_TIME 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的时间（TIME）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_TIME 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 TIME 格式。一旦转换完成，转换后的 TIME 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为时间格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_UDINT 宽字符串转无符号双整型功能块

F_WSTRING_TO_UDINT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为无符号双字整数（UDINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的数值数据时。

以下是对 F_WSTRING_TO_UDINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号双字整数（UDINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_UDINT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 UDINT 格式。一旦转换完成，转换后的 UDINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从宽字符串格式转换为无符号双字整数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_ULINT 宽字符串转无符号长整型功能块

F_WSTRING_TO_ULINT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为无符号长整数（ULINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的大数值数据时。

以下是对 F_WSTRING_TO_ULINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号长整数（ULINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_ULINT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 ULINT 格式。一旦转换完成，转换后的 ULINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从字符串格式转换为无符号长整数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_USINT 宽字符串转无符号短整数功能块

F_WSTRING_TO_USINT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为无符号短整数（USINT）。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的小数值数据时。

以下是对 F_WSTRING_TO_USINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的无符号短整数（USINT）格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_USINT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 USINT 格式。一旦转换完成，转换后的 USINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从宽字符串格式转换为无符号短整数格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_WORD 宽字符串转字型功能块

F_WSTRING_TO_WORD 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为 WORD 数据类型。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的二进制数值数据时。

以下是对 F_WSTRING_TO_WORD 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的 WORD 格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_WORD 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 WORD 格式。一旦转换完成，转换后的 WORD 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从宽字符串格式转换为 WORD 格式，便于进行进一步的数据处理和通信。

F_WSTRING_TO_UINT 宽字符串转字型功能块

F_WSTRING_TO_UINT 是一个功能块，它用于将宽字符串（WSTRING）数据类型转换为 UINT 数据类型。在 PLC 编程中，这个功能块非常有用，尤其是在需要将文本数据转换为可以由设备直接处理的二进制数值数据时。

以下是对 F_WSTRING_TO_UINT 功能块的详细介绍：

REQ：这是一个输入事件，当此事件被触发时，功能块开始执行转换操作。

IN：这是一个输入接口，接收需要转换的宽字符串（WSTRING）值。

CNF：这是一个输出事件，当转换操作完成时，此事件被触发。

OUT：这是一个输出接口，输出转换后的 UINT 格式的值。

简单来说，当 REQ 事件被触发时，F_WSTRING_TO_UINT 功能块就开始运行，并将从 IN 接口输入的 WSTRING 值转换为 UINT 格式。一旦转换完成，转换后的 UINT 值就会通过 OUT 接口输出，并触发 CNF 事件。这样的转换允许数据从宽字符串格式转换为 UINT 格式，便于进行进一步的数据处理和通信。

FB_CTD 递减计数器功能块

E_CTD 是一个功能块。它用于实现一个带有下限的递减计数器，计数器的值为 DINT（双字整数）类型。以下是它的各个参数的解释：

CD：计数输入。当此输入为 TRUE（真） 时，计数器的值减少。

LD：加载输入。当此输入为 TRUE（真） 时，计数器的值被设置为预设值 PV。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

总结来说，功能块 E_CTD 在 CD 输入为 TRUE（真） 时减少计数器的值，当 LD 输入为 TRUE（真） 时将计数器的值设置为预设值 PV，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTU 整型向上计数器功能块

FB_CTU 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向上计数器的功能。它通常用于处理整数计数任务。以下是对 FB_CTU 功能块的详细介绍：

CU：计数输入。当此输入为 TRUE（真） 时，计数器的值增加。

R：复位输入。当此输入为 TRUE（真） 时，计数器的值被重置为 0。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

FB_CTU 功能块在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTUD 双向计数功能块

FB_CTUD 是一个功能块，用于在可编程逻辑控制器（PLC）编程中实现标准的向上和向下计数器功能。它适用于需要进行计数操作的各种工业应用场景。以下是对 FB_CTUD 功能块的详细介绍：

CU：这是一个输入事件，当此事件被触发时，功能块开始执行向上计数操作。

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

R：这是一个输入事件，用于重置计数器到其初始值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

CV：这是一个输出接口，显示当前的计数值。它的数据类型通常为 INT 或 DINT，适用于标准范围的计数。

QU：这是一个输出事件，当计数值递增到预设值时，此事件被触发。

QD：这是一个输出事件，当计数值递减到预设值时，此事件被触发。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

FB_CTUD 功能块在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTD_DINT 双整型计数器功能块

FB_CTD_DINT 是一个功能块，用于在可编程逻辑控制器（PLC）编程中实现向下计数器的功能。它可以处理 DINT（双整数）数据类型，这是一种32位的整数类型，允许较大范围的计数值。

以下是对 FB_CTD_DINT 功能块的详细介绍：

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

CNF：这是一个输出事件，当计数值达到预设值时，此事件被触发。

CV：这是一个输出接口，显示当前的计数值。

Q：这是一个输出事件，每次计数值递减时，此事件被触发。

简单来说，当 CD 事件被触发时，FB_CTD_DINT 功能块就开始运行，并从 LD 接口加载的初始值开始向下计数。计数器的当前值会在 CV 接口显示，并且每次计数值递减时，CNF 事件会被触发。一旦计数值达到在 PV 接口设置的预设值，Q 事件就会被触发。这个功能块非常适合在需要跟踪和控制事件发生次数的应用场景中使用。

FB_CTD_LINT 无符号长整型计数器功能块

FB_CTD_LINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向下计数器的功能。它处理 LINT（长整数）数据类型，这是一种64位的整数类型，允许非常大范围的计数值。以下是对 FB_CTD_LINT 功能块的详细介绍：

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

Q：这是一个输出事件，当计数值达到预设值时，此事件被触发。

CV：这是一个输出接口，显示当前的计数值。

简单来说，当 CD 事件被触发时，FB_CTD_LINT 功能块就开始运行，并从 LD 接口加载的初始值开始向下计数。计数器的当前值会在 CV 接口显示，并且每次计数值递减时，CNF 事件会被触发。一旦计数值达到在 PV 接口设置的预设值，Q 事件就会被触发。这个功能块非常适合在需要跟踪和控制大量事件发生次数的应用场景中使用。

FB_CTD_UDINT 无符号双整型计数器功能块

FB_CTD_UDINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向下计数器的功能。它处理 UDINT（无符号双整数）数据类型，这是一种32位的整数类型，允许正整数范围的计数值。以下是对 FB_CTD_UDINT 功能块的详细介绍：

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

Q：这是一个输出事件，当计数值达到预设值时，此事件被触发。

CV：这是一个输出接口，显示当前的计数值。

简单来说，当 REQ 事件被触发时，FB_CTD_UDINT 功能块就开始运行，并从 LD 接口加载的初始值开始向下计数。计数器的当前值会在 CV 接口显示，并且每次计数值递减时，CNF 事件会被触发。一旦计数值达到在 PV 接口设置的预设值，Q 事件就会被触发。这个功能块非常适合在需要跟踪和控制大量事件发生次数的应用场景中使用。

FB_CTD_ULINT 无符号长整型计数器功能块

FB_CTD_ULINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向下计数器的功能。它处理 ULINT（无符号长整数）数据类型，这是一种64位的整数类型，允许非常大范围的正整数计数值。以下是对 FB_CTD_ULINT 功能块的详细介绍：

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

CV：这是一个输出接口，显示当前的计数值。

Q：这是一个输出事件，当计数值递增到预设值时，此事件被触发。

简单来说，当 CD 事件或REQ 事件被触发时，FB_CTD_ULINT 功能块就开始运行，并从 LD 接口加载的初始值开始向下或向上计数。计数器的当前值会在 CV 接口显示，并且每次计数值递减或递增时，相应的CD事件或LD事件会被触发。一旦计数值达到在 PV 接口设置的预设值，相应的 Q 或 CNF 事件就会被触发。这个功能块非常适合在需要跟踪和控制事件发生次数的应用场景中使用。

FB_CTU_DINT 双整数递增功能块

FB_CTU_DINT 是一个功能块。它用于实现一个带有上限的递增计数器，计数器的值为 DINT（双字整数）类型。以下是它的各个参数的解释：

CU：计数输入。当此输入为 TRUE（真） 时，计数器的值增加。

R：复位输入。当此输入为 TRUE（真） 时，计数器的值被重置为 0。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

总结来说，功能块 FB_CTU_DINT 在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTU_LINT 长整型递增计数器功能块

FB_CTU_LINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向上计数器的功能。它通常用于处理整数计数任务。以下是对 FB_CTU 功能块的详细介绍：

CU：计数输入。当此输入为 TRUE（真） 时，计数器的值增加。

R：复位输入。当此输入为 TRUE（真） 时，计数器的值被重置为 0。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

功能块 FB_CTU_LINT 在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTU_ULINT 无符号长整型向上计数功能块

FB_CTU_ULINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向上计数器的功能。它通常用于处理极大数量级的整数计数任务。以下是对 FB_CTU_ULINT 功能块的详细介绍：

CU：计数输入。当此输入为 TRUE（真） 时，计数器的值增加。

R：复位输入。当此输入为 TRUE（真） 时，计数器的值被重置为 0。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

FB_CTU_ULINT 功能块在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTUD_DINT 双整型双向计数器功能块

FB_CTUD_DINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向上和向下计数器的功能。它通常用于处理双向整数计数任务。以下是对 FB_CTUD_DINT 功能块的详细介绍：

CU：这是一个输入事件，当此事件被触发时，功能块开始执行向上计数操作。

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

R：这是一个输入事件，用于重置计数器到其初始值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

CV：这是一个输出接口，显示当前的计数值。它的数据类型为 LINT（长整数），适用于非常大范围的计数。

QU：这是一个输出事件，当计数值递增到预设值时，此事件被触发。

QD：这是一个输出事件，当计数值递减到预设值时，此事件被触发。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

FB_CTUD_DINT 功能块在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTUD_LINT 长整型双向计数器功能块

FB_CTUD_LINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向上和向下计数器的功能。它通常用于处理大范围整数计数任务。以下是对 FB_CTUD_LINT 功能块的详细介绍：

CU：这是一个输入事件，当此事件被触发时，功能块开始执行向上计数操作。

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

R：这是一个输入事件，用于重置计数器到其初始值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

CV：这是一个输出接口，显示当前的计数值。它的数据类型为 LINT（长整数），适用于非常大范围的计数。

QU：这是一个输出事件，当计数值递增到预设值时，此事件被触发。

QD：这是一个输出事件，当计数值递减到预设值时，此事件被触发。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

FB_CTUD_LINT 功能块在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTUD_ULINT 无符号长整数双向计数功能块

FB_CTUD_ULINT 是一个功能块，专门用于在可编程逻辑控制器（PLC）编程中实现向上和向下计数器的功能。它通常用于处理极大范围整数计数任务。以下是对 FB_CTUD_ULINT 功能块的详细介绍：

CU：这是一个输入事件，当此事件被触发时，功能块开始执行向上计数操作。

CD：这是一个输入事件，当此事件被触发时，功能块开始执行向下计数操作。

R：这是一个输入事件，用于重置计数器到其初始值。

PV：这是一个输入接口，代表预设值（Preset Value），功能块将根据此值进行计数。

CV：这是一个输出接口，显示当前的计数值。它的数据类型为 ULINT（无符号长整数），适用于非常大范围的计数。

QU：这是一个输出事件，当计数值递增到预设值时，此事件被触发。

QD：这是一个输出事件，当计数值递减到预设值时，此事件被触发。

LD：这是一个输入接口，用于加载或设置计数器的初始计数值。

FB_CTUD_ULINT 功能块在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

FB_CTU_UDINT 双字无符号整数递增计数器功能块

FB_CTU_UDINT 是一个功能块。它用于实现一个带有上限的递增计数器，计数器的值为UDINT（无符号双字整数）类型。以下是它的各个参数的解释：

CU：计数输入。当此输入为 TRUE（真） 时，计数器的值增加。

R：复位输入。当此输入为 TRUE（真） 时，计数器的值被重置为 0。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

总结来说，功能块 FB_CTU_UDINT 在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

F_MUX_2 信号二选一功能块

F_MUX_2 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于根据选择信号来选择两个输入信号中的一个。这个功能块特别适用于需要根据条件选择不同信号源的场合。以下是对 F_MUX_2 功能块的详细介绍：

IN1, IN2：这些是输入参数，表示需要进行选择的两个数值。

K：这是一个选择信号，用于决定输出哪一个输入参数的值。

OUT：这是一个输出参数，根据选择信号 SEL 的状态，输出 IN0 或 IN1 的值。

F_MUX_2 功能块通常用于各种应用场景，例如在工业自动化中，当我们需要根据当前的工作模式或条件来选择不同的控制信号时，可以使用 F_MUX_2 来进行选择。它可以帮助提高系统的灵活性和适应性。

F_SEL 输入信号选择功能块

F_SEL 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于根据条件选择两个输入信号中的一个。这个功能块特别适用于需要根据条件选择不同信号源的场合。以下是对 F_SEL 功能块的详细介绍：

IN0, IN1：这些是输入参数，表示需要进行选择的两个数值。

G：这是一个选择信号，用于决定输出哪一个输入参数的值。

OUT：这是一个输出参数，根据选择信号 G的状态，输出 IN0 或 IN1 的值。

F_SEL 功能块通常用于各种应用场景，例如在工业自动化中，当我们需要根据当前的工作模式或条件来选择不同的控制信号时，可以使用 F_SEL 来进行选择。它可以帮助提高系统的灵活性和适应性。

FB_TOF 断开延时功能块

FB_TOF 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于实现定时器的“断开延时”功能。这个功能块特别适用于需要在信号断开后延时一段时间再执行动作的场合。以下是对 FB_TOF 功能块的详细介绍：

IN：这是一个输入参数，表示定时器的启动信号。

PT：这是预设时间参数，用于设置定时器的延时长度。

Q：这是一个输出参数，表示定时器的输出状态。

ET：这是一个输出参数，表示已经过去的时间。

当输入信号 IN 为真时，定时器开始计时，ET 开始累计时间。一旦 IN 变为假，如果 ET 小于预设时间 PT，输出 Q 会保持为真，直到 ET 达到 PT。这样，即使输入信号已经断开，输出信号也会在预设的时间后才变为假，从而实现断开延时的效果。

FB_TOF 功能块通常用于各种应用场景，例如在工业自动化中，当我们需要在设备停止后延时关闭阀门或断开电源时，可以使用 FB_TOF 来进行控制。它可以帮助避免突然停止造成的冲击或损害。

FB_TON 接通延时功能块

FB_TON 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于实现定时器的“接通延时”功能。这个功能块特别适用于需要在信号接通后延时一段时间再执行动作的场合。以下是对 FB_TON 功能块的详细介绍：

IN：这是一个输入参数，表示定时器的启动信号。

PT：这是预设时间参数，用于设置定时器的延时长度。

Q：这是一个输出参数，表示定时器的输出状态。

ET：这是一个输出参数，表示已经过去的时间。

当输入信号 IN 为真时，定时器开始计时，ET 开始累计时间。如果 IN 保持为真，并且 ET 达到预设时间 PT，输出 Q 会变为真，从而实现接通延时的效果。FB_TON 功能块通常用于各种应用场景，例如在工业自动化中，当我们需要在设备启动后延时启动另一部分设备时，可以使用 FB_TON 来进行控制。它可以帮助避免启动时的冲击或提供必要的预热时间。

FB_TP 脉冲延时功能块

FB_TP 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于实现定时器的“脉冲延时”功能。这个功能块特别适用于需要在信号接通后延时一段时间产生一个短暂脉冲的场合。以下是对 FB_TP 功能块的详细介绍：

IN：这是一个输入参数，表示定时器的启动信号。

PT：这是预设时间参数，用于设置定时器的延时长度。

Q：这是一个输出参数，表示定时器的输出状态。

ET：这是一个输出参数，表示已经过去的时间。

当输入信号 IN 为真时，定时器开始计时，ET 开始累计时间。如果 IN 保持为真，并且 ET 达到预设时间 PT，输出 Q 会变为真，产生一个脉冲，从而实现脉冲延时的效果。FB_TP 功能块通常用于各种应用场景，例如在工业自动化中，当我们需要在设备启动后延时产生一个控制信号时，可以使用 FB_TP 来进行控制。它可以帮助实现精确的时间控制和操作序列。

FB_F_TRIG

FB_F_TRIG 是一个功能块，它在可编程逻辑控制器（PLC）编程中用于实现边沿触发功能。这个功能块特别适用于需要检测信号从低到高的瞬间变化的场合。以下是对 FB_F_TRIG 功能块的详细介绍：

CLK：这是一个输入事件，当检测到此信号的上升沿时，功能块将被触发。

Q：这是一个输出事件，当 CLK 输入的上升沿被检测到时，Q 输出将短暂地变为高电平。

FB_F_TRIG 功能块通常用于捕捉快速发生的事件，例如传感器信号的瞬间变化。它可以帮助提高系统的响应速度和准确性。

FB_R_TRIG 上升沿检测器功能块

E_R_TRIG 是一个功能块。它用于检测输入信号的边沿（从 TRUE（真） 到 FLASE（假） 的变化）。以下是它的各个参数的解释：

CLK：输入信号。当输入信号从 1（真） 变为 0（假） 时，触发输出信号。

Q：输出信号。当检测到输入信号的下降沿时，输出CLK的信号。

总结来说，功能块 E_R_TRIG 用于检测输入信号的边沿上升沿变化，并在检测到时触发输出信号 Q。

FB_RS RS触发器功能块

"FB_RS"是一个功能块，它通常被称为 Set-Reset（设定-复位）或者 RS 触发器，在自动化控制和编程中被广泛应用。以下是各部分的具体释义：

REQ：这是输入事件，在该事件被触发时，功能块开始执行操作。

S：这是一个布尔（BOOL）类型的输入参数，表示设定（Set）信号。设为真TRUE（真 时，Q1 将被设定为真，即便在之后 S 变为FLASE（假）。

R1：这是一个布尔（BOOL）类型的输入参数，表示复位（Reset）信号。设为TRUE（真）时，无论 S 的值如何，Q1 都将被复位设为FLASE（假）。

CNF：这是输出事件，当操作完成时，该事件会被触发。

Q1：这是一个布尔（BOOL）类型的输出参数，表示输出状态。它的值由S 和R1 控制，当 S 为真时Q1 为真，当R1 为真时Q1 为假。

例如，在 S 和 R1 都为FLASE（假）的基础状态下，假如将 S 设为真TRUE（真并触发REQ 事件，那么功能块便将 Q1 设为真TRUE（真并触发CNF 事件。若此时将R1 设为真TRUE（真并触发 REQ 事件，无论 S 的值如何，Q1 都将被复位成FLASE（假），并触发 CNF 事件。

FB_SR SR触发器功能块

"FB_SR" 是一个功能块，通常被称为 Set-Reset（设定-复位）或 SR 触发器，在自动化控制和编程中被广泛应用。以下是具体的参数解释：

REQ: 这是输入事件，在该事件被触发时，功能块开始执行操作。

S1: 这是一个布尔（BOOL）类型的输入参数，表示设定（Set）信号。设为真TRUE（真）时，Q1 将被设定为TRUE（真）。

R: 这是一个布尔（BOOL）类型的输入参数，表示复位（Reset）信号。设为TRUE（真）时，无论 S1 的值如何，Q1 都将被复位为FLASE（假）。

CNF: 这是输出事件，当操作完成时，该事件会被触发。

Q1: 这是一个布尔（BOOL）类型的输出参数，反应设定和复位信号的执行结果。一般来说，当S1为真TRUE（真）时，Q1为真TRUE（真），当R为真TRUE（真）时，Q1为FLASE（假）。

例如，假设S1和R都默认为FLASE（假）。当你把S1设为真TRUE（真）并且触发 REQ 事件，那么Q1就会被设为真TRUE（真）并触发CNF事件。然后，即使S1变回FLASE（假），Q1仍然保持真TRUE（真）。之后，如果你把R设为真TRUE（真）并且触发REQ事件，Q1 就会被复位为FLASE（假），无论 S1 的值如何，并且触发CNF事件

RT_E_CYCLE 实时循环功能块

RT_E_CYCLE 是一个实时事件功能块，它用于根据设定的时间周期性地触发事件。这个功能块的主要特点和功能如下：

START: 开启定时事件的输入事件接口。

STOP: 停止定时事件的输入事件接口。

EO: 时间到了触发的输出事件接口。

DT: 配置时间间隔参数的数据输入接口，数据类型为字符串。

DeadlINe: 这是指事件必须在特定时间内完成的最后期限。在 RT_E_CYCLE 功能块中，DeadlINe 确保事件在设定的时间周期内触发。如果事件未能在规定的时间内完成，可能会导致系统性能下降或其他问题。

WCET: 这是指在最坏情况下，功能块执行所需的最长时间。对于 RT_E_CYCLE 功能块，WCET 是确保定时事件在设定的时间周期内能够可靠触发的重要参数。它帮助设计者评估系统在最不利条件下的性能。

例如，如果您将 DT 设置为 T#5S，则每5秒触发一次 EO 事件。您也可以设置不同的时间单位，如毫秒（MS）、微秒（US）、分钟（M）、小时（H）或天（D）。

RT_E_CYCLE 功能块继承自 CTimedFB 类，它负责处理定时相关的逻辑。当 START 接收到事件时，定时器开始计时，并在达到 DT 所设定的时间间隔后，通过 EO 接口触发事件。如果在计时过程中接收到 STOP 事件，定时器将停止

这个功能块在需要周期性执行任务的自动化控制系统中非常有用，比如定期检查传感器数据或定时控制机械设备的操作。

RT_E_DELAY 实时延时功能块

RT_E_DELAY 是一个实时事件功能块，用于实现事件的延时。这个功能块允许用户设置一个延时时间，在该时间过后触发一个事件。以下是 RT_E_DELAY 功能块的详细介绍：

START: 这是一个输入事件，用于启动延时。

STOP: 这是一个输入事件，用于停止延时。

EO: 这是一个输出事件，当延时结束时触发。

DT: 这是一个数据输入，用于设置延时的时间长度，数据类型为 TIME。

其中TmIN，DeadlINe WCET三个参数可以不设置

例如，如果您将 DT 设置为 T#10s，那么在 START 事件触发后，10秒钟之后，EO 事件将被触发。如果在计时过程中接收到 STOP 事件，延时将被取消，并且 EO 事件不会被触发。

RT_E_DELAY 功能块在需要延时控制事件触发的应用中非常有用，例如在启动一个过程之前需要等待一段时间，或者在两个操作之间需要一个时间间隔。

RT_E_DEMUX 实时信号分配功能块

RT_E_DEMUX 是一个实时事件功能块，它用于根据输入事件选择性地触发多个输出事件。这个功能块的主要特点和功能如下：

EI：这是一个输入事件，当事件到达时，根据 K 的值决定触发哪个输出事件。

K：这是一个数据输入，用于设置选择哪个输出事件，数据类型为 INT。

EO0, EO1, ..., EOn：这些是输出事件，根据 K 的值，事件 EI 将触发相应的输出事件。

其中 WCET0，DeadlINe0,WCET1，DeadlINe1.....与EO0，EO1...相对应可以单独设置也可以不设置

例如，如果 K 设置为 1，当 EI 事件到达时，将只触发 EO1 事件。如果 K 设置为 2，则触发 EO2 事件，以此类推。

RT_E_DEMUX 功能块在需要根据条件选择不同执行路径的控制逻辑中非常有用，例如，在不同的传感器输入或操作模式下执行不同的任务。

RT_E_EC_COUPLER 实时事件耦合功能块

RT_E_EC_COUPLER 是一个实时事件功能块，它用于在不同的控制应用之间耦合事件链。这个功能块允许用户在分布式系统中同步和传递事件，确保控制逻辑的一致性和协调。以下是 RT_E_EC_COUPLER 功能块的详细介绍：

EI：这是一个输入事件，用于接收外部触发的事件。

EO：这是一个输出事件，当输入事件 EI 被触发后，EO 事件将被发送到连接的功能块。

例如，如果您有多个控制系统需要在特定事件发生时同时执行操作，您可以使用 RT_E_EC_COUPLER 功能块来实现这一点。当 EI 事件在一个系统中被触发时，通过 ID 标识的所有其他系统中的相应 EO 事件也会被触发。

RT_E_EC_COUPLER 功能块在需要确保多个控制系统之间事件同步的应用中非常有用，例如在工业自动化和过程控制中。

RT_E_F_TRIG 实时下降沿监测功能块

RT_E_F_TRIG 是一个实时事件功能块，主要用于在特定条件下触发事件。以下是 RT_E_F_TRIG 功能块的详细介绍：

EI：这是一个输入事件，当事件到达时，将根据 QI 的值和计时条件来决定是否触发输出事件 EO。

QI：这是一个布尔数据输入，用于启用或禁用功能块。当 QI 为 TRUE（真） 时，功能块处于激活状态；当 QI 为 FLASE（假） 时，功能块不会触发输出事件。

Tmin：这是一个时间数据输入，用于设置触发条件的时间阈值。数据类型为 TIME。

EO：这是一个输出事件，当输入事件 EI 到达并且满足计时条件时，将触发此输出事件。

例如，如果您希望在输入事件发生后的特定时间间隔内触发一个操作，您可以设置 TI 为所需的延迟时间，并在 EI 事件到达时激活 QI。一旦达到 TI 设定的时间阈值，EO 事件就会被触发。

RT_E_F_TRIG 功能块在需要基于时间条件控制事件触发的应用中非常有用，例如，在工业自动化中的定时操作或延时启动过程。

RT_E_MERGE 实时合并功能块

RT_E_MERGE 是一个实时事件功能块，它用于合并来自不同源的事件。这个功能块允许多个输入事件合并成一个输出事件，这对于同步不同的控制流程非常有用。以下是 RT_E_MERGE 功能块的详细介绍：

EI1, EI2, ..., EIN：这些是输入事件，可以从不同的功能块接收事件。

EO：这是一个输出事件，当任何一个输入事件被触发时，EO 事件将被发送到连接的功能块。

ID：这是一个数据输入，用于标识事件合并器的唯一性，数据类型为 STRING。

Tmin：这是一个时间数据输入，用于设置触发条件的时间阈值。数据类型为 TIME。

例如，如果您的控制系统中有多个传感器，每个传感器都能触发一个事件，但您希望在任何一个传感器触发时执行相同的操作，您可以使用 RT_E_MERGE 功能块来实现这一点。当任何一个 EI 事件被触发时，EO 事件将被激活，并触发连接的功能块。

RT_E_MERGE 功能块在需要从多个源同步事件的应用中非常有用，例如在复杂的自动化系统中，需要根据来自多个传感器的输入来做出决策。

RT_E_PERMIT 实时信号阻断功能块

RT_E_PERMIT 是一个实时事件功能块，主要用于根据条件允许或禁止事件的传递。以下是 RT_E_PERMIT 功能块的详细介绍：

EI：这是一个输入事件，当事件到达时，将根据 QI 的值来决定是否允许事件通过并触发输出事件 EO。

QI：这是一个布尔数据输入，用于启用或禁用功能块。当 QI 为 TRUE（真） 时，功能块处于激活状态；当 QI 为 FLASE（假） 时，功能块不会允许事件通过。

PERMIT：这是一个布尔数据输入，用于控制事件的传递。只有当 PERMIT 为 TRUE（真） 时，输入事件 EI 才会触发输出事件 EO。

Tmin：这是一个时间数据输入，用于设置触发条件的时间阈值。数据类型为 TIME。

EO：这是一个输出事件，当输入事件 EI 到达并且 QI 和 PERMIT 都为 TRUE（真） 时，将触发此输出事件。

例如，如果您希望在特定条件满足时才允许某个操作发生，您可以将 PERMIT 设置为 TRUE（真），并在 EI 事件到达时激活 QI。只有当 PERMIT 也为 TRUE（真） 时，EO 事件才会被触发。

RT_E_PERMIT 功能块在需要基于特定条件控制事件传递的应用中非常有用，例如，在工业自动化中的条件启动过程或安全检查。

RT_E_R_TRIG 实时上升沿监测功能块

RT_E_R_TRIG 是一个实时事件功能块，它的作用是在满足特定条件时触发事件。以下是 RT_E_R_TRIG 功能块的详细介绍：

EI：这是一个输入事件，当事件到达时，将根据 QI 的值和计时条件来决定是否触发输出事件 EO。

QI：这是一个布尔数据输入，用于启用或禁用功能块。当 QI 为 TRUE（真） 时，功能块处于激活状态；当 QI 为 FLASE（假） 时，功能块不会触发事件。

Tmin：这是一个时间数据输入，用于设置触发条件的时间阈值。当 EI 事件到达并且已经过了 TIME 设定的时间后，如果 QI 为 TRUE（真），则会触发 EO 事件。

EO：这是一个输出事件，当输入事件 EI 到达并且满足 QI 为 TRUE（真） 和 TIME 条件后，将触发此输出事件。

例如，如果您希望在系统启动后一定时间内不执行任何操作，您可以使用 RT_E_TRIG 功能块来设置一个延时。当 EI 事件到达并且过了设定的 TIME 时间，如果 QI 为 TRUE（真），EO 事件就会被触发。

RT_E_R_TRIG 功能块在需要基于时间条件控制事件触发的应用中非常有用，例如，在工业自动化中的定时控制或延时启动过程。

RT_E_REND 实时信号运行次数选择功能块

RT_E_REND 是一个实时事件功能块，它的作用是在满足特定条件时结束事件的传递。以下是 RT_E_REND 功能块的详细介绍：

EI1，EI2：这是一个输入事件，当事件到达时，将根据 QI 的值来决定是否结束事件的传递并阻止输出事件 EO。

QI：这是一个布尔数据输入，用于启用或禁用功能块。当 QI 为 TRUE（真） 时，功能块处于激活状态；当 QI 为 FLASE（假） 时，功能块不会结束事件的传递。

Tmin：这是一个时间数据输入，用于设置触发条件的时间阈值。当 EI 事件到达并且已经过了 TIME 设定的时间后，如果 QI 为 TRUE（真），则会触发 EO 事件。

EO：这是一个输出事件，当输入事件 EI 到达并且 QI 为 TRUE（真） 但 REND 为 FLASE（假） 时，将触发此输出事件。

例如，如果您希望在系统检测到特定错误时停止某个操作，您可以将 REND 设置为 TRUE（真），并在 EI 事件到达时激活 QO。只有当 REND 为 FLASE（假） 时，EO 事件才会被触发。RT_E_REND 功能块在需要基于特定条件控制事件结束的应用中非常有用，例如，在工业自动化中的紧急停止过程或错误处理。

RT_E_SELECT 实时信号输入选择功能块

RT_E_SELECT 是一个实时事件功能块，它的作用是根据条件选择性地传递事件。以下是 RT_E_SELECT 功能块的详细介绍：

EI：这是一个输入事件，当事件到达时，将根据 G 的值来决定是否传递到 EO1 或 EO2。

G：这是一个布尔数据输入，用于控制事件的选择传递。当 G 为 TRUE（真） 时，事件将传递到 EO1；当 G 为 FLASE（假） 时，事件将传递到 EO2。

EO1：这是一个输入事件，当输入事件 EI 到达并且 G 为 TRUE（真） 时，将触发此输出事件

EO2：这是一个输入事件，当输入事件 EI 到达并且 G 为 FLASE（假） 时，将触发此输出事件。

QI：这是一个布尔数据输入，用于启用或禁用功能块。当 QI 为 TRUE（真） 时，功能块处于激活状态；当 QI 为 FLASE（假） 时，功能块不会触发事件。

Tmin：这是一个时间数据输入，用于设置触发条件的时间阈值。当 EI 事件到达并且已经过了 TIME 设定的时间后，如果 QI 为 TRUE（真），则会触发 EO 事件。

例如，如果您希望根据某个条件来选择执行两个不同操作中的一个，您可以使用 RT_E_SELECT 功能块。当 EI 事件到达时，根据 G 的值，要么触发 EO1，要么触发 EO2。

RT_E_SELECT 功能块在需要根据条件选择不同操作路径的应用中非常有用，例如，在工业自动化中的流程控制或决策逻辑。

RT_E_SPLIT 实时分发功能块

RT_E_SPLIT 是一个实时事件功能块，它的作用是将一个输入事件分割成多个输出事件。以下是 RT_E_SPLIT 功能块的详细介绍：

EI：这是一个输入事件，当事件到达时，RT_E_SPLIT 将根据内部逻辑将其分割成多个输出事件。

EO1, EO2, ... EOn：这些是输出事件，当输入事件 EI 到达时，RT_E_SPLIT 将触发这些事件，数量和具体的输出取决于功能块的配置和逻辑。

QI：这是一个布尔数据输入，用于启用或禁用功能块。当 QI 为 TRUE（真） 时，功能块处于激活状态；当 QI 为 FLASE（假） 时，功能块不会触发事件。

Tmin：这是一个时间数据输入，用于设置触发条件的时间阈值。当 EI 事件到达并且已经过了 TIME 设定的时间后，如果 QI 为 TRUE（真），则会触发 EO 事件。

例如，如果您有一个传感器事件，需要同时通知多个处理单元，您可以使用 RT_E_SPLIT 功能块来实现这一点。当传感器事件 EI 到达时，RT_E_SPLIT 可以生成多个输出事件，分别触发不同的处理流程。

RT_E_SPLIT 功能块在需要将一个事件同时分发给多个接收者的应用中非常有用，例如，在工业自动化中的并行处理或在复杂事件处理系统中的事件分发。

RT_E_SWITCH 实时信号输出选择功能块

RT_E_SWITCH 是一个实时事件功能块，它的作用是根据输入条件选择性地传递事件到不同的输出。以下是 RT_E_SWITCH 功能块的详细介绍：

EI：这是一个输入事件，当事件到达时，将根据 K 的值来决定传递到哪个输出。

G：这是一个布尔型的数据输入，用于控制事件的路由。G的值决定了传递那个事件。

EO1, EO2：这些是输出事件，当输入事件 EI 到达并且 G 的值对应时，将触发相应的输出事件。

例如，如果您有一个事件需要根据不同的条件传递到不同的处理模块，您可以使用 RT_E_SWITCH 功能块。当 EI 事件到达时，根据 G的值，事件将被路由到对应的 EO。

RT_E_SWITCH 功能块在需要根据不同条件路由事件的应用中非常有用，例如，在工业自动化中的分支控制或在复杂事件处理系统中的条件路由。

RT_E_TRAIN 实时置位复位功能块

RT_E_TRAIN 是一个实时事件功能块，它的作用是在特定条件下触发一系列的事件。以下是 RT_E_TRAIN 功能块的详细介绍：

DT：这是一个输入事件，设定事件触发后的延迟时间。

N：指定要处理的事件数量。

例如，如果您有一个需要在一系列条件满足时才触发的复杂事件处理流程，您可以使用 RT_E_TRAIN 功能块来实现这一点。当传感器事件 EI 到达并且满足预设条件时，RT_E_TRAIN 可以生成一系列输出事件，按照特定的顺序触发不同的处理流程。

RT_E_TRAIN 功能块在需要根据一系列复杂条件来触发事件的应用中非常有用，例如，在工业自动化中的序列控制或在复杂事件处理系统中的条件触发。

BOOL2BOOL 布尔数据固定功能块

BOOL2BOOL 是一个功能块，用于将布尔值（Boolean）输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：布尔类型的输入信号

OUT：布尔类型的输出信号，直接反映输入信号的状态。

当IN输入为布尔值时，OUT将会输出与IN完全一致的布尔值，若输入为其他类型，则OUT将会输出FALSE

INT2INT 整型数据固定功能块

INT2INT 是一个功能块，用于将整型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：整型的输入信号

OUT：整型的输出信号，直接反映输入信号的状态。

当IN输入为整型值时，OUT将会输出与IN完全一致的整型值，若输入为其他类型，则OUT将会输出0。

BYTE2BYTE 整型数据固定功能块

BYTE2BYTE 是一个功能块，用于将字节值输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：字节类型的输入信号

OUT：字节类型的输出信号，直接反映输入信号的状态。

当IN输入为比特型值时，OUT将会输出与IN完全一致的比特型值，若输入为其他类型，则OUT将会输出0

DINT2DINT 整型数据固定功能块

DINT2DINT 是一个功能块，用于将双整型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：双整型的输入信号

OUT：双整型的输出信号，直接反映输入信号的状态。

当IN输入为双整型值时，OUT将会输出与IN完全一致的双整型值，若输入为其他类型，则OUT将会输出0。

DWORD2DWORD 整型数据固定功能块

DWORD2DWORD 是一个功能块，用于将双字型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：双字节类型的输入信号

OUT：双字节类型的输出信号，直接反映输入信号的状态。

当IN输入为双字节类型值时，OUT将会输出与IN完全一致的双字节类型值，若输入为其他类型，则OUT将会输出0。

LREAL2REAL 长实数型数据固定功能块

LREAL2LREAL 是一个功能块，用于将长实数型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：长实数型的输入信号

OUT：长实数型的输出信号，直接反映输入信号的状态。

当IN输入为长实数型值时，OUT将会输出与IN完全一致的长实数型值，若输入为其他类型，则OUT将会输出0。

REAL2REAL 实数型数据固定功能块

REAL2REAL 是一个功能块，用于将实数型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：实数型的输入信号

OUT：实数型的输出信号，直接反映输入信号的状态。

当IN输入为实数型时，OUT将会输出与IN完全一致的实数型值，若输入为其他类型，则OUT将会输出0。

SINT2SINT 短整型数据固定功能块

SINT2SINT是一个功能块，用于将短整型值输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：短整型的输入信号

OUT：短整型的输出信号，直接反映输入信号的状态。

当IN输入为短整型时，OUT将会输出与IN完全一致的短整型值，若输入为其他类型，则OUT将会输出0。

STRING2STRING 字符串型数据固定功能块

STRING2STRING 是一个功能块，用于将字符串型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：字符串型的输入信号

OUT：字符串型的输出信号，直接反映输入信号的状态。

当IN输入为字符串型时，OUT将会输出与IN完全一致的字符串型值，若输入为其他类型，则OUT将会输出0。

TIME2TIME 时间型数据固定功能块

TIME2TIME是一个功能块，用于将时间型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：时间型的输入信号

OUT：时间型的输出信号，直接反映输入信号的状态。

当IN输入为时间型时，OUT将会输出与IN完全一致的时间型值，若输入为其他类型，则OUT将会输出0。

UDINT2UDINT 无符号双整型数据固定功能块

DINT2DINT 是一个功能块，用于将无符号双整型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：无符号双整型的输入信号

OUT：无符号双整型的输出信号，直接反映输入信号的状态。

当IN输入为无符号双整型时，OUT将会输出与IN完全一致的无符号双整型值，若输入为其他类型，则OUT将会输出0。

UINT2UINT 无符号整型数据固定功能块

UINT2UINT 是一个功能块，用于将无符号整型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：无符号整型的输入信号

OUT：无符号整型的输出信号，直接反映输入信号的状态。

当IN输入为无符号整型时，OUT将会输出与IN完全一致的无符号整型值，若输入为其他类型，则OUT将会输出0。

USINT2USINT 无符号短整型数据固定功能块

USINT2USINT 是一个功能块，用于将无符号短整型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：无符号短整型的输入信号

OUT：无符号短整型的输出信号，直接反映输入信号的状态。

当IN输入为无符号短整型时，OUT将会输出与IN完全一致的无符号短整型值，若输入为其他类型，则OUT将会输出0。

WORD2WORD 字型数据固定功能块

WORD2WORD是一个功能块，用于将字型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：字型的输入信号

OUT：字型的输出信号，直接反映输入信号的状态。

当IN输入为字型时，OUT将会输出与IN完全一致的字型值，若输入为其他类型，则OUT将会输出0。

WSTRING2WSTRING 长字符型数据固定功能块

WSTRING2WSTRING是一个功能块，用于将长字符串型输入信号传递到输出信号。它的主要作用是确保输入信号的状态能够准确地传递到输出信号。以下是它的主要参数：

IN：长字符串型的输入信号

OUT：长字符串型输出信号，直接反映输入信号的状态。

当IN输入为长字符串型时，OUT将会输出与IN完全一致的长字符串型值，若输入为其他类型，则OUT将会输出0。

E_CTD 递减计数器功能块功能块

E_CTD 是一个事件功能块。它用于实现一个带有下限的递减计数器，计数器的值为 DINT（双字整数）类型。以下是它的各个参数的解释：

CD：计数输入。当此输入为 TRUE（真） 时，计数器的值减少。

LD：加载输入。当此输入为 TRUE（真） 时，计数器的值被设置为预设值 PV。 PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

总结来说，功能块 E_CTD 在 CD 输入为 TRUE（真） 时减少计数器的值，当 LD 输入为 TRUE（真） 时将计数器的值设置为预设值 PV，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

E_CTU 递增计数器功能块

E_CTU 是一个事件功能块。它用于实现一个带有上限的递增计数器，计数器的值为 DINT（双字整数）类型。以下是它的各个参数的解释：

CU：计数输入。当此输入为 TRUE（真） 时，计数器的值增加。

R：复位输入。当此输入为 TRUE（真） 时，计数器的值被重置为 0。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

Q：输出。当计数器的值达到预设值 PV 时，此输出为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

总结来说，功能块 E_CTU 在 CU 输入为 TRUE（真） 时增加计数器的值，当 R 输入为 TRUE（真） 时重置计数器，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

E_CTUD 双向计数器功能块

E_CTUD 是一个事件功能块。它用于实现一个带有上下限的双向计数器，计数器的值为 DINT（双字整数）类型。以下是它的各个参数的解释：

CU：计数增加输入。当此输入为 TRUE（真） 时，计数器的值增加。

CD：计数减少输入。当此输入为 TRUE（真） 时，计数器的值减少。

R：复位输入。当此输入为 TRUE（真） 时，计数器的值被重置为 0。

LD：加载输入。当此输入为 TRUE（真） 时，计数器的值被设置为预设值 PV。

PV：预设值。计数器达到此值时，输出 Q 变为 TRUE（真）。

CV：当前值。显示计数器当前的计数值。

总结来说，功能块 E_CTUD 在 CU 输入为 TRUE（真） 时增加计数器的值，在 CD 输入为 TRUE（真） 时减少计数器的值，当 R 输入为 TRUE（真） 时重置计数器，当 LD 输入为 TRUE（真） 时将计数器的值设置为预设值 PV，并在计数器的值达到预设值 PV 时通过 Q 输出信号。

E_T_FF 信号保持功能块

E_T_FF 是一个事件功能块。它用于检测和保持输入信号的状态。以下是它的各个参数的解释：

CLK：输入事件。当接收到输入事件时，触发功能块的执行。

Q：输出信号。根据输入事件的状态，输出相应的信号。

总结来说，功能块 E_T_FF 用于检测输入事件的状态，并保持该状态直到下一个输入事件到来。

E_MERGE 信号合并功能块

E_MERGE 是一个事件功能块。它用于将多个输入信号合并成一个输出信号。以下是它的各个参数的解释：

EI1，EI2：输入信号。这些信号将被合并成一个输出信号。

EO：输出信号。合并后的信号输出。

总结来说，功能块 E_MERGE 将多个输入信号 EI1, EI2 等合并成一个输出信号 EO。

E_REND 信号选择功能块

E_REND 是一个事件功能块。它用于从多个输入信号中选择一个信号

EI1，EI2：输入信号。当输入信号从 FLASE（假） 变为 TRUE（真） 时，触发输出信号。

R：输入信号。由R的值控制E0输出为EI1或EI2，当值为0时输出EI1，当值为1时输出EI2。

总结来说，功能块 E_REND 用于选择特定的输出信号。

E_PERMIT 信号阻断功能块

E_PERMIT是一个事件功能块。它用于控制信号的导通。以下是它的各个参数的解释：

EI：输入信号。当输入信号从 TRUE（真） 变为 FLASE（假） 时，触发输出信号。

EO：输出信号。当检测到输入信号为1时，功能块将导通。当输入信号为0时，信号会被阻止。

总结来说，功能块 E_PERMIT 用于根据输入信号来判断信号是否导通。

E_RESTART 重启功能块

E_RESTART 是一个事件功能块。它用于重新启动某个过程或操作。以下是它的各个参数的解释：

WARM：输入信号。当重新启动操作成功时，输出信号为 TRUE（真）。

COLD：输入信号。当重新启动操作成功时，输出信号为 TRUE（真）。

STOP：输出信号。当重新启动操作成功时，输出信号为 FLASE（假）。

总结来说，功能块 E_RESTART 用于在输入信号为 TRUE（真） 时，触发重新启动操作，并在操作成功时输出信号

E_TRAIN 置位复位功能块

E_TRAIN 是一个事件功能块。它用于实现置位和复位功能。以下是它的各个参数的解释：

DT：延迟输入信号代表延迟的时间。

N：时间数量输入信号。当输入信号为 TRUE（真） 时，输出信号 Q 被复位为 FLASE（假）。

CV：当前执行次数信号。

总结来说，功能块 E_TRAIN的功能是能够在单位间隔发送单位次数事件。

E_SELECT 信号输入选择功能块

E_SELECT 是一个事件功能块。它用于将多个个输入事件选择输出某个事件。以下是它的各个参数的解释：

EO：输入事件。当接收到输入事件时，触发输出事件。

EO1：第一个输入事件。由G控制是否输出。

EO2：第二个输入事件。由G控制输出。

G：控制输出哪个信号

总结来说，功能块 E_SELECT 用于将一个输入事件分成多个输出事件，从而实现事件的选择。

E_SWITCH 信号输出选择功能块

E_SWITCH 是一个事件功能块。它用于将一个输入事件分成多个输出事件。以下是它的各个参数的解释：

EO：输入事件。当接收到输入事件时，触发输出事件。

EO1：第一个输出事件。由G控制输出。

EO2：第二个输出事件。由G控制输出。

G：是一个布尔值控制输出哪个信号

总结来说，功能块 E_SWITCH 用于将一个输入事件分成多个输出事件，从而实现事件的选择。

E_DEMUX 信号分配功能块

E_DEMUX 是一个事件功能块。它用于将一个输入信号分配到多个输出信号。以下是它的各个参数的解释：

EI：输入信号。当此输入为 TRUE（真） 时，信号将被分配到相应的输出。

K：选择信号。用于选择哪个输出信号将被激活。

EO0, EO1, EO2, ...：输出信号。根据选择信号K的值，相应的输出信号将被激活。

总结来说，功能块 E_DEMUX 根据选择信号 K 的值，将输入信号 EI 分配到相应的输出信号 EO0，EO1，EO2，EO3 等。

E_D_FF 数据锁存同步功能块

E_D_FF 是一个事件功能块。它用于实现数据锁存和同步功能。以下是它的各个参数的解释：

EO：数据输出。当时钟信号到来时，数据输出的值将被锁存。

CLK：时钟信号。当时钟信号的上升沿到来时，数据输入的值被传递到输出。

Q：输出信号。锁存的数据值在时钟信号的上升沿到来时被输出。

D：使能信号。当使能信号为 TRUE（真） 时，触发器工作；当使能信号为 FLASE（假） 时，输出保持不变。

总结来说，功能块 E_D_FF 在时钟信号的上升沿到来时，将数据输入 D 的值锁存并输出到 Q，同时使能信号 EN 控制触发器的工作状态。

E_F_TRIG 下降边沿检测功能块

E_F_TRIG 是一个事件功能块。它用于检测输入信号的边沿（从 TRUE（真） 到 FLASE（假） 的变化）。以下是它的各个参数的解释：

QI：输入信号。当输入信号从 TRUE（真） 变为 FLASE（假） 时，触发输出信号。

EO：输出信号。当检测到输入信号的下降沿时，输出信号为 TRUE（真）。

总结来说，功能块 E_F_TRIG 用于检测输入信号的下降边沿变化，并在检测到时触发输出信号 Q。

E_R_TRIG 上升沿检测功能块

E_R_TRIG 是一个事件功能块。它用于检测输入信号的上升沿到达情况。以下是它的各个参数的解释：

QI：输入信号。当输入信号从 TRUE（真） 变为 FLASE（假） 时，触发输出信号。

EO：输出信号。当检测到输入信号的上升沿时，输出信号为 TRUE（真）。

总结来说，功能块 E_R_TRIG 用于检测输入信号的边沿上升沿变化，并在检测到时触发输出信号 Q。

E_RS 置位复位功能块

E_RS 一个事件功能块，主要用于实现置位和复位操作。具体来说：

置位优先：当置位S和复位R信号同时为高电平时，输出Q将被置位。

复位优先：当复位R信号为高电平时，输出Q将被复位，无论置位S信号的状态如何。

这种功能块常用于需要记忆状态的场合，例如启动和停止控制

E_SPLIT 信号分发功能块

E_SPLIT 是一个事件功能块。它用于将一个输入事件分成多个输出事件。以下是它的各个参数的解释：

EI：输入事件。当接收到输入事件时，触发输出事件。

EO1：第一个输出事件。当接收到输入事件时，触发此输出事件。

EO2：第二个输出事件。当接收到输入事件时，触发此输出事件。

总结来说，功能块 E_SPLIT 用于将一个输入事件分成多个输出事件，从而实现事件的分发。

E_SR 复位触发器功能块

E_SR 是一个事件功能块。它用于需要优先复位的场景。以下是它的各个参数的解释：

S：置位端。

R：复位端。

Q：输出端。

EO：信号触发端

当RS同时为1时，输出Q将会被复位为0，当R为0且S为1时，输出Q被置位为1，当RS都为0时，Q保持之前状态。

E_CYCLE 循环功能块

E_CYCLE 是一个事件功能块。它用于根据设定的时间周期性触发一个事件。以下是它的各个参数的解释：

START：开启定时事件。当此输入为 TRUE（真） 时，定时器开始计时。

STOP：停止定时事件。当此输入为 TRUE（真） 时，定时器停止计时。

EO：输出事件。当设定的时间间隔到达时，触发此事件。

DT：配置时间间隔参数。数据类型为字符串，格式如 T#5S（每5秒触发一次）、T#5MS（每5毫秒触发一次）等。

总结来说，功能块 E_CYCLE 在 START 输入为 TRUE（真） 时开始计时，在 STOP 输入为 TRUE（真） 时停止计时，并在设定的时间间隔到达时通过 EO 输出信号

E_DELAY 延时功能块

E_DELAY 是一个事件功能块。它用于实现一个延时功能。以下是它的各个参数的解释：

START：输入信号。当此输入为 TRUE（真） 时，延时计时开始。

STOP：输入信号。当此输入为 TRUE（真） 时，延时计时停止。

DT：预设时间。设定延时时间的长度，数据类型为时间（如 T#5S 表示 5 秒）。

EO：输出信号。当延时时间到达时，此输出为 TRUE（真）。

总结来说，功能块 E_DELAY 在 START 输入为 TRUE（真） 时开始计时，经过预设时间 DT 后，通过 EO 输出信号。

使用案例

1：构建一个E_DELAY的测试工程

2：在DT输入TIME#100ms 触发后可以发现EO随着触发次数变化而变化

E_RDELAY 延时功能块

E_RDELAY 是一个事件功能块。它用于实现延迟功能。以下是它的各个参数的解释：

START：输入信号。当输入信号为 TRUE（真） 时，开始计时。

STOP:输入信号。当输入信号为 TRUE（真） 时，停止计时。

DT：预设时间。延迟的时间长度。

EO：输出信号。当延迟时间到达时，输出信号为 TRUE（真）。

总结来说，功能块 E_REDELAY 用于在输入信号为 TRUE（真） 后，经过预设时间 PT 后，输出信号 Q 变为 TRUE（真），同时显示经过的时间。

M_W 将BOOL值写入普通寄存器功能块

M_W是一个实现写入中间继电器的功能块,其功能为存储一个0或者1的值。以下是它的各个参数的解释：

SET：写入中间继电器的值。类型为BOOL，大小为1位BOOL型，内容为真（假）

M：选择对应的中间继电器的地址直接通过变量表选择。

STATUS：监视功能块运行情况。

总结来说，功能块M_W的功能为，将一个真（假）的状态写入PLC的寄存器之中，这样在需要使用时方便取出。

M_R 从普通寄存器中读取BOOL值功能块

M_R是一个实现写读取普通寄存器的功能块，其功能为读取一个0或者1的值。以下是它的各个参数的解释：

M：选择对应的寄存器的地址直接通过变量表选择。

STATUS：监视功能块运行情况。

总结来说，功能块 M_R 的功能为，从寄存器中读取出一个真（假）的值，从OUT端口中输出。

B_W 将（8位）字节写入普通寄存器功能块

B_W 是一个实现将字节数据写入普通寄存器的功能块。以下是它的各个参数的解释：

SET：写入寄存器的值。类型为USINT

B：选择对应的普通寄存器的地址直接通过变量表选择。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块B_W是将一个字节（8位）的数据写入B类普通寄存器中。

B_R 普通寄存器中读取字节（8位）功能块

B_R是一个实现从普通寄存器中读取字节数据的功能块。以下是它的各个参数的解释：

B：选择对应的普通寄存器的地址，直接通过变量表选择。

OUT：输出并且显示B类寄存器，选择的寄存器中的数据内容。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 B_R 的功能：读取B类普通寄存器，将数据按字节读取从OUT端口中输出，若是有错误可以在STATUS中看见。

W_W 将（16位）字写入普通寄存器

W_W 是一个实现将字数据写入普通寄存器的功能块。以下是它的各个参数的解释：

SET：写入寄存器的值。类型为UINT(16位)

W：根据变量表设置选择寄存器地址。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块W_W是将一个字（16位）的数据写入W类普通寄存器中。

W_R 从普通寄存器中读取字（16位）功能块

W_R是一个实现从普通寄存器中读取字（16位）数据的功能块。以下是它的各个参数的解释：

W：根据变量表设置选择寄存器地址。

OUT：从普通寄存器中读取的数据。类型为UINT(16位)，范围0~65535。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 W_R 的功能：读取W类普通寄存器，将数据按字读取从OUT端口中输出，若是有错误可以在STATUS中看见。

D_W 双字（32位）写入普通寄存器功能块

D_W 是一个实现将双字数据写入普通寄存器的功能块。以下是它的各个参数的解释：

SET：写入寄存器的值。类型为UDINT(32位)

D：根据变量表设置选择寄存器地址。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块D_W是将一个双字（32位）的数据写入D类普通寄存器中。

D_R 普通寄存器中读取双字（32位）功能块

D_R是一个实现从普通寄存器中读取双字数据的功能块。以下是它的各个参数的解释：

D：根据变量表设置选择寄存器地址。

OUT：从普通寄存器中读取的数据。类型为UDINT(32位)。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 D_R 的功能：读取D类普通寄存器，将数据按双字读取从OUT端口中输出，若是有错误可以在STATUS中看见。

L_W （64位）长字写入普通寄存器功能块

L_W 是一个实现将长字数据写入普通寄存器的功能块。以下是它的各个参数的解释：

SET：写入寄存器的值。类型为ULINT(64位)

L：根据变量表设置选择寄存器地址。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块L_W是将一个长字（64位）的数据写入L类普通寄存器中。

L_R 普通寄存器中读取长字（64位）功能块

L_R是一个实现从普通寄存器中读取长字数据的功能块。以下是它的各个参数的解释：

L：根据变量表设置选择寄存器地址。

OUT：从普通寄存器中读取的数据。类型为ULINT(64位)。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 L_R 的功能：读取L类普通寄存器，将数据按长字读取从OUT端口中输出，若是有错误可以在STATUS中看见。

FERAM_M_W 将BOOL值写入保持寄存器（1位）功能块

FERAM_M_W 是一个实现写入保持寄存器的功能块。以下是它的各个参数的解释：

SET：写入保持寄存器的值。类型为BOOL，大小为1位BOOL型，内容为真（假）

M：选择对应的寄存器地址，直接通过变量表选择。

STATUS：监视功能块运行情况。

总结来说，功能块FERAM_M_W用于将一个真（假）的数据写入PLC的保持寄存器中，可以在掉电重启的情况下保持数据。

FERAM_M_R 从保持寄存器读取BOOL型功能块

FERAM_M_R 是一个实现读取保持寄存器的功能块。以下是它的各个参数的解释：

M：选择对应的保持寄存器的地址直接通过变量表选择。

STATUS：监视功能块运行情况。

OUT：输出保持寄存器的值。

总结来说，功能块 FERAM_M_R 的功能从保持寄存器中读取一个BOOL型（1位）数据。

FERAM_B_W 写入保持寄存器（8位）功能块

FERAM_B_W是一个实现将字节数据写入保持寄存器的功能块。以下是它的各个参数的解释：

SET：读取铁电寄存器器的值。类型为USNT(8位)，范围0~255。

B：根据变量表设置选择寄存器地址。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_B_W的功能是将一个字节数据（8位）写入保持寄存器中。

FERAM_B_R 写铁电存储器功能块

FERAM_B_R是一个实现写铁电存储器的值的功能块。以下是它的各个参数的解释：

B：根据变量表设置选择寄存器地址。

OUT：从保持寄存器中读取字节型数据。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_B_R的功能从保持寄存器中读取字节型数据从OUT端口中输出，若是有错误可以在STATUS中看见。

FERAM_W_W 字数据写入保持寄存器（16位）功能块

FERAM_W_W是一个实现将16位数据写入保持寄存器的功能块。以下是它的各个参数的解释：

SET：读取保持寄存器的值。类型为UINT(16位)，范围0~65535。

W：根据变量表设置选择寄存器地址。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_W_W的功能是将一个字数据（16位）写入保持寄存器中。

FERAM_W_R 保持寄存器读取字型数据（16位）功能块

FERAM_W_R是一个实现从保持寄存器中读取16位数据的功能块。以下是它的各个参数的解释：

W：根据变量表设置选择寄存器地址。

OUT：从保持寄存器中读取的数据。类型为UINT(16位)，范围0~65535。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_W_R的功能从保持寄存器中读取字型数据从OUT端口中输出，若是有错误可以在STATUS中看见。

FERAM_D_W 双字数据写入保持寄存器（32位）功能块

FERAM_D_W是一个实现将双字（32位）数据写入保持寄存器的功能块。以下是它的各个参数的解释：

SET：读取保持寄存器的值。类型为UDINT(32位)。

D：根据变量表设置选择寄存器地址。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_D_W的功能是将一个双字数据（32位）写入保持寄存器中。

FERAM_D_R 保持寄存器读取双字型数据（32位）功能块

FERAM_D_R是一个从保持寄存器中读取双字（32位）数据的功能块。以下是它的各个参数的解释：

D：根据变量表设置选择寄存器地址。

OUT：从保持寄存器中读取的数据。类型为UDINT(32位)。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_D_R的功能从保持寄存器中读取双字型数据从OUT端口中输出，若是有错误可以在STATUS中看见。

FERAM_L_W 长字数据写入保持寄存器（64位）功能块

FERAM_L_R是一个实现将长字（64位）数据写入保持寄存器的功能块。以下是它的各个参数的解释：

SET：读取保持寄存器的值。类型为ULINT(64位)。

L：根据变量表设置选择寄存器地址。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_L_W的功能是将一个长字数据（64位）写入保持寄存器中。

FERAM_L_R 保持寄存器读取长字型数据（64位）功能块

FERAM_L_R是一个从保持寄存器中读取长字（64位）数据的功能块。以下是它的各个参数的解释：

L：根据变量表设置选择寄存器地址。

OUT：从保持寄存器中读取的数据。类型为ULINT(64位)。

STATUS;显示写入的结果，如有错误将会显示。

总结来说，功能块 FERAM_L_R的功能从保持寄存器中读取长字型数据从OUT端口中输出，若是有错误可以在STATUS中看见。

关于如何使用：

1.需要在编程项目时建立你自己的变量表。

你可在IDE窗口的右侧看见变量表选项，点击进入变量表后，即可进行你的参数编辑。

首先点击左下角的新增数据即可生成一个空变量，这时你需要按照你的需求修改你的变量，并且为它取名

例如这里我们需要一个中间变量表示真或假，我们创建一个M类型的寄存器，地址为M0 此时就可以在组态时选择M的地址,M的地址范围是0~1024。这里我们设置地址为M0和M1，这时你就可以在画布进行编程。

SCALE 比例算法功能块

SCALE功能块用于进行比例转换的功能块

以下是它的各个参数的解释：

IN：需要转换的参数。

IN_MIN:写入参数的最小值。

IN_MAX:写入的最大值。

OUT_MIN:输出最小值。

OUT_MAX:输出最大值。

OUT:最后计算得到的输出值。

总结来说，功能块SCALE的功能块是参数值进行比例转换，例如将0~10的数放大到0~100等于将值放大10倍。

PID功能块

PID是实现PID计算的功能块。以下是它的各个参数的解释：

INIT:初始化算法参数

REQ:触发算法

RST:重置算法

InERROR：输入的误差值

Noise：噪声设置（输入误差值小于噪声范围时将被置0）

KP：算法中的KP设置

Ki：算法中的KI设置

Kd：算法中的KD设置

Interval：PID计算周期

LIM_H：PID输出上限

LIM_L：PID输出下限

Y：输出PID计算结果

LIM：计算结果是否超过设置范围

MEDIAN_FILTER 中值滤波功能块

MEDIAN_FILTER是实现中值滤波的功能块。以下是它的各个参数的解释：

WINDOW：窗口大小，设置中值滤波的窗口大小，需要触发INIT初始化窗口值

VALUE：输入的参数值

VALUE_ME：经过滤波输出的参数

总结来说，功能块MEDIAN_FILTER的功能是实现软件中值滤波。

MOV_AVERAGE 移动平均滤波功能块

MOV_AVERAGE是实现移动平均滤波的功能块。以下是它的各个参数的解释：

WINDOW：窗口大小，设置中值滤波的窗口大小，需要触发INIT初始化窗口值

VALUE：输入的参数值

VALUE_ME：经过滤波输出的参数

总结来说，功能块MEDIAN_FLITER的功能是实现软件移动平均滤波。

ESP_GET_TIME ESP32PLC获取系统时间

ESP_GET_TIME是实现读取esp32内部系统时间的功能块。以下是它的各个参数的解释：

O1：触发后将输出当前PLC的系统时间。

总结来说，功能块ESP_GET_TIME的功能是实现ESP32获取系统时间。

ESP_SET_TIME ESP32PLC设置系统时间

ESP_GET_TIME是实现读取esp32内部系统时间的功能块。以下是它的各个参数的解释：

SET:输入需要设置的系统时间，触发后将时间写入系统时间

总结来说，功能块ESP_SET_TIME的功能是实现ESP32设置系统时间。

X 读取PLC的IO输入状态功能块

X是一个实现读取IO输入端子状态的功能块,其功能为读取外部输入状态：

X：设置需要读取的IO号，通过变量表配置。

OUT：输出IO读取到的高低电平状态。

STATUS：输出IO设备的某些错误。

总结来说，功能块X的功能为，读取某个IO口并且输出IO的状态。

Y 控制PLC的IO输出功能块

Y是一个实现控制IO端子输出状态的功能块：

SET：控制IO端子输出高电平或者低电平。

Y：设置需要输出的IO号，通过变量表配置。

STATUS：输出IO设备的某些错误。

总结来说，功能块Y的功能为，控制某个IO输出高电平或者低电平。

HX 读取PLC的高速IO输入状态功能块（仅供VAR-P-500使用）

HX是一个实现读取高速IO输入端子状态的功能块,其功能为读取外部输入状态：

HX：设置需要读取的高速IO号，通过变量表配置。

OUT：输出高速IO读取到的高低电平状态。

STATUS：输出I高速O设备的某些错误。

总结来说，功能块HX的功能为，读取某个高速IO口并且输出IO的状态。

HY 控制PLC的IO输出功能块

HY是一个实现控制高速IO端子输出状态的功能块：

SET：控制高速IO端子输出高电平或者低电平。

HY：设置需要输出的高速IO号，通过变量表配置。

STATUS：输出高速IO设备的某些错误。

总结来说，功能块HY的功能为，控制某个高速IO输出高电平或者低电平。

ADC读功能块

ADC是一个实现读取ADC数据的功能块。以下是它的各个参数的解释：

NUM：选择硬件设备ADC的端口，1表示1号端口，2表示2号端口。

OUT：根据NUM输入的1或2输出相应的十六进制ADC的值，类型为REAL。

V：根据NUM输入的1或2输出相应端口的电压值，类型为REAL。

STATUS:如果端口号超过所使用型号PLC将会提示报错。

DAC发功能块

DAC是一个实现控制设备DAC输出的功能块。以下是它的各个参数的解释：

NUM：选择硬件设备DAC的端口，1表示1号端口，2表示2号端口。

SET：希望DAC端口输出的电流值。输入参数为0~4095对应电流0~25mA

STATUS:如果端口号超过所使用型号PLC将会提示报错。

RTC_WRITE 修改RTC时钟功能块

RTC_WRITE是一个实现修改RTC时钟的功能块。RTC是令PLC在掉电状态下持续记录时间。这个功能块可以修改RTC中当前的时间。通常用于设置时间。

以下是它的各个参数的解释：

DATA：需要写入RTC的时间。

STATUS:写入失败时会显示你的错误原因。

总结来说，功能块RTC_WRITEC的功能修改RTC时钟的值。

RTC_READ RTC时钟读取功能块

RTC_READ是一个实现读取RTC时钟的功能块。以下是它的各个参数的解释：

DATA：你从RTC中读取到的系统时间。

总结来说，功能块 RTC_READ的功能读取RTC时间的值。

CONFIG_485 配置485端口功能块

CONFIG_485是一个配置485端口的功能块。以下是它的各个参数的解释：

COM：同来选择需要使用的485端口，有0号和1号端口可用。

PARITY：配置485端口的校验位，支持的校验位为，EVEN偶校验 NONE无校验 ODD奇校验。

DATA_BIT：配置485端口的数据位，支持的数据位为，8 7 6 5。

STOP_BIT：配置485端口的停止位，支持的停止位为，1 1.5 2。

BAUD: 配置485端口的波特率，支持的波特率为2400 4800 9600 19200 38400 57600 115200。

STATUS:如果配置参数错误，将会提示。

总结来说，功能块CONFIG_485的功能将485端子按照你的需求配置。

MODBUS_RTU_MASTER modbus协议串口发送功能块

MODBUS_RTU_MASTER是一个串口发送功能块。以下是它的各个参数的解释：

COM：用来配置使用哪个串口进行发送。

SLAVE：设置MODBUS的从站地址

RW：设置MODBUS帧的功能码 支持，1 读取线圈 2 读取离散数 3读取保持寄存器

5 写单个线圈 6 写单个寄存器

ADDR：寄存器地址

COUNT：寄存器个数

QO:modbus请求帧是否成功

STATUS：显示可能出现的错误

MODBUS_RTU_SLAVE MODBUS6从栈功能块

MODBUS_RTU_SLAVE是MODBUS从站功能块，当接收到MODBUS请求帧时，进行相应的寄存器操作，一般就是读写。以下是它的各个参数的解释：

COM：配置为从站的485端口，支持0和1

ADDR：配置从站地址

QO：接收的请求帧是否正确

STATUS:显示请求帧的错误类型

总结来说，功能块MODBUS_RTU_SLAVE的功能是令PLC在MODBUS中充当从站时应用。

ESP_PWM ESP32输出PWM功能块

ESP_PWM是实现PWM输出的功能块。以下是它的各个参数的解释：

SPEED_MODE：设置高速或者低速模式

PWM_NUM：选择PWM通道，支持通道有 1 2 3 4

DUTY_CYCLE：设置占空白比，支持一位小数，设置时需要比实际值放大10倍（需要设置占空比为52.0时需要输入520）

HZ：PWM的频率设置

总结来说，功能块ESP_PWM的功能是实现ESP32输出PWM。

PUBLISH_1 发布UDP消息

PUBLISH功能块是实现PLC之间通信的功能块

INIT:初始化算法参数

REQ:触发执行发送

INITO:初始化完成

CNF：发送完成

QI：开启通信（若设置为0则无法通信）

ID：设置通信的地址（224.0.0.0 - 239.255.255.255）

SD_1：发送的数据内容

QO：发送是否成功（TRUE为成功）

STATUS：显示发送功能块的状态

说明：

PUBLISH功能块使用的是UDP多波发送所以ID的范围为224.0.0.0 - 239.255.255.255，还需要在地址后加上端口号，完整设置例如224.0.0.0：61499

使用范例：

首先初始化PUBLISH功能块，而后需要发送时触发REQ事件，并且将需要发送的参数连接至SD_1

其他功能：

如果需要更多的参数点发送，则可以创建多参数点的功能块，而且无需编译，例如一个参数点为PUBLISH_1，两个参数点则为PUBLISH_2。

在上方工具栏内点击功能，选择新建功能块，创建一个服务功能块。

像这样创建一个新的功能块，接口大多相同只需要添加一个参数点若是需要的更多则需要在命名时对应，5个接口则需要命名为PUBLISH_5。

SUBSCRIBE_1 接收UDP消息

SUBSCRIBE功能块是实现PLC之间通信的功能块

INIT:初始化算法参数

RSP:触发执行发送

INITO:初始化完成

IND：发送完成

QI：开启通信（若设置为0则无法通信）

ID：设置通信的地址（224.0.0.0 - 239.255.255.255）

QO：发送是否成功（TRUE为成功）

STATUS：显示发送功能块的状态

RD_1：接收到的内容

说明：

SUBSCRIBE功能块使用的是UDP多波接收所以ID的范围为224.0.0.0 - 239.255.255.255，还需要在地址后加上端口号，完整设置例如224.0.0.0：61499

使用范例：

首先初始化SUBSCRIBE功能块，而后接收时触发IND事件，并且将接收到的参数自RD_1中输出。

其余功能与PUBLISH相同也支持添加参数点。

CLIENT_1 通讯主站

CLIENT功能块是实现PLC之间通信的功能块

INIT:初始化算法参数

REQ:触发执行发送

INITO:初始化完成

CNF：发送完成

QI：开启通信（若设置为0则无法通信）

ID：设置通信的地址

SD_1：发送的数据内容

QO：发送是否成功（TRUE为成功）

STATUS：显示发送功能块的状态

说明：

CLIENT功能块允许使用多种协议，由填写不同的ID参数进行区分。

例如使用TCP/IP协议时，填写格式为IP地址加端口号例如：10.22.22.4:61000

使用modbus_rtu时填写格式为：modbus[rtu:设备标识符:波特率:校验方式:数据位数:停止位数:轮询频率:功能码:从站 ID:读取地址:发送地址(:响应超时时间:字节超时时间)]。

例如：modbus[rtu:/dev/uart/1:9600:N:8:1:2000:3:1:0..3:0..3] 读取地址与发送地址，可以指定 0-65535 之间的地址。可以使用以下命令指定多个地址（最多 100 个）逗号表示单独的地址 0,2,65500。5..10意为5到10之间的所有值。

使用modbus_tcp时填写格式为：modbus[目标设备的IP地址:目标设备的端口号:轮询频率:功能码:从站 ID:读取地址:发送地址(:响应超时时间:字节超时时间)]

例如：modbus[127.0.0.1:502:2000:3:1:0..3]

使用DDCE协议时填写格式为：DDCE[MAC:目标mac地址]例如：DDCE[MAC:FFFFFFFFFFFF]

使用范例：

首先初始化CLIENT功能块INITO事件，而后需要发送时触发REQ事件，并且将需要发送的参数连接至SD_1

其他功能：

如果需要更多的参数点发送，则可以创建多参数点的功能块，而且无需编译，例如一个参数点为CLIENT_1，两个参数点则为CLIENT_2。

在上方工具栏内点击功能，选择新建功能块，创建一个服务功能块。

像这样创建一个新的功能块，接口大多相同只需要添加一个参数点若是需要的更多则需要在命名时对应，5个接口则需要命名为CLIENT_5。

SERVER_1 通讯从站

SERVER功能块是实现PLC之间通信的功能块

INIT:初始化算法参数

RSP:触发执行发送

INITO:初始化完成

IND：发送完成

QI：开启通信（若设置为0则无法通信）

ID：设置通信的地址

QO：发送是否成功（TRUE为成功）

STATUS：显示发送功能块的状态

RD_1：接收到的内容

说明：

SERVER功能块用于接收主站发送的消息 SERVER功能块目前只支持TCP/IP，使用TCP/IP协议时，填写格式为本地IP地址加端口号例如：10.22.22.4:61000 和DDCE协议，使用DDCE协议时填写格式为：DDCE[MAC:目标mac地址]例如：DDCE[MAC:FFFFFFFFFFFF]

使用范例：

首先初始化SERVER功能块，而后接收时触发IND事件，并且将接收到的参数自RD_1中输出。

其余功能与PUBLISH相同也支持添加参数点。

简单示例 闪烁

一个简单的示例程序，实现IO闪烁

• 选择功能块E_CYCLE，这个功能块按照设置时间持续生成事件，是主要功能块之一，设置这个时间相当于系统扫描周期，决定了你的程序多久循环一次。这里设置参数T#1s意为1s循环一次。
• 然后选择E_SWITCH与E_SR。E_SWITCH会根据G的参数选择输出的事件，若G为FALSE则输出事件EO0，若G为TRUE则输出事件EO1。E_SR则会根据输入的事件改变输出参数，若输入事件S则Q输出为TRUE，若输入事件R则Q输出FALSE。两个功能块组合实现了Q参数的闪烁变化。
• 接下来在变量表中创建我们的Y端口。
• 现在只需要连接上IO输出控制功能块Y，并且选择变量表中的接口即可实现闪烁。

多设备示例

简单的多设备部署和通信示例

• 当你需要进行多设备编程时，可以在编程时添加相应设备。

• 

• 添加完设备名称后点击添加设备即可添加一台新的设备。

• 

• 接下来需要进行颜色的选择，将不同设备绑定不同的颜色这会方便你分辩不同设备的程序。

• 在编程中你可以选择不同的功能块并且选择其归属的设备，其会变化为相应设备的归属颜色。

• 接下来设置两个设备之间的通信。

• 使用PUBLISH功能块将设备的闪烁信号发送给另一台设备，需要在启动发送时初始化PUBLISH功能块，因此最好将其 INIT 事件直接连接到 START。将 QI 值设置为 1，并将 PUBLISH_COUNT FB 的 ID 输入数据设置为 239.0.0.1:61000。PUBLISH_X 中的数字 X 是您要在消息中发送的数据元素的数量。由于我们只发送一个值，因此我们使用了 PUBLISH_1。每次触发 REQ 时，都会根据输入的 ID 发送一条消息。

• PUBLISH_X FB 用于通过网络发送消息，该消息由相应的 SUBSCRIBE_X FB 接收。这一对FB需要有相同的ID。

• 

PID示例

简单的PID示例，使用加热棒进行PID控制水温

• 在温度控制项目中，温度的读取非常重要，这里选取的是支持485通信的温度传感器。
• 首先配置串口，按照温度计手册将COM口设置为0,意思为配置第一路485，校验位设置为EVEN偶校验，数据位为8，停止位为1，波特率为9600。
• 读取温度计温度值按照说明手册需读取保存寄存器的第4号寄存器因此设置MODBUS主站功能块读取4号保持寄存器。 设置控制目标温度，温度传感器返回值是实际值的10倍。按照我们的设置将当前值与目标值的差传入PID功能块，根据设置的KP,KI,KD值，PID功能块将会计算需要从Y接口输出的参数值。LIM_H与LIM_L分别为PID输出的最大值与最小值。
• 
• 设置噪声过滤为0。
• 使用SCALE功能块将计算值比例放大，使用DAC功能块控制DAC输出。
• 这就是整体项目。

示例项目 15匹机

• 下面由具体项目进行演示，示例项目为冰蓄冷机组-单15匹机。

• 下面是项目具体方案：

• 下面我们进行编程演示，首先进入IDE编译页面，创建我们的新项目

• 进入项目后点击添加设备，并且选择你的网关。（若是不会绑定网关参考说明书“用户管理”）随后点击变量表定义项目所需要的IO。

• 我们按图配置所需要的输入口X，并且加上相应的注释。

• 不要忘记点击确认修改，不然不会保存修改的变量表。

• Vcore的编程方式非常灵活，既支持类梯形图的轮询方式，也支持中断的控制方式。下面我们介绍利用轮询方式编程。在初始启动功能块触发之后，我们设置并且启动一个定时器作为IO设备的轮询时钟。

• 这里设置轮询时间为100ms，意为100ms查询一次IO状态，由X功能块的OUT口输出IO的状态，针对使用的X端口我们需要在下拉框中选择，这其中的参数对应刚才变量表填写的参数。

• 现在我们按照项目要求，编写一个状态检测程序。

• 可以看见整体程序的功能块以及线段较多，我们可以创建一个组来存储它。点击画布后右键选择生成组而后加上相关注释后可以将程序隐藏

• 点击上面的加号还可以将组展开。

• 我们来解析一下这段程序，由X1,X2,X3分别代表低油位保护，吸气压力保护，排气压力保护，需要常闭连接，因此将信号量取反。和相序保护信号一起经过，与逻辑后存入中间寄存器M0。当系统状态为故障时将M0寄存器设置为真。X4为压力连控风机接口，若是压力过高X4将接收到高电平，将M1寄存器设置为真。在此程序中将故障状态与风机启动状态存入中间寄存器M中。

• 接下来编写开机启动程序，首先我们去变量表中添加输出端口的定义。

• 根据项目需求，X6端口作为开机按钮输入，同时在故障状态时不允许开机。若是系统状态正常则按照需求依次输出。同时使用M2寄存器用以表明当前是开机状态。

• 同样的关机程序也是相同，并且在故障状态下需要令故障灯实现闪烁。

• 最后在另一循环中读取机器是否启动，是否需要启动散热风机。