JP2002268896A - Method and device for generating control program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for generating a control program by which wasteful labor and time for quoting a user function is relieved and an input mistake is reduced. SOLUTION: A user function extracting means 105 generates the reference form definition information 102a of the user function to be utilized in the control program and a user function general purpose language source code 102b from a source code 102 which is described by a user through the use of a general purpose language. A general purpose language converting means 104 converts the control program 101 where the description of the user function is mixed into a control program general purpose language source code 101a and a machine language converting means 106 converts the source code 101a into a machine language through the use of definition information 102a and the source code 102b.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a control program creating method for generating a machine language executable by a control device by translating a control program described in a dedicated language suitable for a problem, and an apparatus therefor.

[0002]

2. Description of the Related Art In a control device such as a robot or a plant,
Write the control program in a problem-specific language (for example, robot language or ladder diagram) and execute it after translating this control program into machine language by a compiler, or interpret and execute this control program sequentially with an interpreter I do.

In such a control device, a standard function library for implementing various control functions is prepared so that a user can easily create a control program, and this can be used as an instruction in a dedicated language. If the user needs a control function that is not included in this standard function, the function is realized by combining instructions of a special language prepared in advance, or the user's specification is stored in the standard function library by some method. New function based on the API (user function)
It is necessary to modify the compiler or interpreter so that it can be used as a new instruction in a special language.

[0004] However, in the case of the description combining instructions of the former dedicated language, the description ability is limited,
Control functions required by the user may not be described. Alternatively, even if the description can be made, the description may be complicated and the decipherability of the program may be reduced. In the case of execution by an interpreter, if such a complicated operation is described in a special language, the interpretation processing time of the program increases, and the responsiveness of the control system may decrease. On the other hand, in order to add a user function to the library, generally, a manufacturer is requested to remodel the software, which may cause a large cost. In some cases, the user owns the control functions required by the user as a program in a general-purpose language, and there has been a demand for effective use of such existing software resources. Could not be easily realized.

As a known example of an attempt to solve such a problem, there is a control device described in Japanese Patent Application Laid-Open No. H11-338521. This known example describes an invention in which a basic function of a control device has a user function registration function. In this user function registration function,
The grammar that the user defines the name and arguments of the user function, the contents of the operation of the user function are described in a general-purpose language, and the entry address of the execution module of the user function in the memory is input to the special language standard. A user function different from the function can be registered. According to this known technique, the user function can be described as it is when the control program is created, so that the readability of the program does not deteriorate. Further, the execution code of the user function is called when the control program is executed. Is not expected to increase significantly. Further, there is no need to request a third party to modify the control device, and the user himself can newly register a desired user function.

[0006]

SUMMARY OF THE INVENTION The above-mentioned Japanese Patent Application Laid-Open No.
In the user function registration function described in Japanese Patent Publication No. 338521, it is necessary for the user himself to input the grammar for defining the name and arguments of the user function and the entry address of the execution module of the user function according to a predetermined format.
Not only does the user take extra time, but also an input error may occur at this stage, and further improvement in program creation efficiency is desired. Also, if the user already has software assets in a general-purpose language,
If the user wants to use this partly, the user function registration function may need to re-edit the source code. Further, in the above-mentioned known example, since it is assumed that the control program is executed by the interpreter method, there is room for improvement also in terms of program execution efficiency.

In view of the above, the present invention provides a control program creation method and a control program creation method in which a function created in a general-purpose language by a user can be incorporated into a control program by a simple operation and the execution speed is not particularly reduced by the incorporation. The purpose is to do.

[0008]

SUMMARY OF THE INVENTION The present invention provides a control program creating apparatus for converting a control program described in a dedicated language suitable for a problem into a machine language executable by a control apparatus. User function extraction means for generating, from the source code group, reference format definition information of a user function used in a control program and a user function general-purpose language source code obtained by extracting only a process related to the user function, General-purpose language conversion means for generating a general-purpose language source code of a control program from a control program in which the description of the user function is mixed in the description of the language; reference format definition information and user functions generated by the user function extraction means The general-purpose language source code is used to generate a generalized control program generated by the general-purpose language conversion means. It discloses a machine language conversion means for converting the language source code into the machine language, a control program creating device characterized by comprising a.

