JP2000112737A - Program generating device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To easily perform bug correction or execution confirmation by designating an optional block that is reproduced and displayed in the same form as when it is generated. SOLUTION: A program generated by a 1st program generating means 21 is associated with a program generated by a 2nd program generating means 31 and an execution program 41 is edited. A target CPU 39 loads the program 41 and drives each subsystem in prescribed procedures. A debugger 61 that debugs the program 41 is further prepared. Whether or not an obtained executable machine code is correctly operated is verified by using a debug monitor, and the operation of the target processor is monitored according to the operation of the debugger 61 on a source level. After designating an optional program to be debugged among reproduced programs, only a designated block and the program of a lower hierarchical block of this block are executed only by performing a start command.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a program creating apparatus for creating real-time software for causing a plurality of tasks to be processed in parallel by a single or a plurality of microprocessors.

[0002]

2. Description of the Related Art Software installed for the purpose of control device control, communication control, and the like conceptually includes, in concept, the inside of the software and the outside world to be controlled. The operation is performed while maintaining the relationship. And when something changes in the outside world,
It is necessary to perform corresponding processing within a limited time. Real-time software refers to software that has the property of performing a predetermined process within the time specified as described above. Among such real-time software, software that receives a stimulus as an input from the outside world and performs processing in a series of performing processing on the stimulus is a discrete event-driven real-time software. The so-called, so-called microprocessor embedded control software is usually in this category.

In recent years, with the development of software engineering, techniques for efficiently creating software using a structured programming language, a high-level language, and the like have been proposed, and these are techniques applicable to all software. is there. However, the discrete event-driven real-time software described above has a special feature compared to other software, and in addition to the creation method applicable to the whole software, the creation of such software There is still room for improvement to make it easier.

That is, discrete event-driven real-time software operates in parallel on a local area network as represented by software for driving a plurality of industrial robots arranged on a production line. You need to describe multiple processes. However, such software creation that has been performed so far is programmed by describing one step at a time on a CRT using a certain programming language, and thus such a creation method operates in parallel. It is necessary to individually create a plurality of processes, and thereafter to synthesize these individually created processes so that the created processes are executed in a parallel operation state on each microprocessor. However, by programming a plurality of processes that are executed in parallel at the same time, the program creator needs to accurately control the overall flow of control and the flow of control executed individually by the microprocessor. It is difficult to recognize these, and it is difficult to ensure their consistency. For this reason, it is often difficult to efficiently create a target program.

Therefore, the applicant of the present application has proposed a language suitable for describing discrete event-driven real-time software (this language is
Hereinafter, it is referred to as a planet (PLANET). ), And a development support environment for it, and invented it in Japanese Patent Application Hei 2-3
No. 37781. This invention is disclosed in
As disclosed in Japanese Patent Publication No. 205423, various requirements such as parallel operation and synchronization of processes can be realized in a description format based on Petri nets. In addition, a diagram can be introduced throughout the entire programming to improve the description and understanding of the processing requirements.

Although the details are disclosed in the above-mentioned published patent publication, for example, the processing represented by the flow chart shown in FIG. 42 (A) is performed by programming in a procedural language (for example, a BASIC-like language or C language). 42
As shown in FIG. 42 (B), if a planet is used, as shown in FIG. 42 (C), a single screen for program creation displayed by the screen display means is displayed by the pattern selection means. The program can be created on the same screen by repeating the operation of alternately selecting the graphic pattern indicating the processing requirement and the directional branch or the directional branch. Therefore, by introducing a diagram throughout programming, the descriptiveness and intelligibility of processing requirements are improved, so that discrete event-driven real-time software can be created efficiently and easily.

[0007] In Planet, in a program,
Just specify the layering of this program and the lower-level program, create a program for each block,
When editing it, a lower hierarchy processing column is automatically created.

[0008]

However, when a program is hierarchized like a conventional planet, when debugging a program in a lower hierarchy, it is necessary to execute a program in an upper hierarchy as well. In order to execute a lower layer program at a stage where a program has not been created, a dummy program must be separately created. In addition, even when the program of the upper hierarchy has been created, if a machine body with a long operation stroke moves, processing, assembling, chemical processing, inspection, etc. are performed in the program of the upper hierarchy, Even when it is desired to debug only the lower layer program, the lower layer program to be debugged is not executed until the execution of the upper layer program is completed. Furthermore, when a large-scale and complicated machine control program is created, it is often the case that a plurality of individuals share the programming, but to debug such a program, the shared program must be created last. If you don't combine with, there is a problem that you can not debug.

[0009] In view of the above problems, an object of the present invention is to provide:
A program creation device for creating each program that is processed in parallel by a plurality of control entities on a network so that each block has a hierarchical relationship on each program. It is to provide a possible configuration.

[0010]

In order to solve the above-mentioned problems, in the present invention, each program to be processed in parallel by a plurality of control entities on a network is arranged such that each block has a hierarchical relationship on each program. A program creating device for creating a program for each block on a display screen, a storage device for storing a program created by the program creating device for each block, Debugging means for debugging the program, wherein the debugging means reproduces and displays the created program block by block in the same form as that at the time of debugging; A block designating means for designating an arbitrary block to be debugged, and And having a start command means for instructing the program execution start of the constant-block.

In the present invention, after designating an arbitrary block to be debugged out of the reproduced program, only a start command is issued, and only the program of the designated block and the lower layer block of the specified block are executed, and the upper layer is executed. No debugger or execution is performed for the block program. Therefore, a dummy program for running the lower hierarchical block is not required even when the upper hierarchical block has not been created. Further, even if a machine body having a long operation stroke moves in a block other than the designated block, or processing such as processing, assembly, chemical processing, and inspection is performed, such a block that is not a target is not executed. That is, the bug correction or the execution confirmation is performed only on the designated block, so that the bug correction or the execution confirmation does not require much trouble.
In addition, since blocks that are not targeted are not executed, bug correction or execution confirmation can be performed only on designated blocks without executing bug-fixed or execution-confirmed blocks. It does not take. Furthermore, even if there is no higher-level block, the ability to correct bugs or confirm execution of individual lower-level blocks alone is suitable for creating large-scale and complicated machine control programs. . In other words, when creating a large-scale and complicated machine control program, a method is used in which a plurality of persons share programming and perform final debugging after combining the programs. Even if there is no block in the upper layer, the creation device can correct a bug or confirm execution of only the block in each lower layer. Therefore, after completing these, individual blocks can be combined.

