WO2018030831A1 - Apparatus and method for converting plc control program into structured data - Google Patents

Abstract

An apparatus for converting a PLC control program into structured data according to the present invention is characterised by comprising: a class library construction unit for building a class library including rungs and classes for each of an input contact point and an output contact point of the PLC control program; and a structure generation unit for receiving input of a common format PLC control program that is converted from a text-based PLC control program, and generating structured data including rungs and objects for each of an input contact point and an output contact point of the common format PLC control program, based on the class library.

Description

Apparatus and method for converting a PLC control program into structure data

The present invention relates to a PLC control program, and more particularly, to an apparatus and method for converting a text-based PLC control program into a structure data consisting of objects.

Programmable Logic Controller (PLC) is a stable control device for process control in the automation industry.It is programmable to cope with frequent system changes in the field caused by small quantity production of various products, and from the need for a controller that is small and relatively free of system changes. Developed.

Programming language to operate PLC is LD (Ladder Diagram), Function Block Diagram (FBD), Structured Text (ST), Instruction List (IL), Sequential Function Chart (SFC) and Continuous Function Chart (CFC). It is specified in 61131-3.

The structure of the PLC control program can be largely divided into tag information containing information about a PLC contact point and logic information containing information about a driven PLC control program. Among these, logic information is the most basic element in operating an automated process, and includes all the information about sequences and conditions for facility / process / line control. Can be used as key information for

A key element of the automated process operation analysis is to enable rapid and accurate cause identification and response to various abnormal situations occurring in the automated process, which aims to improve productivity and process optimization.

The abnormal occurrence of the automation process is caused by the occurrence (ON or OFF) of an abnormal symbol (ON or OFF) on the PLC control program that operates the automation process. A myriad of abnormal signals are included for each process up to and including the abnormal signal.

In the current industrial field, when the abnormal situation of the automation process occurs, the alarm is displayed through the Alarm List of the HMI (Human-Machine Interface) controller. Experience is solving the problem.

The abnormal situation information displayed on the HMI controller is an abnormal signal belonging to the upper stage among the abnormal signals of the process in which the abnormality occurred, and does not include information on the actual cause of the abnormality (abnormal signal belonging to the lower stage). It is impossible to reproduce the situation.

In order to solve such an abnormal situation or to optimize the process operation, a PLC control program in the form of a structure data is required, but at present, a PLC manufacturer or a PLC programming software, for example, an LD-based PLC control program or a text-based PLC control program converted therefrom. It does not provide PLC control program of structure data format.

Accordingly, an object of the present invention is to provide an apparatus and method for automatically converting a text-based PLC control program into a PLC control program having a structure data format.

An apparatus for converting a PLC control program into structure data according to the present invention for solving the above technical problem is to build a class library including classes for each of the rung (Rung), input contact and output contact of the PLC control program Class library construction unit; And receiving a common PLC control program converted from a text-based PLC control program, and based on the class library, an object for each of a rung, an input contact, and an output contact of the PLC control program of the common type. And a structure generator for generating structure data to be included.

The class library further includes a relationship class for representing a relationship between a corresponding input contact or output contact for each input contact or output contact and at least one other input contact or output contact, wherein the structure data is in the common format. The apparatus may further include a relationship object representing a relationship between a corresponding input contact or output contact for each input contact or output contact of the PLC control program and at least one other input contact or output contact. Here, the relationship class and the relationship object may be data fields and may have a data field for representing a previous input contact, a previous output contact, a next input contact, or a next output contact based on the corresponding input contact or output contact.

The structure generating unit may include: an index generating unit for assigning an index to each contact included in the corresponding rung for each rung of the common type PLC control program; An object generation unit for generating an object and a relationship object for each of a rung, an input contact and an output contact of the PLC control program of the common type by reflecting the given index based on the class library; And a relationship forming unit defining the data field of the relationship object.

The relationship forming unit may define an index of a previous input contact, a previous output contact, a next input contact, or a next output contact as the data field.

The common type PLC control program includes a symbol indicating an OR coupling relationship, and the relationship forming unit uses a symbol indicating the OR coupling relationship, and the common type is combined in an OR relationship in the PLC control program of the common type. A relation block generator that defines a relation block, wherein the relation block has a data field for representing a previous input contact, a previous output contact, a next input contact, or a next output contact; An in-step relationship forming unit defining, for each rung of the PLC control program of the common type represented by the relationship block, the data field for the relationship block, the input contact point, and the output contact constituting the rung; And a relationship forming unit in a relationship block defining the data field with respect to the contacts included in the relationship block.

The relationship forming unit in the relationship block may distinguish internal elements coupled in an OR relationship in the relationship block, and may include at least one input contact included in the internal elements based on the data field defined for the relationship block, or The data field of the output contact can be defined.

The relationship forming unit in the relationship block may redefine the data field of the previous or next input contact or output contact of the corresponding relationship block based on the data field defined for the contacts included in the relationship block.

According to an embodiment of the present invention for solving the above technical problem, a method for converting a PLC control program into structure data includes: constructing a class library including classes for each of a rung, an input contact, and an output contact of the PLC control program; step; And receiving a common PLC control program converted from a text-based PLC control program, and based on the class library, an object for each of a rung, an input contact, and an output contact of the PLC control program of the common type. And generating the structure data to include.

The class library further includes a relationship class for representing a relationship between a corresponding input contact or output contact for each input contact or output contact and at least one other input contact or output contact, wherein the structure data is in the common format. The apparatus may further include a relationship object representing a relationship between a corresponding input contact or output contact for each input contact or output contact of the PLC control program and at least one other input contact or output contact. Here, the relationship class and the relationship object may be data fields and may have a data field for representing a previous input contact, a previous output contact, a next input contact, or a next output contact based on the corresponding input contact or output contact.

The generating of the structure data may include: assigning an index to each contact included in the corresponding rung for each rung of the PLC control program of the common type; Generating an object and a relationship object for each of a rung, an input contact and an output contact of the PLC control program of the common type by reflecting the given index based on the class library; And defining the data field of the relationship object.

In the defining of the data field, an index of a previous input contact, a previous output contact, a next input contact, or a next output contact may be defined as the data field.

The common type PLC control program includes a symbol indicating an OR coupling relationship, and the step of defining the data field includes: (a) OR in the common type PLC control program using a symbol indicating the OR coupling relationship; Defining a common type combined in a relationship as a relationship block, wherein the relationship block has a data field for representing a previous input contact, a previous output contact, a next input contact, or a next output contact based on the relationship block; ; (b) defining, for each rung of the PLC control program of the common format represented by the relationship block, the data field for the relationship block, the input contact point and the output contact point constituting the rung; And (c) defining the data field with respect to the contacts included in the relationship block.

In step (c), the internal elements coupled in the OR relationship in the relationship block are distinguished, and at least one input contact or output included in the internal elements based on the data field defined for the relationship block. And defining the data field of the contact.

The step (c) may include redefining the data field of a previous or next input contact or output contact of the relation block based on the data field defined for the contacts included in the relation block. Can be.

According to the present invention, by converting a text-based PLC control program to a PLC control program of the structure data format automatically, using the PLC control program of the structure data format, the highest stage of the process where an error occurs when an abnormal situation of the automation process occurs. It is possible to enable automatic tracking from the abnormal signal of to the lowest abnormal signal of the actual cause. In addition, the PLC control program of the structure data format can be the basis of a system that visualizes and traces the actual cause of the occurrence of an abnormal situation in the automation process, thereby contributing to the improvement of the productivity of the automation process and the optimization of the process operation. Can be.

1 is a block diagram of an apparatus for converting a PLC control program into structure data according to an embodiment of the present invention.

2 is an example of an XML file format for a common command.

3 shows a specific configuration of the common format conversion unit 13.

4 is a flowchart of a conversion method to a common format for a text-based PLC control program performed by the common format conversion unit 13.

5A shows an example of a PLC control program of the Mitsubishi LD structure.

FIG. 5B illustrates a text-based PLC control program converted from the PLC control program of FIG. 5A.

FIG. 6 shows IL objects generated by the IL object generator 14 for the first rung and the second rung, respectively.

7A shows IL blocks generated by the IL block generator 15 for the first rung.

FIG. 7B shows IL blocks generated by the IL block generator 15 for the second rung.

