JPH11353009A - Method for automatically generating command input processing to common processing routine, method for defining command for common processing routine and storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To automatically generate command input processing so as to make only a single command effective to parts for stopping an input of plural commands. SOLUTION: Once a stop command has bean set to a robot on an input picture of the command, as the step processing of an element for stopping the robot 1 of a main routine, processing for setting '0' to a command terminal and initializing it and processing for setting '1' to the command terminal of the stop selected by a user are automatically generated. Thus, only the stop command becomes effective as a command to the robot 1 and the other commands become ineffective.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for automatically generating a command input process for a common processing routine, a method for defining a command for a common processing routine, an automatic program generation device, and a recording medium on which an automatic generation program is recorded.

[0002]

2. Description of the Related Art Programmable controllers are used for operation of machines or control of conveyors in factories. In order to control devices by the programmable controller, it is necessary to create a sequence program that defines the control operation of the programmable controller.
When creating a sequence program, a machine engineer without programming knowledge describes the operation specifications of the machine in an operation flow, and based on this, a person in charge of programming creates a flowchart of the sequence program. In this case, the two flows have different meanings for each element,
The programmer needs to interpret the contents of each element of the operation flow to create a program flow. This is program development itself, and depends on the person in charge of programming, and it has been difficult to completely match the operation flow with the program flow. In order to solve such a problem, the present inventor has previously proposed in Japanese Patent Application No. 9-354522 a method of automatically generating a sequence program from an operation flow describing a sequence operation of a controlled device. .

In the above-mentioned application, a common processing routine for a conveyor, a robot, and the like is defined as a part. However, it is conceivable that a control instruction for the part is defined as a command. When it is not allowed to give a plurality of commands simultaneously to a component having a plurality of executable commands, it is necessary to exclusively manage the commands so that a plurality of commands are not given to this component at the same time.

FIG. 23 is a diagram showing input / output terminals when stop, carry-in, and carry-out commands are defined for components of the robots 1 and 2, and FIG. 24 is a diagram showing internal processing of the components. In the case where a command terminal such as stop and carry-in is provided for a component as shown in FIG. 23, an nC1 check process for performing exclusive control of a command as an internal process of the component as shown in FIG. In this case, the user needs to create an error output process for outputting an error as an internal process of the component.

[0005]

However, if a check program for performing exclusive control of commands is created as internal processing of parts, a user who is not accustomed to creating a program can execute a command processing program for stopping, loading, etc. Even if the check program is created, the check program may be forgotten and the control of the device may be inconvenient.

In the method of creating a check program as internal processing of a component, it is necessary to output error information to the main routine for each component, and the main routine stores the error information of each component correspondingly. Needs to be defined, and a memory area for storing the variable must be reserved. In addition to this, it is necessary to describe processing for a component error in the main processing. This is a problem in effective use of the memory because the required memory capacity increases as the number of components increases.

An object of the present invention is to automatically generate a command input process for a common processing routine.

[0008]

According to the first aspect of the present invention,
An automatic generation method of a program based on a definition method in which a plurality of instructions for specifying processing contents to be executed for a plurality of common processing routines is defined. Automatically generates a program that makes only the command selected among the commands valid and invalidates other commands.

For example, a program for exclusively controlling a plurality of commands is automatically generated as a part of a main routine that calls a common processing routine. According to the first aspect of the present invention, it is not necessary for the user to create a check program for performing exclusive control of commands for the common processing routine. Therefore, the user forgets to create a check program and simultaneously issues different commands to the common processing routine. Is not caused.

When a check program is created in each common processing routine, if the check result indicates an error, error information is notified to the main routine, and the error information of each common processing routine is stored. An area must be reserved in memory. According to the second aspect of the present invention, since a program for performing exclusive management is generated as a part of the main routine, it is not necessary to notify the main routine of error information from the common processing routine. Therefore, there is no need to provide an area for storing error information from the common processing routine in the memory, and the memory capacity can be saved. In addition to this, there is no need to describe processing for component errors in the main routine.

[0011]

Embodiments of the present invention will be described below with reference to the drawings. A method of automatically generating a sequence program from an operation flow describing a sequence operation of a controlled device, which is a premise of the present invention, will be described.

FIG. 1 is a block diagram of a sequence program creating apparatus according to an embodiment of the present invention. When the user operates the keyboard 11 and the mouse 12 to input the elements of the operation flow and the connection information of the elements, the flow drawing processing unit 15 in the apparatus main body 13 displays the operation flow corresponding to the input data on the display 14. At the same time, the element data of each element is written to the net (net) file 16. Parts such as robots and conveyors described in the operation flow and used in the sequence program are stored in the parts database 17.

