JPH1124905A - Program developing method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program developing method for adding a new instruction without changing an existed editor, facilitating the change of a function and the enlargement of the function, and generating a program which directly contains a function peculiar to execution environment in different developing environment. SOLUTION: At the time of developing a program containing a special instruction which is not registered in an editor 1, a special instruction is mentioned in the editor 1 by adding a specified identifier to the existing instruction. When an element in the program outputted from the editor 1 applies to the identifier displayed in a conversion rule 4, the element is converted based on the conversion rule 4 by using the conversion rule 4 in which the specified identifier is set to be a keyword showing the special instruction. In the conversion rule 4, the specified identifier is set as the keyword and a specified function and the number of arguments are registered as attributes on the keyword.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for developing a program.
LC (Programmable Logic Con)
The present invention relates to a method of developing a ladder program or the like used as a program such as a program (controller), and more particularly to an improvement in extensibility of a development and execution environment.

[0002]

2. Description of the Related Art Conventionally, in a program development environment, all usable instructions in a programming language to be used must be registered in an editor of the programming language, and specifications such as adding instructions and changing arguments are changed. Attempting to modify the editor was necessary. When an instruction is added or an argument is changed, a graphic display or the like often needs to be changed accordingly. Such a change of the graphic display is a complicated operation. Generally, in these environments, when the specification of an instruction changes frequently, such as a test of a new instruction, it takes more time to modify the editor than to test the developed program itself.

For example, FIG. 7 shows a change in a graphic display area when a special instruction is inserted.
7A shows a display before the special instruction is inserted, and FIG. 7B shows a display after the special instruction is inserted. Here, X1, X2, Y
1, Y2 are existing instructions in the editor, and the special instruction 'A
The DD 'instruction has three arguments. For example, the argument A is set to IN1.
, An argument B as an IN2 terminal, and an argument C as an OUT terminal. FIG. 8 shows a change in the area required for graphic display when the number of arguments is different, and FIG. 8A shows the display of the instruction “ADD” when there are three arguments, and FIG. ) Is the instruction 'NO when there is no argument
The display of T 'is shown.

As shown in FIGS. 7 and 8, when an unregistered special instruction is added to the editor or the number of arguments changes, the size of the area required for graphic display changes. Since the size of the element to be displayed differs according to each of the instructions, when editing the editor, the display must be rewritten according to the element to be displayed, and a complicated editor correction work is required.

[0005]

As described above, in the conventional program development method, all instructions that can be used in developing a program need to be registered in the editor. When changing the specification of an instruction, the editor first had to be modified. In addition, when the size of the display symbol is changed for each terminal or function, the display interval changes due to the insertion or deletion of the display symbol. For example, a complicated operation of recalculating the display position when displaying on the CRT is required. Was needed.

Further, the conventional development environment is closely connected to the execution environment, and a program that directly includes a function unique to each execution environment can be developed only in the development environment corresponding to the execution environment. Could not be created in the development environment.

SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and it is possible to add a new instruction without changing an existing editor, and to easily change or extend a function. It is an object of the present invention to provide a method for developing a program that can create a program directly including functions specific to an execution environment in different development environments.

[0008]

According to a first aspect of the present invention, there is provided a program development method for developing a program including a special instruction which has not been registered in an editor, the special instruction being assigned to a specific identifier of an existing instruction in the editor. And describe it,
When using a conversion rule with a specific identifier as a keyword representing a special instruction, and an element in the program output from the editor corresponds to the identifier represented in the conversion rule,
This element is converted based on a conversion rule.

Further, in the method for developing a program according to the second configuration of the present invention, the conversion rule in the first configuration includes a specific identifier as a keyword and a specific function and the number of arguments for the keyword as attributes. You have registered,
When an element in a program output from the editor corresponds to a keyword, the element is converted into a function registered in a conversion rule.

In a third aspect of the present invention, in the method for developing a program according to the first or second aspect, the program is a ladder program.