In the program creating apparatus, when correcting a bug or confirming execution of a program in a lower hierarchy, variables used in an upper hierarchy program as well as this program may be used. Even in such a case, in the present invention, the program creating means declares, on one of the blocks, a variable that can be commonly used in a program group to which the block belongs when creating a program for each block. Keep it. Therefore, according to the present invention, it is possible to execute the program only for the specified block and the lower hierarchical block of the specified block without executing the program for the upper layer block of the specified block.

[0013]

Embodiments of the present invention will be described below.

[Outline of Planet] A plurality of types of graphics representing the contents of each process processed in chronological order on the display screen in order to create a program which is processed in parallel by a plurality of control entities on the network. Regarding a program creating apparatus for creating a program using a pattern, a prior application filed by the present applicant (Japanese Patent Application No. Hei 2-3
37781 / Japanese Patent Application Laid-Open No. Hei 4-205423), so a detailed description is omitted here. However, since the program creation device according to the present invention is based on planets and is an improvement, The outline will be described first.

The program creation device according to the present embodiment has the following configuration as a development environment. Control body side microprocessor (editor, compiler) Main storage device Display console (mouse) Target side drive system processor Communication device Storage device I / O are doing. Also, the program creating apparatus to which the present invention is applied also constitutes software by a correlation between a control entity (a task divided by defining an input event from the outside world and an internal process) and the control means. , Which expresses various requirements such as parallel operation and synchronization of processes included in the internal processing of the control entity in a description format based on Petri nets, and is common to Planet in that it improves the description and intelligibility of processing requirements. .

In a real-time control system to which the planet is applied, an input group (various sensor groups) / an output (actuator group) and a communication path are connected. In a relatively large-scale system having many inputs / outputs, an input / output group is divided for each function. Conventionally, a method has been applied in which a system has a plurality of modules (tasks) for controlling each divided input / output group, and the system is described by exchanging these modules. Therefore, in Planet, the function modules existing in the system are called control entities or subsystems. Further, the exchange between the control entities is performed by transmitting and receiving messages. On the other hand, the machine to be controlled and the whole system to be realized are defined here as a project (real world). In the real world, multiple machines work simultaneously, and data is collected at the same time. Therefore, realizing these with one program is complicated and
It becomes a huge program and maintenance becomes difficult.
Therefore, the real world is extracted to a level that can be easily managed, and divided into a program. This division is the above-mentioned subsystem (control entity).

For example, a control machine including an industrial machine as shown in FIG. 1 has a number of operating points (sensors, solenoids, etc.), and it is possible to treat each of them as a subsystem. Too many systems make management difficult. Therefore, a group of processes that can be easily managed is extracted as a subsystem. For example, assuming that the machine shown in FIG. 1 is a machine that incorporates A or B parts into a pallet according to an instruction from a computer, this machine includes a control panel 11, a material supply unit 12, and a unit group of an incorporation unit 13. Therefore, these groups of units are referred to as subsystems. Here, in order for the control panel 11, the supply unit 12, and the built-in unit 13 to operate as subsystems, the operation is triggered by some event. If this trigger is defined as an initial event, the processing system executed after the initial event is
It operates to evaluate and process the initial event. Then, when the processing sequence ends, the operation is performed to detect the initial event again.

For example, in the machine shown in FIG. 1, the control panel 11 receives a component instruction from an external computer (initial event) and issues a component instruction to the material supply unit 12 (processing content). When the parts run out (initial event), the material supply unit 12 supplies the parts (processing content). When the pallet and parts are prepared (initial event), the incorporating unit 13 incorporates the parts into the pallet (processing contents). Therefore, some kind of exchange is required between the subsystems connected in the pre-process and the post-process, and performing this in software is defined as message communication.

Therefore, in the machine shown in FIG.
1, message communication as shown in FIG. 2 is performed between the supply unit 12 and the built-in unit 13. In this figure, the direction of the arrow indicates the direction of the message.

First, between the subsystem "control panel" and the subsystem "embedded unit", messages "part information" and "installation end" are exchanged, and the subsystem "supply unit" is exchanged with the subsystem "embedded unit". The message "component presence / absence" is transmitted to the "unit".

Therefore, when the program is started, a "start" message is transmitted from the subsystem "control panel" to the subsystems "supply unit" and "embedded unit". Then, in the subsystem “control panel”, component information indicating which component, A or B, is to be incorporated from outside through the user I / O “A”, “B”. Based on this component information, the “component information” is transmitted to the subsystem “embedded unit”, and when the completion of the installation is received from the subsystem “embedded unit”, preparation for receiving the next information is made.

These processing sequences are extremely simple and can be easily realized. However, due to the nature of real-time control software, multiple input events occur asynchronously, and the events to be detected change every moment depending on the internal state. It becomes a bottleneck at the time.

Therefore, in order to express each processing sequence in a straightforward manner, the planet employs a description format using a directed graph structure based on Petri nets instead of a one-dimensional processing sequence using character strings.

That is, in the planet, the processing sequence in the subsystem "control panel" is created using a graphic pattern as shown in FIG. 3 as a language element. Here, the graphic pattern includes a plurality of types of graphic patterns indicating processing contents,
A directed branch indicating the time-dependent flow direction of the processing requirement, and a first arrow (branch-directed) indicating that the processing requirement that branches at least into two branches and that follows in time series is to be processed in parallel. Branch) and a second arrow (branching directed branch) indicating that the subsequent processing requirement is a processing operation in which at least two branch branches are processed in synchronization with the end of a plurality of preceding processing requirements. ). Of the various graphic patterns indicating the processing contents, the oval cells are message input cells, and those output by arrows indicate the beginning of the processing sequence, and are described here as "BEGIN". The message input cell to which the arrow is input indicates the end of the processing sequence, and “END” is written here. The cell surrounded by a double rectangle is an event waiting cell, and when an entered event occurs in event detection, the processing is terminated. The cells surrounded by rectangles are activity processing cells, indicating activity requirements,
When it is driven, it performs processing immediately. A cell with two rectangles and a triangle below is a conditional branch cell. Fill in the condition in the left square, and if it meets the condition, it will be executed according to the arrow below.