Further, according to the present invention, the user function extracting means generates and displays a checklist having function declaration statements included in a source code group described in the general-purpose language and check boxes corresponding to these functions. Disclosed is a control program creating apparatus, comprising a display unit, which automatically generates the reference format definition information and the user function general-purpose language source code for a user function selected by a check box.

Further, according to the present invention, the dedicated language has an instruction command for designating a block described in a general-purpose language using a user function. Generating a general-purpose language source code of a control program by converting a command in a special-purpose language not specified by the instruction command into a standard function in a general-purpose language, and copying the contents of the block specified by the instruction command as it is. A control program creation device characterized by the following.

Further, according to the present invention, the program combines a graphic format description of a sequential function chart with a text format description to generate a creation program by using an IF corresponding to a state transition of each step of a sequence.
A general-purpose language conversion unit that converts each of the rules into a function that is executed when a step is activated, and converts the rule into a function that is executed when a step is activated. Disclosed is a control program creation device that generates a language source code.

Further, the present invention relates to a control program creating method for converting a control program described in a dedicated language suitable for a problem into a machine language executable by a control device.
A block described in a general-purpose language using a user function is described in a control program using an instruction command for designating the block, and reference definition information of the user function is obtained from each source code of the user function. And a user function general-purpose language source code describing the processing of the user function, and converting the description of the dedicated language of the control program not specified by the instruction command into a control program general-purpose language source code. A method of creating a control program, characterized by converting a control program universal language source code into a machine language using the reference definition information and the user function universal language source code, is disclosed.

[0013]

Embodiments of the present invention will be described below with reference to the accompanying drawings. FIG. 1 is a diagram showing an example of a processing procedure of the control program creating device according to the present invention. This control program creation device is a dedicated language program written using standard function libraries prepared in dedicated languages such as a sequence control language for programmable logic controllers, a motion control language for motion controllers, and a robot language for robot controllers. A user function included in a general-purpose language source code 102 created by a user is incorporated in 101, and these are finally translated into a machine language to generate a control program machine language object code 103.

For this purpose, the control program creating apparatus shown in FIG. 1 includes, from the general language source code 102, user function reference format definition information 102a for using a user function in the control program, and information related to the user function. User function general-purpose language source code 102b extracting only processing
Is provided automatically. The user functions extracted here can be described in the dedicated language control program 101. As described above, the dedicated language control program 101 in which the description of the user function is mixed in the description of the dedicated language is used by the universal language conversion unit 104 to generate the control program universal language source code 1.
01a. The machine language conversion means 106 can be finally executed in the control device from the control program general-purpose language source code 101a, the user function reference format definition information 102a, and the user function general-purpose language source code 102b generated as described above. A control program machine language object code 103 is generated. In the following, it is assumed that the C language, which is generally widely used, is used as a general-purpose language.

The machine language conversion means 106 converts the control program general-purpose language source code 101a and the user function general-purpose language source code 102b into intermediate machine language conversion means 106c.
Thus, they are converted into a control program intermediate machine language object code 101b and a user function intermediate machine language object code 102c, respectively. Here, a user function is described in the control program general-purpose language source code 101a, and the substance of the user function is described in another user function general-purpose language source code 102b. The user function reference format definition information 102a is required to enable external reference of such a user function, and the control program general-purpose language source code 101a
Is used to convert to an intermediate machine language. Similarly, the entities of various standard functions included in the dedicated language and the general-purpose language are included in the standard function library provided in the general-purpose language processing system. The reference format definition information 106a is required, and the control program general-purpose language source code 101
a, User function Used when converting the general-purpose language source code 102b into an intermediate machine language.

Intermediate machine language object code combining means 1
06d is a control program intermediate machine language object code 101b, a user function intermediate machine language object code 102c, and a standard function intermediate machine language object code 106b obtained by converting a standard function library into an intermediate machine language.
, The external reference of the standard function and the user function are resolved, and at the same time, the respective intermediate machine language object codes are combined to generate the control program machine language object code 103 which is the final execution module.