FIG. 8A illustrates a process of expressing a coupling relationship between common blocks by applying a joint instruction OR to the common blocks shown in FIG. 7A in a common format.

8B illustrates a process of expressing a coupling relationship between common blocks by applying a joint instruction OR to the common blocks shown in FIG. 7B in a common format.

FIG. 9 illustrates a process of expressing a coupling relationship between common blocks by applying a joint command ORB to common blocks after applying the joint command OR through FIG. 8B.

10 shows the result of applying the combined command MPS used in the output unit.

11 shows the result of applying the combined command MPP used in the output unit.

FIG. 12 shows common formats of common blocks represented through FIGS. 9 through 11 for the second rung.

FIG. 13 shows the final common format for the first rung N0 and the second rung N5, converted from the text-based PLC control program of FIG. 5B.

14 shows the structure of a class library constructed by the class library constructing unit 21.

15A to 15E illustrate data field structures of a 'Step' class, a 'Coil' class, a 'Contact' class, a 'Relation' class, and a 'Tag' class, respectively.

16 shows a specific configuration of the structure generation unit 22 according to an embodiment of the present invention.

FIG. 17 shows an example of the indices given to the contacts for the PLC control program of the common type shown in FIG.

FIG. 18 illustrates examples of objects generated from a PLC-type control program of a common type indexed as shown in FIG. 17 based on the class libraries of FIGS. 14 and 15.

FIG. 19 illustrates a PLC control program in which the common type PLC control program with an index is expressed in the form of an object as shown in FIG. 17.

20 shows a specific configuration of the relationship forming unit 25 according to an embodiment of the present invention.

21 shows a result of expressing NO step using a relationship block.

22 shows the result of defining the relationship between the contacts (or the relationship block) for the NO step.

23 shows a format in which the relationship block is divided into internal elements.

FIG. 24A shows a result of applying the relation block RBK ₀ shown in FIG. 22 to the format of FIG. 23.

24B shows a result of defining a relationship with other contacts for each contact included in the relationship block RBK ₀ .

FIG. 25 illustrates a result in which all of the relationships between the corresponding input contact or output contact and another input contact or output contact are expressed for each input contact or output contact of the NO step.

26 shows the result of expressing N5 Step using a relationship block.

27 shows a result of defining a relationship between contacts (or a relationship block) for N5 Step.

FIG. 28 shows the result of applying the relationship block RBK ₀ and the relationship block RBK ₁ shown in FIG. 27 to the format of FIG. 23 and defining the relationship with other contacts for each contact included in the RBK ₀ and RBK ₁ .

FIG. 29 illustrates a result of replacing relation block RBK ₁ in relation block RBK ₀ with contacts I2 and I3 included in FIG. 28.

Figure 30 shows the results of replacing with a, a relationship is defined between the contact included in the block RBK _0, i.e. RBK ₀ in FIG. 29 the relationship block RBK ₀ of Fig.

FIG. 31 shows a result of applying the relation block RBK ₂ shown in FIG. 27 to the format of FIG. 23.

Figure 32 shows the results of replacing with a, a relationship is defined, the contact in the relation RBK block _2, i.e. ₂ RBK of the relationship RBK block ₂ of Fig. 30 Fig. 31.

33 shows an example of structure data finally generated according to an embodiment of the present invention.

34 is a flowchart of a method of converting a common PLC control program into structure data according to an embodiment of the present invention.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings. In the following description and the accompanying drawings, the substantially identical components are represented by the same reference numerals, and thus redundant description will be omitted. In addition, in the following description of the present invention, if it is determined that a detailed description of a related known function or configuration may unnecessarily obscure the subject matter of the present invention, the detailed description thereof will be omitted.

1 is a block diagram of an apparatus for converting a PLC control program into structure data (hereinafter, referred to as a structure data converting apparatus) according to an embodiment of the present invention.

The structure data converting apparatus according to the present embodiment includes a common instruction library constructing unit 11, a storage unit 12, a common format converting unit 13, a class library constructing unit 21, and a structure forming unit 22. can do.

In the structure of the structure data conversion apparatus according to the present embodiment, the common instruction library construction unit 11, the storage unit 12, and the common format conversion unit 13 share a PLC control program having a different text format for each PLC manufacturer. By converting into a PLC control program of a common type, a so-called common type conversion device (hereinafter, referred to as a common type conversion device) of a PLC control program can be configured. The common format conversion apparatus is disclosed in detail and in detail in Korean Patent Application No. 10-2015-0181242 filed by the applicant of the present invention, the entire contents of which are incorporated herein by reference.

According to the embodiment, the common format converting apparatus is composed of a common instruction library constructing unit 11, a storage unit 12, and a common format converting unit 13, and the structure data converting apparatus is connected to the class library constructing unit 21. It may be composed of the structure forming part 22.

The common instruction library construction unit 11 generates a common instruction library for instructions used in text-based PLC control programs having different formats according to the common instruction generation algorithm, constructs a common instruction library, and stores the storage unit 12. ).

In order to facilitate the construction of such a common instruction library, first, the instruction information used in the PLC control program for each PLC manufacturer and the corresponding instruction information corresponding to the PLC instruction before the start of construction of the common instruction library are already in the common instruction library construction unit 11. It is preferable that the storing or input is completed.

When the instructions used in the PLC control program for each PLC manufacturer are prepared in this way, the common instruction library building unit 11 constructs the common instruction library according to the common instruction generation algorithm.

At this time, the common command generation algorithm is an algorithm that sequentially performs the first step, the second step and the third step to generate a common command for the commands used in text-based PLC control programs having different formats to be.

The first step is to classify the commands used for text-based PLC control programs having different formats into the same display command groups having the same meaning on the display.

For example, the command 'equal' is displayed as 'OR =' for Mitsubishi, 'EQU' for AB, and '== I' for Siemens. In the case of LSIS, 'OR =' is displayed. Therefore, in the first step, the 'equal' command group includes 'OR =' for Mitsubishi, 'EQU' for AB, '== I' for Siemens, and 'OR =' for LS. This may be included.

Thereafter, the second step is to check whether all the commands belonging to the same display command group have the same function.

For example, in the second step, whether or not 'OR =', 'EQU', '== I' and 'OR =' belonging to the 'same' command group are all the same function.

The third step is to generate a common command in a different manner depending on whether all of the commands belonging to the same display command group are the same function or not.

First, when all the commands belonging to the same display command group have the same function, a dictionary word indicating the same commands belonging to the same display command group and having the same function is a common command for the commands having the same function. Is generated.

For example, the words 'OR =', 'EQU', '== I', and 'OR =' belonging to the 'Equal' command group all have the same function, so the dictionary word for 'equal' is 'EQUAL' may be generated as a common command for commands having the same function. It is not limited to using only the word 'EQUAL' as a common command in the dictionary.

When generating a common command for the commands having the same function, a parameter qualifier included in the command having the same function may be inserted into the common command for the command having the same function. Qualifiers that define the parameters of these instructions: D (Double), BK (Block), U (Unsigned), G (Group), R (Real), L (Long), 4 (4 bit), 8 (8 Bit), If any one of $ (String) and C (Complement) is included in the command, the parameter qualifier may be inserted as a prefix to the common command of the command. However, the position at which the parameter qualifier is inserted is not limited thereto.

For example, AB's command 'DEQU' for 'equal' is a command with the parameter qualifier D (Double) appended to the command 'EQU'. 'D' limits the parameter size of the command 'EQU'. The 'EQU' command processes 1 Word (16bit), and the 'DEQU' command processes 2 Word (32bit). As such, parameter qualifiers that define command parameters may be inserted as prefixes of common commands.

When generating a common command for the commands having the same function, an operation modifier included in the command having the same function may be inserted into the common command for the commands having the same function. If any one of the operation qualifiers limiting the operation of the command, that is, P (Negative Pulse) or N (Negative Pulse) is included in the corresponding command, the operation qualifier may be inserted as a suffix in the common command of the command. However, the position at which the operation modifier is inserted is not limited thereto.

For example, Mitsubishi's 'ANDP' command is 'P', an operation qualifier that converts 'AND', which has a function to turn on when the address value is On, to a positive pulse form. (Positive pulse) '. Therefore, 'XICP', a common command for 'ANDP', may be generated by suffixing an operation modifier 'P' to 'XIC (eXamine If Closed)', a common command for 'AND'.