As shown in FIG. 4, the material supply unit operates by receiving a "start ()" message from the subsystem "control panel" as shown in FIG. First, the presence or absence of a component is detected by a sensor, and the supply operation is performed. The actual operation of the supply is further performed by the lower-layer block “supply”. When the supply is completed, the subsystem "Equipment presence / absence"
Send a message. When there are no more parts, the stockout processing is performed by the lower layer block "Stockout processing".

As shown in FIG. 5, the built-in unit also includes the processing sequence created by the planet as shown in FIG.
It operates by receiving a “start ()” message from. First, when the pallet and parts are set,
Install components. Which component A or B is to be incorporated is specified by the variable “type” of the message “component information” from the subsystem “control panel”. When the installation is completed, a message "installation end" is transmitted to the subsystem "control panel" to prepare for obtaining the next information. Note that "D
The description "IM type AS REAL" is a declaration of a variable described later.

When such a program becomes large in scale, the diagram becomes huge and complicated, and it becomes difficult to understand. Therefore, Planet has set one process.
It is stored in a single diagram, which can be called as one processing requirement in the higher-level abstract level diagram.

[Hierarchical Structure] FIG. 6 shows this relationship. This relationship is called a hierarchical procedure. Here, the processing of the lower layer is driven when the control reaches the processing requirement of the upper layer. That is, when the processing of the upper hierarchical block reaches the activity processing cell of the lower hierarchical block, control is transferred to the BEGIN terminal of the lower hierarchical block, and the lower hierarchical processing sequence starts executing. Then, when the processing of the lower layer processing proceeds and reaches the END terminal, all controls in the lower layer are discarded, and control is returned to the upper layer. Then, the returned control continues the processing requirements in the upper layer. In short, on one screen, the up-down direction means the time-series direction of the processing, and the spread left and right means the parallelism of the processing. That is, the so-called depth direction of the screen means the hierarchy. In such a procedure hierarchization, when hierarchy is designated by the above-mentioned hierarchy processing sequence, a lower hierarchy processing sequence is automatically created, and its state is represented by a tree view as described later. With this configuration, the upper layer describes only the flow of processing with a high level of abstraction, so that it is simpler and easier to understand than a procedural language that describes all the procedure sequences of a program. Become.

When the procedures are hierarchized in this way,
A group of subprocedure programs described as control requirements in an upper layer program is called a block.
The block is given a name, and the lower hierarchical block is called by filling in the processing requirements of the upper hierarchical block. To call the lower hierarchical block,
Recursion and indirect recursion are allowed.

[Handling of Variables] Here, the variables required to run each block are composed of three different types of variables including local variables, global variables, and backup variables. You must declare the type of the variable before using it. Each variable is given a variable name.

Of these variables, local variables are common only in blocks, global variables are common in subsystems, and backup variables are common in the entire project and are backed up (meaning non-volatile). . This is shown in FIG. To use these variables, use the following statement in the block: Local variable DIM variable name ... AS variable type Global variable GLOBAL variable name ... AS variable type Backup variable SYS variable name ... AS variable type declare.

Numeric variables are classified into integer types and real types. The following statement formats are used: [variable declaration] [variable name] 名, [variable name] nAS
Defined in [Type declaration]. Here, even in the integer type, an integer from -128 to 127, and -2147483648 to 21474
In the case of an integer up to 83648, the number of used bytes is different from 1 or 4, so that [BYTE],
Use a type declaration statement with [INTEGER]. Further, even in the case of a real number type, since the number of bytes used is different between 4 and 8 for a 7-digit real number and a 14-digit real number, type declaration statements of [REAL] and [DOUBLE] are used, respectively.

A character string variable is also defined by the following statement format: [variable declaration] [character string variable name] {, [character string variable name] nAS STRING]}.

An array variable is a group of variables of the same type. Numeric variables and character string variables have the following statement format: [variable declaration] [variable name] [a ｛, ｛, c｝] [type declaration statement] , A, b, and c are the numbers of arrays in each dimension, each of which is 0 to 2
An integer variable of 54 * a * b * c (product of a, b, c) ≦ 32767 can be used as an array variable.

[Example of Program] An example of a program created by a planet having such a configuration will be described with reference to FIGS.

The program shown here has control programs (operation panel control program, unit control program) corresponding to each of the two subsystems (operation panel, unit), as shown in the tree view. Each has a hierarchical structure.

That is, as shown in FIG. 8, the operation panel control program and the unit control program each include a root block RootBl as an upper hierarchical block.
For example, the unit control program has an automatic operation block, a home position return block, a teaching block, and a manual operation block as its lower hierarchical blocks.

Of these lower hierarchical blocks, the unit control / origin return block, for example, has two types of manipulator setting (L side and R side) blocks as lower hierarchical blocks. Further, as shown in FIG. 9, the unit control / automatic operation block has a unit control left supply position moving block and the like as further lower hierarchical blocks.

The example shown here uses diagrams throughout programming. However, the unit control left feeding position moving block as a lower layer block of the unit control / automatic operation block can also be created in a procedural language as shown in FIG. 10, and this block is created in a procedural language. Sometimes it is more concise.