The compiler 18 performs processing shown in FIG. 2, that is, a processing order file generation processing ST201 for determining the processing order of each element, based on the element data of the net file 16 and the part data of the part database 17, Flow element processing generation processing ST20 for generating step processing and transition processing described later based on the processing
2. Component processing generation processing ST203 for generating component processing in accordance with the activation method of the component function block FB of the component database 17 and task designation, and the net file 16
The range specification data is searched for from the element data of (1), and when the range is specified, the range specification process generation process ST204 for generating the range specification process for each range specification number is executed.

As a result, a sequence program 19 including a flow element process, a component process, a range designation process, and the like is generated by the compiler 18 and output to the programmable logic controller PLC 20.

The net file 16 is a file composed of a plurality of element data created by the flow drawing processing unit 15 for each element of the operation flow, and is determined according to a certain rule in the arrangement order of the elements. Element number and element type (for example, start, command, wait, parallel branch, selective branch, parallel merge, select merge, END, RETURN, RE
PEAT), the number of destination elements, the number of destination elements, the number of destination elements, the number of destination elements, and the item to be executed by the element (for example, if the type is a command, input to each terminal of the component. Value) and, if the element is ranged, the range designation number and the position within the range (entrance or middle or exit)
It is composed of The range number further includes an event, that is, range designation information including a monitoring type indicating whether the event monitoring is a change in the event or a timer monitoring, a time in the case of the timer monitoring, and a signal name in the case of the event monitoring. Consists of

When the net file 16 is created as described above, a processing order file 40 as shown in FIG. 4 is created based on the net file 16. Hereinafter, the processing content of the processing order file creation processing ST201 of FIG. 2 will be described with reference to the flowchart of FIG.

First, "1" is set to the pointer P, the element number n1 of the element data whose element type is started is obtained from the net file 16, and the element number n1 and the number of data (in this case, the element type is Therefore, the number of data "1" is set at the head of the processing order file (FIG. 3, ST30).
1). As a result, the element number n1 of the start element and the number of data “1” are stored at address 1 of the processing order file 40 of FIG. 4 as data.

Next, the data D1 and the data number k1 of the address pointed to by the pointer P of the processing order file 40 are obtained (ST302). A plurality of data d as data D1
Exists, in the next step ST303, it is determined whether or not the data d1 in the data D1 consists only of the element number or the element number and the destination element number.

If it is determined in step ST303 that the element number is the element number, the process proceeds to step ST304 to execute an element number-destination element number set process. Step ST
Proceeding to 305, an element number setting process is executed.

Next, the element number setting process of step ST305 in FIG. 3 will be described with reference to FIG. First, it is determined whether or not the destination element number of the element d1 is stored at the address indicated by the pointer P1 + 1 of the processing order file 40 (FIG. 5, ST501). In the initial state, no data is stored at the address pointed to by the pointer P1 + 1.
The destination element number of the element d1 is stored at the address indicated by 1 as the element number of the next element. Then, it is determined whether or not the above processing is repeated for k1 times of data (ST50).
3).

FIGS. 6A to 6D are views showing an example of a processing order file created by the above-described element number setting processing. The processing order file 40 includes an element number cell including an element number, and an element number + a destination element number cell including an element number and a destination element number.

FIG. 6A shows that the pointer P1 has the element number n.
When 1 and the destination element number n2 point to the address "5" stored, it indicates that the destination element number n2 is stored at the next address "6" of the processing order file 40a. Then, the destination element of the element n2 is searched from the net file 16, and the element number n2 of the element n2 and the element number of the destination element are set to the next address "7".
Is stored in That is, in the processing order file 40a, element numbers and element numbers + destination element numbers are stored alternately. The element number in the element number + destination element number cell in which the element number and the destination element number are stored exists in the element number cell arranged immediately before the cell, and the element number + destination element number cell The destination element number will be in the next element number cell of that cell.

Similarly, FIG. 6B shows that when the element number of the cell indicated by the pointer P1 is n1 and the destination element numbers of the connection destinations are n2, n3, and n4, the cell next to the address indicated by the pointer P1 is displayed. This indicates that the destination element number of the cell immediately before the address is stored as element numbers n2, n3, and n4.

FIG. 6C shows a case where the element number of the destination element of the cell elements n1, n2 and n3 indicated by the pointer P1 is n4, and the destination element number n4 is stored at the next address P1 + 1. It is stored as a number n4.

FIG. 6D shows a case where the element numbers of the destination elements of the elements n1, n2, and n3 of the cell indicated by the pointer P1 are n4, n5, and n6, respectively, and the cell at the next address of the pointer P1 is shown. Destination element number n as the element number of
4, n5 and n6 are stored.