On the other hand, when the commands belonging to the same display command group do not all have the same function, the dictionary words for displaying the same commands belonging to the same display command group but not all have the same function do not have the same function. It is possible to generate a common command for the commands, and insert the manufacturer name of the PLC controlled by the PLC control program in which the command having the same function is not used in the common command for the commands having the same function.

For example, when all of the commands belonging to the same display command group do not have the same function, the command 'LIMIT' may be mentioned. The command 'LIMIT' is used the same in the PLC control program of Mitsubishi, LS Industrial Systems and AB, but it does not have the same function. 'LIMIT' command is not used in Siemens PLC control program.

Therefore, the common command for the command 'LIMIT' may be generated as the word 'LIMIT' in the dictionary. Since the command 'LIMIT' does not have the same function for each PLC manufacturer, the manufacturer name of each PLC can be inserted in the common command 'LIMIT'. For example, Mitsubishi's 'm', 'S' for Siemens, 'ab' for AB, and 'ls' for LS prenatal can be inserted as a prefix of the common command 'LIMIT'. In other words, it can be 'mLIMIT' for Mitsubishi, 'sLIMIT' for Siemens, 'abLIMIT' for AB, and 'lsLIMIT' for LS.

When generating a common command for the commands that do not have the same function, a parameter qualifier included in the command that does not have the same function may be inserted into the common command for the commands that do not have the same function.

For example, AB's command 'DLIMIT' is a command with the parameter qualifier D (Double) appended to the command 'LIMIT'. 'D' limits the parameter size of the command 'LIMIT'. The 'LIMIT' command processes 1 Word (16bit), and the 'DLIMIT' command processes 2 Word (32bit). As such, parameter qualifiers that define command parameters may be inserted into common commands, which may be placed after a prefix indicating the PLC manufacturer, for example, 'ab' indicating the AB company. After all, the common command for AB 'DLIMIT' may be 'abDLIMIT'.

When generating a common command for the commands that do not have the same function, an operation modifier included in the command that does not have the same function may be inserted into the common command for the commands that do not have the same function. For example, Mitsubishi's 'LIMITP' command includes 'P (Postive Pulse)', an operation modifier that converts the positive 'pulse' form of the command 'LIMIT'. As such, an action modifier that restricts the operation of the command may be inserted as a suffix to the public command. After all, the public command for Mitsubishi's command 'LIMITP' may be 'mLIMITP'.

In this way, the common command generated by sequentially performing steps 1 to 3 may be converted into an XML (eXtensible Markup Language) file format to build a common command library in the storage unit 12.

An example of the XML file format for this common instruction is shown in FIG. 2. Referring to FIG. 2, the XML file for the common command includes instructions corresponding to each of the Instructio Name 'XIC', 'XICP', and 'XICF' for each PLC manufacturer.

For example, for the common command 'XIC', the command 'XIC' corresponds to AB, and for Mitsubishi's' LD ',' AND 'and' OR ', respectively, and for Siemens' A', ' O 'corresponds and' LOAD ',' AND ', and' OR 'correspond to LS.

After the common instruction library is constructed through the above process, when there is a conversion request to the common format, the operation of the common format converting unit 13 shown in FIG. 3 will be described.

The common format converting unit 13 converts the text-based PLC control program that is requested to be converted into a common format into a common PLC control program, and uses the common command library to read the text-based PLC control program. Convert to a common PLC control program.

As shown in FIG. 3, the common format conversion unit 13 includes an IL object generation unit 14, an IL block generation unit 15, a common block conversion unit 16, and a joint relationship expression unit 17. The text-based PLC control program is converted into the PLC control program of the common format.

The IL object generation unit 14 confirms whether the text-based PLC control program requested for conversion to the common format can be converted to the PLC control program of the common format.

In this case, whether the text-based PLC control program can be converted to the common format can be determined using at least one of a file extension and a data structure of the text-based PLC control program.

For example, whether or not the text-based PLC control program can be converted to a common format is primarily checked for the file extension of the text-based PLC control program.

If the checked file extension corresponds to the set file extension, it is secondly checked whether the data structure of the text-based PLC control program corresponds to the set data structure.

As a result of the check, when the data structure of the text-based PLC control program corresponds to the set data structure, it may be determined that the text-based PLC control program can be converted into a common PLC control program.

In the case of having a data structure other than such a set data structure, the text-based PLC control program cannot be converted into a common PLC control program.

The IL object generation unit 14 performs a rung constituting the control logic of the text-based PLC control program as the text-based PLC control program requested to be converted to the common format can be converted to the PLC control program of the common format. ), At least one contact point is generated as an IL object including a command and a tag, respectively, according to a logic order. That is, the IL object used throughout the present invention is used in the same sense as the contact point.

The IL block generation unit 15 generates at least one IL block by blocking at least one IL object generated by the IL object generation unit 14 using a block command.

In this case, the block instruction includes LD, LDI, ANB, OR, ORB, MPP, MRD, and MPS.

LD is an abbreviation of Load and indicates that the contact point on the control logic is loaded. The LD may continue to produce blocks of control logic of the PLC program.

LDI stands for Load Inverse. It contains Inverse meaning, so the contact is ON when the tag is OFF.

ANB stands for AND Block, indicating that two blocks created before the ANB instruction are in AND relationship with each other.

OR indicates that the symbol preceding the OR command and the symbol of the OR command are ORed together.

ORB stands for OR Block, indicating that two blocks created before the ORB instruction are OR'ed together.

MPS stands for Multi Point Start. When multiple output contacts appear, the first output contact is written to the front of the first output contact and the contacts associated with that output contact.

MRD stands for Multi Read Down and is used when three or more output contacts appear.

MPP stands for Multi Point Period. When multiple output contacts appear, the MPP is written at the front of the last output contact and the contacts associated with that output contact.

At this time, OR, ORB, ANB, MPS, MRD, and MPP among the block commands are combined commands used in the connection relationship expression unit 17. Among these, the combined instruction except the OR instruction includes only the instruction when expressing the IL object, and expresses only the association relationship between each block. Therefore, since the block combining instruction indicating the relationship between the blocks, the instruction of the IL object including the block combining instruction is not converted into the common instruction when the transform unit 16 is executed to the common block.

The IL block generation unit 15 checks whether a block instruction is included in the IL objects while moving the IL objects arranged in the control logic order, and generates a new IL block if the block instructions are included. On the other hand, if the block instruction is not included, the IL object is sequentially included in the previously generated IL block until a new block instruction appears.

The common block converting unit 16 generates a common object by converting the instruction into a common instruction for each of the at least one IL object in the at least one IL block by using the common instruction library, and thus, the at least one IL block. Converts to at least one shared block.

The coupling relationship expression unit 17 expresses the coupling relationship between the at least one shared block by at least one of the symbols "[", "]" and "," using a coupling command.

In this case, the combined instruction may include OR, ORB, ANB, MPP, MPS, and MRD. The combined instructions used for the input (conditional) are OR, ANB and ORB, and the combined instructions used for the output are MPS, MRD and MPP.

Using such a coupling command, the coupling relationship expression unit 17 may express the coupling relationship between the common blocks expressed in the common format with at least one of the symbols "[", "]" and ",". To this end, the coupling relationship expression unit 17 expresses the coupling relationship between the common blocks expressed in the common form according to the coupling instruction used in the input unit (conditional) with at least one of the symbols "[", "]" and "," After that, the coupling relationship between the common blocks represented by the coupling command used in the input unit may be expressed by at least one of the symbols "[", "]" and "," according to the combining command used in the output unit.

In the exemplary embodiment of the present invention, the coupling command used in the input unit is applied to the common blocks expressed in the common format in the order of OR-> ANB-> ORB, and the symbol "[" , "]" And "," can be expressed by at least one. The application of the combined command used in the input unit to the common blocks expressed in the common format in the order of OR-> ANB-> ORB is just one embodiment, but is not limited thereto.

The common blocks represented by the combined command used in the input unit may be applied to the common blocks represented by the combined command used in the input unit in the order of MPS-> MRD-> MPP. The coupling relationship between the two may be expressed by at least one of the symbols "[", "]" and ",". The application of the combined command used in the output unit to the common blocks represented by the combined command used in the input unit in the order of MPS-> MRD-> MPP is just one embodiment and is not limited thereto.