Therefore, in the present embodiment, as will be described below, the conventional planet allows the introduction of a diagram throughout the entire programming, whereas the improved planet to which the present invention is applied (hereinafter, referred to as a planet 95). In this example, a lower-layer program created in a procedural language is linked to be edited into an execution program. For example, as shown in FIG. 10, the unit control left supply position moving block is created by a programming tool in a procedural language, and other programs or programs of a higher hierarchy are created on the planet 95, In the blocks of the hierarchy,
By simply specifying a lower-level block, regardless of whether it is created on the planet or in a procedural language, one execution program can be created by linking and editing. For this reason, engineers called veterans are responsible for creating programs using a familiar procedural language, and young engineers who have flexibly accepted new programming languages such as planets have this A method of completing one program can be achieved while being in charge of a program creation operation using a new programming language such as PLANET. In addition, there is an advantage that a program asset created by a procedural language can be used as it is.

[Linked Editing Example 1] FIG. 11 is a functional block diagram showing program linking and editing operations performed in the program creating apparatus to which the present invention is applied.

Referring to FIG. 11, a program creating apparatus to which the present invention is applied has a graphic program for generating a program on a display screen using a plurality of types of graphic patterns representing the contents of each processing performed in chronological order of the program. Editor 2 for creating (hereafter, a PLANET program)
1 is prepared as a first program creating means,
The editor 21 creates a PLANET source file 212 in block units for each subsystem. Also, a procedural program editor 31 for creating, using a procedural language, a lower layer program of a processing element displayed by a graphic pattern in the program created by the first program creating means 21 as a second program creating means. It is prepared and this editor 3
1 creates a procedural program source file 312 in block units. As the second program creating means 31, a text editor mounted on the planet 95 itself or a general-purpose text editor can be used. As the second program creating means 31,
When a text editor mounted on the planet 95 itself is used, the file name is automatically added and saved on the planet 95. On the other hand, when a general-purpose editor is used as the second program creation means 31, the file is saved with a file name having a predetermined extension.

In the planet 95 of this embodiment, the PLA
The source code of the NET source file 312 allows a program created in a procedural language to be referred to as a lower-layer program. For this reason, in the compiling or interpreter processing described below, information of the procedural program declared in the source code and thereafter left as link information can be identified, and the procedural program can be linked. In the editor 21, a link to the procedural program is declared by a method as shown in FIG. First, it is assumed that lower-level blocks called SUB1 and SUB2 are described in a PLANET source “SUBMAIN” that describes the processing of a certain subsystem. Normally, the lower-level blocks are also graphic programs, and when "SUB1" is opened, the PLAN
ET1 source code, SUB1 property is PL
ANET is selected. On the other hand, "SUB2"
When you open, it is an empty block, and the property is procedural program selected. Further, the file name (SUB2.PRG) of the procedural program linked as the block SUB2 is described. As described above, the graphic program editor 21 according to the present embodiment can select a graphic program (PLANET) or a procedural program as a property of a block, and the information is referred to as link information by a compiler and an interpreter. .

The program creation system of the PLANET 95 according to the present embodiment includes first and second program creation means 21.
And 31, each of which has a compiler 22 and 32, so that the graphic program compiler 22 functions as a cooperative editing means. In this example, one execution program is edited for each target CPU (processor) from the blocks (programs) created by the first and second program creation means 21 and 31. First, the compiler 22 converts the program for each block created by the first program means 21 using the graphic pattern into a program that can be directly executed on the control device based on the graphic information. In this case, the execution rules of Petri net are introduced at the time of program analysis, and DFS, BFS, DAG in graph theory are introduced.
The control flow and the data flow are analyzed by using a method such as that described above, and the planet program structure obtained by the graphic is developed into a plurality of sequential processes operating in parallel.
Applying microprocessor code selection and generated code optimization to each process generated in this way,
At the same time, the actual running code is generated while linking the blocks created in the procedural language by the second program creating means 31.

The above processing will be described in more detail as follows.

First, the parser 221 analyzes the graphic information file 212 of the planet program (sole file) created by the editor 21, generates a running code of the virtual machine, and generates a block-based intermediate code corresponding to the source file 212. Store it in a file. The parser 221
Analysis is performed for each program frame of each block. The generated program information for each block is combined by the subsequent operations to form a large program.

Next, the sorter 222 links the analysis results for each block output by the parser 221 at an intermediate code level. That is, if a block with the same processor name is searched from the specified input file group and the intermediate code of the block is stored in the file, and a lower hierarchical block is called in this block,
The lower-level block is searched and added to the file.
Similarly, the blocks of all control entities activated in these blocks are searched and added to the file. When all necessary blocks are stored in the file in this manner, the address and name information of the I / O port and bit of the processor are searched, and the I / O port and bit in the block are searched. If you are using, write the address to a file. Also, the global variables accessed by the lower hierarchical blocks are linked. As a result, the sorter 222 causes the intermediate code file 232 for each processor and the intermediate code file 2
A link information file 233 is described in which link information necessary for performing the processing by the H.32 is described. The link information file 233 may be formed as a file having a different name from the intermediate code file 232, or
It goes without saying that the intermediate code file 232 may be included as link information.

Next, the code generator 223 receives the intermediate code of the virtual machine output by the sorter 222 as input, generates a machine code equivalent to the intermediate code, and outputs a machine code file 234. Further, the code generator 223, based on the information included in the intermediate code of the virtual machine output by the sorter 222, not only the machine code, but also the link information on the network, the link information with the assembler, and the procedural language. A link information file 235 including link information and the like is also generated.

On the other hand, the second program means 31
A program created as a lower layer block in a procedural language is translated into an intermediate code by a parser 321 of a compiler 32, and further converted by a code generator 323 into a program that can be directly executed on a control device. A machine code file 334 is created.

Linker 2 of Compiler 22 for Planet
24 links all the requirements, such as link information on the network, link information with the assembler, and link information with the procedural language, generated by the code generator 223, to generate machine code that can be actually operated by the machine. ,
An execution program 41 is output. For example, based on the link information supplied in the link information file 235, a module described by an assembler is searched from the designated library file 50, and a driving mode is added. Also,
Based on the information for linking the blocks generated in the procedural language, the specified file is searched for the blocks and the driving mode is added. The travel code thus obtained is output as the actual travel code file 41. Therefore, when a plurality of processors are described in a planet program, a relatively large state in which all the processors can be executed as they are, that is, a state in which an associated library or an execution module of all lower-layer programs is incorporated. An actual running code file is generated.