The program development method according to a fourth configuration of the present invention is characterized in that, in the third configuration, when a special instruction is described as an existing instruction in an editor, the existing instruction is described at an output terminal. Is what you do.

[0012]

BEST MODE FOR CARRYING OUT THE INVENTION

Embodiment 1 FIG. Hereinafter, a method for developing a program according to the first embodiment, for example, a method for developing a ladder program will be described. FIG. 1 is a flowchart showing a development procedure using the ladder program development method according to the present embodiment.

FIG. 2 is a block diagram showing the overall configuration of a ladder program development and execution environment using the program development method according to the present embodiment. In FIG. 2, 1 is a ladder editor, 2 is a rule conversion filter, 3
Is an execution environment, 4 is a conversion rule, 5 is an A system for developing a ladder program, and 6 is a B system for executing a program developed with the ladder program. The ladder editor 1 belongs to the A system, and the execution environment 3 belongs to the B system.

Hereinafter, a specific example in the case of developing a program based on FIGS. 1 and 2 will be described. Here, the system for developing the ladder program (A system 5) and the system for executing the ladder program (B system 6) are assumed to be different. In the program, as a special instruction not registered in the ladder editor 1 of the A system 5, 'ADD 'Command. The 'ADD' instruction has three arguments A, B, and C.

First, in step ST1, a program for a device is developed using a ladder program. At this time, A
An 'ADD' command and its argument that are not registered in the ladder editor 1 belonging to the system 5 are described, for example, as shown in FIG. In FIG. 3, 'IN'11 and' OU '
T'16 is an existing instruction in the ladder editor 1, and the new instruction 'ADD'is'ADD'12,'A'13,'
B'14, 'C'15, input terminal'IN'11
Are described as the same instruction as above, and for example, a name is given as a specific identifier as shown in the figure. As a result of editing by the ladder editor 1, an intermediate program is output.

FIG. 4 is an output example showing an intermediate program edited and output by the ladder editor 1 of the program shown in FIG. That is, the 'ADD' instruction and the three arguments are respectively the existing instruction 'AN' of the ladder editor 1.
It is output as D 'and has been edited to an existing instruction' AND 'as in text 21.