Assuming that the C language is used as the general language as described above, the control program general language source code 101a and the user function general language source code 102b
Are the source code of the C language, and the standard function reference format definition information 106a and the user function reference format definition information 102a are stored in a header file (include file) describing the C language external declaration of the standard function and the user function, respectively. Equivalent to. These header files are included in the preprocessor instruction #include at the beginning of the control program general-purpose language source code 101a.
captured by e. In addition, intermediate machine language conversion means 1
06c and intermediate machine language object code combining means 1
06d corresponds to a C (cross) compiler and a linker, respectively.

In the program creating apparatus shown in FIG. 1, the features of the present invention are the user function extracting means 105 and the general-purpose language converting means 104. Hereinafter, the operation centering on these will be described in a specific example. It will be described using FIG.

FIG. 2 is a diagram showing an example of a control program editing screen. Here, the processing flow (sequence) of the control program is described by SFC (sequential function chart), and the processing of each step of the sequence is described by a text-format dedicated language. In the sequence edit window 201, the sequence of each device to be controlled is described in the SFC graphic format.
In the command editing window 202, the operation of each step of the sequence is described as a command in a special language. In the end condition edit window 203, a condition for ending each step is described as a conditional expression. Step S10 of SFC described in the sequence edit window 201
0, S101... Indicate the unit operation of each device.
02.

The command editing window 202 on the right side of FIG. 2
Describes the command sequence of step S103, obtains parameters for calculating the target position of the positioner, calculates the target position using a user function, and further moves the positioner to this target position. This is a step of opening a chuck for gripping the workpiece, and starting an on-delay timer for monitoring the chuck opening operation. Also, transitions 201b, 201c
Indicates a state transition between steps, and the transition condition is described in the end condition edit window 203 as the end condition of the input step S103 of these transitions.
There are two types of ending conditions in step S103. When the chuck is completely opened within the time limit (end condition T1), when the chuck is not completely opened within the time limit (end condition T).
The conditional expression that defines 2) is described. Termination condition T
1, T2 is a condition for transitioning from step S103 to the next step, as the output transition 201
b, 201c.

In the command editing window 202, not only commands in a dedicated language prepared in advance on the control device side but also user functions created by a user in a general-purpose language such as C language can be described. In the configuration of FIG. 1, commands #C and #END_C are prepared in order to clearly indicate a portion (hereinafter, a user function block) describing a user function in C language in a command sequence, and are surrounded by these. The shaded portion represents a user function block. In the part of the command sequence shown in the command editing window 202 shown in FIG. 2 that is surrounded by #C and #END_C, that is, in the user function block 202a, a user function calc_pos_ defined separately in C language is included.
The target position of the positioner is calculated by x () and calc_pos_y (), and these are converted into variables VR4, V
R5 (in C language notation, VR [4], VR
The processing to be substituted in [5]) is described. Variable VR
4, VR5 is a command (MOVE AXIS1VR4 AXI) of a special language following the user function block 202a.
S2 VR5 F 2000. ) Parameter. Note that, as shown here, the notation in the user function block 202a is a notation according to the grammar of the C language. Also, various numbered variables (VRn and the like) prepared in a dedicated language can be used in the user function block 202a, and these can be used in the C language array (VR
[N] etc.).

By providing such a command indicating the user function block 202a, the user function can be easily described in accordance with the C language grammar that the user is familiar with. Also, by using the command that explicitly specifies the user function block 202a, the processing of the general-purpose language conversion unit 104 that converts the dedicated language control program 101 into the control program general-purpose language source code 101a is simplified as described later. be able to.

In the SFC as shown in FIG. 2, steps for expressing the synchronization between the sequences executed in parallel are prepared, and these steps are called synchronization steps.
For example, the synchronization step REQ1 shown in the sequence editing window 201 is an input to the input transition (201f) in step S103, which means that the input transition (201f) waits for a synchronization signal output by another sequence. I do. That is, the transition to step S103 is performed in the immediately preceding step S1.
02 ends with the end condition T1, and the synchronization step RE
This occurs when Q1 is activated.