In this manner, the link editing means for editing the execution program 41 by associating the program created by the first program creation means 21 with the program created by the second program creation means 31 is constituted. I have. Then, each target CPU loads the execution program 41 and drives each subsystem according to a predetermined procedure. Further, a debugger 61 for debugging each execution program 41 is provided in the PLANET system, and each execution program 41 can be debugged. This debugger 61 will be further described below.

[Second Example of Linkage Editing] FIG. 13 is a functional block diagram showing another linkage and editing operation of a program performed by the program creating apparatus to which the present invention is applied.

In FIG. 13, first, editors 21 and 31 are used in the same manner as in the PLANET system shown in FIG.
Source files 212 and 312 respectively
Is created. Next, the PLANET source file 21
2 is the parser 2 in the compiler 22 as described above.
In 21, a running code of the virtual machine is generated from the program 212 for each block created using the graphic pattern,
Stored in the intermediate code file. Next, the sorter links the analysis result for each block output by the parser 221 at an intermediate code level. That is, a block having the same processor name is searched from the specified input file group, the intermediate code of the block is stored in the file, and if a lower layer block is called in this block, the lower layer is called. Find the block and add it to the file. Similarly, the blocks of all control entities activated in these blocks are searched and added to the file. When all necessary blocks are stored in the file in this manner, the address and name information of the I / O port and bit of the processor are searched, and the I / O port and bit in the block are searched. If you are using, write the address to a file.
Also, the global variables accessed by the lower hierarchical blocks are linked. The code generator receives the intermediate code of the virtual machine output by the sorter as input and generates a machine code equivalent thereto. In addition, based on the information contained in the intermediate code of the virtual machine output by the sorter, the generator not only outputs the machine code but also the link information on the network, the link information with the assembler, and the link information with the procedural language. Generate. Since the configuration of the compiler 22 is the same as that of the above example, it is omitted in the drawing.

In this way, a file of machine code and a file of link information are generated for each CPU by the code generator in the same manner as in the above example. In the system of this example, the linker 22 is used by using these files.
4 fetches an execution module from the library 50 or the like, but generates an execution program file 42 in a state where the execution module of the procedural program is not fetched, and a link information file 43 including link information to the procedural program. In the system of this example, the link information file 43 is created in the form of a header file for linking blocks generated in the procedural language. This link information can of course be stored in the execution program file.

On the other hand, the source file 312 of the lower hierarchical block created by using the procedural language by the editor 31 as the second program creating means is converted (translated) into an intermediate code which can be interpreted by the interpreter 34 by the parser 321. And output as an intermediate code file 331.

As a result, the target CPU 39 determines that the portion described in the graphic type program (PLANET program) is the execution program 42 translated into machine code.
Is loaded and processed, and the portion described in the procedural program is interpreted by the interpreter 34 based on the link information 43.
Performs processing based on the machine code translated into the machine language. Accordingly, the interpreter 34 functions as a link editing unit that provides a program executable by the processor by linking the PLANET program and the procedural program based on the link information.

[Example 3 of Linked Editing] FIG. 14 is a block diagram showing still another example of a program creation system to which the present invention is applied. In FIG. 14, first, FIG.
The source files 212 and 312 are created by the editors 21 and 31 in the same manner as in the PLANET system shown in FIG. Next, the PLANET source file 212 is stored in the compiler 22 in the same manner as described above.
The parser 221 creates an intermediate code file for each block, and the sorter 222 creates an intermediate code file 232 for each processor. This intermediate code file 23
At the same time, the I / O port and bit address of the processor, the global variables accessed by the lower hierarchical block, the link information on the network, the link information with the assembler, and the link information with the procedural language The link information file 233 including the is created. In this example, the output is output from the compiler 22 without being converted into the machine code in this state.

On the other hand, the source file 312 of the lower hierarchical block created by using the procedural language by the editor 31, which is the second program creating means, is translated by the parser 321 into an intermediate code which can be interpreted by the interpreter 34. It is output as a code file 331.

As a result, the graphic program (PLANE
The part described in the T program) and the part described in the procedural program are provided to the target CPU 39 in an intermediate code state. In the target CPU 39,
The interpreter 34 is already mounted, and at the time of execution, the intermediate code is interpreted line by line and executed. Further, when the library 50 is referred to, the interpreter 3
4, the execution module is loaded and the CPU
39. Therefore, if the interpreter 34
The LANET program and the procedural program are linked on the basis of the link information and function as a link editing means for supplying a program executable by the processor. In the system of this example, since the graphic type program and the procedural type program are stored in the memory at the stage when the intermediate code is translated, the machine code can be executed immediately after all the programs are translated into the machine code. The memory capacity may be smaller than when stored in the memory. Further, since the intermediate code is translated, the processing time of the interpreter 34 can be reduced, and the execution speed of the program can be secured.

[Debugger / Confirmation of Execution] Whether or not the executable machine code obtained in this way operates correctly can be determined by using a debug monitor in any of the embodiments described with reference to FIGS. To verify. This debug monitor program can be executed on various computers. The contents of this debugger 61 (debugging means)
Download program, trace program, I
Monitoring of the / O port. By the operation of the debugger 61, the operation of the target processor can be monitored at the source level. Therefore, since debugging can be performed at the source level, debugging can be performed efficiently.

Further, in this embodiment, after designating an arbitrary block to be debugged out of the reproduced program, only a start command is executed to execute only the designated block and the program of the lower hierarchical block of this block. As shown in FIGS. 15A and 15B, the control frames are tree-structured. That is, FIG.
In (B), the block frame control block (BFCB) F of the highest-order block frame A
A, the block frame control blocks FB and FC of the block frames B and C one level lower than it, and the block frame control block FD of the block frame D one layer lower than it, respectively, the one lower layer block frame (ChildFrames) Are listed. For this reason, when block C is executed to perform a debugging operation on block C,
In this block frame control block FC,
In addition to the TCB of this block frame, an upper layer block frame A (ParentFrame), a preceding block frame B (PreFrame), and a block frame D (ChildFrames) one layer lower than that are listed. Frame A
Without executing the program, the thread of the lower-layer block frame D is executed as a subroutine,
The return address allows the user to jump again and continue the thread.