Returning to FIG. 3, the element number-destination element number setting process in step ST304 is completed.
When the data d1 is not END, RETURN, or REPEAT in the determination of step 06, or in step ST3
When the element number setting process of 05 is completed, the process proceeds to step ST307, where "1" is added to the pointer P1.
The processing after step ST302 described above is repeated. And END, RETURN or REPE as an element
If an AT is detected, the processing order file creation processing ends.

After the processing order file is created from the operation flow as described above, the flow element processing is generated based on the processing order file. FIG. 7 is a flowchart showing the processing contents of the flow element processing generation processing ST202 of FIG.

First, the pointer P1 is initialized (FIG. 7,
ST701). Next, from the address designated by the pointer P1 of the processing order file 40, the data D1 and the data number k
1 is read (ST702). Then, it is determined whether or not data is stored at the corresponding address in the processing order file 40 (ST703).

If it is determined in step ST703 that data is stored in the processing order file 40,
It is determined whether the data type is an element number or an element number-destination element number (ST704). If the data type is the element number, the step processing generation processing of step ST705 is executed, and if the data type is the element number-destination element number, the transition processing generation processing of step ST706 is executed. When the generation of the step processing or the transition processing is completed, the pointer P1 is incremented, the process returns to ST702, and the above processing is repeated.

Here, the step processing generation processing ST shown in FIG.
The processing content of 705 will be described with reference to FIG. First, the data d1 in the data D1 at the address designated by the pointer P1 of the processing order file is read, and a step skeleton corresponding to the data d1 is generated (FIG. 8, ST801).

In this embodiment, for each element of the operation flow, an activation flag (activation information) indicating whether the element is in an executable state, and an executed flag indicating whether the element has been executed. (Executed information) and a pending flag (pending information) for putting the element in a pending state are provided to manage the execution order of processing corresponding to the element. The processing corresponding to the element is divided into step processing, which is execution processing of the element itself, and transition processing, in which a token is moved to the next element. Step processing and transition processing for each element are automatically generated from the operation flow. ing.

Specifically, when the activation flag of an element is on and the executed flag is off in the step processing, the processing of the element itself is executed, and when the processing is completed, the executed flag of the element is turned on. I do. Then, when the activation flag of the upstream element is on, the executed flag is on, and the hold flag is off in the transition processing, the activation flag and the execution flag of the element are turned off, and the activation flag of the next element is turned on. The token (execution right) is moved to the next element so that the next element can be executed.

The above step skeleton generation processing ST8
01 is a process for generating a step process having a basic configuration as shown in FIG. Basic step processing is
It comprises a step ST901 for determining whether or not the activation flag of the element n is on and the execution flag is off, and a step ST902 for turning on the execution flag when the activation flag is on and the execution flag is off. .

The basic transition processing is as follows:
As shown in FIG. 9B, step ST903 to determine whether the activation flag of the upstream element n is on, the executed flag is on, and the suspension flag is off, When on, the executed flag is on, and the hold flag is off, the activation flag of the upstream element n is turned off, the executed flag is turned off, and the token is transferred to the downstream element n.
Step ST904 of turning on the activation flag of the next element n1 in order to shift to 1.

In these basic step processing and basic transition processing, processing of the element itself (for example, command,
For example, a branch process), a condition determination process, and the like are added to generate a step process and a transition process for each element.

Returning to FIG. 8, once the step skeleton is generated, the element type of the element d1 is changed to the net file 16
From the element type is command, wait, RETURN
Or other (ST802 in FIG. 8).

If the element type is a command or a wait, the process proceeds to step ST803 to generate a component terminal input process for setting a component parameter. If the component is a functional component that is called only when executing an element of the operation flow, a component process that calls a component function block in the component database 17 is generated. If the part is a continuous part that operates independently of the flow progression, or
If the activation task is generated and is a task different from the program, a component process is generated by the component process generation process (ST203 in FIG. 2).

Here, the component terminal input processing in step ST803 will be described with reference to FIG. The component name used in the step element created by the flow drawing processing unit 15 (see FIG. 1) is acquired from the net file 16 (see FIG. 1) (FIG. 17, ST1701).

Next, the component database 17 (see FIG. 1) is searched based on the component names, and all input terminal information is obtained (FIG. 17, ST1702). Then, a command for this component is obtained from the net file 16, and processing is performed to validate only this command and invalidate other commands for one searched input terminal (FIG. 17, ST17).
03).