4 is a flowchart of a conversion method to a common format for a text-based PLC control program performed by the common format conversion unit 13.

Referring to FIG. 4, the IL object generating unit 14 converts the control logic of the text-based PLC control program as the text-based PLC control program requested to be converted into a common format can be converted into a PLC control program of the common format. For each rung, at least one contact point is generated as an IL object including a command and a tag, respectively, in a logic order (S71).

The IL block generation unit 15 generates at least one IL block by blocking the at least one IL object by using a block command. This may correspond to steps S72 to S76 in FIG. 4.

That is, the IL block generation unit 15 sequentially extracts the IL object from the IL object list (S72), until the final IL object of the rung (S73) is assigned to the block instruction 'LD, AND, Check whether OR, ORB, MPP, MRD, and MPS 'are included (S74), and if so, create a new IL block (S75), and if not, insert the IL object into the most recently generated IL block. Repeat (S76).

The common block converting unit 16 generates a common object by converting an instruction into a common instruction for each of at least one IL object in the at least one IL block by using a common instruction library to generate the at least one IL block. At least one common block is converted (S77).

The coupling relationship expression unit 17 expresses the coupling relationship between the at least one shared block by at least one of the symbols "[", "]" and "," using a coupling command. This may be performed by steps S78 to S90 in FIG. 4.

That is, the coupling relationship expression unit 17 sequentially extracts the public blocks shown in FIG. 8 (S78), and checks whether the extracted public block is the last public block (S79).

If the extracted common block is not the last shared block, the association relationship expression unit 17 checks whether the combined instruction ORB or OR is included in the extracted common block (S80). If included, "[", ",", "]" is inserted into the two previous shared blocks (S81).

If the combined common block ORB or OR is not included in the extracted common block, the association relation expression unit 17 checks whether the combined common block ANB is included in the extracted common block (S82). If included, the two preceding public blocks of the extracted common block are pasted (S83).

If the combined common block ANB is not included in the extracted common block, the association relationship expression unit 17 checks whether the combined common block MPS is included in the extracted common block. If included, insert "[" in front of the corresponding common block (S85).

If the joint command MPS is not included in the extracted common block, the association relationship expression unit 17 checks whether the joint command MRD is included in the extracted common block (S86). If included, the "," is inserted in front of the corresponding common block (S87).

If the combined common block MRD is not included in the extracted common block, the association relationship expression unit 17 determines that the combined common block MPP is included in the extracted common block, and inserts "," in front of the corresponding common block. Insert "]" at the rear (S88).

On the other hand, if the common block extracted in step S79 is the last common block, the joint relationship expression unit 17 sequentially merges the common blocks in which the joint relationship is indicated in the common format (S89), and the joint relationship between the merged public blocks. Output the common format indicated by (S90).

FIG. 5A illustrates an example of a PLC control program of an LD structure of Mitsubishi, and FIG. 5B illustrates a text-based PLC control program converted from the PLC control program of FIG. 5A. Hereinafter, the process of converting the text-based PLC control program of FIG. 5B into the common control PLC control program by the above-described common format conversion unit 13 will be described.

The PLC control program of FIGS. 5A and 5B is composed of two rungs, and includes, as instructions, LD, OR, AND, ANI, OUT, LDI, ORB, MPS, MPP, and the like with tags X0, X1, M0. , X3, Y0, X4, X5, X6, X8, X7, X9, X10, Y2 and the like.

FIG. 6 shows IL objects generated by the IL object generator 14 for the first rung and the second rung, respectively. Referring to FIG. 6, the IL objects may be arranged according to the control logic order of the text-based PLC control program illustrated in FIG. 5B. That is, the order of the IL objects is the same as the control logic order of the text-based PLC control program. Specifically, if the order of IL objects is listed in the order of Command, LD, OR, AND, ANI, OUT for the first rung, and LDI, AND, for the second rung. LDI, OR, AND, ORB, AND, MPS, OUT, MPP, ANI, OUT

7A shows IL blocks generated by the IL block generator 15 for the first rung.

Referring to the IL objects of the first rung of FIG. 6 and FIG. 7A, an IL block 1 is generated by a block instruction 'LD' and includes one IL object, that is, an IL object that is an instruction LD.

The IL block 2 is generated by the block instruction 'OR' and includes four IL objects, that is, an IL object that is an instruction OR, an IL object that is an instruction AND, an IL object that is an instruction ANI, and an IL object that is an instruction OUT.

In addition, FIG. 7A illustrates a result of converting IL blocks into shared blocks by the common block converter 16.

First, for the IL block # 1, the common block converting unit 16 converts the IL block # 1 by converting an IL object having an instruction 'LD' into a common object having a common command 'XIC' using the common command library. Convert to shared block # 1. Therefore, the common type of shared block 1 can be expressed as 'XIC (X0)'.

For the IL block # 2, the common block converting unit 16 converts the IL object having the instruction 'OR' into the common object having the common instruction 'XIC' using the common instruction library, and the IL object having the instruction 'AND'. Is converted to a public object with public command 'XIC', IL object with command 'ANI' is converted to a public object with public command 'XIO', and IL object with command 'OUT' is converted to a public object with public command 'OUT' By transforming, the IL block 2 is converted into the 2 common block. Therefore, the common type of shared block 2 can be expressed as 'XIC (X1) XIC (M0) XIO (X3) OUT (Y0)'.

FIG. 7B shows IL blocks generated by the IL block generator 15 for the second rung.

Referring to the IL objects of the second rung of FIG. 6 and FIG. 7B, the IL block # 1 is generated by the block instruction 'LDI' and includes two IL objects, that is, the IL object that is the instruction LDI, and the instruction AND. Contains an IL object.

The IL block 2 is generated by the block instruction 'LDI' and includes one IL object, that is, the IL object which is the instruction LDI.

The IL block 3 is generated by the block instruction 'OR' and includes two IL objects, that is, an IL object that is an instruction OR and an IL object that is an instruction AND.

The IL block 4 is generated by the block instruction 'ORB' and includes two IL objects, that is, an IL object that is an instruction ORB and an IL object that is an instruction AND.

The IL block 5 is generated by the block instruction 'MPS' and includes two IL objects, that is, the IL object which is the instruction MPS and the IL object which is the instruction OUT.

The IL block 6 is generated by the block instruction 'MPP' and includes three IL objects, that is, the IL object which is the instruction MPS, the IL object which is the instruction ANI, and the IL object which is the instruction OUT.

In addition, FIG. 7B illustrates a result of converting IL blocks into shared blocks by the common block converter 16.

First, for the IL block # 1, the common block converting unit 16 converts the IL object having the instruction 'LDI' into a common object having the common instruction 'XIC' using the common instruction library, and has the instruction 'AND' By converting the IL object into a public object with the common instruction 'XIC', the IL block 1 is converted into a public block 1. Therefore, the common type of common block 1 can be expressed as 'XIC (X4) XIC (X5)'.

For the IL block # 2, the common block converting unit 16 converts the IL object having the instruction 'LDI' to a common object having the common instruction 'XIC' using the common instruction library, thereby converting the IL block # 2 twice. Convert to shared block. Therefore, the common type of common block 2 can be expressed as 'XIC (X6)'.

For IL block 3, the common block converting unit 16 converts the IL object having the instruction 'OR' into the common object having the common instruction 'XIC' using the common instruction library, and the IL object having the instruction 'AND'. Converts IL block 3 to public block 3 by converting it to a public object with public command 'XIC'. Therefore, the common type of common block 3 can be expressed as 'XIC (X8) XIC (X7)'.

For the IL block # 4, the common block converting unit 16 does not convert the IL object that is the block combining instruction 'ORB' into the common instruction using the common instruction library, and converts the IL object that is the instruction 'AND' into the common instruction. By converting the shared object to 'XIC', IL block 4 is converted to 4 public blocks. Therefore, the common type of common block 4 can be expressed as 'XIC (X9)'.

For IL block # 5, the common block converting unit 16 does not convert the IL object that is the block combining instruction 'MPS' into the common instruction using the common instruction library, and converts the IL object that is the instruction 'OUT' into the common instruction. Converts IL block 5 to public block 5 by converting it to a public object that is 'OUT'. Therefore, the common type of common block 5 can be expressed as 'OUT (M0)'.