Further, as shown in FIG. 15B, the TCB of each of the block frames A, B, C, and D includes
In addition to CB (NextTCB, PreTCB), its own intermediate code string is stored as a block frame parameter.

(Debug: Setting of Break Points) In the program creating apparatus thus configured,
To set a breakpoint, select "Break" in the toolbar as shown in FIG. Move the mouse to the cell where you want to set a breakpoint and click. The procedure for setting a breakpoint is the same as that for setting a breakpoint.

(Debug: Execution of Subsystem) To execute the program, select "Run" from the toolbar. Then, as shown in FIG. 17, the execution of the program is started, and a message appears in the output window.
If a breakpoint is set during the program, the red ball will stop at that location, indicating that the program is "paused". To advance the suspended red ball, click on the point where the red ball should pass next (st
ep). When the designated function key (for example, F5) is pressed, the program can be restarted regardless of the break point.

(Forced termination of program) When the execution of the program is stopped, "Abt (Stop)" is selected from the toolbar as shown in FIG.

The debugging work is performed in the same manner as the execution confirmation.
Like the program creation by the editor, the program can be performed on a multi-window using a mouse and a keyboard. The multi-window, the mouse and the keyboard constitute a block designating means for designating a block to be executed.

For example, referring to the example shown in FIG.
First, a target block is clicked on the tree view to select a block. As a method of selecting the target block, not only the specification on the tree view but also a method of directly specifying the window of the program opened on the screen may be used. As a result, the target block is specified, and the corresponding source program is called from the source file (storage means) and displayed. When "execute" is selected from the pop-up menu (start command means), execution is started from the BEGIN terminal in an arbitrary block of the target processor, executed until control reaches the END terminal, and terminated. In addition, as an instruction method of the execution start, the execution instruction may be performed not only from the pop-up menu but also from a pull-down menu, a shortcut key, a function key, or the like. The execution instruction may be given by drag and drop.

At this time, when the target block includes the lower hierarchical block, the lower hierarchical block is also executed. That is, in the hierarchical structure shown in FIG. 6, when the block B1 is designated as a target, the block B2 which is a lower hierarchical block is also executed. Variables are necessary for such execution, but in the present embodiment, as described with reference to FIG. 7, variables used only in the corresponding block are set as local variables and shared in the subsystem. Of the variables, a global variable accessed by a lower hierarchical block may be declared to be a global variable in this block when any block is created.

As described with reference to FIGS. 11 to 14, when linking the analysis result for each block output by the parser 221 of the compiler 22 at the intermediate code level,
The sorter 222 also outputs information about the global variables as a link information file 233 along with other link information. Therefore, processing such as setting appropriate values for these global variables can be performed. Therefore,
Since an arbitrary block can be selected and executed together with this block alone or a lower-level block included therein, it is possible to execute only a specific block.

Therefore, up to the upper hierarchical block,
Since there is no need for a debugger or execution, there is no need for a dummy program for running the upper hierarchical block. In addition, a machine body with a long operation stroke moves, blocks,
Even if processes such as assembly, drug processing, and inspection are performed, such non-target blocks are not executed. That is, the bug correction or the execution confirmation is performed only on the designated block, so that the bug correction or the execution confirmation does not require much trouble. In addition, since blocks that are not targeted are not executed, bug correction or execution confirmation can be performed only on designated blocks without executing bug-fixed or execution-confirmed blocks. It does not take.
Furthermore, even if there is no higher-level block, the ability to correct bugs or confirm execution of individual lower-level blocks alone is suitable for creating large-scale and complicated machine control programs. . That is,
When creating large and complex machine control programs,
A method is adopted in which multiple people share programming and combine them last, and then perform comprehensive debugging.However, in the program creation device of this embodiment, even if there is no higher-level block, individual Bug correction or execution confirmation can be performed only on the lower-level blocks, and after these steps are completed, individual blocks can be combined.

[Operation Method] With reference to FIGS. 19 to 41, the overall function will be described while explaining the operation method of the planet 95.

(Activation of Planet 95) Double-click "PLANET.EXE" on the desktop.

(Creation of a New Project) As shown in FIG. 19, a new project is created for writing a program. Next, when a project name is input to the new project name (N) and an "OK" button is pressed, a project name is created. Here, the project name "s
sample ". Here, the project refers to a file constituting one device.

(Target Definition) One controller (FA / PC or the like) unit is called a target. Here, the name of the target is defined. To do that,
As shown in FIG. 20, after selecting the hardware tab, right-click the hardware in the tree view, and then click Properties.

Then, a "target definition" window is displayed as shown in FIG. To define a target, press the "Add" button.

Then, a “target property” window is displayed as shown in FIG. After inputting the target name and making various settings, and pressing the "OK" button, the target is defined. In the example shown here,
Target name “Target1”.

When the target is defined as described above,
As shown in FIG. 23, a target name “Target1” is displayed below the hardware.

(Definition of Subsystem) When defining a subsystem, as shown in FIG. 24, click on the program tab and double-click the project name (“sample” in this example) created in the tree view. click. Then, the subsystem configuration window is opened.

Next, as shown in FIG. 25, when the “subsystem” icon is selected from the toolbar,
Enter subsystem creation mode.

While pressing the left mouse button in the subsystem configuration window, drag to an arbitrary size to draw a rectangle. Then, as shown in FIG. 26, a “subsystem property” dialog box appears. When the subsystem name is entered in the “subsystem property” dialog and the “OK” button is pressed, the subsystem name “subsystem 1” is entered in this example.

Then, as shown in FIG. 27, a subsystem called “subsystem 1” is created, and the definition of the subsystem is completed.

(Confirmation of reflection in tree view) Similarly,
As shown in FIG. 28, “subsystem 2” is created as a second subsystem. Then, it is confirmed that the created “subsystem 1” and “subsystem 2” are reflected in the left tree view.