Further, similar processing is generated for the remaining input terminals based on the information of the net file 16 (FIG. 17, ST1704). Accordingly, when a command for a component is set, an exclusive process for the command is automatically generated, so that the user does not need to create a check program as a part of the component process as in the related art.
Forgetting to create the check program, it is possible to prevent a situation in which a plurality of commands are described at the same time and an inconvenience in operation occurs.

Further, since there is no need for a check process in the component, it is not necessary to output error information from the component to the main routine. This eliminates the need to define the error information of the components used in the main routine as variables and secure an area for storing the variables in the memory, thereby limiting the memory capacity and eliminating the need for processing for component errors. Become.

If it is determined in step ST802 that the element type of the data d1 is RETURN, a RETURN generation process in step ST804 is executed. Also, the element type of data d1 is command, wait, RETURN
Otherwise, the process proceeds to step ST805 without executing any processing. In step ST805, it is determined whether or not the step processing generation processing for the number of data k1 has been performed, and if the processing has been performed k1 times, the process returns to the original processing.

FIG. 10 is a diagram schematically showing a sequence program generated from an operation flow by the above-described sequence program creating device. In this operation flow, after giving a command to move the conveyor 1 by 1 m, a stop command is given to the motor 1. The entire operation flow is periodically executed as a task 1, and the motor 1 processing is executed as a task 2 every 5 ms.

By the above-described processing order file creation processing, a processing order file 40 corresponding to the operation flow is created, and further, step processing and transition processing are generated based on the processing order file 40, as shown in FIG. From the first element “start” and the second element of the operation flow, step 1 processing of step processing, tran 1-2 processing of transition processing, and step 2 processing of step processing are generated, and so on. Processing and transition processing are generated.

By the above-described automatic generation method of the sequence program, step processing is performed for each element of the operation flow,
A transition process for determining the connection between elements and a condition determination is generated, a process for starting the process of moving the conveyor 1 is generated as a component process, a process for starting the motor 1 process and the like every 5 ms, and a range designation process are generated. You.

Next, a description will be given of a process of automatically generating an exclusive process for a part as a part of a main routine when the above-described sequence program is automatically generated.
When creating a part to be called from the main routine, the user sets input / output terminal names of the part and attributes thereof, for example, data types.

FIG. 11 shows a terminal setting screen.
Select “command” from the terminal types such as “command”, “state”, and “input”, and describe “stop”, “import”, and “export” as the terminal names, and “BOOL” as their data types.
Select Here, “BOOL” is data represented by 1 bit ON / OFF. Other input / output terminals, terminal names such as status, and attributes can be similarly set.

FIG. 12 is a diagram showing a data structure in the component database 17 of the component set on the command terminal setting screen. The component name, terminal name (command and status indicate the type of terminal), and data type are stored as paired data.

FIG. 13 is a diagram showing input / output terminals of a component based on a definition method in which a control instruction for the component is defined as a command. In the present embodiment, since the instruction check processing is not performed inside the component, an error output terminal for outputting an error when an error is detected by the instruction check processing is unnecessary.

FIG. 14 is a diagram showing internal processing of a component. When “Stop”, “Load in”, and “Unload” are set as commands for the component names “Robot 1 and Robot 2”, stop processing for stopping the operation of the robot, loading processing for loading and unloading parts and the like to the robot, and unloading Processing, stop output, unloading output, control output processing for outputting unloading output from output terminal based on those processings, output of stop complete, import complete, and export complete indicating that the commanded operation is completed The state output process is performed by the user, but the nC1 check process and the error output process shown in FIG. 23 are not required.

FIG. 15 is a view showing an input screen for inputting a command for a component after the setting of the input / output terminals is completed as described above. The input screen of FIG.
6 shows a case where a command is input based on the operation flow of “stop robot 1”.

In the command input screen, when the user clicks the arrow button in the command column on the screen, the command set on the component input / output terminal setting screen shown in FIG.
"Import" and "Export" are displayed in a menu format.
The user selects a command defined in the operation flow from the displayed commands. Further, a device number is set as a parameter. A parameter is information that qualifies a directive,
Use this when you want to give detailed settings to a part at the same time as a command. The robot 1 used in this example carries parts in and out of a plurality of assembling machines.
A device number for specifying the assembly machine is required, and for this purpose, the device number is specified as a parameter.

Next, an example of a program generated by the automatic program generation method according to the present invention is shown in FIGS. This program is created from the operation flow shown in FIG.

First, in the initial setting process of FIG. 18, a 1-bit value "1" is loaded ("LD BOOL # 1"), and the value is set as a variable "INIFLG". Active flag "STS1 [1]" and element 4
Is stored in the activation flag “STS1 [4]”.