FIG. 4 is a flowchart showing a schematic process of the user function extracting means 105, and FIG. 3 is an explanatory diagram showing an example of the process. Normally, a group of source codes describing user functions related to the user is collected in one file. When using some of the user functions,
First, the user opens the source code described by designating the corresponding file (process 401). The source code 301 of the C language in FIG. 3 is a description example thereof, and functions calc_vel_x, calc_vel_y, and calc_vel_x, calc_vel_y, and cal which calculate a float type value from the float type variables x, y, and c
c_pos_x, calc_pos_y... are described. However, the part of ｛...｝ that defines the processing of each function is
Usually, the description is divided into a plurality of lines, but in FIG. 3, this is represented by one line {｛}. Next, the user functions in the displayed source code are checked, a checklist 302 of the user functions is created, and this is presented to the user (process 402). This checklist 302
Consists of function declaration statements and check boxes provided for each function. The user refers to this checklist and clicks a check box to select a user function to be used in the control program (process 403).

When the selection of the user function is completed, all the functions that are directly or indirectly called in the selected user function are examined (operation 404), and the source of the selected user function and its related functions are checked. A new user function source code 304 from which the code is extracted is generated (process 405). Further, a checklist 302 of the user function
The external reference declaration header file 303 of the selected user function is generated from the user function declaration sentence (process 40).
6). The user function generation code 304 and the external reference header file 303 generated here correspond to the user function general-purpose language source code 102b and the user function reference format definition information 102a in FIG. 1, respectively. The external reference header file 303 includes “extern” indicating that external reference is possible in the function declaration statement of the selected user function.
Is a list to which is added.

By using the user function extracting means 105 described above, the user can select a user function by simply performing a simple operation of checking a user function check list 302 generated from the C language source code 301. Since it will be available in a dedicated language program,
It is possible to minimize the trouble and input mistakes of the user for citing the user function. Also, if the user already owns a software asset in a general-purpose language, it can be used easily and effectively.

FIG. 6 is a flowchart showing the general processing of the general-purpose language conversion means 104, and FIG. 5 is a diagram showing an example of the processing. A part of the dedicated language control program 101 shown in FIG. It shows the case of converting to 101a. As described with reference to FIG. 2, when the control program is created by the SFC, the sequence of the control program is changed to an SFC
The operation and the end condition of each step of the sequence are described in a text format language as shown in a window 202 in FIG. The dedicated language control program 101 described by combining such a graphic form and a text form is automatically converted into a dedicated language control program 510 in a text form as shown in FIG. 5 and stored as a file.

This dedicated language control program 510
Are described by the rules of the THEN format, the condition part of each rule is a condition defining a state transition from a certain step in the sequence to the next step, and the execution part is a command sequence executed in the next step after the transition. Is described.
For example, in the condition part 511a of the rule 511, step S102 is normally completed (Complete Normally).
y), and the conditional expression that the synchronization step REQ1 is activated (ON) is further described. Rule 511
The first block 511b of the execution unit is a command sequence related to the transition of the step, and inactivates the step S102 and the synchronization step REQ1 (TERM S10
2, TERM REQ1), and set the step S103 to the executing state (EXEC S103). Subsequent blocks 511c, 511d, and 511e are the command strings in step S103 shown in the command editing window 202 in FIG. 2, blocks 511c and 511e are command strings in a special language, and block 511d is a user function block 202a in C language. It is. Last END_IF statement 5
11f indicates the end of the rule 511.

