From 4d6eee558504eee44ab25fa23eb39f10f46d6f9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felix=20Wei=C3=9F?= <72068105+Sandoun@users.noreply.github.com> Date: Wed, 26 Jul 2023 00:20:01 +0200 Subject: [PATCH] Added missing F functions set --- AutoTools.ChmDataExtract/Program.cs | 86 +- MewtocolNet/AutoGeneratedData/FPFunction.cs | 5326 +++++++++++++++++ MewtocolNet/MewtocolNet.csproj | 4 + .../ProgramParsing/PlcBinaryProgram.cs | 40 +- MewtocolNet/PublicEnums/PlcVarType.cs | 9 +- 5 files changed, 5447 insertions(+), 18 deletions(-) create mode 100644 MewtocolNet/AutoGeneratedData/FPFunction.cs diff --git a/AutoTools.ChmDataExtract/Program.cs b/AutoTools.ChmDataExtract/Program.cs index 9dd635d..6a65979 100644 --- a/AutoTools.ChmDataExtract/Program.cs +++ b/AutoTools.ChmDataExtract/Program.cs @@ -2,6 +2,7 @@ using System.Diagnostics; using System.Reflection; using System.Runtime.Serialization.Formatters.Binary; +using System.Text; using System.Text.Json; using System.Text.Json.Serialization; using System.Text.RegularExpressions; @@ -290,7 +291,7 @@ internal class Program { if(descrText != null) { - descrText = descrText.SanitizeLinebreakFormatting(); + descrText = descrText.SanitizeLinebreakFormatting().Replace("\"", "\\\""); functionIns.Description = descrText; @@ -318,10 +319,89 @@ internal class Program { } - var funcsJson = JsonSerializer.Serialize(functions, new JsonSerializerOptions { WriteIndented = true }); + BuildFunctionNamesDictFile(functions); - File.WriteAllText("./function_names.json", funcsJson); + } + static void BuildFunctionNamesDictFile (Dictionary dict) { + + var sb = new StringBuilder(); + + sb.AppendLine("using System.Collections.Generic;\n"); + sb.AppendLine("namespace MewtocolNet.AutoGeneratedData {\n"); + + sb.AppendLine("\tpublic class FPFunction {\n"); + + sb.AppendLine("\t\tpublic string RedundantName { get; private set; }\n"); + sb.AppendLine("\t\tpublic string Description { get; private set; }\n"); + sb.AppendLine("\t\tpublic Dictionary ParametersIn { get; private set; }\n"); + sb.AppendLine("\t\tpublic Dictionary ParametersOut { get; private set; }\n"); + + sb.AppendLine("\t\tpublic static readonly Dictionary functions = new Dictionary {\n"); + + foreach (var item in dict) { + + sb.AppendLine($"\t\t\t{{ \"{item.Key}\", new FPFunction {{"); + + if(item.Value.RedundantName != null) + sb.AppendLine($"\t\t\t\tRedundantName = \"{item.Value.RedundantName}\","); + + if(item.Value.Description != null) + sb.AppendLine($"\t\t\t\tDescription = \"{item.Value.Description}\","); + + if (item.Value.ParametersIn != null) { + + sb.AppendLine("\t\t\t\tParametersIn = new Dictionary {"); + + foreach (var paramIn in item.Value.ParametersIn) { + + sb.AppendLine($"\t\t\t\t\t{{ \"{paramIn.Key}\", new string[] {{"); + + foreach (var paramType in paramIn.Value) { + + sb.AppendLine($"\t\t\t\t\t\t\"{paramType}\","); + + } + + sb.AppendLine("\t\t\t\t\t}},"); + + } + + sb.AppendLine("\t\t\t\t},"); + + } + + if (item.Value.ParametersOut != null) { + + sb.AppendLine("\t\t\t\tParametersOut = new Dictionary {"); + + foreach (var paramOut in item.Value.ParametersOut) { + + sb.AppendLine($"\t\t\t\t\t{{ \"{paramOut.Key}\", new string[] {{"); + + foreach (var paramType in paramOut.Value) { + + sb.AppendLine($"\t\t\t\t\t\t\"{paramType}\","); + + } + + sb.AppendLine("\t\t\t\t\t}},"); + + } + + sb.AppendLine("\t\t\t\t},"); + + } + + sb.AppendLine($"\t\t\t}}}},"); + + } + + sb.AppendLine("\t\t};\n"); + sb.AppendLine("\t}\n"); + sb.AppendLine("}"); + + File.WriteAllText("../../../../MewtocolNet/AutoGeneratedData/FPFunction.cs", sb.ToString()); } diff --git a/MewtocolNet/AutoGeneratedData/FPFunction.cs b/MewtocolNet/AutoGeneratedData/FPFunction.cs new file mode 100644 index 0000000..3b32590 --- /dev/null +++ b/MewtocolNet/AutoGeneratedData/FPFunction.cs @@ -0,0 +1,5326 @@ +using System.Collections.Generic; + +namespace MewtocolNet.AutoGeneratedData { + + public class FPFunction { + + public string RedundantName { get; private set; } + + public string Description { get; private set; } + + public Dictionary ParametersIn { get; private set; } + + public Dictionary ParametersOut { get; private set; } + + public static readonly Dictionary functions = new Dictionary { + + { "F0_MV", new FPFunction { + RedundantName = "MOVE", + Description = "The 16-bit data or 16-bit equivalent constant specified by s is copied to the 16-bit area specified by d, if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F1_DMV", new FPFunction { + RedundantName = "MOVE", + Description = "The 32-bit data or 32-bit equivalent constant specified by s is copied to the 32-bit area specified by d, if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F2_MVN", new FPFunction { + RedundantName = "FP_MOVE_INVERT", + Description = "The 16-bit data or 16-bit equivalent constant specified by s is inverted and transferred to the 16-bit area specified by d if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F3_DMVN", new FPFunction { + RedundantName = "FP_MOVE_INVERT", + Description = "The 32-bit data or 32-bit equivalent constant specified by s is inverted and transferred to the 32-bit area specified by d if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F4_GETS", new FPFunction { + RedundantName = "FP_GET_IO_START_OFFSET", + Description = "The head word No. of the specified slot is read.", + ParametersIn = new Dictionary { + { "s_Slot", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_FirstWX", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_FirstWY", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F5_BTM", new FPFunction { + Description = "1 bit of the 16-bit data or constant value specified by s is copied to a bit of the 16-bit area specified by d according to the content specified by n if the trigger EN is in the ON-state. When the 16-bit equivalent constant is specified by s, the bit data move operation is performed internally converting it to 16-bit binary expression.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F6_DGT", new FPFunction { + Description = "The hexadecimal digits in the 16-bit data or in the 16-bit equivalent constant specified by s are copied to the 16-bit area specified by d as specified by n.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F7_MV2", new FPFunction { + RedundantName = "FP_MOVE2", + Description = "The two 16-bit data or two 16-bit equivalent constants specified by s1 and s2 are copied to the 32-bit area specified by d when the trigger turns ON.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F8_DMV2", new FPFunction { + RedundantName = "FP_MOVE2", + Description = "The function copies two 32-bit data areas specified at inputs s1 and s2 to a 32-bit ARRAY with two elements at output d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..1] of", + }}, + }, + }}, + { "F10_BKMV", new FPFunction { + RedundantName = "FP_MOVE_BLOCK", + Description = "The data block specified by the 16-bit starting area specified by s1_Start and the 16-bit ending area specified by s2_End are copied to the block starting from the 16-bit area specified by d_Start if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F10_BKMV_NUMBER", new FPFunction { + Description = "The data block specified by the 16-bit starting area specified by s1_Start and the number of WORDs specified by s2_Number are copied to the block starting from the 16-bit area specified by d_Start if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F10_BKMV_NUMBER_OFFSET", new FPFunction { + Description = "This instruction is a modification of the F10_BKMV Redundant instruction generated by the compiler. The data block specified by the 16-bit starting area specified by s1_Start and the number of WORDs specified by s2_Number are copied to the block starting from the 16-bit area specified by the offset d_Offset from s1_Start if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_Offset", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F10_BKMV_OFFSET", new FPFunction { + Description = "This instruction is a modification of the F10_BKMV Redundant instruction generated by the compiler. The data block specified by the 16-bit starting area specified by s1_Start and 16-bit ending area specified by s2_End are copied to the block starting from the 16-bit area specified by the offset d_Offset from s1_Start if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_Offset", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F11_COPY", new FPFunction { + RedundantName = "FP_COPY", + Description = "The 16-bit equivalent constant or 16-bit area specified by s is copied to all 16-bit areas of the block specified by d1_Start and d2_End if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F12_EPRD", new FPFunction { + Description = "Using this instruction data will be copied from EEPROM/ Flash-ROM to the destination area (DT). The copy function is carried out with blocks only. Thus you can not copy single words. The block size and the number of blocks is shown in the table \"PLC specific information\". Also ensure that there at least 64/ 2048 free data registers (1 block = 64 words/ 2048 words (DTs)) reserved for the destination area.", + ParametersIn = new Dictionary { + { "EN", new string[] { + "BOOL", + }}, + { "s1_Start", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_Number", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "ENO", new string[] { + "BOOL", + }}, + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F12_ICRD", new FPFunction { + Description = "The data for the number of words specified by s2_Number are read from the address in the IC card extended memory area specified by s1_Start and written to the area specified by d_Start.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_Number", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F13_ICWT", new FPFunction { + Description = "The data for the number of words specified by s2_Number are read from the address specified by s1_Start and written to the extended memory area in the IC card specified by d_Start.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Number", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "d_Start", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F14_PGRD", new FPFunction { + Description = "When the execution criterion of F14_PGRD is turned ON, the execution proceeds until the END. The program subsequently switches to the program specified by s.", + ParametersIn = new Dictionary { + { "s", new string[] { + "ARRAY [0..5] OF WORD", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F15_XCH", new FPFunction { + RedundantName = "FP_EXCHANGE", + Description = "The contents in the 16-bit areas specified by d1 and d2 are exchanged if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F16_DXCH", new FPFunction { + RedundantName = "FP_EXCHANGE", + Description = "Two 32-bit data specified by d1 and d2 are exchanged if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "d2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F17_SWAP", new FPFunction { + Description = "The higher byte (higher 8-bits) and lower bytes (lower 8-bits) of a 16-bit area specified by d are exchanged if the trigger EN is in the ON-state. 1 byte means 8 bit.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F18_BXCH", new FPFunction { + Description = "The function exchanges one 16-bit data block for another. The beginning of the first data block is specified at output d1_Start and its end at output d2_End. Output d3_Start specifies the beginning of the second data block.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d3_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F19_SJP", new FPFunction { + Description = "Jumps to the label LBLs with the same number as the data stored in the area specified by s if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F20_ADD", new FPFunction { + RedundantName = "ADD", + Description = "The 16-bit equivalent constant or 16-bit area specified by s and the 16-bit area specified by d are added together if the trigger EN is in the ON-state. The result is stored in d. All 16-bit values are treated as integer values.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F21_DADD", new FPFunction { + RedundantName = "ADD", + Description = "The 32-bit equivalent constant or 32-bit area specified by s and the 32-bit data specified by d are added together if the trigger EN is in the ON-state. The result is stored in d. All 32-bit values are treated as double integer values.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F22_ADD2", new FPFunction { + RedundantName = "ADD", + Description = "The 16-bit data or 16-bit equivalent constant specified by s1 and s2 are added together if the trigger EN is in the ON-state. The result is stored in d. All 16-bit values are treated as integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F23_DADD2", new FPFunction { + RedundantName = "ADD", + Description = "The 32-bit data or 32-bit equivalent constant specified by s1 and s2 are added together if the trigger EN is in the ON-state. The added result is stored in d. All 32-bit values are treated as double integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F25_SUB", new FPFunction { + RedundantName = "SUB", + Description = "Subtracts the 16-bit equivalent constant or 16-bit area specified by s from the 16-bit area specified by d if the trigger EN is in the ON-state. The result is stored in d (minuend area). All 16-bit values are treated as integer values.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F26_DSUB", new FPFunction { + RedundantName = "SUB", + Description = "Subtracts the 32-bit equivalent constant or 32-bit data specified by s from the 32-bit data specified by d if the trigger EN is in the ON-state. The result is stored in d (minuend area). All 32-bit values are treated as double integer values.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F27_SUB2", new FPFunction { + RedundantName = "SUB", + Description = "Subtracts the 16-bit data or 16-bit equivalent constant specified by s2 from the 16-bit data or 16-bit equivalent constant specified by s1 if the trigger EN is in the ON-state. The result is stored in d. All 16-bit values are treated as integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F28_DSUB2", new FPFunction { + RedundantName = "SUB", + Description = "Subtracts the 32-bit data or 32-bit equivalent constant specified by s2 from the 32-bit data or 32-bit equivalent constant specified by s1 if the trigger EN is in the ON-state. The result is stored in d. All 32-bit values are treated as double integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F30_MUL", new FPFunction { + RedundantName = "MUL", + Description = "Multiplies the 16-bit data or 16-bit equivalent constant specified by s1 and the 16-bit data or 16-bit equivalent constant specified by s2 if the trigger EN is in the ON-state. The result is stored in d (32-bit area). All 16-bit values are treated as integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F31_DMUL", new FPFunction { + RedundantName = "MUL", + Description = "Multiplies the 32-bit data or 32-bit equivalent constant specified by s1 and the one specified by s2 if the trigger EN is in the ON-state. The result is stored in d[0], d[1] (64-bit area). All 32-bit values are treated as double integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY[0..1] OF DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F32_DIV", new FPFunction { + RedundantName = "DIV", + Description = "The 16-bit data or 16-bit equivalent constant specified by s1 is divided by the 16-bit data or 16-bit equivalent constant specified by s3 if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F33_DDIV", new FPFunction { + RedundantName = "DIV", + Description = "The 32-bit data or 32-bit equivalent constant specified by s1 is divided by the 32-bit data or 32-bit equivalent constant specified by s2 if the trigger EN is in the ON-state. The quotient is stored in d and the remainder is stored in the system variable sys_diDDivRemainder. All 32-bit values are treated as double integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F34_MULW", new FPFunction { + RedundantName = "MUL", + Description = "The function multiplies the value specified at input s1 by the value specified at input s2. The result of the function is returned at output d. The result at output d lies between -32768 and 32767 (i.e. between 16#0 and 16#FFFF). All 16-bit values are treated as integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F35_INC", new FPFunction { + RedundantName = "FP_INC", + Description = "Adds \"1\" to the 16-bit data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F36_DINC", new FPFunction { + RedundantName = "FP_INC", + Description = "Adds \"1\" to the 32-bit data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F37_DEC", new FPFunction { + RedundantName = "FP_DEC", + Description = "Subtracts \"1\" from the 16-bit data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "INT,WORD", + }}, + }, + }}, + { "F38_DDEC", new FPFunction { + RedundantName = "FP_DEC", + Description = "Subtracts \"1\" to the 32-bit data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F39_DMULD", new FPFunction { + RedundantName = "MUL", + Description = "The function multiplies the value specified at input s1 by the value specified at input s2. The result of the function is returned at output d. The result at output d lies between -2147483648 and 2147483647 (i.e. between 16#0 and 16#FFFFFFFF). All 32-bit values are treated as double integer values.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F40_BADD", new FPFunction { + Description = "The 4-digit BCD equivalent constant or 16-bit area for 4-digit BCD data specified by s and the 16-bit area for 4-digit BCD data specified by d are added together if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F41_DBADD", new FPFunction { + Description = "The 8-digit BCD equivalent constant or 8-digit BCD data specified by s and the 8-digit BCD data specified by d are added together if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F42_BADD2", new FPFunction { + RedundantName = "FP_ADD_BCD", + Description = "The 4-digit BCD equivalent constants or 16-bit areas for 4-digit BCD data specified by s1 and s2 are added together if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + }}, + { "s2", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F43_DBADD2", new FPFunction { + RedundantName = "FP_ADD_BCD", + Description = "The 8-digit BCD equivalent constants or 32-bit areas for 8-digit BCD data specified by s1 and s2 are added together if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + }}, + { "s2", new string[] { + "DWORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F45_BSUB", new FPFunction { + Description = "Subtracts the 4-digit BCD equivalent constant or 16-bit area for 4-digit BCD data specified by s from the 16-bit area for 4-digit BCD data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F46_DBSUB", new FPFunction { + Description = "Subtracts the 8-digit BCD equivalent constant or 8-digit BCD data specified by s from the 8-digit BCD data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F47_BSUB2", new FPFunction { + RedundantName = "FP_SUB_BCD", + Description = "Subtracts the 4-digit BCD equivalent constant or 16-bit area for 4-digit BCD data specified by s2 from the 4-digit BCD equivalent constant or 16-bit area for 4-digit BCD data specified by s1 if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + }}, + { "s2", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F48_DBSUB2", new FPFunction { + RedundantName = "FP_SUB_BCD", + Description = "Subtracts the 8-digit BCD equivalent constant or 8-digit BCD data specified by s2 from the 8-digit BCD equivalent constant or 8-digit BCD data specified by s1 if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + }}, + { "s2", new string[] { + "DWORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F50_BMUL", new FPFunction { + RedundantName = "FP_MUL_BCD", + Description = "Multiplies the 4-digit BCD equivalent constant or 16-bit area for 4-digit BCD data specified by s1 and s2 if the trigger EN is in the ON-state. The result is stored in d (8-digit area).", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + }}, + { "s2", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F51_DBMUL", new FPFunction { + RedundantName = "FP_MUL_BCD", + Description = "Multiplies the 32-bit BCD (8-digit) equivalent constant or 8-digit BCD data specified by s1 and the one specified by s2 if the trigger EN is in the ON-state. The result is stored in the ARRAY d[0], d[1] (64-bit area).", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..1] OF DWORD", + }}, + }, + }}, + { "F52_BDIV", new FPFunction { + Description = "The 4-digit BCD equivalent constant or the 16-bit area for 4-digit BCD data specified by s1 is divided by the 4-digit BCD equivalent constant or the 16-bit area for 4-digit BCD data specified by s2 if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + }}, + { "s2", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F53_DBDIV", new FPFunction { + Description = "The result is stored in the area specified by d, and the remainder is stored in the system variable sys_diDDivRemainder.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + }}, + { "s2", new string[] { + "DWORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F55_BINC", new FPFunction { + RedundantName = "FP_INC_BCD", + Description = "Adds \"1\" to the 4-digit BCD data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F56_DBINC", new FPFunction { + RedundantName = "FP_INC_BCD", + Description = "Adds \"1\" to the 8-digit BCD data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F57_BDEC", new FPFunction { + RedundantName = "FP_DEC_BCD", + Description = "Subtracts \"1\" from the 4-digit BCD data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F58_DBDEC", new FPFunction { + RedundantName = "FP_DEC_BCD", + Description = "Subtracts \"1\" from the 8-digit BCD data specified by d if the trigger EN is in the ON-state. The result is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F60_CMP", new FPFunction { + RedundantName = "EQ", + Description = "Compares the 16-bit data specified by s1 with one specified by s2 if the trigger EN is in the ON-state. The compare operation result is stored in the system variables sys_bIsGreaterThan (> flag), sys_bIsEqual (= flag), sys_bIsLessThan (< flag) and sys_bIsCarry (carry-flag).", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F61_DCMP", new FPFunction { + RedundantName = "EQ", + Description = "Compares the 32-bit data or 32-bit equivalent constant specified by s1 with one specified by s2 if the trigger EN is in the ON-state. The compare operation result is stored in the system variables sys_bIsGreaterThan (> flag), sys_bIsEqual (= flag), sys_bIsLessThan (< flag) and sys_bIsCarry (carry-flag).", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F62_WIN", new FPFunction { + RedundantName = "WITHIN_LIMITS", + Description = "Compares the 16-bit equivalent constant or 16-bit data specified by s1_In with the data band specified by s2_Min and s3_Max if the trigger EN is in the ON-state. This instruction checks that s1_In is in the data band between s2_Min (lower limit) and s3_Max (higher limit), larger than s3_Max, or smaller than s2_Min. The compare operation considers +/- sign. Since the BCD data is also treated as 16-bit data with sign, we recommend using BCD data within the range of 0 to 7999 to avoid confusion. The compare operation result is stored in the system variables sys_bIsGreaterThan (> flag), sys_bIsEqual (= flag), sys_bIsLessThan (< flag) and sys_bIsCarry (carry-flag).", + ParametersIn = new Dictionary { + { "s1_In", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Min", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_Max", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F63_DWIN", new FPFunction { + RedundantName = "WITHIN_LIMITS", + Description = "Compares the 32-bit equivalent constant or 32-bit data specified by s1_In with the data band specified by s2_Min and s3_Max if the trigger EN is in the ON-state. This instruction checks that s1_In is in the data band between s2_Min (lower limit) and s3_Max (higher limit), larger than s3_Max, or smaller than s2_Min. The compare operation considers +/- sign. Since the BCD data is also treated as 32-bit data with sign, we recommend using BCD data within the range of 0 to 79999999 to avoid confusion. The compare operation result is stored in the system variables sys_bIsGreaterThan (> flag), sys_bIsEqual (= flag), sys_bIsLessThan (< flag) and sys_bIsCarry (carry-flag).", + ParametersIn = new Dictionary { + { "s1_In", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_Min", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s3_Max", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F64_BCMP", new FPFunction { + Description = "Compares the contents of data block specified by s2_Start with the contents of data block specified by s3_Start according to the contents specified by s1_Control if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "WORD", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F65_WAN", new FPFunction { + RedundantName = "AND", + Description = "Executes AND operation of each bit in 16-bit equivalent constant or 16-bit data specified by s1 and s2 if the trigger EN is in the ON-state. The AND operation result is stored in the 16-bit area specified by d. When 16-bit equivalent constant is specified by s1 or s2, the AND operation is performed internally converting it to 16-bit binary expression. You can use this instruction to turn OFF certain bits of the 16-bit data.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "s2", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F66_WOR", new FPFunction { + RedundantName = "OR", + Description = "Executes OR operation of each bit in 16-bit equivalent constant or 16-bit data specified by s1 and s2 if the trigger EN is in the ON-state. The OR operation result is stored in the 16-bit area specified by d. When 16-bit equivalent constant is specified by s1 or s2, the OR operation is performed internally converting it to 16-bit binary expression. You can use this instruction to turn ON certain bits of the 16-bit data.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "s2", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F67_XOR", new FPFunction { + RedundantName = "XOR", + Description = "Executes exclusive OR operation of each bit in 16-bit equivalent constant or 16-bit data specified by s1 and s2 if the trigger EN is in the ON-state. The exclusive OR operation result is stored in the 16-bit area specified by d. When 16-bit equivalent constant is specified by s1 or s2, the exclusive OR operation is performed internally converting it to 16-bit binary expression. You can use this instruction to review the number of identical bits in the two 16-bit data.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "s2", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F68_XNR", new FPFunction { + RedundantName = "XOR", + Description = "Executes exclusive NOR operation of each bit in 16-bit equivalent constant or 16-bit data specified by s1 and s2 if the trigger EN is in the ON-state. The exclusive NOR operation result is stored in the 16-bit area specified by d. When 16-bit equivalent constant is specified by s1 or s2, the exclusive NOR operation is performed internally converting it to 16-bit binary expression. You can use this instruction to review the number of identical bits in the two 16-bit data.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "s2", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F69_WUNI", new FPFunction { + RedundantName = "FP_COMBINE", + Description = "The function combines the two values at inputs s1 and s2 with the value at input s3_Mask by bit-unit processing. The result of the function is returned at output d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "s2", + }}, + { "s3_Mask", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F70_BCC", new FPFunction { + Description = "Calculates the Block Check Character (BCC), which is used to detect errors in message transmission, of s3_Number bytes of ASCII data starting from the 16-bit area specified by s2_Start according to the calculation method specified by s1_Control. The Block Check Code (BCC) is stored in the lower byte of the 16-bit area specified by d. (BCC is one byte. The higher byte of d does not change.)", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "INT", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_Number", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F71_HEX2A", new FPFunction { + RedundantName = "FP_HEX_TO_ASCII", + Description = "Converts the data byte-wise from the 16-bit area specified by s1_Start to ASCII codes that express the equivalent hexadecimals if the trigger EN is in the TRUE-state. The number of bytes to be converted is specified by s3_Number. The converted result is stored in the area starting with the 16-bit area specified by d_Start. ASCII code requires 8 bits (one byte) to express one hexadecimal character. Upon conversion to ASCII, the data length will thus be twice the length of the source data.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_Number", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F72_A2HEX", new FPFunction { + RedundantName = "FP_ASCII_TO_HEX", + Description = "Converts the ASCII codes that express the hexadecimal characters starting from the 16-bit area specified by s1 to hexadecimal numbers if the trigger EN is in the ON-state. s2 specifies the number of ASCII (number of characters) to be converted. The converted result is stored in the area starting from the 16-bit area specified by d. ASCII code requires 8 bits (one byte) to express one hexadecimal character. Upon conversion to a hexadecimal number, the data length will thus be half the length of the ASCII code source data.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + }}, + { "s2_Number", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F73_BCD2A", new FPFunction { + RedundantName = "FP_BCD_TO_ASCII", + Description = "Converts the BCD code starting from the 16-bit area specified by s1 to the ASCII code that expresses the equivalent decimals according to the contents specified by s2 if the trigger EN is in the ON-state. s2 specifies the number of source data bytes and the direction of converted data (normal/reverse).", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + }}, + { "s2_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + }}, + }, + }}, + { "F74_A2BCD", new FPFunction { + RedundantName = "FP_ASCII_TO_BCD", + Description = "Converts the ASCII codes that express the decimal characters starting from the 16-bit area specified by s1 to BCD if the trigger EN is in the ON-state. s2 specifies the number of source data bytes and the direction of converted code source data.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + }}, + { "s2_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + }}, + }, + }}, + { "F75_BIN2A", new FPFunction { + RedundantName = "FP_DEC_TO_ASCII", + Description = "Converts the 16-bit data specified by s1 to ASCII codes that express the equivalent decimal value. The converted result is stored in the area starting from the 16-bit area specified by d as specified by s2. Specify the number of bytes in decimal number in s2. (This specification cannot be made with BCD data.)", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Number", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + }}, + }, + }}, + { "F76_A2BIN", new FPFunction { + RedundantName = "FP_ASCII_TO_DEC", + Description = "Converts the ASCII codes that express the decimal digits, starting from the 16-bit area specified by s1 to 16-bit data as specified by s2. The converted result is stored in the area specified by d. s2 specifies the number of source data bytes to be converted using decimal number. (This specification cannot be made with BCD data.)", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + }}, + { "s2_Number", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F77_DBIN2A", new FPFunction { + RedundantName = "FP_DEC_TO_ASCII", + Description = "Converts the 32-bit data specified by s1 to ASCII code that expresses the equivalent decimals. The converted result is stored in the area starting from the 16-bit area specified by d_Start as specified by s2_Number. s2_Number specifies the number of bytes used to express the destination data using decimal.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_Number", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + }}, + }, + }}, + { "F78_DA2BIN", new FPFunction { + RedundantName = "FP_ASCII_TO_DEC", + Description = "Converts ASCII code that expresses the decimal digits, starting from the 16-bit area specified by s1_Start to 32-bit data as specified by s2_Number. The converted result is stored in the area starting from the 32-bit area specified by d. s2_Number specifies the number of bytes used to express the destination data using decimals.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Number", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F80_BCD", new FPFunction { + RedundantName = "INT_TO_BCD_WORD", + Description = "Converts the 16-bit binary data specified by s to the BCD code that expresses 4-digit decimals if the trigger EN is in the ON-state. The converted data is stored in d. The binary data that can be converted to BCD code are in the range of 0 (0 hex) to 9999 (270F hex).", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F81_BIN", new FPFunction { + RedundantName = "WORD_BCD_TO_INT", + Description = "Converts the BCD code that expresses 4-digit decimals specified by s to 16-bit binary data if the trigger EN is in the ON-state. The converted result is stored in the area specified by d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F82_DBCD", new FPFunction { + RedundantName = "DINT_TO_BCD_DWORD", + Description = "Converts the 32-bit binary data specified by s to the BCD code that expresses 8-digit decimals if the trigger EN is in the ON-state. The converted data is stored in d. The binary data that can be converted to BCD code are in the range of 0 (0 hex) to 99,999,999 (5F5E0FF hex).", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + }}, + }, + }}, + { "F83_DBIN", new FPFunction { + RedundantName = "DWORD_BCD_TO_DINT", + Description = "Converts the BCD code that expresses 8-digit decimals specified by s to 32-bit binary data if the trigger EN is in the ON-state. The converted result is stored in the area specified by d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F84_INV", new FPFunction { + RedundantName = "FP_INVERT", + Description = "Inverts each bit (0 or 1) of the 16-bit data specified by d if the trigger EN is in the ON-state. The inverted result is stored in the 16-bit area specified by d. This instruction is useful for controlling an external device that uses negative logic operation.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F85_NEG", new FPFunction { + RedundantName = "NOT", + Description = "Takes two's complement of 16-bit data specified by d if the trigger EN is in the ON-state. Two's complement of the original 16-bit data is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F86_DNEG", new FPFunction { + RedundantName = "NOT", + Description = "Takes two's complement of 32-bit data specified by d if the trigger EN is in the ON-state. Two's complement of the original 32-bit data is stored in d.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F87_ABS", new FPFunction { + RedundantName = "ABS", + Description = "Gets the absolute value of 16-bit data with the sign specified by d if the trigger EN is in the ON-state. The absolute value of the 16-bit data with +/- sign is stored in d. This instruction is useful for handling data whose sign (+/-) may vary.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F88_DABS", new FPFunction { + RedundantName = "ABS", + Description = "Gets the absolute value of 32-bit data with the sign specified by d if the trigger EN is in the ON-state. The absolute value of the 32-bit data with sign is stored in d. This instruction is useful for handling data whose sign (+/-) may vary.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F89_EXT", new FPFunction { + RedundantName = "INT_TO_DINT", + Description = "16-bit data is converted to 32-bit data without signs and values being changed. F89 copies the sign bit of the 16-bit data specified in s to all the bits of the higher 16-bit area (extended 16-bit area) in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F90_DECO", new FPFunction { + RedundantName = "FP_DECODE", + Description = "Decodes the contents of 16-bit data specified by s according to the contents of n if the trigger EN is in the ON-state. The decoded result is stored in the area starting with the 16-bit area specified by d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F91_SEGT", new FPFunction { + RedundantName = "FP_7SEGMENT", + Description = "Converts the 16-bit equivalent constant or 16-bit data specified by s to 4-digit data for 7-segment indication if the trigger EN is in the ON-state. The converted data is stored in the area starting with the 16-bit area specified by d. The data for 7-segment indication occupies 8 bits (1 byte) to express 1 digit.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F92_ENCO", new FPFunction { + RedundantName = "FP_ENCODE", + Description = "Encodes the contents of data specified by s according to the contents of n if the trigger EN is in the ON-state. The encoded result is stored in the 16-bit area specified by d starting with the specified bit position. Invalid bits in the area specified for the encoded result are set to 0.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F93_UNIT", new FPFunction { + RedundantName = "FP_UNIFY_DIGITS", + Description = "Extracts each lower 4 bits (bit position 0 to 3) starting with the 16-bit area specified by s and combines the extracted data into 1 word if the trigger EN is in the ON-state. The result is stored in the 16-bit area specified by d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F94_DIST", new FPFunction { + RedundantName = "FP_DIVIDE_DIGITS", + Description = "Divides the 16-bit data specified by s into 4-bit units and distributes the divided data into the lower 4 bits (bit position 0 to 3) of 16-bit areas starting with d if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F95_ASC", new FPFunction { + RedundantName = "EQ", + Description = "Converts the character constants specified by s to hexadecimal ASCII code. The hexadecimal code is stored in 6 words starting from the 16-bit area specified by d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "constant", + "no variables possible", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F96_SRC", new FPFunction { + Description = "Searches for the value that is the same as s1 in the block of 16-bit areas specified by s2_Start (starting area) through s3_End (ending area) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F97_DSRC", new FPFunction { + Description = "The function searches for the value specified at input s1 in a block of 32-bit areas whose beginning is specified at input s2_Start and whose end is specified at input s3_End.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_Start", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s3_End", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F98_CMPR", new FPFunction { + RedundantName = "FP_DATA_READ_COMPRESS", + Description = "Shifts out non-zero data stored at the highest address of the table to the specified area and compresses the data in the table to the higher address.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d3", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F99_CMPW", new FPFunction { + RedundantName = "FP_DATA_WRITE_COMPRESS", + Description = "Shifts in data to the smallest address of the specified data table and compresses the data in the table toward the higher address.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F100_SHR", new FPFunction { + RedundantName = "SHR", + Description = "Shifts n bits of 16-bit data area specified by d to the right (to the lower bit position) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F101_SHL", new FPFunction { + RedundantName = "SHL", + Description = "Shifts n bits of 16-bit data area specified by d to the left (to the higher bit position) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F102_DSHR", new FPFunction { + RedundantName = "SHR", + Description = "The function shifts the value at output d to the right. The number of bits at output d to be shifted to the right is specified by the value assigned at input n. This shift can lie between 0 and 255 (only the lower value byte of n is effective). Bits cleared because of the shift become 0. When input n = 0, no shift takes place. A shifting distance larger than 32 does not make sense, since when n = 32 the value at output d is already filled with zeros. The bit at position n - 1 (the last bit shifted out to the right) is simultaneously stored in the system variable sys_bIsCarry (carry flag) so that it can be evaluated accordingly. When n = 0 the content of the carry flag does not change.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F103_DSHL", new FPFunction { + RedundantName = "SHL", + Description = "The function shifts the value at output d to the left. The number of bits at output d to be shifted to the left is specified by the value assigned at input n. This shift can lie between 0 and 255 (only the lower value byte of n is effective). Bits cleared because of the shift become 0. When input n = 0, no shift takes place. A shifting distance larger than 32 does not make sense, since when n = 32 the value at output d is already filled with zeros. The bit at position 31 - n (the last bit shifted out to the left) is simultaneously stored in the system variable sys_bIsCarry (carry flag) so that it can be evaluated accordingly. When n = 0 the content of the carry flag does not change.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F105_BSR", new FPFunction { + RedundantName = "SHR", + Description = "Shifts one hexadecimal digit (4 bits) of the 16-bit area specified by d to the right (to the lower digit position) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F106_BSL", new FPFunction { + RedundantName = "SHR", + Description = "Shifts one hexadecimal digit (4 bits) of the 16-bit area specified by d to the left (to the higher digit position) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F108_BITR", new FPFunction { + Description = "The function shifts the bits of a specified data range, whose beginning and end are specified by the outputs d1 and d2 to the right. The number of bits by which the data range is to be shifted to the right is specified by the value assigned at input n. The value may lie between 0 and 16. Bits cleared because of the shift become 0. When input n = 0, no shift takes place. When input n = 16, a shift of one WORD occurs, i.e. the same process takes place as with function F110_WHSL.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F109_BITL", new FPFunction { + Description = "The function shifts the bits of a specified data range, whose beginning and end are specified by the outputs d1 and d2 to the left. The number of bits by which the data range is to be shifted to the left is specified by the value assigned at input n. The value may lie between 0 and 16. Bits cleared because of the shift become 0. When input n = 0, no shift takes place. When input n= 16, a shift of one word occurs, i.e. the same process takes place as with function F111_WSHL.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F110_WSHR", new FPFunction { + Description = "Shifts one word (16 bits) of the data range specified by d1 (starting) and d2 (ending) to the right (to the lower word address) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F111_WSHL", new FPFunction { + Description = "Shifts one word (16 bits) of the data range specified by d1 (starting) and d2 (ending) to the left (to the higher word address) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F112_WBSR", new FPFunction { + Description = "Shifts one hexadecimal digit (4 bits) of the data range specified by d1 (starting) and d2 (ending) to the right (to the lower digit position) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F113_WBSL", new FPFunction { + Description = "Shifts one hexadecimal digit (4 bits) of the data range specified by d1 (starting) and d2 (ending) to the left (to the higher digit position) if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F115_FIFT", new FPFunction { + Description = "F115 specifies the starting area d1_Start for the FIFO (First-In-First-Out) buffer and the memory size n_Number of the FIFO buffer.", + ParametersIn = new Dictionary { + { "n_Number", new string[] { + "INT", + }}, + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F116_FIFR", new FPFunction { + Description = "F116_FIFR reads the data d1 from the FIFO (First-In-First-Out) buffer and stores the data in area specified by d2.", + ParametersIn = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d2", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F117_FIFW", new FPFunction { + Description = "F/P117 writes the data specified by s into the FIFO buffer specified by d1.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F118_UDC", new FPFunction { + Description = "DOWN counting if the trigger UpDirection is in the OFF state. UP counting if the trigger UpDirection is in the ON state.", + ParametersIn = new Dictionary { + { "UpDirection", new string[] { + "BOOL", + }}, + { "CountTrigger", new string[] { + "BOOL", + }}, + { "Reset_Preset", new string[] { + "BOOL", + }}, + { "s_PresetValue", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F119_LRSR", new FPFunction { + Description = "Shifts 1 bit of the 16-bit data range to the left or to the right.", + ParametersIn = new Dictionary { + { "LeftDirection", new string[] { + "BOOL", + }}, + { "DataInput", new string[] { + "BOOL", + }}, + { "ShiftTrigger", new string[] { + "BOOL", + }}, + { "Reset", new string[] { + "BOOL", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "Carry", new string[] { + "BOOL", + }}, + }, + }}, + { "F120_ROR", new FPFunction { + RedundantName = "ROR", + Description = "Rotates n bits of the 16-bit data specified by d to the right if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F121_ROL", new FPFunction { + RedundantName = "ROL", + Description = "Rotates n bits of the 16-bit data specified by d to the left if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F122_RCR", new FPFunction { + RedundantName = "FP_ROR_CARRY", + Description = "Rotates n bits of the 16-bit data specified by d including the data of carry-flag to the right if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F123_RCL", new FPFunction { + RedundantName = "FP_ROL_CARRY", + Description = "Rotates n bits of the 16-bit data specified by d including the data of carry-flag to the left if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F125_DROR", new FPFunction { + RedundantName = "ROR", + Description = "The function rotates the value at output d to the right. The number of bits at output d to be rotated to the right is specified by the value assigned at input n. This shift can lie between 0 and 255 (only the lower value byte of n is effective). Right rotate means that the bits shifted out of bit position 0 (LSB) are shifted via bit position 31 (MSB) into the value at output d. When input n = 0, no rotation takes place. When at input n > 32, the same result is achieved as with a number n < 32: e.g. n = 32 produces the same result as when n = 0; n = 33 the same as n = 1. The bit at position n - 1 (the last bit shifted out to the right) is simultaneously stored in the system variable sys_bIsCarry (carry flag) so that it can be evaluated accordingly.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F126_DROL", new FPFunction { + RedundantName = "ROL", + Description = "The function rotates the value at output d to the left. The number of bits at output d to be rotated to the left is specified by the value assigned at input n. This shift can lie between 0 and 255 (only the lower value byte of n is effective).Left rotate means that the bits shifted out of bit position 31 (MSB) are shifted via bit position 0 (LSB) into the value at output d.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F127_DRCR", new FPFunction { + RedundantName = "FP_ROR_CARRY", + Description = "The function rotates the value at output d via the carry flag to the right. The number of bits at output d to be rotated to the right is specified by the value assigned at input n. This shift can lie between 0 and 255 (only the lower value byte of n is effective).", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F128_DRCL", new FPFunction { + RedundantName = "FP_ROL_CARRY", + Description = "The function rotates the value at output d via the carry flag to the left. The number of bits at output d to be rotated to the left is specified by the value assigned at input n. This shift can lie between 0 and 255 (only the lower value byte of n is effective).", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F130_BTS", new FPFunction { + Description = "Turns ON the bit specified by the bit position at n of the 16-bit data specified by d if the trigger EN is in the ON-state. Bits other than the bit specified do not change. The range of n is 0 to 15.", + ParametersIn = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + }}, + { "F131_BTR", new FPFunction { + Description = "Turns OFF the bit specified by the bit position at n of the 16-bit data specified by d if the trigger EN is in the ON-state. Bits other than the bit specified do not change. The range of n is 0 to 15.", + ParametersIn = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F132_BTI", new FPFunction { + RedundantName = "FP_INVERT_BIT", + Description = "Inverts [1 (ON) ® 0 (OFF) or 0 (OFF) ® 1 (ON)] the bit at bit position n in the 16-bit data area specified by d if the trigger EN is in the ON-state. Bits other than the bit specified do not change. The range of n is 0 to 15.", + ParametersIn = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "n", new string[] { + "INT", + }}, + }, + }}, + { "F133_BTT", new FPFunction { + RedundantName = "FP_TEST_BIT", + Description = "Checks the state [1 (ON) or 0 (OFF)] of bit position n in the 16-bit data specified by d if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F135_BCU", new FPFunction { + RedundantName = "FP_COUNT_TRUE_BITS", + Description = "Counts the number of bits in the ON state (1) in the 16-bit data specified by s if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "INT", + }}, + }, + }}, + { "F136_DBCU", new FPFunction { + RedundantName = "FP_COUNT_TRUE_BITS", + Description = "Counts the number of bits in the ON state (1) in the 32-bit data specified by s if the trigger EN is in the ON-state.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "INT", + }}, + }, + }}, + { "F137_STMR", new FPFunction { + Description = "The auxiliary timer instruction F137_STMR is a down type timer. The formula of the timer-set time is 0.01 sec. * set value s (time can be set from 0.01 to 327.67 sec.). If you use the special internal flag R900D as the timer contact, be sure to program it at the address immediately after the instruction.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F140_STC", new FPFunction { + Description = "The system variable sys_bIsCarry (carry-flag) goes ON if the trigger EN is in the ON-state. This instruction can be used to control data using carry-flag R9009 (e.g. F122_RCR Redundant instruction and F123_RCL Redundant instruction instructions).", + }}, + { "F141_CLC", new FPFunction { + Description = "Special internal relay R9009 (carry-flag) goes OFF if the trigger EN is in the ON-state. This instruction can be used to control data using carry-flag R9009 (e.g. F122_RCR Redundant instruction and F123_RCL instructions).", + }}, + { "F142_WDT", new FPFunction { + Description = "The scan ‘check watchdog timer’ is preset with the constant specified by s if the trigger EN is in the ON-state. The value specified by s* is 1 to 255 and the preset time becomes 2.5 ms * s* (637.5 ms).", + ParametersIn = new Dictionary { + { "s*", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F143_IORF", new FPFunction { + Description = "Updates the inputs or outputs specified by the value of d1_Start (starting word address) and the value of d2_End (ending word address) immediately after the trigger EN is in the ON-state even in the program execution stage.", + ParametersIn = new Dictionary { + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F145_SEND", new FPFunction { + Description = "Sends data to another station through link modules in the network.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "DWORD", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_AdrType", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_AdrOffs", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F145_WRITE_DATA", new FPFunction { + Description = "Use this instruction to write data from a master to a slave via the communication port using the MEWTOCOL-COM or Modbus RTU protocol, as defined in the system registers of the port used. Make sure the same protocol is set for master and slave. Master and slave must have matching memory areas. If the slave data is not available in the user area of the master, use F145_WRITE_DATA_TYPE_OFFS or F145F146_MODBUS_MASTER. For data transmissions using the Modbus protocol, the compiler generates Modbus commands based on the Modbus reference numbers.", + ParametersIn = new Dictionary { + { "Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveAddress", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "MasterData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + }, + ParametersOut = new Dictionary { + { "SlaveData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + }, + }}, + { "F145_WRITE_DATA_TYPE_OFFS", new FPFunction { + Description = "Use this instruction to write data from a master to a slave via the communication port using the MEWTOCOL-COM or Modbus RTU protocol, as defined in the system registers of the port used. For data transmissions using the Modbus protocol, the compiler generates Modbus commands based on the Modbus reference numbers.", + ParametersIn = new Dictionary { + { "Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveAddress", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "MasterWordData", new string[] { + "ANY", + }}, + { "SlaveWordAddressType", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveWordAddressOffs", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "NumberOfWords_BitsInWords", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F146_READ_DATA", new FPFunction { + Description = "Use this instruction to request data from a slave via the communication port using the MEWTOCOL-COM or Modbus RTU protocol, as defined in the system registers of the port used. Make sure the same protocol is set for master and slave. Master and slave must have matching memory areas. If the slave data is not available in the user area of the master, use F146_READ_DATA_TYPE_OFFS or F145F146_MODBUS_MASTER. For data transmissions using the Modbus protocol, the compiler generates Modbus commands based on the Modbus reference numbers.", + ParametersIn = new Dictionary { + { "Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveAddress", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + }, + ParametersOut = new Dictionary { + { "MasterData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + }, + }}, + { "F146_READ_DATA_TYPE_OFFS", new FPFunction { + Description = "Use this instruction to request data from a slave via the communication port using the MEWTOCOL-COM or Modbus RTU protocol, as defined in the system registers of the port used. For data transmissions using the Modbus protocol, the compiler generates Modbus commands based on the Modbus reference numbers.", + ParametersIn = new Dictionary { + { "Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveAddress", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveWordAddressType", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "SlaveWordAddressOffs", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "NumberOfWords_BitsInWords", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "MasterWordData", new string[] { + "ANY", + }}, + }, + }}, + { "F146_RECV", new FPFunction { + Description = "Receives data from another station through link units in the network.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "DWORD", + }}, + { "s2_AdrType", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_AdrOffs", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F147_PR", new FPFunction { + Description = "Outputs the ASCII codes for 12 characters stored in the 6-word area specified by s_Start via the word output specified by d if the trigger EN is TRUE. If a printer is connected to the output specified by d, a character corresponding to the output ASCII code is printed.", + ParametersIn = new Dictionary { + { "s_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F148_ERR", new FPFunction { + RedundantName = "FP_SET_ERROR", + Description = "The error no. specified by n* is copied into the system variable sys_iSelfDiagnosticErrorCode that reads the corresponding special data register. Setting n*=0, all error numbers greater than 43 are cleared and the error LED turns off.", + ParametersIn = new Dictionary { + { "n*", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F149_MSG", new FPFunction { + Description = "This instruction is used for displaying the message on the FP Programmer II screen. After executing the F149_MSG instruction, you can see the message specified by s_Start on the FP Programmer II screen.", + ParametersIn = new Dictionary { + { "s_Start", new string[] { + "STRING[12]", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F150_READ", new FPFunction { + Description = "Reads data from the shared memory in an intelligent module.", + ParametersIn = new Dictionary { + { "s1_BankSlot", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "INT", + }}, + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F151_WRT", new FPFunction { + Description = "Writes data into the shared memory of an intelligent unit.", + ParametersIn = new Dictionary { + { "s1_BankSlot", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "INT", + }}, + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F152_RMRD", new FPFunction { + Description = "Reads data from the specified intelligent unit of the MEWNET-F Slave station.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "DWORD", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "INT", + }}, + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F153_RMWT", new FPFunction { + Description = "Writes data into the specified intelligent unit of the MEWNET-F slave station.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "DWORD", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "INT", + }}, + { "d_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F155_SMPL", new FPFunction { + Description = "This instruction transfers the sampling data specified by the sampling trace editor into the sampling memory. F155_SMPL can only be used with the sampling mode \"per Scan\".", + }}, + { "F156_STRG", new FPFunction { + Description = "This instruction sets the sampling trigger that stops the sampling after the delay specified by the sampling trace parameters. F156_STRG can be used with both sampling modes \"per Scan\" and \"per Time Interval\".", + }}, + { "F159_MTRN", new FPFunction { + Description = "This instructions sends data using a send buffer to external devices (computer, measuring instrument, bar code reader, etc.) connected to the specified communication port. If applied to the CPU's COM port, it also clears the receive buffer, resets the \"reception done\" flag and allows further reception of data.", + ParametersIn = new Dictionary { + { "s_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F159_MTRN0", new FPFunction { + RedundantName = "SendData", + Description = "The receive buffer is automatically reset when a send instruction is executed. To reset the receive buffer without sending further data, execute this instruction. Alternatively, you can use ClearReceiveBuffer. Resetting the receive buffer sets the number of bytes received in offset 0 to 0 and moves the write pointer back to offset 1. The next data will be stored starting at offset 1 and overwriting the existing data. NOTE When data is received from a Multi-Communication Unit using F161_MRCV, the reception area is cleared and the \"reception done\" flag is reset. Hence the communication port can again receive data. To reset the receive buffer without using F161_MRCV, ClearReceiveBuffer must be used. F159_MTRN with n_Number=0 will cause an operation error.", + ParametersIn = new Dictionary { + { "s_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F159_MWRT_PARA", new FPFunction { + Description = "Communication parameters in the predefined DUT MCU_PARA_DUT are written to the specified port of a Multi-Communication Unit.", + ParametersIn = new Dictionary { + { "s_Para", new string[] { + "MCU_PARA_DUT", + }}, + { "d_Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F160_DSQR", new FPFunction { + RedundantName = "SQRT", + Description = "The square root of the 32-bit data or constant value specified by s is calculated if the trigger EN is in the ON-state. The result (square root) is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F161_MRCV", new FPFunction { + Description = "Use this instruction to copy the data which the Multi-Communication Unit received from the external device to the CPU's receive buffer. The MCU's communication port is specified at s_Port. The receive buffer is defined by d1_Start and d2_End.", + ParametersIn = new Dictionary { + { "s_Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F161_MRCV0", new FPFunction { + Description = "Use this instruction to copy the data which the Multi-Communication Unit received from the external device to the CPU's receive buffer. The MCU's communication port is specified at s_Port. The receive buffer is defined by d1_Start and d2_End.", + ParametersIn = new Dictionary { + { "s_Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F161_MRD_PARA", new FPFunction { + Description = "Communication parameters in the predefined DUT MCU_PARA_DUT are received from a port of a Multi-Communication Unit in a certain slot.", + ParametersIn = new Dictionary { + { "s_Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Para", new string[] { + "MCU_PARA_DUT", + }}, + }, + }}, + { "F161_MRD_STATUS", new FPFunction { + Description = "Status data is read from the specified COM port of a Multi-Communication Unit.", + ParametersIn = new Dictionary { + { "s_Port", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F165_CAM0", new FPFunction { + Description = "Control FPWIN Pro provides different types of libraries in which system instructions are declared: “IEC standard library”: e.g. ADD, CONCAT, MOVE, see also advantages of IEC instructions “FP library”: FP instructions: e.g. FP_MOVE_BLOCK, FP_BAND, see also advantages of FP instructions F instructions: e.g. F0_MV, F159_MTRN, F171_PulseOutput_Home “FP pulsed library”: P instructions (for FP2/2SH, FP3/5, FP10/10SH) are only executed at the rising edge of the EN trigger. Select “Insert P instruction” from the “Instructions” pane if you require a P instruction. “FP tool library”: e.g. Adr_Of_Var I, Unit_AnalogInOut_FP0_A21, HscControl_CountingDisable, Pulse_TargetValueMatch_Reset Use the location filter from the “Instructions” pane to expedite programming. NOTE Please note that the information in this help system can only provide a general overview. For more detailed information, please refer to the manuals on the individual Panasonic PLCs. Related topics: Types of libraries Advantages of FP instructions Advantages of IEC instructions Instruction sorting and filter criteria", + }}, + { "F165_HighSpeedCounter_Cam", new FPFunction { + Description = "This instruction performs cam control as specified by the parameters in the specified DUT with a maximum of 32 ON/OFF points according to the elapsed value of the high-speed counter. For every single cam output, the target value is set as a pair with an ON and an OFF set value. An interrupt program can be executed whenever the elapsed value matches one of the target values.", + ParametersIn = new Dictionary { + { "iHscChannel*", new string[] { + "INT", + }}, + { "s_dutDataTable", new string[] { + "ANY_DUT", + }}, + }, + ParametersOut = new Dictionary { + { "dutBitOutputs", new string[] { + "ANY_DUT", + }}, + }, + }}, + { "F166_HighSpeedCounter_Set", new FPFunction { + Description = "If the elapsed value of the high-speed counter matches the target value, an interrupt process immediately turns the specified output to TRUE.", + ParametersIn = new Dictionary { + { "n_diHscChannel", new string[] { + "DINT", + }}, + { "s_diTargetValue", new string[] { + "DINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Y", new string[] { + "BOOL", + }}, + }, + }}, + { "F166_PulseOutput_Set", new FPFunction { + Description = "If the elapsed value matches the target value of the selected pulse output channel, the specified output immediately turns to TRUE.", + ParametersIn = new Dictionary { + { "n_diPulseOutputChannel", new string[] { + "DINT", + }}, + { "s_diTargetValue", new string[] { + "DINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Y", new string[] { + "BOOL", + }}, + }, + }}, + { "F167_HighSpeedCounter_Reset", new FPFunction { + Description = "If the elapsed value of the high-speed counter matches the target value, an interrupt process immediately turns the specified output to FALSE.", + ParametersIn = new Dictionary { + { "n_diHscChannel", new string[] { + "DINT", + }}, + { "s_diTargetValue", new string[] { + "DINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Y", new string[] { + "BOOL", + }}, + }, + }}, + { "F167_PulseOutput_Reset", new FPFunction { + Description = "If the elapsed value matches the target value of the pulse output channel, the specified output immediately turns to FALSE.", + ParametersIn = new Dictionary { + { "n_diPulseOutputChannel", new string[] { + "DINT", + }}, + { "s_diTargetValue", new string[] { + "DINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Y", new string[] { + "BOOL", + }}, + }, + }}, + { "F168_PulseOutput_Home", new FPFunction { + Description = "This instruction performs a home return according to the parameters in the specified DUT.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "s_dutDataTable", new string[] { + "F168_PulseOutput_Home_DUT", + }}, + { "n_iPulseOutputChannel", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F168_PulseOutput_Trapezoidal", new FPFunction { + Description = "This instruction automatically performs trapezoidal control according to the parameters in the specified DUT.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "s_dutDataTable", new string[] { + "F168_PulseOutput_Trapezoidal_DUT", + }}, + { "n_iPulseOutputChannel", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F169_PulseOutput_Jog", new FPFunction { + Description = "This instruction is used for JOG operation.The specified number of pulses is output after the position control trigger input has turned to TRUE. A deceleration is performed before the target value is reached and pulse output stops.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "s_dutDataTable", new string[] { + "F169_PulseOutput_Jog_DUT", + }}, + { "n_iPulseOutputChannel", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F170_PulseOutput_PWM", new FPFunction { + Description = "This instruction delivers a pulse width modulated output signal according to the specified DUT. Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "s_dutDataTable", new string[] { + "F170_PulseOutput_PWM_DUT", + }}, + { "n_iPulseOutputChannel", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F171_PulseOutput_Home", new FPFunction { + Description = "This instruction performs a home return according to the parameters in the specified DUT.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F171_PulseOutput_Jog_Positioning", new FPFunction { + Description = "The specified number of pulses is output after the position control trigger input has turned to TRUE. A deceleration is performed before the target value is reached and pulse output stops.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F171_PulseOutput_Trapezoidal", new FPFunction { + Description = "This instruction automatically performs trapezoidal control according to the parameters in the specified DUT.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F172_PulseOutput_Jog", new FPFunction { + Description = "This instruction is used for JOG operation.The specified number of pulses is output after the position control trigger input has turned to TRUE. A deceleration is performed before the target value is reached and pulse output stops.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F173_PulseOutput_PWM", new FPFunction { + Description = "This instruction delivers a pulse width modulated output signal according to the specified DUT. Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F173_PulseOutput_PWM_Hz", new FPFunction { + Description = "This instruction delivers a pulse width modulated output signal according to the specified DUT. Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F174_PulseOutput_DataTable", new FPFunction { + Description = "This instruction performs rectangular control according to the parameters in the specified DUT with an arbitrary number of different speeds and target values.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F175_PulseOutput_Linear", new FPFunction { + Description = "Pulses are output from two channels in accordance with the parameters in the specified DUT, so that the path to the target position forms a straight line.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel", new string[] { + "constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F176_PulseOutput_Center", new FPFunction { + Description = "Pulses are output from two channels in accordance with the parameters in the specified DUT, so that the path to the target position forms an arc.The radius of the circle is calculated by specifying the center position and the end position.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F176_PulseOutput_Pass", new FPFunction { + Description = "Pulses are output from two channels in accordance with the parameters in the specified DUT, so that the path to the target position forms an arc.The radius of the circle is calculated by specifying the center position and the end position.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F177_PulseOutput_Home", new FPFunction { + Description = "This instruction performs a home return according to the parameters in the specified DUT.Pulses are output from the specified channel when the control flag for this channel is FALSE and the execution condition is TRUE.", + ParametersIn = new Dictionary { + { "n_iPulseOutputChannel*", new string[] { + "decimal constant", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F178_HighSpeedCounter_Measure", new FPFunction { + Description = "This instruction measures the number of input pulses in a specified counting period and the pulse period.", + ParametersIn = new Dictionary { + { "s1_iHscChannel", new string[] { + "INT", + }}, + { "s2_NumberOfPulses_iPeriodTime_ms", new string[] { + "INT", + }}, + { "s1_NumberOfPulses_iNumberOfPeriods", new string[] { + "INT", + }}, + { "s1_PulsePeriod_iMeasurementMethod", new string[] { + "INT", + }}, + { "s1_PulsePeriod_iTimeoutValueOf1msUnitOutput", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d_NumberOfPulses_diAverage", new string[] { + "DINT", + }}, + { "d_PulsePeriod_diTime_ms", new string[] { + "DINT", + }}, + }, + }}, + { "F180_SCR_DUT", new FPFunction { + Description = "This instruction allows you to configure the screen display of the FP-e for N mode (normal mode) and S mode (switch mode).", + ParametersIn = new Dictionary { + { "ScreenSelection", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "ScreenControl", new string[] { + "F180_DUT", + }}, + { "DataUpperSection", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "DataLowerSection", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F181_DSP", new FPFunction { + Description = "The FP-e display mode is changed to the one specified using s1.", + }}, + { "F182_FILTER", new FPFunction { + RedundantName = "FP_DEBOUNCE", + Description = "Filter processing is executed for specified bits and output bitwise. The instruction can be useful to negate the effects of bounce, e.g. for a switching device.", + ParametersIn = new Dictionary { + { "s1_InputData", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_InputMask", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_FilterTime", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_OutputData", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F183_DSTM", new FPFunction { + Description = "The F183 instruction activates an upward counting 32-bit timer which works on-delayed. The smallest counting unit is 0.01s. During execution of F183 (start = TRUE), elapsing time is added to the elapsed value d. The timer output will be enabled when the elapsed value d equals the set value s. If the start condition EN is set to FALSE, execution will be interrupted and the elapsed value d will be reset to zero. The set value s can be changed during execution of F183.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F190_MV3", new FPFunction { + RedundantName = "FP_MOVE3", + Description = "The function copies three 16-bit data values at inputs s1, s2 and s3 to an ARRAY with three elements that is returned at output d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..2] OF", + }}, + }, + }}, + { "F191_DMV3", new FPFunction { + RedundantName = "FP_MOVE3", + Description = "The function copies three 32-bit data values at inputs s1, s2 and s3 to an ARRAY with three elements that is returned at output d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s3", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..2] OF", + }}, + }, + }}, + { "F215_DAND", new FPFunction { + RedundantName = "AND", + Description = "The function performs a bit-wise AND operation on two 32-bit data items at inputs s1 and s2. The result of the function is returned at output d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F216_DOR", new FPFunction { + RedundantName = "OR", + Description = "The function performs a bit-wise OR operation on two 32-bit data items at inputs s1 and s2. The result of the instruction is returned at output d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F217_DXOR", new FPFunction { + RedundantName = "XOR", + Description = "The function performs a bit-wise exclusive OR operation on two 32-bit data items at inputs s1 and s2. The result of the instruction is returned at output d. Using this instruction you can check how many bits in the two 32-bit data items are different, for example. At each position in which the bits at inputs s1 and s2 are different, a 1 is added in the result.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F218_DXNR", new FPFunction { + RedundantName = "XOR", + Description = "The function performs a bit-wise exclusive NOR operation on two 32-bit data items at inputs s1 and s2. The result of the instruction is returned at output d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F219_DUNI", new FPFunction { + RedundantName = "FP_COMBINE", + Description = "The function combines the two values at inputs s1 and s2 bit-wise with the value at input s3_Mask. The result of the instruction is returned at output d. The data-unite is calculated as follows:", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s3_Mask", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F230_DTBCD_TO_SEC", new FPFunction { + Description = "This function converts time data (date and time) into the number of seconds. It calculates the time span between the specified time date and 01/01/2001 at 00:00 hours. The time data is specified in the DUT \"DTBCD\".", + ParametersIn = new Dictionary { + { "s_DTBCD", new string[] { + "DTBCD", + }}, + }, + ParametersOut = new Dictionary { + { "d_SEC", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F231_SEC_TO_DTBCD", new FPFunction { + Description = "This function converts a specified number of seconds into date and time. The time data is calculated from 01/01/2001 at 00:00 hours.", + ParametersIn = new Dictionary { + { "s_SEC", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d_DTBCD", new string[] { + "DTBCD", + }}, + }, + }}, + { "F235_GRY", new FPFunction { + RedundantName = "FP_BIN_TO_GRAY", + Description = "The function converts a value at input s to a gray code value. The result of the conversion is returned at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F236_DGRY", new FPFunction { + RedundantName = "FP_BIN_TO_GRAY", + Description = "The function converts a value at input s to a gray code value. The result of the conversion is returned at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F237_GBIN", new FPFunction { + RedundantName = "FP_GRAY_TO_BIN", + Description = "The function converts a gray-code value at input s to binary data. The result of the conversion is returned at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F238_DGBIN", new FPFunction { + RedundantName = "FP_GRAY_TO_BIN", + Description = "The function converts a gray-code value at input s to binary data. The result of the conversion is returned at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F240_COLM", new FPFunction { + RedundantName = "FP_WORD_TO_BITCOLUMN", + Description = "The function creates a bit column out of a value given at input s that is returned within an ARRAY at output d. The position of the column in the ARRAY is specified at input n. The value assigned at n can be between 0 and 15.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..15] of", + }}, + }, + }}, + { "F241_LINE", new FPFunction { + RedundantName = "FP_BITCOLUMN_TO_WORD", + Description = "The function converts a bit column out of an ARRAY at input s and returns it at output d. The position at which the conversion takes place is specified at input n. The value assigned at input n should be between 0 and 15.", + ParametersIn = new Dictionary { + { "s", new string[] { + "ARRAY [0..15] OF", + }}, + { "n", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..15] of", + }}, + }, + }}, + { "F250_BTOA", new FPFunction { + Description = "Converts 16-bit/32-bit binary data stored in the area specified by s2_BinaryData to ASCII code. The conversion method is specified by n_ConversionMethod according to the four control characters of s1_Control. The converted result is stored in the area specified by d_AsciiData.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "STRING", + }}, + { "s2_BinaryData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + { "n_ConversionMethod", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_AsciiData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + }, + }}, + { "F251_ATOB", new FPFunction { + Description = "Converts ASCII code stored in the area specified by s2_AsciiData to 16-bit/32-bit binary data. The conversion method is specified by n_ConversionMethod according to the four control characters of s1_Control. The converted result is stored in the area specified by d_BinaryData.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "STRING", + }}, + { "s2_AsciiData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + { "n_ConversionMethod", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_BinaryData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + }, + }}, + { "F252_ACHK", new FPFunction { + Description = "Checks whether the ASCII codes stored in the area specified by s2_AsciiData can be converted correctly using the conversion method specified in by n_ConversionMethod and the 4 control characters specified by s1_Control.", + ParametersIn = new Dictionary { + { "s1_Control", new string[] { + "STRING", + }}, + { "s2_AsciiData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + { "n_ConversionMethod", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_BinaryData", new string[] { + "BOOL", + "INT", + "UINT", + "WORD", + "DINT", + "UDINT", + "DWORD", + "REAL", + "DATE", + "TOD", + "DT", + "STRING", + }}, + }, + }}, + { "F270_MAX", new FPFunction { + Description = "The function searches for the maximum value and its position in a 16-bit data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "Max", new string[] { + "INT", + }}, + { "Pos", new string[] { + "INT", + }}, + }, + }}, + { "F271_DMAX", new FPFunction { + Description = "The function searches for the maximum value and its position in a 32-bit data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_End", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "Max", new string[] { + "DINT", + }}, + { "Pos", new string[] { + "INT", + }}, + }, + }}, + { "F272_MIN", new FPFunction { + Description = "The function searches for the minimum value and its position in a 16-bit data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "Min", new string[] { + "INT", + }}, + { "Pos", new string[] { + "INT", + }}, + }, + }}, + { "F273_DMIN", new FPFunction { + Description = "The function searches for the minimum value and its position in a 32-bit data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_End", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "Min", new string[] { + "DINT", + }}, + { "Pos", new string[] { + "INT", + }}, + }, + }}, + { "F275_MEAN", new FPFunction { + Description = "This function calculates the sum and the arithmetic mean of numbers (both with +/- signs) in the specified 16-bit data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_End", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "Sum", new string[] { + "DINT", + }}, + { "Mean", new string[] { + "INT", + }}, + }, + }}, + { "F276_DMEAN", new FPFunction { + Description = "This function calculates the sum and the arithmetic mean of numbers (both with +/- signs) in the specified 32-bit data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_End", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "Sum", new string[] { + "ARRAY [0..1] OF DINT", + }}, + { "Mean", new string[] { + "DINT", + }}, + }, + }}, + { "F277_SORT", new FPFunction { + Description = "The function sorts values (with +/- sign) in a data table in ascending or descending order.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "INT", + }}, + { "s2_End", new string[] { + "INT", + }}, + { "s3_Descending", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F278_DSORT", new FPFunction { + Description = "The function sorts values (with +/- sign) in a data table in ascending or descending order.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "DINT", + }}, + { "s2_End", new string[] { + "DINT", + }}, + { "s3_Descending", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F282_SCAL", new FPFunction { + Description = "The function renders the value y at position x by performing a linear interpolation based on the neighboring reference points Pw(xw, yw) and Pw+1(xw+1, yw+1). In this example, w is the nearest reference point whose x value is smaller than the input value x, i.e. the function connects the individual reference points in series and renders the output value y based on the input value x.", + ParametersIn = new Dictionary { + { "EN", new string[] { + "BOOL", + }}, + { "x", new string[] { + "INT", + }}, + { "xy_data", new string[] { + "user-defined DUT", + }}, + }, + ParametersOut = new Dictionary { + { "y", new string[] { + "INT", + }}, + { "ENO", new string[] { + "BOOL", + }}, + }, + }}, + { "F283_DSCAL", new FPFunction { + Description = "The function renders the value y at position x by performing a linear interpolation based on the neighboring reference points Pw(xw, yw) and Pw+1(xw+1, yw+1). In this example, w is the nearest reference point whose x value is smaller than the input value x, i.e. the function connects the individual reference points in series and renders the output value y based on the input value x.", + ParametersIn = new Dictionary { + { "EN", new string[] { + "BOOL", + }}, + { "x", new string[] { + "DINT", + }}, + { "xy_data", new string[] { + "user-defined DUT", + }}, + }, + ParametersOut = new Dictionary { + { "ENO", new string[] { + "BOOL", + }}, + { "y", new string[] { + "DINT", + }}, + }, + }}, + { "F284_RAMP", new FPFunction { + RedundantName = "FP_RAMP", + Description = "Executes linear ramp output based on the parameters set.", + ParametersIn = new Dictionary { + { "s1_InitialValue", new string[] { + "INT", + }}, + { "s2_TargetValue", new string[] { + "INT", + }}, + { "s3_RiseTime", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d_OutputValue", new string[] { + "INT", + }}, + }, + }}, + { "F285_LIMT", new FPFunction { + RedundantName = "LIMIT", + Description = "The function compares the input value at input s3_In with a lower and an upper limit. The lower limit is specified at input s1_Min, and the upper limit at input s2_Max. The result of the function is returned at output d as follows.", + ParametersIn = new Dictionary { + { "s1_Min", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Max", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_In", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F286_DLIMT", new FPFunction { + RedundantName = "LIMIT", + Description = "The function compares the input value at input s3_In with a lower and an upper limit. The lower limit is specified at input s1_Min, and the upper limit at input s2_Max. The result of the function is returned at output d as follows:", + ParametersIn = new Dictionary { + { "s1_Min", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_Max", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s3_In", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F287_BAND", new FPFunction { + RedundantName = "FP_BAND", + Description = "The function compares the signed input value at input s3 with a deadband whose lower limit is specified at input s1 and whose upper limit is specified at s2. The result of the function is returned at output d as follows:", + ParametersIn = new Dictionary { + { "s1", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F288_DBAND", new FPFunction { + RedundantName = "FP_BAND", + Description = "The function compares the signed input value at input s3 with a deadband whose lower limit is specified at input s1 and whose upper limit is specified at s2. The result of the function is returned at output d as follows:", + ParametersIn = new Dictionary { + { "s1", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s3", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F289_ZONE", new FPFunction { + RedundantName = "FP_ZONE", + Description = "The function adds an offset value to the input value at input s3_In. The offset values for the negative and positive areas are entered at inputs s1_NegBias and s2_PosBias.", + ParametersIn = new Dictionary { + { "s1_PosBias", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_NegBias", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_In", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F290_DZONE", new FPFunction { + RedundantName = "FP_ZONE", + Description = "The function adds an offset value to the input value at input s3_In. The offset value for the negative and positive area are entered at inputs s1_NegBias and s2_PosBias.", + ParametersIn = new Dictionary { + { "s1_NegBias", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s2_PosBias", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + { "s3_In", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F300_BSIN", new FPFunction { + Description = "The function calculates the sine of BCD code angular data (input s) and stores the result (output d) as a BCD value in an array with three elements.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..2] of WORD", + }}, + }, + }}, + { "F301_BCOS", new FPFunction { + Description = "The function calculates the cosine of BCD code angular data (input s) and stores the result (output d) as a BCD value in an array with three elements.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..2] of WORD", + }}, + }, + }}, + { "F302_BTAN", new FPFunction { + Description = "The function calculates the tangent of BCD code angular data (input s) and stores the result (output d) as a BCD value in an array with three elements.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "ARRAY [0..2] of WORD", + }}, + }, + }}, + { "F303_BASIN", new FPFunction { + Description = "The function calculates the arcsine of a BCD value that is entered at input s as an ARRAY with three elements. The result is returned as BCD angular data in the range of 0° to 360° (16#0 to 16#360) at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "ARRAY [0..2] of WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F304_BACOS", new FPFunction { + Description = "The function calculates the arccosine of a BCD value that is entered at input s as an ARRAY with three elements. The result is returned as BCD angular data in the range of 0° to 360° (16#0 to 16#360) at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "ARRAY [0..2] of WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F305_BATAN", new FPFunction { + Description = "The function calculates the arctangent of a BCD value that is entered at input s as an ARRAY with three elements. The result is returned as BCD angular data in the range 0° to 90° (16#0 to 16#90) or 270° to 360° (16#270 to 16#360) at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "ARRAY [0..2] of WORD", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + }}, + }, + }}, + { "F309_FMV", new FPFunction { + RedundantName = "MOVE", + Description = "The floating point data (32 bits) specified by s is copied to the 32-bit area specified by d when the trigger turns on. The range of real number data which can be set is as follows:", + ParametersIn = new Dictionary { + { "s", new string[] { + "Floating point constant", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F310_FADD", new FPFunction { + RedundantName = "ADD", + Description = "The real number data (2 words) specified by s1 and s2 are added together when the trigger turns on. The added result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "REAL", + }}, + { "s2", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F311_FSUB", new FPFunction { + RedundantName = "SUB", + Description = "Subtracts the real number data specified by s2 from the real number data specified by s1 when the trigger turns on. The subtracted result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "REAL", + }}, + { "s2", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F312_FMUL", new FPFunction { + RedundantName = "MUL", + Description = "Multiplies the real number data specified by s1 and the one specified by s2 when the trigger turns on. The multiplied result is stored in d (32-bit area).", + ParametersIn = new Dictionary { + { "s1", new string[] { + "REAL", + }}, + { "s2", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F313_FDIV", new FPFunction { + RedundantName = "DIV", + Description = "The real number data specified by s1 is divided by the real number data specified by s2 when the trigger turns on. The result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "REAL", + }}, + { "s2", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F314_SIN", new FPFunction { + RedundantName = "SIN", + Description = "The sine of an angle data (units are radians) specified by s is calculated and the result stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F315_COS", new FPFunction { + RedundantName = "COS", + Description = "The cosine of an angle data (units are radians) specified by s is calculated and the result stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F316_TAN", new FPFunction { + RedundantName = "TAN", + Description = "The tangent of an angle data (units are radians) specified by s is calculated and the result stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F317_ASIN", new FPFunction { + RedundantName = "ASIN", + Description = "The arcsine of the value specified in s is calculated, and the result [an angle data (units are radians)] is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F318_ACOS", new FPFunction { + RedundantName = "ACOS", + Description = "The arccosine of the value specified in s is calculated, and the result [an angle data (units are radians)] is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F319_ATAN", new FPFunction { + RedundantName = "ATAN", + Description = "The arctangent of the value specified in s is calculated, and the result [an angle data (units are radians)] is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F320_LN", new FPFunction { + RedundantName = "LN", + Description = "The natural logarithm (LN) is calculated of the data specified in s, and the result is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F321_EXP", new FPFunction { + RedundantName = "EXP", + Description = "The exponent (EXP) is calculated from the real number data specified in s, and the result is stored in d. The calculation is performed with the exponent base (e) equal to 2.718282 (Euler’s number).", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F322_LOG", new FPFunction { + RedundantName = "LOG", + Description = "The logarithm (LOG) is calculated of the data specified in s, and the result is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F323_PWR", new FPFunction { + RedundantName = "EXPT", + Description = "The real number data specified by s1 is raised to the power specified by the real number data of s2, and the result is stored in d.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "REAL", + }}, + { "s2", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F324_FSQR", new FPFunction { + RedundantName = "SQRT", + Description = "The square root of real number data specified by s is calculated and stored in the 32-bit area specified by d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F325_FLT", new FPFunction { + RedundantName = "INT_TO_REAL", + Description = "Converts the 16-bit integer data with sign specified by s to real number data. The converted data is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F326_DFLT", new FPFunction { + RedundantName = "DINT_TO_REAL", + Description = "Converts the 32-bit integer data with sign specified by s to real number data. The converted data is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F327_INT", new FPFunction { + Description = "The function converts a floating point data at input s in the range -32767.99 to 32767.99 into integer data (including +/- sign). The result of the function is returned at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "INT", + "WORD", + }}, + }, + }}, + { "F328_DINT", new FPFunction { + Description = "The function converts a floating point data at input s in the range -2147483000 to 214783000 into integer data (including +/- sign). The result of the function is returned at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DINT", + "DWORD", + }}, + }, + }}, + { "F329_FIX", new FPFunction { + RedundantName = "TRUNC_TO_INT", + Description = "Converts real number data (range: 32767.99 to -32768.99) specified by s to signed 16-bit integer data (rounding the first decimal point down to integer) when the trigger turns on. The converted data is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "INT", + }}, + }, + }}, + { "F330_DFIX", new FPFunction { + RedundantName = "TRUNC_TO_DINT", + Description = "Converts real number data (range: -2,147,483,000 to 2,147,483,000) specified by s to signed 32-bit integer data (rounding the first decimal point down to integer). The converted data is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DINT", + }}, + }, + }}, + { "F331_ROFF", new FPFunction { + RedundantName = "REAL_TO_INT", + Description = "Converts real number data (range: +32767.49 to -32768.49) specified by s to signed 16-bit integer data (rounding the first decimal point off to integer). The converted data is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "INT", + }}, + }, + }}, + { "F332_DROFF", new FPFunction { + RedundantName = "REAL_TO_DINT", + Description = "Converts real number data (range: -2,147,483,000 to 2,147,483,000) specified by s to signed 32-bit integer data (rounding the first decimal point off to integer). The converted data is stored in d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DINT", + "DWORD", + }}, + }, + }}, + { "F333_FINT", new FPFunction { + RedundantName = "FP_ROUND_DOWN", + Description = "The function rounds down the decimal part of the real number data and returns it at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F334_FRINT", new FPFunction { + RedundantName = "FP_ROUND", + Description = "The function rounds off the decimal part of the real number data and returns it at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F335_FSIGN", new FPFunction { + RedundantName = "MUL", + Description = "The function changes the sign of the floating point value at input s and returns the result at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F336_FABS", new FPFunction { + RedundantName = "ABS", + Description = "Calculates the absolute value of real number data specified by s. The result (absolute value) is stored in d. NOTE This instruction cannot be programmed in the interrupt program.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F337_RAD", new FPFunction { + RedundantName = "FP_RAD", + Description = "The function converts the value of an angle entered at input s from degrees to radians and returns the result at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F338_DEG", new FPFunction { + RedundantName = "FP_DEG", + Description = "The function converts the value of an angle entered at input s from radians to degrees and returns the result at output d.", + ParametersIn = new Dictionary { + { "s", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F345_FCMP", new FPFunction { + RedundantName = "EQ", + Description = "Compares the real number data (floating point data) specified by s1 with that specified by s2. The comparison result is stored in special internal flags R9009, and R900A to R900C.", + ParametersIn = new Dictionary { + { "s1", new string[] { + "REAL", + }}, + { "s2", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F346_FWIN", new FPFunction { + RedundantName = "WITHIN_LIMITS", + Description = "The function compares a data band whose upper and lower limits are specified at inputs s2_Min and s3_Max with a value that is entered at input s1_In. The result is returned as follows:", + ParametersIn = new Dictionary { + { "s1_In", new string[] { + "REAL", + }}, + { "s2_Min", new string[] { + "REAL", + }}, + { "s3_Max", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F347_FLIMT", new FPFunction { + RedundantName = "LIMIT", + Description = "The output value (real number data) stored in the area specified by d is controlled based on whether or not the input value (real number data) specified by s3 falls within the range bounded by the upper and lower limits (real number data) set in s1 and s2.", + ParametersIn = new Dictionary { + { "s1_Min", new string[] { + "REAL", + }}, + { "s2_Max", new string[] { + "REAL", + }}, + { "s3_In", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F348_FBAND", new FPFunction { + RedundantName = "FP_BAND", + Description = "The function compares the input value at input s3_In with a deadband whose lower limit is specified at input s1_Min and whose upper limit is specified at s2_Max. The result of the function is returned at output d as follows:", + ParametersIn = new Dictionary { + { "s1_Min", new string[] { + "REAL", + }}, + { "s2_Max", new string[] { + "REAL", + }}, + { "s3_In", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F349_FZONE", new FPFunction { + RedundantName = "FP_ZONE", + Description = "The function adds an offset value to the input value at input s3_In. The offset value for the negative and positive area are entered at inputs s1_NegBias and s2_PosBias.", + ParametersIn = new Dictionary { + { "s1_NegBias", new string[] { + "REAL", + }}, + { "s2_PosBias", new string[] { + "REAL", + }}, + { "s3_In", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "REAL", + }}, + }, + }}, + { "F350_FMAX", new FPFunction { + Description = "The function searches for the maximum value and its position in a floating point data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "REAL", + }}, + { "s2_End", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "Max", new string[] { + "REAL", + }}, + { "Pos", new string[] { + "INT", + }}, + }, + }}, + { "F351_FMIN", new FPFunction { + Description = "The function searches for the minimum value and its position in a floating point data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "REAL", + }}, + { "s2_End", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "Min", new string[] { + "REAL", + }}, + { "Pos", new string[] { + "INT", + }}, + }, + }}, + { "F352_FMEAN", new FPFunction { + Description = "This function calculates the sum and the arithmetic mean (both with +/- signs) of floating point values in the specified 32-bit data table.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "REAL", + }}, + { "s2_End", new string[] { + "REAL", + }}, + }, + ParametersOut = new Dictionary { + { "Sum", new string[] { + "REAL", + }}, + { "Mean", new string[] { + "REAL", + }}, + }, + }}, + { "F353_FSORT", new FPFunction { + Description = "The function sorts values (with +/- sign) in a data table in ascending or descending order.", + ParametersIn = new Dictionary { + { "s1_Start", new string[] { + "REAL", + }}, + { "s2_End", new string[] { + "REAL", + }}, + { "s3_Descending", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F354_FSCAL", new FPFunction { + Description = "This function performs scaling (linearization) of a real number data table and renders the output (Y) for an input value (X).", + ParametersIn = new Dictionary { + { "x", new string[] { + "REAL", + }}, + { "xy_data", new string[] { + "user-defined DUT", + }}, + }, + ParametersOut = new Dictionary { + { "y", new string[] { + "REAL", + }}, + }, + }}, + { "F355_PID_DUT", new FPFunction { + Description = "The PID processing instruction is used to regulate a process (e.g. a heater) given a measured value (e.g. temperature) and a predetermined output value (e.g. 20°C).", + ParametersIn = new Dictionary { + { "s", new string[] { + "PID_DUT_31", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F356_PID_PWM", new FPFunction { + Description = "PID processing is performed to keep the process value PV as close as possible to the set point value SP. In contrast to F355_PID_DUT, this instruction enables a PWM output (on-off output). Auto-tuning is also available to automatically calculate the PID control data Kp, Ti, and Td.", + ParametersIn = new Dictionary { + { "Run", new string[] { + "BOOL", + }}, + { "Control", new string[] { + "F356_Control_DUT", + }}, + { "ParametersHold", new string[] { + "F356_Parameters_Hold_DUT", + }}, + { "ParametersNonHold", new string[] { + "F356_Parameters_NonHold_DUT", + }}, + { "ProcessValue", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + { "PWM_Output", new string[] { + "BOOL", + }}, + }, + }}, + { "F373_DTR", new FPFunction { + RedundantName = "FP_DETECT_CHANGE", + Description = "The function detects changes in a value at input s by comparing it with its former value that is stored at output d. If the new input value at s does not coincide with the old value, the function assigns the new value to output d. To signal the change, the system variable sys_bIsCarry is set simultaneously.", + ParametersIn = new Dictionary { + { "s", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F374_DDTR", new FPFunction { + RedundantName = "FP_DETECT_CHANGE", + Description = "The function detects changes in a value at input s by comparing it with its former value that is stored at output d. If the new input value at s does not coincide with the old value, the function assigns the new value to output d. To signal the change, the system variable sys_bIsCarry is set simultaneously.", + ParametersIn = new Dictionary { + { "s", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + ParametersOut = new Dictionary { + { "d", new string[] { + "DWORD", + "DINT", + "UDINT", + "DATE", + "TOD", + "DT", + }}, + }, + }}, + { "F380_Positioning_Start", new FPFunction { + Description = "This instruction starts the positioning operation according to the data specified in the positioning memory (positioning table area). The following operations are possible: E (end point) control P (pass point) control (P ® E) C (continuance point) control (C ® E) J (speed point) control (J ® E) Linear interpolation", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_TableNumber", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_OutputCalculationOnly", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F381_Positioning_Jog", new FPFunction { + Description = "This instruction starts the JOG operation according to the parameters specified in the positioning memory (axis setting area). While the execution condition is valid, the JOG operation continues.", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s3_DirectionReverse", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F382_Positioning_Home", new FPFunction { + Description = "This instruction starts the home return operation according to the parameters specified in the positioning memory (axis setting area).", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "INT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F383_Positioning_StartMultiple", new FPFunction { + Description = "This instruction starts the positioning tables for multiple axes specified on Configurator PMX. The tables of the E point control, P point control and C point control can be started.", + ParametersIn = new Dictionary { + { "s1_dutMultipleChannels", new string[] { + "F383_MultipleChannels_DUT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F384_Positioning_ReadData", new FPFunction { + Description = "This instruction reads the following positioning parameter data stored in the positioning memory of the unit to the operation memory area: common area-axis information area-axis setting area positioning table data area", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s1_Area", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Offset", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d_Start", new string[] { + "WORD", + }}, + }, + }}, + { "F385_Positioning_WriteData", new FPFunction { + Description = "This instruction is used to write the following positioning parameters and positioning table data with user programs. common area-axis information area-axis setting area positioning table data area.", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_Start", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "n_Number", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s1_Area", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d_Offset", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F386_Positioning_SetTable", new FPFunction { + Description = "This instruction starts positioning using the channel specified at s1_Channel according to the positioning table set at s2_TableNumber if the trigger EN is TRUE. Configure the positioning table in the Configurator PM7.", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "s2_TableNumber", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + }, + }}, + { "F387_Positioning_GetStatus", new FPFunction { + Description = "This instruction obtains status data from the positioning unit using the channel specified by s1_Channel if the trigger EN is TRUE. The result is stored in d1_Status.", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Status", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F388_Positioning_GetError", new FPFunction { + Description = "This instruction obtains error and warning codes from buffer 1 of the positioning unit using the channel specified by s1_Channel if the trigger EN is TRUE.The error code is stored in d1_Error and the warning code is stored in d2_Warning.", + ParametersIn = new Dictionary { + { "s1_Channel", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + ParametersOut = new Dictionary { + { "d1_Error", new string[] { + "WORD", + "INT", + "UINT", + }}, + { "d2_Warning", new string[] { + "WORD", + "INT", + "UINT", + }}, + }, + }}, + { "F389_Positioning_ClearError", new FPFunction { + Description = "This instruction clears an error or warning in the unit attached if the trigger EN is TRUE.", + }}, + { "F410_SET_INDEXREG_BANK", new FPFunction { + Description = "After importing an FPWIN GR project into Control FPWIN Pro, the program is loaded into the GR type editor. This editor is similar to the LD editor but uses different default color settings, which you can adapt under “Extras” > “Options” > “Program options” > “Fonts and colors”. You can edit, save and run your program inside the GR type editor. Transfer of networks or functions into the LD editor is only possible using copy and paste. After pasting networks or parts of programs into the LD editor, please read the warnings and comments carefully to avoid any malfunctions caused by the different behavior of the GR type editor. Different behavior compared to LD/FBD editor The GR type editor handles read access from a variable after write access in the same network differently than the LD/FBD editors. CAUTION Danger for user and machinery When copying&pasting networks between the GR type editor and LD/FBD editors, how \"read values from temporary copies\" are processed can produce different results. Additional GR functionalities not supported by the other programming editors Direct addresses are allowed as parameters of array, DUT or string type arguments REAL addresses as RDT100 Index register modifiers for constants IXK100 for 16-bit constants DIXK100 for 32-bit constants Integer devices for REAL arguments 16-bit integer device §DT100 32-bit integer device §DDT100 The following functions are critical and should be monitored carefully: Index register bank instructions F410_SET_INDEXREG_BANK F411_CHANGE_INDEXREG_BANK F412_POP_INDEXREG_BANK File register band instructions F414_SET_FILEREG_BANK F415_CHANGE_FILEREG_BANK F416_POP_FILEREG_BANK SFC instructions (known as \"step ladder instructions\" to users of FPWIN GR) SSTP_STEP_START NSTL_NEXT_STEP NSTP_NEXT_STEP_PULSE CSTP_CLEAR_STEP SCLR_CLEAR_MULTIPLE_STEPS STPE_STEP_LADDER_END Tip Please refer to \"FP-Series Programming Manual\" for details on instructions that are only available in the GR type editor. Related topics: Access to variables (\"late assignment\") Ladder Diagram (LD) and Function Block Diagram (FBD) Particularities of GR import Examples of FPWIN GR file import", + }}, + { "F411_CHANGE_INDEXREG_BANK", new FPFunction { + Description = "After importing an FPWIN GR project into Control FPWIN Pro, the program is loaded into the GR type editor. This editor is similar to the LD editor but uses different default color settings, which you can adapt under “Extras” > “Options” > “Program options” > “Fonts and colors”. You can edit, save and run your program inside the GR type editor. Transfer of networks or functions into the LD editor is only possible using copy and paste. After pasting networks or parts of programs into the LD editor, please read the warnings and comments carefully to avoid any malfunctions caused by the different behavior of the GR type editor. Different behavior compared to LD/FBD editor The GR type editor handles read access from a variable after write access in the same network differently than the LD/FBD editors. CAUTION Danger for user and machinery When copying&pasting networks between the GR type editor and LD/FBD editors, how \"read values from temporary copies\" are processed can produce different results. Additional GR functionalities not supported by the other programming editors Direct addresses are allowed as parameters of array, DUT or string type arguments REAL addresses as RDT100 Index register modifiers for constants IXK100 for 16-bit constants DIXK100 for 32-bit constants Integer devices for REAL arguments 16-bit integer device §DT100 32-bit integer device §DDT100 The following functions are critical and should be monitored carefully: Index register bank instructions F410_SET_INDEXREG_BANK F411_CHANGE_INDEXREG_BANK F412_POP_INDEXREG_BANK File register band instructions F414_SET_FILEREG_BANK F415_CHANGE_FILEREG_BANK F416_POP_FILEREG_BANK SFC instructions (known as \"step ladder instructions\" to users of FPWIN GR) SSTP_STEP_START NSTL_NEXT_STEP NSTP_NEXT_STEP_PULSE CSTP_CLEAR_STEP SCLR_CLEAR_MULTIPLE_STEPS STPE_STEP_LADDER_END Tip Please refer to \"FP-Series Programming Manual\" for details on instructions that are only available in the GR type editor. Related topics: Access to variables (\"late assignment\") Ladder Diagram (LD) and Function Block Diagram (FBD) Particularities of GR import Examples of FPWIN GR file import", + }}, + { "F412_RESTORE_INDEXREG_BANK", new FPFunction { + Description = "After importing an FPWIN GR project into Control FPWIN Pro, the program is loaded into the GR type editor. This editor is similar to the LD editor but uses different default color settings, which you can adapt under “Extras” > “Options” > “Program options” > “Fonts and colors”. You can edit, save and run your program inside the GR type editor. Transfer of networks or functions into the LD editor is only possible using copy and paste. After pasting networks or parts of programs into the LD editor, please read the warnings and comments carefully to avoid any malfunctions caused by the different behavior of the GR type editor. Different behavior compared to LD/FBD editor The GR type editor handles read access from a variable after write access in the same network differently than the LD/FBD editors. CAUTION Danger for user and machinery When copying&pasting networks between the GR type editor and LD/FBD editors, how \"read values from temporary copies\" are processed can produce different results. Additional GR functionalities not supported by the other programming editors Direct addresses are allowed as parameters of array, DUT or string type arguments REAL addresses as RDT100 Index register modifiers for constants IXK100 for 16-bit constants DIXK100 for 32-bit constants Integer devices for REAL arguments 16-bit integer device §DT100 32-bit integer device §DDT100 The following functions are critical and should be monitored carefully: Index register bank instructions F410_SET_INDEXREG_BANK F411_CHANGE_INDEXREG_BANK F412_POP_INDEXREG_BANK File register band instructions F414_SET_FILEREG_BANK F415_CHANGE_FILEREG_BANK F416_POP_FILEREG_BANK SFC instructions (known as \"step ladder instructions\" to users of FPWIN GR) SSTP_STEP_START NSTL_NEXT_STEP NSTP_NEXT_STEP_PULSE CSTP_CLEAR_STEP SCLR_CLEAR_MULTIPLE_STEPS STPE_STEP_LADDER_END Tip Please refer to \"FP-Series Programming Manual\" for details on instructions that are only available in the GR type editor. Related topics: Access to variables (\"late assignment\") Ladder Diagram (LD) and Function Block Diagram (FBD) Particularities of GR import Examples of FPWIN GR file import", + }}, + { "F414_SET_FILEREG_BANK", new FPFunction { + Description = "After importing an FPWIN GR project into Control FPWIN Pro, the program is loaded into the GR type editor. This editor is similar to the LD editor but uses different default color settings, which you can adapt under “Extras” > “Options” > “Program options” > “Fonts and colors”. You can edit, save and run your program inside the GR type editor. Transfer of networks or functions into the LD editor is only possible using copy and paste. After pasting networks or parts of programs into the LD editor, please read the warnings and comments carefully to avoid any malfunctions caused by the different behavior of the GR type editor. Different behavior compared to LD/FBD editor The GR type editor handles read access from a variable after write access in the same network differently than the LD/FBD editors. CAUTION Danger for user and machinery When copying&pasting networks between the GR type editor and LD/FBD editors, how \"read values from temporary copies\" are processed can produce different results. Additional GR functionalities not supported by the other programming editors Direct addresses are allowed as parameters of array, DUT or string type arguments REAL addresses as RDT100 Index register modifiers for constants IXK100 for 16-bit constants DIXK100 for 32-bit constants Integer devices for REAL arguments 16-bit integer device §DT100 32-bit integer device §DDT100 The following functions are critical and should be monitored carefully: Index register bank instructions F410_SET_INDEXREG_BANK F411_CHANGE_INDEXREG_BANK F412_POP_INDEXREG_BANK File register band instructions F414_SET_FILEREG_BANK F415_CHANGE_FILEREG_BANK F416_POP_FILEREG_BANK SFC instructions (known as \"step ladder instructions\" to users of FPWIN GR) SSTP_STEP_START NSTL_NEXT_STEP NSTP_NEXT_STEP_PULSE CSTP_CLEAR_STEP SCLR_CLEAR_MULTIPLE_STEPS STPE_STEP_LADDER_END Tip Please refer to \"FP-Series Programming Manual\" for details on instructions that are only available in the GR type editor. Related topics: Access to variables (\"late assignment\") Ladder Diagram (LD) and Function Block Diagram (FBD) Particularities of GR import Examples of FPWIN GR file import", + }}, + { "F415_CHANGE_FILEREG_BANK", new FPFunction { + Description = "After importing an FPWIN GR project into Control FPWIN Pro, the program is loaded into the GR type editor. This editor is similar to the LD editor but uses different default color settings, which you can adapt under “Extras” > “Options” > “Program options” > “Fonts and colors”. You can edit, save and run your program inside the GR type editor. Transfer of networks or functions into the LD editor is only possible using copy and paste. After pasting networks or parts of programs into the LD editor, please read the warnings and comments carefully to avoid any malfunctions caused by the different behavior of the GR type editor. Different behavior compared to LD/FBD editor The GR type editor handles read access from a variable after write access in the same network differently than the LD/FBD editors. CAUTION Danger for user and machinery When copying&pasting networks between the GR type editor and LD/FBD editors, how \"read values from temporary copies\" are processed can produce different results. Additional GR functionalities not supported by the other programming editors Direct addresses are allowed as parameters of array, DUT or string type arguments REAL addresses as RDT100 Index register modifiers for constants IXK100 for 16-bit constants DIXK100 for 32-bit constants Integer devices for REAL arguments 16-bit integer device §DT100 32-bit integer device §DDT100 The following functions are critical and should be monitored carefully: Index register bank instructions F410_SET_INDEXREG_BANK F411_CHANGE_INDEXREG_BANK F412_POP_INDEXREG_BANK File register band instructions F414_SET_FILEREG_BANK F415_CHANGE_FILEREG_BANK F416_POP_FILEREG_BANK SFC instructions (known as \"step ladder instructions\" to users of FPWIN GR) SSTP_STEP_START NSTL_NEXT_STEP NSTP_NEXT_STEP_PULSE CSTP_CLEAR_STEP SCLR_CLEAR_MULTIPLE_STEPS STPE_STEP_LADDER_END Tip Please refer to \"FP-Series Programming Manual\" for details on instructions that are only available in the GR type editor. Related topics: Access to variables (\"late assignment\") Ladder Diagram (LD) and Function Block Diagram (FBD) Particularities of GR import Examples of FPWIN GR file import", + }}, + { "F416_RESTORE_FILEREG_BANK", new FPFunction { + Description = "After importing an FPWIN GR project into Control FPWIN Pro, the program is loaded into the GR type editor. This editor is similar to the LD editor but uses different default color settings, which you can adapt under “Extras” > “Options” > “Program options” > “Fonts and colors”. You can edit, save and run your program inside the GR type editor. Transfer of networks or functions into the LD editor is only possible using copy and paste. After pasting networks or parts of programs into the LD editor, please read the warnings and comments carefully to avoid any malfunctions caused by the different behavior of the GR type editor. Different behavior compared to LD/FBD editor The GR type editor handles read access from a variable after write access in the same network differently than the LD/FBD editors. CAUTION Danger for user and machinery When copying&pasting networks between the GR type editor and LD/FBD editors, how \"read values from temporary copies\" are processed can produce different results. Additional GR functionalities not supported by the other programming editors Direct addresses are allowed as parameters of array, DUT or string type arguments REAL addresses as RDT100 Index register modifiers for constants IXK100 for 16-bit constants DIXK100 for 32-bit constants Integer devices for REAL arguments 16-bit integer device §DT100 32-bit integer device §DDT100 The following functions are critical and should be monitored carefully: Index register bank instructions F410_SET_INDEXREG_BANK F411_CHANGE_INDEXREG_BANK F412_POP_INDEXREG_BANK File register band instructions F414_SET_FILEREG_BANK F415_CHANGE_FILEREG_BANK F416_POP_FILEREG_BANK SFC instructions (known as \"step ladder instructions\" to users of FPWIN GR) SSTP_STEP_START NSTL_NEXT_STEP NSTP_NEXT_STEP_PULSE CSTP_CLEAR_STEP SCLR_CLEAR_MULTIPLE_STEPS STPE_STEP_LADDER_END Tip Please refer to \"FP-Series Programming Manual\" for details on instructions that are only available in the GR type editor. Related topics: Access to variables (\"late assignment\") Ladder Diagram (LD) and Function Block Diagram (FBD) Particularities of GR import Examples of FPWIN GR file import", + }}, + }; + + } + +} diff --git a/MewtocolNet/MewtocolNet.csproj b/MewtocolNet/MewtocolNet.csproj index b7d1b09..7318b21 100644 --- a/MewtocolNet/MewtocolNet.csproj +++ b/MewtocolNet/MewtocolNet.csproj @@ -43,5 +43,9 @@ + + + + diff --git a/MewtocolNet/ProgramParsing/PlcBinaryProgram.cs b/MewtocolNet/ProgramParsing/PlcBinaryProgram.cs index fd31e56..5d9c7ed 100644 --- a/MewtocolNet/ProgramParsing/PlcBinaryProgram.cs +++ b/MewtocolNet/ProgramParsing/PlcBinaryProgram.cs @@ -4,6 +4,7 @@ using System.IO; using System.Collections.Generic; using System.Linq; using System.Globalization; +using MewtocolNet.AutoGeneratedData; namespace MewtocolNet.ProgramParsing { @@ -46,17 +47,6 @@ namespace MewtocolNet.ProgramParsing { { "R901E", "sys_bPulse1min" }, }; - static readonly Dictionary stepFunctions = new Dictionary { - { "F0", "MV" }, - { "F1", "DMV" }, - { "F2", "MVN" }, - { "F3", "DMVN" }, - { "F5", "BTM" }, - { "F8", "DMV2" }, - { "F11", "COPY" }, - { "F61", "DCMP" } - }; - // ST R50_1 21 AC => WR system area start was set to 50 // ST R57_1 91 AC => WR system area start was set to 57 // ST R901_3 F7 FF 53 A9 @@ -196,7 +186,33 @@ namespace MewtocolNet.ProgramParsing { private string GetFunctionName (string funcName) { - return stepFunctions.ContainsKey(funcName) ? $"{funcName} ({stepFunctions[funcName]})" : funcName; + var found = FPFunction.functions.FirstOrDefault(x => x.Key.StartsWith(funcName)); + + if (!found.Equals(default(KeyValuePair))) { + + var sb = new StringBuilder(); + + var splt = found.Key.Split('_'); + + sb.Append($"{splt[0]} (*{splt[1]}*)"); + + if(found.Value.ParametersIn.Count > 0) { + + sb.Append($" IN: {found.Value.ParametersIn.Count}"); + + } + + if (found.Value.ParametersOut.Count > 0) { + + sb.Append($" OUT: {found.Value.ParametersOut.Count}"); + + } + + return sb.ToString(); + + } + + return funcName; } diff --git a/MewtocolNet/PublicEnums/PlcVarType.cs b/MewtocolNet/PublicEnums/PlcVarType.cs index 0c10927..52a1a67 100644 --- a/MewtocolNet/PublicEnums/PlcVarType.cs +++ b/MewtocolNet/PublicEnums/PlcVarType.cs @@ -3,16 +3,19 @@ public enum PlcVarType { BOOL, + WORD, INT, UINT, + DWORD, DINT, UDINT, REAL, TIME, + DATE_AND_TIME, + DATE, + TIME_OF_DAY, STRING, - WORD, - DWORD - + } }