Next, the start number of each process is set, "256" is set as the maximum process number "KTNO_MAX", "0" is set as the effective range designation number "HNO_MAX", and "5" is set as the effective element number "YNO_MAX". ID"
TRNO_MAX ”is set to“ 3 ”.

Further, variable names used in this program, for example, the activation flags “STS1 [1]”, “STS2”
[1] is a variable name used for monitoring “STS_
1 "," STS2_1 "...

Similarly, the variable names of the temporary stop and the variable names of the transition process in the flow of FIG. 19 are converted. next,
Variable "PG_PSE" for temporarily stopping the program
[1] ”is loaded into the accumulator and it is determined whether or not the value is“ 0 ”(“ JMPCN FL ”in FIG. 19).
WCNT1 ") The variable" PG_PSE [1] "is" 1 "
If it is, the process jumps to the component processing of the last "FLWCNT1" of the flow, and if it is "0", it proceeds to the next step.

In the next step, the step processing "ACT1" for element 1 is executed. In this step processing, the value of the activation flag “STS1 [1]” of the element 1 is loaded into the accumulator (“LD STS1 [1]”), and the contents of the accumulator and the executed flag “STS2” of the element 1 are loaded.
[1] AND with the inverted value of ""("AN
DNSS2 [1] ”). Then, it is determined whether or not the operation result is“ 0 ”. If the operation result is“ 0 ”, that is, if the element 1 is inactive or has been executed,“ ACT1E ”is set. If the operation result is "1", that is, if the element 1 is active and not executed, the process proceeds to the next step ("JM
PCN ACT1E ").

If the element 1 is active and has not been executed, it is necessary to execute the processing of the element 1. In this case, since the element 1 is the "start element", no processing of the element 1 is executed. Instead, the executed flag “STS2 [1]” of the element 1 is set (“S STS2 [1]”) to bring the element 1 into the executed state. After that, the integer type numerical value “1” is loaded into the accumulator (“LD INT # 1”), and the contents of the accumulator are set as the number of active tokens of the element 1 and the variable “PG
_STR1 [1] ".

Next, when the element 1 is active and has been executed, a transition process for transferring the execution right from the element 1 to the element 3 (* transition 1-3 *) is executed. 1 activation flag "STS1"
The value of [1] is loaded into the accumulator, the logical product of the contents of the accumulator and the value of the executed flag "STS2 [1]" is taken ("AND STS2 [1]"), and the result and the element 1 are reserved. The logical product of the flag "STS3 [1]" and the inverted value is taken ("ANDN STS3
[1] ”) Then, it is determined whether or not the result is“ 0 ”. If the result is“ 0 ”, that is, if the element 1 is inactive, not executed, or suspended,“ TRN1out1 ” If the result is “1”, that is, if the element 1 is active, executed, and not pending, the process proceeds to the next step.
The operation result is stored in “TRN1 [1]”.

If the element 1 is active, executed, and not held, the activation flag “STS1 [1]” of the element 1 is reset (“RSTS1 [1]”), and the execution flag of the element 1 is reset. “STS2 [1]” is reset, and the activation flag “STS1 [3]” of the element 3 is set (“S STS”).
1 [3] ").

As a result, the element 1 becomes inactive and not executed, the element 3 becomes active, and the execution right moves from the element 1 to the element 3. Note that the command “R” in FIG. 19 means a reset command, and “S” means a set command. The element 3 corresponds to an element for stopping the robot in the operation flow of FIG. 16, and the element 1 corresponds to a start element, and the element 2 described later corresponds to an end element.

Next, step processing ACT3 of element 3 is executed. First, the activation flag “STS1 [3]” of the element 3
Is loaded into the accumulator, and the logical product of the contents of the accumulator and the inverted value of the executed flag “STS2 [3]” of the element 3 is obtained. Then, it is determined whether or not the operation result is “0”. If the operation result is “0”,
That is, if the element 3 is inactive or has been executed, the processing jumps to the transition process "(* transition 3-2 *). If the operation result is" 1 "and the element 3 is active and not executed, the next processing is performed. Proceed to step.

If the element 3 is active and has not been executed, after setting the executed flag "STS2 [3]" of the element 3 in FIG. 20 to make it executed ("S STS2 [3]") ,
Initialize the command terminal.

First, a process of clearing variables is performed to initialize the command terminal of the robot 1 defined as a part. The 1-bit value “0” is loaded into the accumulator (“LD BOOL # 0”), and the contents of the accumulator are stored in the variable “FLWFN00001_stop” (“ST FLWFN00001_stop”). Initialization is similarly performed for carry-in and carry-out instructions. Further, the numerical value “0” is changed to a variable “FLWFN00001_device”.
And the device number of the component parameter is initialized to “0”.

Next, in order to give a command to stop the robot 1, a 1-bit value "1" is loaded into the accumulator (LD BOOL # 1), and the contents of the accumulator are stored in a variable "FLWFN00001_stop". (“ST FLWFN00001_device”), whereby the variable “FLWF” for giving a command to the robot 1 is obtained.
“1” is set to “N00001_stop”.

Further, the numerical value "0" is loaded into the accumulator (LD INT # 0), and the contents of the accumulator are loaded into the variable "FLWFN00001_device", whereby the variable specifying the device number of the target device is read.
FLWFN00001_device ”as device number“ 0 ”
Is set. In this case, the initial value and the actual device number are the same. In addition, the input data control flag
"1" is stored in FCNT [1] ".

As described above, the process of validating only the command input on the component input screen and invalidating other commands is automatically generated as the process of the element 3 of the main routine. This eliminates the need for the user to create a check process for performing exclusive control of a command on a component as part of the component process, so that the user may forget to create the check process and cause inconvenience in the operation of the controlled device. Disappears.

When the step processing of the element 3 is completed, the transition processing of the element 3-2 is executed. In this transition processing, the activation flag “STS1” of the element 3
[3] ”is loaded into the accumulator, the logical product of the contents of the accumulator and the executed flag“ STS2 [3] ”is obtained, and the result is further combined with the hold flag“ STS3 ”.
The logical product of the value obtained by inverting the value of [3] "is obtained, and the result is stored in a variable" TRN1 [2] ". Then, it is determined whether or not the operation result is" 0 ". If "0", that is, if the element 3 is inactive, not executed, or suspended, the process jumps to the step of "TRN2out1E", and if the element 3 is active, executed, and not suspended,
Proceed to the next step ("JMPCN TRN2out1"
E ").

If the element 3 is active, executed, and not suspended, the activation flag “STS1 [3]” of the element 3 is reset to deactivate, and the executed flag “STS2”
[3] ”is reset to not be executed, the activation flag“ STS1 [2] ”of the element 2 is set, and the execution right is moved to the element 2.

Next, the step processing of the element 2 is executed.
In this step processing, the activation flag “STS1” of the element 2
[2] ”is loaded into the accumulator, and the contents of the accumulator and the executed flag“ STS2 ”of the element 2 are loaded.
[2] ”is ANDed with the inverted value of“ 2. ”Then, it is determined whether or not the operation result is“ 0 ”. If the operation result is“ 0 ”, that is, element 2 is inactive, Alternatively, if the execution has been completed, the process jumps to the step “ACT2E”. If the element 2 is active and has not been executed, the process proceeds to the next step.

In the next step, since the element 2 is the end element, no processing is executed and the executed flag "S"
TS2 [2] "is set to be executed. Further, the integer type number" 0 "is stored in the variable" PG_STR1 [1] ", and the number of active tokens is set to" 0 ".

Next, transition processing A of the end element 2
In the CT2E, the activation flag “STS1 [2]” of the element 2
Is loaded into the accumulator, the logical product of the contents of the accumulator and the value of the executed flag "STS2 [2]" is obtained, and the result is compared with the value obtained by inverting the value of the pending flag "STS3 [2]". Take the logical product. Then, it is determined whether the operation result is “0”, and if the operation result is “0”,
That is, if the element 2 is inactive, not executed, or suspended, the process jumps to the “TRN2ENDE” step, and if the operation result is “1”, the process proceeds to the next step.

If the operation result is “1” and the element 2 is active, has been executed, and is not pending, the activation flag of the element 2
Reset STS1 [2] "to deactivate element 2,
The executed flag “STS2 [2]” of the element 2 is reset to be not executed.

Next, a process of calling a component and giving a command will be described. First, the input data control flag "FC
NT [1] "is loaded into the accumulator (" LD
FCNT [1] ”), the accumulator content is“ 0 ”
By determining whether or not the input data control flag is set, it is determined whether or not the input data control flag is set. When the accumulator is "0", that is, when the input data control flag is not set, the process jumps to the step of "FNCCNT1". When the accumulator is "1" and the input data control flag is set, the process proceeds to the next step. .

In the next step, the variable “FLWFN00
001_Stop ”is loaded into the accumulator, and the contents of the accumulator are stored as a command for the parts of the robot 1 (“ ST Robot 1._Stop ”in FIG. 21). This is set as a command for the robot 1. Also, the variable “FLWFN000” is set.
The device number “0” stored in “1” is set as the device number of the parameter of the robot 1.

By the above-described processing, for example, only the command selected by the user on the command input screen for parts shown in FIG. 15 becomes “1”, and the other commands become “0”. Only "stop" is valid, and other commands such as loading and unloading are invalid.

Finally, the parts processing of the robot 1 is called (“
Then, the CAL robot 1 ") performs a 1-bit value" 0 "in the input data control flag" FCNT [1] "and resets the control flag. In addition, robot 1
Is loaded with the information of "stop complete" of the output terminal of the component indicating whether or not it is in the stop complete state, and the information is stored in a variable "FLWFN".
"00001_stop complete". Similarly, robot 1
Is an output terminal indicating whether or not loading is complete. "
Load the information of "Load complete" and store the information in the variable "FLWF".
N00001_loading complete ". Information of" output complete "which is an output terminal indicating whether or not the robot 1 is in the state of completion of loading is loaded, and the information is stored in a variable" FL ".
WFN00001_Unloading Completed ". By these processes, the state of the robot 1 is stored in the above-described variables, and by reading the variables in the main routine,
The state of the robot 1 can be recognized.

According to the above-described embodiment, when a command for a component is set by a user, a process for validating only the set command and invalidating other commands is automatically generated. This eliminates the need for the user to create a check process inside the component process. Thus, it is possible to prevent a problem that the user forgets to create the check process and different commands are given to one part at the same time. Further, since it is not necessary to create the check process as an internal process of the component process, it is not necessary for each component to output error information for notifying the check result to the main routine. This eliminates the need to define variables for storing error information of those components even when a large number of components are present and to secure an area for storing the variables in the memory, thereby saving memory capacity. can do. Further, since there is no need to provide a process for processing error information defined by variables in the main routine, the program is simplified accordingly.

Further, the automatic generation program of the sequence program according to the present invention is stored in a storage medium such as a floppy disk 2201 or CDROM 2202 shown in FIG. 22, and the storage medium is used as an information processing device (personal computer or the like) 2203. Medium drive device (floppy disk driver, CDROM driver, etc.) 22
04 may be used to automatically generate a reading sequence program. Alternatively, an automatic generation program is stored in a storage device such as a hard disk of a computer of a program provider, transferred to a user's computer by communication, stored in a hard disk or the like, and a sequence program is generated using the automatic generation program. You may do so.

According to the above-described embodiment, the activation flag, the executed flag, and the hold flag are provided for each element of the operation flow, and when those flags satisfy a certain condition, the execution right is passed to the next element. With this configuration, it is possible to automatically generate a program that passes the execution right to the next element when the processing corresponding to the element of the operation flow and the processing of the element are completed.

Further, in the present embodiment, step processing and transition processing corresponding to each element of the operation flow are automatically generated, so that the steps that occur when a programmer creates a program as in the related art are described. Transition omission is eliminated. Further, since the transition processing is always generated between the step processing, the user does not need to pay attention to the description order of the steps and the transition as in the sequential function chart. Furthermore, when changing specifications, if only the operation flow is changed, a sequence program corresponding to the operation flow is created, so only the sequence program is changed as in the conventional case, and the operation flow is different from the actual program. The problem does not arise.

Further, conventionally, it has been necessary to describe a flow for each task necessary for the operation of a component to be used and to design software for exchanging data between tasks. However, one operation flow requires another task. Since the components to be operated can be described, these operations become unnecessary. As a result, the user does not need to consider whether the used parts such as the motor operate by another task, and can generate the sequence program only by describing the machine operation itself.

In the above-described embodiment, a case has been described in which, when a sequence program is automatically generated, a program for exclusively managing commands is automatically generated. However, the present invention is also applicable to a case where other programs are automatically generated. Is applicable.

[0085]

According to the present invention, it is possible to automatically generate a program for exclusively controlling a command for a common processing routine. For this reason, the user forgets to create a program for checking a command, causing inconvenience in processing. Can be prevented. In addition, by creating a program for performing exclusive management of commands for the common processing routine not in the common processing routine but in the main routine, it is not necessary to notify the main routine of error information from the common processing routine. As a result, even when there are a plurality of common processing routines, there is no need to secure a memory area for storing each error information, so that the memory capacity can be saved.

[Brief description of the drawings]

FIG. 1 is a block diagram of a sequence program creation device according to an embodiment.

FIG. 2 is a diagram showing processing contents of a compiler 18;

FIG. 3 is a diagram showing a processing order file creation process.

FIG. 4 is a diagram showing an example of the configuration of a processing order file 40.

FIG. 5 is a diagram showing an element number setting process.

FIGS. 6A to 6D are diagrams illustrating an example of a processing order file.

FIG. 7 is a diagram showing a flow element process generation process.

FIG. 8 is a diagram showing a step process generation process.

FIG. 9 is a diagram showing a basic configuration of step processing and transition processing.

FIG. 10 is a diagram illustrating an example of a sequence program generated from an operation flow.

FIG. 11 is a diagram illustrating a setting screen of a terminal of a component.

FIG. 12 is a diagram showing a data structure of component data.

FIG. 13 is a diagram showing input / output terminals of components registered in the component database 17;

FIG. 14 is a diagram showing internal processing of a component.

FIG. 15 is a view showing a command input screen.

FIG. 16 is a diagram showing an operation flow creation screen.

FIG. 17 is a flowchart for generating a component terminal input process;

FIG. 18 is a diagram (part 1) illustrating one example of a sequence program;

FIG. 19 is a diagram (part 2) illustrating one example of a sequence program;

FIG. 20 is a diagram (part 3) illustrating one example of a sequence program;

FIG. 21 is a diagram (part 4) illustrating one example of a sequence program;

FIG. 22 is an explanatory diagram when a storage medium is used.

FIG. 23 is a diagram showing input / output terminals of a component when a plurality of commands are defined for the component.

FIG. 24 is a diagram showing internal processing of a component when a plurality of commands are defined for the component.

[Explanation of symbols]

 16 Net file 17 Parts database 18 Compiler 40 Processing order file

Claims (9)

[Claims] 1. A method for automatically generating a program based on a definition method defining a plurality of instructions for instructing processing contents to be executed for a plurality of common processing routines, wherein exclusive management of the plurality of instructions is required. A method for automatically generating a command for validating only a command selected from among the plurality of commands and invalidating other commands, wherein a command input process for a common process routine is automatically generated. 2. A program for performing exclusive management of the plurality of instructions is automatically generated as a part of a main routine that calls the common processing routine.
Automatic generation of command input processing for the common processing routine described. 3. An automatic generation method of a sequence program for automatically generating a program based on an operation flow describing a sequence operation of a control target device, wherein each element of the operation flow is in an executable state. Active information indicating whether or not the element has been executed, and execution information indicating whether or not the element has been executed, and suspension information for suspending the execution of the element. 3. A method according to claim 1, wherein a sequence program for giving execution right to a process corresponding to each of the elements is generated based on the information and the hold information. 4. A process corresponding to the element of the operation flow, wherein when the activation information of the element is active and the executed information is not executed, the processing of the element itself is executed and the executed Step processing for making the information executed, and when the activation information of the element is active, the execution information has been executed, and the suspension information is non-suspension, the activation information of the element is inactivated, and the execution information is not executed. 4. A method for automatically generating a command input process for a common processing routine according to claim 3, wherein a transition process for moving the execution right to the next element is generated. 5. A method according to claim 1, further comprising defining a plurality of commands for instructing processing contents to be executed with respect to a plurality of common processing routines, making only the command specified among said plurality of commands valid, and invalidating other commands. A method for defining a command for a common processing routine, characterized in that exclusive management is performed. 6. An automatic program generating apparatus for automatically generating a program based on a method of defining a common processing routine defining a plurality of instructions for instructing processing contents to be executed for a plurality of common processing routines, Input means for inputting one of the plurality of instructions; and when exclusive control of the plurality of instructions is required, only one instruction input by the input means based on an operation flow is validated. And a program generating means for automatically generating a program for invalidating other commands. 7. A program according to claim 6, wherein said program generating means automatically generates a program for exclusively controlling said plurality of commands as a part of a main routine different from said common processing routine. Automatic program generator. 8. An automatic sequence program generation apparatus for automatically generating a program based on an operation flow describing a sequence operation of a control target device, wherein each of the operation flows is in an executable state. Activation information indicating whether or not the element has been executed, execution information indicating whether the element has been executed, and execution information generation means for generating hold information for holding the execution of the element in a hold state, the input means And selecting only one command from the plurality of commands. The program generating means is configured to execute the element itself based on the activation information, executed information, and suspension information of the element generated by the execution information generating means. 7. The automatic program generation device according to claim 6, wherein a step process as an execution process of the step (a) and a transition process for shifting an execution right to a next element are generated. 9. A recording medium for recording an automatic generation program for automatically generating a program based on a definition method defining a plurality of instructions for specifying processing contents to be executed for a plurality of common processing routines, In the case where exclusive control of commands is required, only an instruction selected from the plurality of commands is made valid, and an automatic generation program for automatically generating a command input process of invalidating other commands is recorded. Characteristic computer-readable recording medium.