For IL block 6, the common block converting unit 16 does not convert the IL object that is the block combining instruction 'MPP' into the common instruction using the common instruction library, and converts the IL object that is the instruction 'ANI' into the common instruction. The IL block 6 is converted to the common block 6 by converting the IL object of the instruction 'OUT' into an IL object of the common instruction 'OUT'. Therefore, the common type of common block 6 can be expressed as 'XIO (X10) OUT (Y2)'.

When the process of converting the IL blocks into common blocks is completed, by expressing the coupling relationship between the common blocks, the text-based PLC control program is finally converted into a common PLC control program.

In this case, the PLC control program of the common format may be expressed in a common format for at least one rung constituting the control logic of the text-based PLC control program.

In the common rung, at least one point of contact in the text-based rung is represented as a common object including a common instruction and a tag, and the at least one common object is A coupling relationship between at least one common block generated by blocking may be represented by at least one of the symbols "[", "]" and ",". At this time, the symbols "[", "]" represent a coupling point, and the symbol "," represents a branch point.

The association relation representation between these common blocks may be performed by the association relation representation unit 17.

8A is a diagram illustrating a process of expressing a coupling relationship between common blocks by applying a joint instruction OR to the common blocks shown in FIG. 7A in a common format.

Referring to FIG. 8A, the coupling relationship expression unit 17 checks whether the common block shown in FIG. 7A includes a common block including a coupling instruction OR. The coupling relationship between the public block and the two public blocks of the previous public block is expressed using the symbols "[", "]" and ",".

In FIG. 8A, a coupling relationship between a common block 2 including a joint instruction OR and a shared block 1 is expressed using the symbols "[", "]" and ",".

This will be described in more detail. First, a "[" is inserted at the beginning of the common type expression of the common block 1 before the common block 2 including the joint instruction OR (S1).

Next, "," is inserted at the beginning of the common form representation of the common block 2 including the joint instruction OR (S2).

If the next public block of the common block 2 including the combined instruction OR does not include the combined instruction OR, inserts "]" after the common format of the IL object including the OR instruction among the common forms of the current public block 2 (S3). . If the next public block of the current public block containing an OR contains a combined instruction OR, insert "," at the end of the public format of the current public block.

Thereafter, the common type representation of the common block of the first common block and the common block of the second common block, that is, the common format of the first common block, is merged (S4).

Therefore, the common type of the 2nd common block of the first rung becomes '[XIC (X0), XIC (X1)] XIC (M0) XIO (X3) OUT (Y0)'.

FIG. 8B is a diagram illustrating a process of expressing a coupling relationship between common blocks by applying a joint instruction OR to the common blocks shown in FIG. 7B in a common format.

Referring to FIG. 8B, the coupling relationship expression unit 17 checks whether the common block including the coupling instruction OR is present in the common blocks illustrated in FIG. 7B. The coupling relationship between the public block and the two public blocks of the previous public block is expressed using the symbols "[", "]" and ",".

In FIG. 8B, the coupling relationship between the common block 3 and the common block 2 including the combining instruction OR is expressed using the symbols "[", "]" and ",".

This will be described in more detail. First, a "[" is inserted at the beginning of the common type expression of the common block 2 before the common block 3 including the joint instruction OR (S5).

Next, "," is inserted at the beginning of the common format expression of the common block 3 including the combined instruction OR (S6).

If the next public block of the common block 3 including the combined instruction OR does not include the combined instruction OR, inserts "]" after the common format of the IL object including the OR instruction among the common forms of the current public block 3 (S7). . If the next public block of the current public block containing an OR contains a combined instruction OR, insert "," at the end of the public format of the current public block.

Thereafter, the common type representation of the common block of the common block 2 and the common block of the common block 2, that is, the common block of the common block 2, is merged (S8).

FIG. 9 is a diagram illustrating a process of expressing a coupling relationship between common blocks by applying a joint command ORB to common blocks after applying the joint command OR through FIG. 8B.

Referring to FIG. 9, the coupling relationship expression unit 17 checks whether the common block including the coupling instruction ORB is present in the common blocks after applying the coupling instruction OR. Two non-empty public blocks in front of the public block including the included public block and the joint instruction ORB are used to express the association relationship to the public blocks.

That is, the association relationship expression unit 17 inserts "[" at the beginning of the common format expression of the first public block of the first non-empty public blocks of the two non-empty public blocks in front of the common block ORB. (S9).

Next, the association relationship unit 17 adds "," to the beginning of the common type representation of the third common block, which is the second common block of the two non-empty common blocks before the fourth common block including the joint instruction ORB. Insert (S10).

In addition, the association relationship expression unit 17 checks whether the public block including the association instruction OR and the common block including the association instruction ORB exist in the public block after the fourth common block including the association instruction ORB, and only when it does not exist. Insert "]" at the beginning of the common type representation of the common block 4, including the combined instruction ORB (S11).

Thereafter, the joining relation expression unit 17 merges the first public block and the third public block into the fourth public block with the lowest number among the first public block, the third public block, and the fourth public block, and then merges the fourth public block. The public object including the combined instruction ORB is deleted from the public block (S12).

Therefore, the common type of shared block 4 of the second rung is '[XIC (X4) XIC (X5), [XIO (X6), XIC (X8)] XIC (X7)] XIC (X9)'. do.

10 is a view showing a result of applying the combined command MPS used in the output unit.

Referring to FIG. 10, the association relationship expression unit 17 checks whether there is a common block including the combined instruction MPS, and inserts "[" in front of the common form representation of the corresponding common block if there is a shared block including the combined instruction MPS. (S13).

That is, the association relation expression unit 17 inserts "[" at the beginning of the common format representation of the common block 5 including the association instruction MPS.

Therefore, the common format of the 5th common block of the second rung is '[OUT (M0)'.

11 is a view showing a result of applying the combined command MPP used in the output unit.

Referring to FIG. 11, the association relationship expression unit 17 checks whether there is a common block including the combined instruction MPP, and if there is a shared block including the combined instruction MPP, inserts "," at the beginning of the common form representation of the corresponding common block. And inserting "]" at the end of the common format expression of the corresponding common block (S14).

That is, the association relationship expression unit 17 inserts "," at the front and "]" at the front of the common format representation of the common block 6 including the association instruction MPP.

Therefore, the common type of common block 6 of the second rung is ', XIO (X10) OUT (Y2)]'.

FIG. 12 shows common formats of common blocks represented through FIGS. 9 through 11 for the second rung. Referring to FIG. 12, when the common formats of the 4th, 5th and 6th common blocks are merged in order, the final common format for the second rung is obtained.

So the final common format for the second rung is '[XIC (X4) XIC (X5), [XIO (X6), XIC (X8)] XIC (X7)] XIC (X9) [OUT (M0)' , XIO (X10) OUT (Y2)] '.

FIG. 13 shows a final common format for the first rung N0 and the second rung N5 converted from the text-based PLC control program of FIG. 5B through the above process.

Referring back to FIG. 1, the following describes a process of converting a PLC control program of a common format output from the common format conversion unit 13 into structure data by the class library construction unit 21 and the structure generation unit 22. .

The class library construction unit 21 is different from the rungs, input contacts, output contacts, tags for the PLC control program, and the corresponding input contact or output contact for each input contact or output contact. Constructs and stores a class library including relation classes, which are classes representing relations with input contacts or output contacts.

14 shows the structure of a class library constructed by the class library constructing unit 21. Referring to FIG. 14, the class library includes 'StepS' representing a set of all 'Steps' as a top-level class, and a rung of the PLC control program as a subclass of 'StepS' (the logic of the PLC control program). 'Step' which represents the constituent unit), 'CoilS' which represents the set of all 'Coil' as a subclass of 'Step', and 'C' which indicates the output contact which belongs to the rung as a subclass of 'CoilS'. Coil ',' ContactS 'representing the set of all' Contacts' as a subclass of 'Step', 'Contact' representing the input contacts belonging to the rung as a subclass of 'ContactS', and 'Coil' Or 'Relation' as a subclass of 'Contact' to express the relationship between the corresponding input or output contact and other input or output contacts, and as a subclass of 'Coil' or 'Contact' As a "Tag" that represents a tag It is sex.

15A to 15E illustrate data field structures of a 'Step' class, a 'Coil' class, a 'Contact' class, a 'Relation' class, and a 'Tag' class, respectively.