In the intermediate program output by the A system 5, a new 'ADD' instruction is temporarily created as another instruction (AND). Therefore, in step ST2, a conversion rule 4 for editing a new special instruction is created, and a rule conversion filter 2 for editing an “ADD” instruction, which is a special instruction, is created based on the conversion rule 4. The conversion rule 4 arbitrarily associates a specific identifier as a keyword representing a special instruction with a specific function and attribute, and a specific example is shown in FIG.
Specifically, the number of keywords and arguments and the conversion code ({1,
2,. . . Represents the name of the terminal following the keyword).

In step ST3, the intermediate program is converted by the rule conversion filter 2 and the program B is output. When the intermediate program shown in FIG. 4 is edited based on the conversion rule shown in FIG. 5 by the rule conversion filter 2,
It is converted as shown in FIG. That is, “ADD” in FIG.
Is recognized as a keyword in the conversion rule 4 of, and CALL ADD ($ 1, $ 2, $ 3) is converted as a corresponding conversion code. At the same time, the arguments are recognized and converted into CALL ADD (A, B, C) as shown in the text 22, and a program B is generated as shown in FIG. This program B can be executed by the B system 6, and is executed in step ST4.

A system 5 which is a program development environment
And a B-system 6, which is an execution environment, is different from the B-system 6. Therefore, there is no inherent compatibility with a program including a special instruction which is a system-dependent code of the execution environment. In the present embodiment, the intermediate program output by the ladder editor 1 is a program that can be executed in an execution environment that depends on the A system 5 to which the ladder editor 1 belongs. When this is converted by the rule conversion filter 2 into a program in which an instruction including a keyword is replaced with a special instruction using the conversion rule 4, a program B including a special instruction executable in the execution environment of the B system 6 is generated. You.

In the conventional program development method, 'AD
Although the D 'instruction needs to be registered in the ladder editor, the program development method according to the present embodiment registers the special instruction' ADD 'as a keyword as shown in FIG. Multiple input terminals 12
The function of ADD can be expressed using only １５15. In this case, a conversion rule of interpreting as a special command is used only when the input terminal uses this keyword as an identifier.

As described above, when the terminal has a specific identifier, the existing ladder editor 1 is provided by providing the rule conversion filter 2 which interprets and converts it as another command different from the normal function by the keyword matching method. A new instruction can be added, a function can be easily changed or a function can be easily extended without changing a program, and a program directly including a function peculiar to an execution environment can be created in a different development environment. Also, even if the ladder editor 1 and the execution environment 3 belong to different systems (A system, B system) which are not compatible with each other, a program using special instructions specific to the execution environment can be created without modifying the ladder editor 1. can do.

In this example, the input terminals 12 to 15 to be converted are treated as normal inputs. However, by always setting the values of these terminals to TRUE, the output of the subsequent instruction is output. The sequence of input commands does not affect the state of the terminal 16. For this reason, the program output by the ladder editor 1 is directly converted to the A to which the ladder editor 1 belongs.
Even if executed by the system 5, the special instruction portion is a row of terminals that do not affect the state of other terminals. Therefore, the program excluding the portion corresponding to the special instruction can be directly debugged in the development environment to which the ladder editor 1 belongs.

Further, if the present embodiment is used as a prototype for testing a new instruction, the most time-consuming work of modifying the ladder editor 1 is not required.
Can be easily tested.

The conversion rule 4 shown in FIG. 5 is an example of a conversion rule based on ordinary keyword matching. That is, the number of arguments given to the special instruction and the code to be converted are specified as the attributes of the keyword. With this configuration, the number and contents of the arguments are determined only by the conversion rules, so that the number of arguments given to the specially interpreted instruction can be set to an arbitrary number.
Also, these changes can be easily made. Although the conversion rule 4 is not limited to the configuration shown in FIG. 5, the conversion rule is formed in a general format as a conversion rule, and by giving versatility,
The rule conversion filter 2 does not need to be created each time according to the development program, and a program including a special instruction can be developed only by adding or modifying the conversion rules.

Embodiment 2 In the first embodiment, the special instruction is described using the input terminal among the existing instructions in the ladder editor. However, when the ladder editor capable of describing a plurality of output terminals in one rung is used, the special instruction is described. An existing instruction for assigning an argument may be used as an output terminal.

The value at the output terminal does not affect the state of subsequent terminals. For this reason, when described with an input terminal, the value of the input terminal must always be set to TRUE, but when described with an output terminal, it is not necessary to maintain the values of these output terminals at TRUE. .

Embodiment 3 The configurations and operations of the A system and the B system that implement the program development method according to the third embodiment are the same as those in the first embodiment. Where A
Only standard instructions such as input / output terminals are registered as the ladder editor 1 in the system. Instructions related to system-dependent functions other than the input / output terminals are all described as dummy instructions, that is, existing instructions in the ladder editor 1 given specific identifiers. The intermediate program edited and output by the ladder editor 1 is converted by a keyword matching method based on a conversion rule using a specific identifier as a keyword representing a special instruction.

In this case, only a simple function of the ladder editor 1 needs to be prepared, and the intermediate program edited and output by the ladder editor 1 does not include an instruction that cannot be used in another system. Ladder editor 1
Conversion rule 4 for special instructions not registered in
Has a general file structure, and if you add or modify information about special instructions in this file,
A program that can be easily ported can be developed. Further, the conversion rule 4 may be separately created and exchanged.

In this embodiment, since all the system-dependent functions use the conversion method based on the keyword matching method, a new instruction is added or an instruction specification is changed.
Modification of the ladder editor 1 becomes unnecessary, and the efficiency of program development increases.

When this program development method is used, the ladder editor 1 becomes very small and simple, and expensive GUI processing (Graphic User I / O) is performed.
Even without performing the interface process, a low-functional editor such as a character editor can be realized. Furthermore, since the intermediate program output by the ladder editor 1 is also simple, the compiler is also simple, and a small and simple development environment can be realized. With these, an inexpensive system can be provided.
Suitable for incorporation into equipment that requires lower cost and smaller size of / W parts.

Although the first to third embodiments for ladder programs have been described above, the method for developing this program is applicable not only to ladder programs but also to general program development. For example, in the NC field, a multi-language development environment including languages such as motion, robot, and vision is required, but the existence of unique instructions in these language systems also lowers the portability of programs. . Also in this multilingual system, the same effects as in the case of a ladder program can be obtained by applying the present invention to individual instructions and arguments.

[0032]

As described above, according to the first configuration of the present invention, when a program including a special instruction not registered in the editor is developed, the special instruction is assigned to the editor by giving a specific identifier to the existing instruction. Use a conversion rule that uses a specific identifier as a keyword representing a special instruction. If an element in the program output from the editor corresponds to the identifier indicated in the conversion rule, this element is converted. By converting based on rules, new instructions can be added without changing existing editors, functions can be easily changed and functions can be easily extended, and programs that directly include functions specific to the execution environment can be converted to different development environments. You can get a method of developing a program that can be created with.

According to the second configuration of the present invention, the first
The conversion rule in the above configuration is that a specific identifier is used as a keyword, a specific function and the number of arguments are registered as attributes for this keyword, and when an element in the program output from the editor corresponds to the keyword, By converting this element into a function registered in a conversion rule, a method of developing a program that can easily and arbitrarily set the number and contents of arguments of a special instruction can be obtained.

According to the third configuration of the present invention, the first
Alternatively, since the program in the second configuration is a ladder program, even if the ladder editor and the execution environment belong to different systems that are not compatible with each other, the ladder editor corrects the ladder program using special instructions specific to the execution environment. A program development method that can be created without any problems is obtained.

According to the fourth configuration of the present invention, the first
In the above configuration, when a special instruction is described as an existing instruction in the editor, the existing instruction is used as an output terminal, so that the state of subsequent terminals is not affected, and verification and execution of parts other than the special instruction can be performed. A program development method that can be performed as it is can be obtained.

[Brief description of the drawings]

FIG. 1 is a flowchart showing a method for developing a program according to a first embodiment of the present invention.

FIG. 2 is an explanatory diagram showing a program development system according to the first embodiment;

FIG. 3 is an explanatory diagram showing a ladder program according to the first embodiment.

FIG. 4 is an explanatory diagram showing an intermediate program according to the first embodiment.

FIG. 5 is an explanatory diagram showing conversion rules according to the first embodiment.

FIG. 6 is an explanatory diagram showing a program B according to the first embodiment.

FIG. 7 is an explanatory diagram showing a description example of a conventional ladder program.

FIG. 8 is an explanatory diagram showing a description example of a conventional ladder program.

[Explanation of symbols]

1 ladder editor, 2 rule conversion filter, 3 execution environment, 4 conversion rule, 5 A system, 6 B system, 12 terminal with keyword in name, 13-15
Terminals as arguments of special instructions, 16 subsequent output terminals, 21 text of special instructions and terminals corresponding to their arguments, 22 text of converted special instructions.

Claims (4)

[Claims] When developing a program including a special instruction that is not registered in an editor, the special instruction is described by adding a specific identifier to an existing instruction in the editor, and the specific identifier is written in the special instruction. When an element in a program output from the editor corresponds to an identifier represented by the conversion rule, the element is converted based on the conversion rule using a conversion rule that is a keyword representing an instruction. How to develop the program. 2. The conversion rule according to claim 1, wherein a specific identifier is used as a keyword, a specific function and the number of arguments are registered as attributes for the keyword, and an element in a program output from an editor is used as the keyword. 2. The method according to claim 1, wherein, when applicable, the element is converted into a function registered in the conversion rule. 3. The method according to claim 1, wherein the program is a ladder program. 4. The program development method according to claim 3, wherein when the special instruction is described as an existing instruction in the editor, the existing instruction is an output terminal.