(Message definition) To create a message, as shown in FIG.
t ".

Then, the mouse is right-clicked on the subsystem that is the message transmitting side. Then, a pop-up menu appears as shown in FIG. From the pop-up menu, select "New Message Tap (N)".

When "new message tap (N)" is clicked, a message property appears as shown in FIG. Set the message name and arguments. In this example, the message name is set to "message 1", the type of the argument attached to the message is set to "INTGER", and the argument name is set to "argument 1".

(Setting of Reception Subsystem) As shown in FIG. 32, when the “Reception Setting” button of the message property is pressed, a “Reception Subsystem” window appears. Click the name of the receiving subsystem. And
Check that the selection field has a double circle. In the example shown in this figure, since the message transmitted from the subsystem 1 is received by the subsystem 2, "subsystem 2" is clicked and a double circle is added. When the selection of the receiving subsystem is completed, press the "OK" button.

(End of Message Definition) When the procedure up to now is completed, “O”
Press the "K" button. Message definition is completed by the above procedure. To re-edit the message once defined,
As shown in FIG. 33, right-click on the message terminal on the transmitting side to be edited. Then, a pop-up menu appears. Select "Tap message edit" in the pop-up menu.

(Setting of manipulator / I / O label)
Select the Hardware tab. Right click on the target name in the tree view, as shown in Fig. 34,
A pop-up menu opens. When "open" is selected in the pop-up menu, a window for defining an I / O label is displayed, so that each setting can be performed.

(Creation of Block) Next, block creation is performed. Subsystem 1 "in the tree view window
Double-click “RootBlk”.
As shown in FIG. 5, “Subsystem 1: RootBlk”
A window opens. Select the icon of the cell you want to input from the toolbar and write the program.

When calling [lower hierarchy],
When the lower hierarchy in the tBlk window is created,
As shown in FIG. 36, it is also reflected on the tree view. In the example shown here, a lower hierarchy “operation end ()” is created.

[Setting of Message Transmission Terminal] As shown in FIG. 37, the setting of the message terminal is represented by the same ellipse as BEGIN.

[Connection of Arc (Arrow)] After the drawing of the graphic cells is completed, as shown in FIG. 38, the cells are connected by arcs. The operation procedure of the arc connection is as follows. First, the mouse is placed in the cell on the output side and clicked once, and then, once in the cell on the input side, the arc is connected. If the connection fails, the connection point turns red, so delete it with the DEL button and reconnect.

The connection of the arcs, which represents the branch / confluence point of the processing, is possible only when the respective lines are vertical or horizontal. At this time, if an arc is drawn while pressing the Shift key, the line becomes vertical or horizontal. PLAN
In ET95 (PLANET), it is necessary to output arcs from all output nodes.

[Message Reception] As shown in FIG.
RootBl of the "subsystem that will be the message receiver"
k ”is opened and described. In the example shown here, since“ Subsystem 2 ”receives the data,“ Root ”of the subsystem 2 is used.
Blk "is opened. In the description of message reception, an argument is written in the message name and () in the single weight. If there is no argument, only () is displayed.

[Compile] When the description of all the programs is completed, select "compile" from the toolbar and execute. When the processing is completed without a compile error, a message of "compilation completed" appears in the output window as shown in FIG. If compilation fails due to an error or the like, the location and content of the error are displayed in the output window. Double-click the error display in the output window to open the window of the error display location.

[Debug: System mode after execution in EXE mode] After compiling, "EX
E (execute button) ". Then, as shown in FIG. 41, the system monitor is displayed, and the status of each variable and I / O are displayed.

(Debug: Setting Break Point) To set a break point, select "Break" in the toolbar as shown in FIG. That is, the mouse is moved to a cell where a breakpoint is to be set, and clicked. The procedure for setting a breakpoint is the same as that for setting a breakpoint.

(Debug: Execution of Subsystem) To execute a program, "Run" is selected from the toolbar. Then, as shown in FIG. 17, the execution of the program is started, and a message appears in the output window.
If a breakpoint is set during the program, the red ball will stop at that location, indicating that the program is "paused". To advance the suspended red ball, click on the point where the red ball should pass next (st
ep). When the designated function key (for example, F5) is pressed, the program can be restarted regardless of the break point.

(Forced termination of program) To stop the execution of the program, select "Abt (stop)" from the toolbar as shown in FIG.

[0100]

As described above, in the program creating apparatus according to the present invention, an arbitrary block to be debugged among the reproduced programs is designated, and only the designated block and the program of the lower hierarchical block of the designated block are designated. Is executed, there is no need to execute a debugger or execution even for the program in the upper hierarchical block. Therefore, a dummy program for running the lower hierarchical block is unnecessary even when the upper hierarchical block has not been created. Also, bug fixes or execution confirmations are performed only on the specified blocks,
There is no need to fix bugs or confirm execution. Further, the ability to correct a bug or confirm the execution of only the individual lower-layer blocks even if there is no upper-layer block is suitable for creating a large-scale and complicated machine control program. In other words, when creating a large-scale and complicated machine control program, a method is employed in which a plurality of persons share programming and perform final debugging after combining the programs. Even if there is no block in the upper layer, the creation device can correct a bug or confirm execution of only the block in each lower layer. Therefore, after completing these, individual blocks can be combined.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram for explaining a project and a subsystem in a program creation device to which the present invention is applied.

FIG. 2 is an explanatory diagram of message communication performed between subsystems shown in FIG. 1;

FIG. 3 is an explanatory diagram showing a route block of a control panel (subsystem) shown in FIG. 1;

FIG. 4 is an explanatory diagram illustrating a route block of the material supply unit (sub system) illustrated in FIG. 1;

FIG. 5 is an installation unit (subsystem) shown in FIG. 1;
FIG. 4 is an explanatory diagram showing a route block of FIG.

FIG. 6 is an explanatory diagram showing hierarchization of blocks in a program creation device to which the present invention is applied.