First, the general-purpose language conversion means 104 opens the file of the special-purpose language control program 101 specified by the user (process 601), and fetches the special-purpose language control program 510 described in the above format line by line. (Process 602). Next, it is checked whether the fetched line is an IF statement (process 603). If the line is an IF statement, a function declaration is made from the first conditional expression of the IF statement so that the rule from this line to the next END_IF statement becomes one function. A part (function type and name) is generated (process 604), and an if conditional statement is generated from the first conditional expression (process 605). The function corresponding to the rule generated here is a function executed when each step is activated, and the function name corresponds to the step number to be activated. In the case of the rule 511 of FIG. 5, step S102 of FIG. 2 is activated (step S10).
2 is the first conditional expression), and in step 504, the function name corresponding to the rule 511 is “st” for step S102.
t102 ”, and in the process 605, the corresponding if conditional statement“ if (stt [102] ==
Complete Normally "is generated.

The next line is fetched, and if this is not an IF statement (NO in step 603), it is a & (and)
If the condition is satisfied (YES in step 606), the continuation of the if conditional statement is generated from the conditional expression (step 607). If the condition is not &, the process proceeds to step 608. In the example of FIG. 5, since the second line is the & condition “& REQ1 = ON” following the IF statement, the corresponding if conditional expression “&& Req [1]
== ON ”is generated. The process 607 is repeated until the & condition is no longer present. Thus, the condition part 511a of the rule 511 is converted into an if sentence of the C language, and the block 52 is executed.
1a is generated.

If the fetched line is neither an IF statement nor a & condition (NO in steps 603 and 606), the line is
It is determined whether the sentence is an N sentence (process 608).
Return to 2. If the determination result of the process 608 is a THEN statement, the process proceeds to generation of an if statement execution unit. Here, one more line is fetched (process 609). This is not a #C statement (NO in process 610), and if it is not an END_IF statement (NO in process 611), this is a command in a special language. It is converted into a language standard function (process 612). If the fetched line is “#C” (Y in step 610)
ES), the user function block starts from here, and the user function block is fetched line by line (process 614). If this is not a #END_C statement (NO in process 615), the fetched character string, that is, the notation in C language It is copied as it is (process 616). This process is repeated until a #END_C statement is reached (YES in process 615). When the end of the user function block is reached in this manner, 1 is returned again.
The line is fetched line by line (process 609), and the generation process of the execution part of the if sentence as described above is repeated until this becomes an END_IF sentence (YES in process 611). When the END_IF statement is reached (process 611), the end part of the if statement and the end part of the function are generated (process 613). The above conversion process is repeated until the last line is reached (process 614).

The execution unit generation processing (processing 608 to 608 in FIG. 6)
614) with respect to the rule 511 of FIG. 5, the block 521b corresponding to the execution part of the if statement of the function 521,
521c, 521d, and 521e are rules 51, respectively.
One block 511b, 511c, 511d, 511e
From among the blocks 521b, 521c,
Numeral 521e is obtained by converting a command sequence in a special language into a corresponding standard function in C language, and block 521d is obtained by copying the contents of a user function block 511d in C language. Block 5 of the last part of the function 521
21f is generated in the process 613 corresponding to the last END_IF statement of the rule 511. Rule 512 following FIG.
Similarly, a function 522 is generated.

As described above, by converting the control program into a general-purpose language, it is easy to cite user functions in the general-purpose language, and further, by compiling and linking the source codes of these general-purpose languages, the It is possible to generate a machine language object code that can be executed at high speed.

In this embodiment, C is used as a general-purpose language.
Although an example using a language is shown, another general-purpose language (for example, C
++) can be used to realize a similar control program creation device. Further, in the present embodiment, an example is shown in which a general-purpose language for describing a user function and a general-purpose language obtained by converting a special-purpose language are the same C language, but these are respectively different general-purpose languages (for example, the former language). In assembly language, and the latter in C language). In this case, the user function general-purpose language source code and the control program general-purpose language source code are respectively converted into intermediate machine language object codes by different intermediate machine language conversion means (compilers), and they are connected by the intermediate machine language object code connection means. By doing so, it is possible to realize a similar control program creation method.

[0035]

According to the present invention, it is possible to mix user function descriptions in a control program in a special language only by selecting a necessary user function from functions included in a general language source code. Is automatically generated, it is possible to reduce unnecessary labor and input mistakes for quoting a user function, and to improve program creation efficiency. Further, according to the present invention, since an object code that can be directly executed by the microprocessor of the control device is generated from the control program, it is possible to improve the program execution efficiency.

[Brief description of the drawings]