Referring to FIG. 15A, a 'Step' class has a step key, a unique identifier of a corresponding 'Step', a Program, a name of a PLC control program, and a Step Index, an index of the 'Step', as a data field. It has 'CoilS' and 'ContactS'. Step key can consist of the name and rung number of the PLC control program. For example, if the name of the PLC control program is 'Main', the step index for the rung number '0' can be 'Main.0' and the step index for the rung number '5' can be 'Main.5'. . The rung number can be used as the step index.

Referring to FIG. 15B, the 'Coil' class has a command which is a command for a corresponding output contact as a data field, an Index which is a unique index in a corresponding Step, and has a 'Tag' and a 'Relation' as a subclass.

Referring to FIG. 15C, the 'Contact' class has a command which is a command for a corresponding input contact as a data field, an Index which is a unique index in a corresponding Step, and has a 'Tag' and a 'Relation' as subclasses.

Referring to FIG. 15D, the 'Relation' class is a data field based on a corresponding contact or coil, and includes a previous contact, a previous contact index, a previous coil, a previous coil, a next contact index, and a next contact. It has Next Coil which is the index of Coil of.

Referring to FIG. 15E, the 'Tag' class has a data field as an address of a corresponding tag and a description as a description of the corresponding tag.

Referring back to FIG. 1, the structure generation unit 22 receives a PLC control program of a common format from the common format conversion unit 13, and based on the class library constructed by the class library construction unit 21, Rungs, input contacts, output contacts, objects for tags, and other input contacts or outputs different from the corresponding input contact or output contact for each input contact or output contact of the PLC control program of the common type. Structure data including a relationship object, which is an object representing a relationship with a contact point, is formed, and a PLC control program in the form of a structure is output.

Hereinafter, a process in which the structure generation unit 22 generates structure data from the PLC control program of the common format will be described using the PLC control program of the common format shown in FIG. 13 as an example. Referring to FIG. 13, a PLC control program of a given common type is composed of two rungs, so there are two steps.

16 shows a specific configuration of the structure generation unit 22 according to an embodiment of the present invention. The structure generator may include an index generator 23, an object generator 24, and a relationship generator 25.

The index generator 23 internally assigns an index to each contact included in the corresponding rung for each rung (ie, one sentence or line) of the common PLC control program. The index may be sequentially assigned to the contacts, for example, with integers of zero or more. These indices are used by the relationship forming unit 25 to be described later to express the relationship between the contacts.

FIG. 17 shows an example of the indices given to the contacts for the PLC control program of the common type shown in FIG. Referring to FIG. 17, the five contacts XIC (X0), XIC (X1), XIC (M0), XIO (X3) and OUT (Y0) of the first (zero) rung are respectively 0, 1, 2, Index of 3, 4 is given, 9 contacts of the second (5th) rung XIC (X4), XIC (X5), XIO (X6), XIC (X8), XIC (X7), XIC (X9) , OUT (M0), XIO (X10), and OUT (Y2) are given indices of 0, 1, 2, 3, 4, 5, 6, 7, and 8, respectively.

The object generator 24 divides the contacts of the command (Tag) type of the PLC control program of the given common type into an input contact and an output contact, and is given by the index generator 23. Reflecting the index, a step object, a contact object, a coil object, a tag object, a relation object, and the like are generated based on the class library. Step object, Contact object, Coil object, Tag object, and Relation object correspond to Step class, Contact class, Coil class, Tag class, Relation class of class library, respectively.

The criteria for dividing the contacts into input contact and output contact is made by 'Command' in the form of 'Command (Tag)'. For example, 'Command' corresponding to the input contact point is a common command corresponding to the input such as XIC, XIO, AFI, INV, MEP, MEF, EGP, EGF, EQU, GEQ, GRT, LEQ, LES, MEQ, LIM, Including CMP, 'Command' corresponding to the output contact is the common command corresponding to the output, OUT, SET, RST, MOV, TON, TOFF, RTO, TMR, CTU, CTD, UDCNT, MCR, FOR, NEXT, Includes BREAK, LABEL, RET, CJ, SCJ, CALL, JMP, SBRT, FROM, TO, and more. Here, 'Command' for the distinction between input contact and output contact is a parameter qualifier (eg Double Word: D, Block: BK) or operation qualifier (eg Positive Pulse: P, Negative). Also included are common commands combined with Pulse: N).

Referring to FIG. 17, XIC (X0), XIC (X1), XIC (M0), and XIO (X3) correspond to an input contact and OUT (Y0) corresponds to an output contact in a first rung. Corresponds to In the second (5th) rung, XIC (X4), XIC (X5), XIO (X6), XIC (X8), XIC (X7), XIC (X9), and XIO (X10) correspond to the input contacts and OUT ( M0) and OUT (Y2) correspond to output contacts.

FIG. 18 illustrates examples of objects generated from a PLC-type control program of a common type indexed as shown in FIG. 17 based on the class libraries of FIGS. 14 and 15. Referring to FIG. 18, Step 0 has a Step key, a Program, and a Step Index of Main.0, Main, and 0, respectively, and have four Contact objects and one Coil object. For example, a Contact object with an index of 0 has a command of 'XIC', and a Tag object belonging to it has an Address of X0 and a Description of IN0.

In Step 5, Step key, Program, and Step Index are Main.5, Main, and 5, respectively, and have 7 Contact objects and 2 Coil objects. For example, a Contact object with an index of 2 has a command of 'XIO', and a Tag object belonging to it has an Address of X6 and a Description of IN6.

Referring to FIG. 18, it can be seen that all data fields are defined except a Relation object. Therefore, the data fields of each Contact object and the Relation object belonging to each Coil object (see FIG. 15D), that is, Previous Contact, Previous Coil, Next Contact, or Next Coil, are defined. For an input contact or an output contact, this corresponds to defining a relationship between the corresponding contact or output contact and another input or output contact.

FIG. 19 illustrates a PLC control program in which the common type PLC control program with an index is expressed in the form of an object as shown in FIG. 17. Referring to FIGS. 17 and 19, an input contact is represented by 'I', an output contact is represented by 'O', and an index is represented by a subscript.

20 shows a specific configuration of the relationship forming unit 25 according to an embodiment of the present invention. The relationship forming unit 25 may include a relationship block generating unit 26, an in-step relationship forming unit 27, and an relationship block forming unit 28.

The common type PLC control program according to an embodiment of the present invention includes symbols "[", "]" and "," representing a coupling relationship, and has a common type structure beginning with "[" and ending with "]". Is defined as a 'Relation Block'. The relationship block generator 26 generates such a relationship block. The inner elements of the relation block are combined in an OR relationship, and the criteria for distinguishing the inner elements is ",". In some cases, a relation block may exist inside the relation block (for example, referring to FIG. 19, '[I ₀ I ₁ , [I ₂ , I ₃ ] I ₄ ]' of N5 Step).

The relation block generation unit 26 may express the relation block to be generated as "RBK" and assign an index to each relation block in Step. For example, in N0 Step, the relation block [I ₀ , I ₁ ] can be represented by RBK ₀ . Then, N0 Step is expressed as 'RBK ₀ I ₂ I ₃ O ₄ ' as shown in FIG.

In-step relationship forming unit 27 defines a relationship with other contacts (or relationship blocks) with respect to the contacts (or relationship blocks) in Step. Specifically, the intra-step relationship forming unit 27 defines a previous contact, previous coil, next contact, or next coil of a relation object belonging to each contact or relationship block in the step. In this case, if the index to be included in the previous contact, previous coil, next contact, or next coil belongs to the relation block, 'R' may be indicated before the index to indicate the relation block. When defining Previous Contact, Previous Coil, Next Contact, or Next Coil of one contact (or relation block), if Next Contact or Next Coil is defined, Previous Contact, Previous Coil of the next contact (or relation block) should correspond to it. Can be defined automatically.

22 shows the result of defining the relationship between the contacts (or the relationship block) for the NO step.

21 and 22, since the next contact of RBK ₀ is I ₀ , that is, an input contact, the Next Contact field of RBK ₀ is defined as '2'. Correspondingly, the Previous Contact field of I ₂ is defined as R 0. Since the next contact of I ₂ is I ₃ , that is, the input contact, the Next Contact field of I ₂ is defined as '3', and the Previous Contact field of I ₃ is defined as '2'. Since the next contact of I ₃ is O ₄ , that is, the output contact, the Next Coil field of I ₃ is defined as 4, and correspondingly, the Previous Contact field of O ₄ is defined as '3'.