FIG. 7 is an explanatory diagram showing handling of variables in a program creation device to which the present invention is applied.

FIG. 8 is an explanatory diagram showing an example of a program created by a program creating apparatus to which the present invention is applied.

FIG. 9 is an explanatory diagram showing a state where another block is displayed in a program created by the program creating apparatus to which the present invention is applied.

FIG. 10 is an explanatory diagram showing an example in which lower-level blocks are created in a procedural language in the program shown in FIG. 9;

FIG. 11 is a block diagram showing a configuration for linking and editing a program created by using a graphic pattern and a program created by using a procedural language as a lower layer program in the program creating apparatus to which the present invention is applied. FIG.

FIG. 12 is a diagram illustrating an example of setting a property of a block.

FIG. 13 shows another configuration for linking and editing a program created by using a graphic pattern and a program created by using a procedural language as a lower layer program in the program creating apparatus to which the present invention is applied. FIG.

FIG. 14 is a block diagram showing an outline of a different system of a program creating apparatus to which the present invention is applied.

FIG. 15 is a block diagram showing an outline of still another system of the program creating apparatus to which the present invention is applied.

FIG. 16 is an explanatory block diagram showing a configuration of a block frame in a program creating apparatus to which the present invention is applied.

FIG. 17 is an explanatory diagram showing an operation for executing debugging in the program creation device to which the present invention is applied.

FIG. 18 is an explanatory diagram showing an operation for forcibly terminating a program in a program creating apparatus to which the present invention is applied.

FIG. 19 is an explanatory diagram showing an operation for creating a new project in the program creating apparatus to which the present invention is applied.

FIG. 20 is an explanatory diagram showing an operation of displaying a window for defining a target in the program creation device to which the present invention is applied.

FIG. 21 is an explanatory diagram showing an operation of defining a target on a window in a program creation device to which the present invention is applied.

FIG. 22 is an explanatory diagram showing a target property window for performing a target definition on a window in the program creation device to which the present invention is applied.

FIG. 23 is an explanatory diagram showing a window after target definition is performed in the program creation device to which the present invention is applied.

FIG. 24 is an explanatory diagram showing a window for defining a subsystem in the program creation device to which the present invention is applied.

FIG. 25 is an explanatory diagram of a subsystem creation mode window when a subsystem is defined in the program creation device to which the present invention is applied.

FIG. 26 is an explanatory diagram of a subsystem property dialog when defining a subsystem in the program creation device to which the present invention is applied.

FIG. 27 is an explanatory diagram of a window after one subsystem is defined in the program creation device to which the present invention is applied.

FIG. 28 is an explanatory diagram of a window after two subsystems are defined in the program creation device to which the present invention is applied.

FIG. 29 is an explanatory diagram showing an operation for defining a message in a program creation device to which the present invention is applied.

FIG. 30 is an explanatory diagram showing an operation for defining a message in the program creation device to which the present invention is applied.

FIG. 31 is an explanatory diagram showing message properties displayed when defining a message in the program creation device to which the present invention is applied.

FIG. 32 is an explanatory diagram of a receiving-side subsystem window in the program creation device to which the present invention is applied.

FIG. 33 is an explanatory diagram showing an operation for selecting message tap editing on the transmission side in the program creation device to which the present invention is applied.

FIG. 34 is an explanatory diagram of a window for setting an I / O label in the program creation device to which the present invention is applied.

FIG. 35 is an explanatory view showing a state in which a program is described by selecting an icon of a cell to be input from a toolbar in a program creating apparatus to which the present invention is applied.

FIG. 36 is an explanatory diagram showing a tree view when a lower hierarchy is created in the program creation device to which the present invention is applied.

FIG. 37 is an explanatory diagram of a window for setting a message terminal in the program creation device to which the present invention is applied.

FIG. 38 is an explanatory diagram showing a method of connecting arcs (arrows) in a program creation device to which the present invention is applied.

FIG. 39 is an explanatory diagram for describing message reception in the program creation device to which the present invention is applied.

FIG. 40 is an explanatory diagram showing a message of a compile result performed after writing a program in the program creating apparatus to which the present invention is applied.

FIG. 41 is an explanatory diagram showing an operation for performing debugging in a program creation device to which the present invention is applied.

42 (A), 42 (B), and 42 (C) are an explanatory diagram showing a process in a flowchart, an explanatory diagram showing an example in which a program is created in a procedural language, and an example in which a program is created in a planet. FIG.

[Explanation of symbols]

 21 first program creating means (editor) 22, 32 compiler 31 second program creating means (editor) 34 interpreter 41 executable program 50 library file 61 debugger 211, 311 editor 212, 312 source file 221 parser 222 sorter 223 code generator 224 linker

Continued on the front page (72) Inventor Hiroyuki Kanai 3-3-5 Yamato, Suwa-shi, Nagano F-term in Seiko Epson Corporation (reference) 5B076 DD03 EC01 5H215 AA07 BB10 CC07 CX02 GG04 GG20 JJ14 5H220 AA05 BB12 CC07 CX02 DD10 EE08 JJ02 JJ12 JJ13 JJ29 JJ53 JJ60 KK08 LL04

Claims (2)

[Claims] 1. Each program, which is processed in parallel by at least one or more control entities on a network,
In a program creating apparatus for creating each block in each program so as to have a hierarchical relationship, a program creating means for creating a program for each block on a display screen, and a program created by the program creating means for each block. And debugging means for debugging the created program. The debugging means reproduces the created program for each block at the time of debugging in the same form as when the program was created. A display unit for displaying, a block designating unit for designating an arbitrary block to be debugged out of the reproduced program, and a start instruction unit for instructing a start of program execution of the block designated by the block designating unit A program creation device characterized by the above-mentioned. 2. The program creation means according to claim 1, wherein the program creation means declares, on one of the blocks, a variable that can be commonly used in a program group to which the block belongs when creating a program for each block. By doing so, the debugging means does not execute a program for a block in a higher layer of the designated block,
A program creating apparatus capable of executing a program only for a specified block and a lower hierarchical block of the block.