FIG. 1 is a diagram showing an example of a processing procedure of a control program creating device according to the present invention.

FIG. 2 is a diagram illustrating an example of an edit screen of a control program.

FIG. 3 shows an example of processing by a user function extracting means.

FIG. 4 is a flowchart showing a schematic process of a user function extracting unit.

5 is a diagram showing an example in which a part of the dedicated language control program shown in FIG. 2 is converted into a control program general-purpose language source code by a general-purpose language conversion unit.

FIG. 6 is a flowchart illustrating a schematic process of a general-purpose language conversion unit.

[Explanation of symbols]

101 Dedicated language control program 101a Control program general-purpose language source code 101b Control program intermediate machine language object code 102 General-purpose language source code 102a User function reference format definition information 102b User function general-purpose language source code 102c User function intermediate machine language object code 103 Control program Machine language object code 104 General-purpose language conversion unit 105 User function extraction unit 106 Machine language conversion unit 106a Standard function reference format definition information 106b Standard function intermediate machine language object code 106c Intermediate machine language conversion unit 106d Intermediate machine language object code combining unit 201 Sequence Edit window 202 Command edit window 202a User function block 203 End condition edit window 301C Word source 302 user function checklist 302a checkbox 302b user function declaration 303 user function as external references the header file 304 user function source code 510 dedicated language control program 511 rules 520 control program general purpose language source code 521 functions in

 ──────────────────────────────────────────────────続 き Continuing from the front page (72) Inventor Tsurumasa Matsushita 4-6-6 Kanda Surugadai, Chiyoda-ku, Tokyo Inside Hitachi, Ltd. (72) Inventor Tadao Shimotsu 4-6-6 Kanda Surugadai, Chiyoda-ku, Tokyo Hitachi, Ltd. F term in the factory (reference) 5B081 AA10 CC01 5H220 BB12 CC05 CX02 DD04 DD07 JJ12 JJ24 JJ53

Claims (5)

[Claims] 1. A control program creation device for converting a control program described in a dedicated language suitable for a problem into a machine language executable by a control device, comprising:
A user function extracting means for generating reference format definition information of a user function used in the control program and a user function general-purpose language source code extracting only a process related to the user function; and A general-purpose language conversion unit that generates a general-purpose language source code of the control program from a control program in which the description of the user function is mixed; and a reference format definition information and a user function general-purpose language source code generated by the user function extraction unit. And a machine language conversion unit for converting a universal language source code of the control program generated by the universal language conversion unit into the machine language. 2. The user function extracting unit according to claim 1, wherein the checklist display unit generates and displays a checklist having function declaration statements included in the source code group described in the general-purpose language and check boxes corresponding to these functions. 2. The control program creating apparatus according to claim 1, wherein said reference format definition information and said user function general-purpose language source code are automatically generated for a user function selected by a check box. 3. The general-purpose language has an instruction command for designating a block described in a general-purpose language using a user function, and the general-purpose language conversion unit includes an instruction command of the control program. Converting a dedicated language command not specified by the command into a standard function of a general language, and generating a general language source code of the control program by directly copying the contents of the block specified by the instruction command. The control program creation device according to claim 1, wherein 4. The control program according to claim 1, wherein the control program is a program created by combining a graphic format description of the sequential function chart and a text format description with IF-TH corresponding to the state transition of each step of the sequence.
A general-purpose language conversion unit that converts each of the rules into a function to be executed when a step is activated, and converts the rule into a function to be executed when a step is activated. 2. The control program creation device according to claim 1, wherein the control program creation device generates a source code. 5. A control program creating method for converting a control program described in a dedicated language suitable for a problem into a machine language executable by a control device, wherein a block described in a general-purpose language is utilized by using a user function. A user function general language source that is described in a control program using an instruction command for instructing the block, and from each source code of the user function, reference definition information of the user function and processing of the user function are described. After converting a description of the dedicated language of the control program that is not specified by the instruction command into a control program general language source code, the control program general purpose language source code is referred to as the reference definition information and the user. Control characterized by conversion to machine language using function general-purpose language source code How to create a program.