The relationship forming unit 28 in the relationship block defines a relationship with other contacts (or relationship blocks) with respect to the contacts (or relationship blocks) included in the relationship block. Specifically, the relationship forming unit 28 in the relationship block defines a previous contact, previous coil, next contact, or next coil of a relation object belonging to each contact or relationship block in the relationship block. If there is a relation block in the relation block, first define the relation to the contacts (or relation blocks) of the outer relation block. Since the internal elements of the relationship block are combined in an OR relationship, the relationship forming unit 28 in the relationship block may distinguish the internal elements based on ",". Each inner element may be referred to as OR ₁ , OR ₂ , ..., OR _n for convenience. 23 shows a format in which the relationship block is divided into internal elements.

FIG. 24A illustrates a result of applying RBK ₀ illustrated in FIG. 22 to the format of FIG. 23. Referring to FIGS. 21 and 22, since RBK ₀ = [I ₀ , I ₁ ], RBK ₀ has I ₀ and I ₁ as internal elements, and Next Contact is an index '2'. Accordingly, as shown in FIG. 24A, a Relation object of I ₀ is included in OR ₁ , a Relation object of I ₁ is included in OR ₂ , and Next Contact is represented by an index '2'.

In the form of dividing a relationship block into internal elements, the Previous Contact or Previous Coil of the relationship block becomes the Previous Contact or Previous Coil of the first (ie leftmost) contact that is placed for every internal element. Also, the next contact or next coil of the relation block becomes the next contact or next coil of the last (ie rightmost) contact point for all internal elements. Of course, if the internal element consists of one contact, the contact becomes the first and last contact (in the case of Fig. 24).

Referring to FIG. 24A, since RBK ₀ has the next contact as the index '2', as shown in FIG. 24B, both the contact I _{0 of the} OR1 and the contact I _{1 of the} OR2 are defined as the index '2'.

When a relationship with another contact is defined for the contacts included in the relationship block, the relationship forming unit 28 in the relationship block selects the relationship block from the result of defining the relationship between the contacts (or relationship block) for the step. Replace with the contacts included therein. In this process, the relationship forming part 28 in the relationship block is defined as 'R #' by the relationship forming part 27 in the step. ) Is redefined as a relation with the contact point included in the relation block. Here, the contact point that has the relationship block as Previous Contact or Previous Coil, the index of the last contact point is defined as Previous Contact or Previous Coil for all internal elements of the relationship block, and the relationship block is called Next Contact or Next Coil. For each contact, the index of the first contact is defined as Next Contact or Next Coil for all internal elements of the relation block.

For example, in the result of defining a relationship between RBK ₀ , I ₂ , I ₃ , and O ₄ with respect to N0 Step as shown in FIG. 22, when RBK ₀ is replaced with the contacts I ₀ and I ₁ (see FIG. 24B) included therein, It becomes the form similar to FIG. 22 and 24, since I ₂ has RBK ₀ as a previous contact and the last contact point of all internal elements of RBK ₀ is I ₀ and I ₁ , the previous contact of I ₂ is shown in FIG. 25. Overridden to '0, 1'.

FIG. 25 illustrates a result in which all of the relationships between the corresponding input contact or output contact and another input contact or output contact are expressed with respect to each input contact or output contact of the NO step.

Hereinafter, a process of expressing a relationship between the corresponding input contact or output contact and another input contact or output contact for each input contact or output contact of N5 Step by the relationship forming unit 25 will be described.

In N5 Step, between blocks is represented by the _{RBK 0 [I 0 I 1,} [I 2, I 3] I 4], the relationship block in the _{RBK 0 [I 2, I 3} ] is represented by RBK _1, between the block [O ₆ , I ₇ O ₈ ] may be represented by RBK ₂ . Then, as shown in FIG. 26, N5 Step is expressed as 'RBK ₀ I ₅ RBK ₂ (where RBK ₀ = [I ₀ I ₁ , RBK ₁ I ₄ ], RBK ₁ = [I ₂ , I ₃ ])'.

27 shows a result of defining a relationship between contacts (or a relationship block) for N5 Step.

Referring to FIGS. 26 and 27, since the next contact of RBK ₀ is I ₅ , that is, an input contact, the Next Contact field of RBK ₀ is defined as '5', and the Previous Contact field of I ₅ is correspondingly defined as R0. . Since the next contact of I ₅ is RBK ₂ , the Next Contact field of I ₅ is defined as 'R2', and the Previous Contact field of RBK ₂ is defined as '5'.

FIG. 28 shows the results of applying RBK ₀ and RBK ₁ shown in FIG. 27 to the format of FIG. 23.

In FIG. 26 and FIG. 27, since RBK ₀ = [I ₀ I ₁ , RBK ₁ I ₄ ], RBK ₀ has I ₀ I ₁ and RBK ₁ I ₄ as internal elements, and Next Contact is index '5'. Therefore, as shown in FIG. 28, a Relation object of I ₀ I ₁ is included in OR ₁ , and a Relation object of RBK ₁ I ₄ is included in OR ₂ , and Next Contact is represented by an index '5'. Also, because RBK ₁ = [I ₂ , I ₃ ], RBK ₁ has I ₂ and I ₃ as internal elements, and Next Contact is index '4'. Therefore, as shown in FIG. 28, a relation object of I ₂ is included in OR ₁ , a relation object of I ₃ is included in OR ₂ , and the next contact is represented by an index '4'.

Also within RBK _0, then the contact of the I ₀ is defined as a "1" Next Contact field of the I ₀ Since I _1, I correspond be defined as _one of the Previous Contact field is '0' it. Since the next contact of RBK ₁ is I ₄ , the Next Contact field of RBK ₁ is defined as '4' and the Previous Contact field of I ₄ is defined as 'R1'. RBK ₀ is Next Contact index "5" Because this Next Contact of I ₁ contacts placed at the end of the OR1 is defined as a '5', the last Next Contact the junction of I ₄ is placed in OR2 also '5' Is defined as

In addition, since RBK ₁ has the next contact as the index '4', the next contact is defined as the index '4' for both the contact I _{2 of} OR1 and the contact I _{3 of} OR2.

FIG. 29 shows a result of replacing RBK ₁ in RBK ₀ with I ₂ and I ₃ included in the contacts in FIG. 28. In this process, since I ₄ has RBK ₁ as a previous contact and the last contact point of all internal elements of RBK ₁ is I ₂ and I ₃ , as shown in FIG. 29, the previous contact of I ₄ is '2, 3'. To be redefined.

Figure 30 shows the results of replacing with a, the relationship between the contact point included in the definition RBK _0, i.e. ₀ RBK of the RBK 29 ₀ of Fig. When 27 and FIG. 29, I ₅ has a RBK ₀ to RBK ₀ to Previous Contact and the RBK Since the last contact point of all the internal elements of ₀ I ₁ and I _4, as shown in Fig. 30 I ₅ Previous Contact is redefined as '1, 4.'

FIG. 31 shows a result of applying RBK ₂ shown in FIG. 27 to the format of FIG. 23. In FIG. 26 and FIG. 27, since RBK ₂ = [O ₆ , I ₇ O ₈ ], RBK ₂ has O ₆ and I ₇ O ₈ as internal elements, and Previous Contact is '5'. Therefore, as shown in FIG. 31, a Relation object of O ₆ is inserted into OR ₁ , and a Relation object of I ₇ O ₈ is contained in OR ₂ , Previous Contact is represented by index '5'.

Also, in RBK ₂ , since the next contact of I ₇ is O ₈ , the Next Coil field of I ₇ is defined as '8', and correspondingly, the Previous Contact field of O ₈ is defined as '7'. RBK ₂ is because the Previous Contact index "5", the contact O ₆ placed at the beginning of the OR1 Previous Contact is defined as a '5', the contacts I ₇ placed at the beginning of the OR2 Previous Contact is also defined as a '5' do.

Figure 32 shows the results of replacing with a, the relationship between the contact point included in the definition RBK _2, i.e. RBK ₂ of the RBK ₂ of Fig. 30 Fig. 31. 30 and 31, since I ₅ has RBK ₂ as a next contact and the first contact point of all internal elements of RBK ₂ is O ₆ and I ₇ , the next contact of I ₅ as shown in FIG. 32. Is redefined to '7' and Next Coil to '6'.

FIG. 33 is structure data finally generated through the above process, in which the relations are defined in the objects of FIG. 18 for each contact point of N0 Step as shown in FIG. 25 and each contact point of N5 Step as shown in FIG. Represents the structure data that reflects the result of defining relations.

34 is a flowchart of a method of converting a common PLC control program into structure data according to an embodiment of the present invention. The method according to the present embodiment consists of the steps processed in the structure data converting apparatus described above. Therefore, even if omitted below, the above description of the structure data converting apparatus also applies to the method according to the present embodiment.

In step 110, the common instruction library building unit 11 constructs a common instruction library by generating common instructions for instructions used in text-based PLC control programs having different formats.

In step 120, the class library building unit 21 includes a class library including a rung of the PLC control program, a class for an input contact, an output contact, and a class for expressing a relationship between a corresponding contact and another contact for each contact. Build.

In step 130, the common format converting unit 13 converts the text-based PLC control program into a common PLC control program using the common command library.

In step 140, the structure generating unit 22 establishes a relationship between the rung, the input contact and the output contact of the PLC control program of the common type, the corresponding contact for each contact, and the other contact, based on the class library. Create structure data containing the objects to represent.

Combinations of each block of the block diagrams and respective steps of the flowcharts attached to the present invention may be performed by computer program instructions. These computer program instructions may be mounted on a processor of a general purpose computer, special purpose computer, or other programmable data processing equipment such that instructions executed through the processor of the computer or other programmable data processing equipment may not be included in each block or flowchart of the block diagram. It will create means for performing the functions described in each step. These computer program instructions may be stored in a computer usable or computer readable memory that can be directed to a computer or other programmable data processing equipment to implement functionality in a particular manner, and thus the computer usable or computer readable memory. It is also possible for the instructions stored in to produce an article of manufacture containing instruction means for performing the functions described in each block or flowchart of each step of the block diagram. Computer program instructions may also be mounted on a computer or other programmable data processing equipment, such that a series of operating steps may be performed on the computer or other programmable data processing equipment to create a computer-implemented process to create a computer or other programmable data. Instructions that perform processing equipment may also provide steps for performing the functions described in each block of the block diagram and in each step of the flowchart.

In addition, each block or step may represent a portion of a module, segment or code that includes one or more executable instructions for executing a specified logical function (s). It should also be noted that in some alternative embodiments, the functions noted in the blocks or steps may occur out of order. For example, the two blocks or steps shown in succession may in fact be executed substantially concurrently or the blocks or steps may sometimes be performed in the reverse order, depending on the functionality involved.

The above description is merely illustrative of the technical idea of the present invention, and those skilled in the art to which the present invention pertains may make various modifications and changes without departing from the essential characteristics of the present invention. Therefore, the embodiments disclosed in the present invention are not intended to limit the technical idea of the present invention but to describe the present invention, and the scope of the technical idea of the present invention is not limited by these embodiments. The scope of protection of the present invention should be interpreted by the following claims, and all technical ideas falling within the scope of the present invention should be construed as being included in the scope of the present invention.

Claims (16)

A class library construction unit for constructing a class library including classes for each of a rung, an input contact, and an output contact of the PLC control program; And Receives a common PLC control program converted from a text-based PLC control program, and includes objects for the rung, input contact, and output contact of the PLC control program of the common format based on the class library. Characterized in that it comprises a structure generating unit for generating structure data to Device for converting PLC control programs into structure data. The method of claim 1, The class library further includes a relationship class for representing a relationship between a corresponding input contact or output contact for each input contact or output contact and at least one other input contact or output contact, The structure data may further include a relationship object representing a relationship between a corresponding input contact or output contact for each input contact or output contact of the PLC control program of the common format and at least one other input contact or output contact. Made, Device for converting PLC control programs into structure data. The method of claim 2, The relationship class and the relationship object is a data field, and has a data field for representing a previous input contact, a previous output contact, a next input contact, or a next output contact based on the corresponding input contact or output contact. Device for converting PLC control programs into structure data. The method of claim 3, The structure generation unit, An index generator for assigning an index to each contact included in the corresponding rung for each rung of the common type PLC control program; An object generation unit for generating an object and a relationship object for each of a rung, an input contact and an output contact of the PLC control program of the common type by reflecting the given index based on the class library; And And a relationship forming unit defining the data field of the relationship object. Device for converting PLC control programs into structure data. The method of claim 4, wherein The relationship forming unit may define an index of a previous input contact, a previous output contact, a next input contact, or a next output contact as the data field. Device for converting PLC control programs into structure data. The method of claim 4, wherein The common type PLC control program includes a symbol representing an OR coupling relationship, The relationship forming unit, By using the symbol representing the OR coupling relationship, the common type combined in the OR relationship in the PLC control program of the common type is a relation block. The relation block is based on the corresponding relation block. A relation block generating unit for defining an input contact or a data field for representing the next output contact; An in-step relationship forming unit defining, for each rung of the PLC control program of the common type represented by the relationship block, the data field for the relationship block, the input contact point, and the output contact constituting the rung; And And a relationship forming unit in a relationship block defining the data field with respect to the contacts included in the relationship block. Device for converting PLC control programs into structure data. The method of claim 6, The relationship forming unit in the relationship block may distinguish internal elements coupled in an OR relationship in the relationship block, and may include at least one input contact included in the internal elements based on the data field defined for the relationship block, or Defining the data field of the output contact, Device for converting PLC control programs into structure data. The method of claim 6, The relationship forming unit in the relationship block, On the basis of the data field defined for the contacts included in the relationship block, characterized in that to redefine the data field of the previous or next input contact or output contact of the relationship block, Device for converting PLC control programs into structure data. Building a class library including classes for each of a rung, an input contact, and an output contact of the PLC control program; And Receives a common PLC control program converted from a text-based PLC control program, and includes objects for the rung, input contact, and output contact of the PLC control program of the common format based on the class library. Characterized in that it comprises the step of generating the structure data, How to convert PLC control program into structure data. The method of claim 9, The class library further includes a relationship class for representing a relationship between a corresponding input contact or output contact for each input contact or output contact and at least one other input contact or output contact, The structure data may further include a relationship object representing a relationship between a corresponding input contact or output contact for each input contact or output contact of the PLC control program of the common format and at least one other input contact or output contact. Made, How to convert PLC control program into structure data. The method of claim 10, The relationship class and the relationship object is a data field, and has a data field for representing a previous input contact, a previous output contact, a next input contact, or a next output contact based on the corresponding input contact or output contact. How to convert PLC control program into structure data. The method of claim 11, Generating the structure data, Assigning an index to each contact included in the corresponding rung for each rung of the common type PLC control program; Generating an object and a relationship object for each of a rung, an input contact and an output contact of the PLC control program of the common type by reflecting the given index based on the class library; And Defining the data field of the relationship object, How to convert PLC control program into structure data. The method of claim 12, The defining of the data field may include defining an index of a previous input contact, a previous output contact, a next input contact, or a next output contact as the data field. How to convert PLC control program into structure data. The method of claim 12, The common type PLC control program includes a symbol representing an OR coupling relationship, Defining the data field, (a) Using a symbol representing the OR coupling relationship, the common type coupled in an OR relationship in the PLC control program of the common type is a relation block. The relation block is a previous input contact or a previous output based on the relation block. Defining a data field for representing a contact, a next input contact, or a next output contact; (b) defining, for each rung of the PLC control program of the common format represented by the relationship block, the data field for the relationship block, the input contact point and the output contact point constituting the rung; And (c) defining the data field with respect to the contacts included in the relation block. How to convert PLC control program into structure data. The method of claim 14, In step (c), the internal elements coupled in the OR relationship in the relationship block are distinguished, and at least one input contact or output included in the internal elements based on the data field defined for the relationship block. Defining the data field of a contact; How to convert PLC control program into structure data. The method of claim 14, The step (c) includes the step of redefining the data field of the previous or next input contact or output contact of the relation block based on the data field defined for the contacts included in the relation block. Characterized in that, How to convert PLC control program into structure data.

Images