JPH04205423A - Program creation device - Google Patents

Abstract

PURPOSE:To efficiently and easily form a desecrate event driving type real time software by forming parallel processing programs on the same screen. CONSTITUTION:A program former repeats the operations for alternately selecting a graphic pattern indicating a processing condition and a directional branch or a dispersed directional branch by a pattern selecting means and forms a program on the same program forming screen displayed by a screen display means. The formed program is converter into a program constituted of machine words capable of practically driving a microprocessor. Consequently, the desecrate event driving type real time software can be efficiently and easily formed.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a program creation device that can efficiently write real-time software. More specifically, the present invention relates to a program creation device that can efficiently (and easily) create parallel processing programs on the same screen for processing multiple tasks in parallel by a single or multiple microprocessors.

[Conventional technology]

Conceptually speaking, software installed for the purpose of control equipment control, communication control, etc. always exists inside the software and the outside world of the controlled object, and operates while maintaining some kind of mutual relationship with the outside world. It is. When some change occurs in the outside world, it is necessary to deal with it within a certain limited time. Software that must perform predetermined processing within a specified time is called real-time software. Among such real-time software, software that executes processing in a sequence of receiving a stimulus as input from the outside world and processing it is called discrete event-driven real-time software. Software for control equipment incorporating so-called microprocessors usually falls into this category.

In recent years, with the development of software engineering, methods have been proposed for efficiently creating software using structured programming languages, high-level languages, etc., and these methods are applicable to all types of software. However, the above-mentioned discrete event-driven real-time software has special characteristics compared to other software, and in addition to creation methods that can be applied to software in general, there are
There is still room for improvement in making the creation of such software efficient and easy.

[Problem to be solved by the invention]

In other words, such discrete event-driven real-time software is typically a software for driving multiple work robots placed on a manufacturing line, and multiple processes running in parallel on a local area network. It is necessary to write.

However, this kind of software that has been used up until now is based on CR using a certain programming language.
It is programmed by writing one step at a time on T. In this creation method, multiple processes that run in parallel are created individually, and then these individually created processes are synthesized so that the created processes are executed in parallel on each microprocessor. There is a need.

However, by programming multiple processes to be processed in parallel in this way, the programmer cannot accurately determine the overall flow of control and the flow of control that is executed individually by the microprocessor. It is difficult to recognize them, and it is difficult to make them consistent. For this reason, it is often difficult to efficiently create a target program.

In view of the above points, an object of the present invention is to realize a program creation device that can efficiently and easily create such discrete event-driven real-time software.

[Means for Solving the Problems] Based on the above background, the present inventor has realized a language suitable for describing discrete event-driven real-time software and a development support environment therefor.

Hereafter, this language will be referred to as PLANET. In the program creation device of the present invention using this planet, various requirements such as parallel operation and synchronization of processes can be expressed in a description format based on Petri net. In addition, it is possible to introduce diagrams throughout the programming process, improving the descriptiveness and understandability of processing requirements.

That is, the present invention provides a program creation device for creating a program to be processed in parallel by a plurality of control entities on a network, which includes: hardware information holding means that holds hardware information of a network including a plurality of control entities; screen display means for displaying a program creation area as one screen; program creation means for creating a program on the display screen; translation means for translating the created program into machine language; It basically consists of a storage means for storing a program.

The above program creation means includes a graphic pattern generation means for program creation that can generate multiple types of drawing patterns that display the contents of each process that is processed in chronological order of the program, which is a language element of Planet, and the above program creation means. It is equipped with hardware information input means that can input hardware information onto a single display screen for program creation, and pattern selection means that sequentially selects graphic patterns and displays them on the program display screen. Drawing patterns, which are programming language elements, consist of multiple types of graphic patterns that indicate processing contents, directed branches that indicate the chronological flow direction of processing requirements, and processing requirements that branch into at least two branches and that follow chronologically. A first directed branch indicating that there is something that should be processed in parallel, and at least two branched branches are combined, and subsequent processing requirements are processed in synchronization with the completion of multiple preceding processing requirements. and a second branching directed branch indicating that it is a processing operation.

On the other hand, the translation means causes each of the plurality of processing element sequences following the first branching branch to be processed in parallel by each of the plurality of control means, based on the information obtained from the hardware information holding means. It has a parallel processing program allocation means for allocating a program to be used as a parallel processing program, and the program created by the operator on one screen is automatically classified by each control means by this means, and the program is assigned to each control means. Assigned.

[Effect]

In the program creation device of the present invention, the program creator selects a graphic pattern indicating processing requirements and a directed branch on one screen for program creation displayed by the screen display means, using the pattern selection means. Or, by repeating the operation of alternately selecting branching and directed branches,
Programs can be created on the same screen. Here, if multiple screens can be displayed by the screen display means, the program on the lower level of the processing element of the program created on the same screen will be displayed on another sheet defined as the lower level of the processing element. can be created on the screen.

The program created in this manner is converted by a translation means into a program composed of machine language that can actually drive a microprocessor. In the conversion process in this translation means, a group of parallel processing elements connected by a directed branch and a bifurcated directed branch of the programming language are converted into a program for each control entity based on hardware information. Classify and assign to corresponding control means. In this way, in the present invention, programs to be processed in parallel can be easily created on the same screen.

The created program is debugged by a debugger means. This debugging means reproduces and displays the same screen as when it was created, and debugging can be performed on this screen. The program after being debugged is
For example l? It will be stored in a storage medium such as ON and run on the actual processing device.

〔Example] The present invention will be explained in detail below.

First, the programming language Planet (P
The contents of LANET will be explained.

In this planet, software is composed of a group of control entities (tasks divided by specifying input events from the outside world and internal processing) and the mutual relationships between the control entities. Furthermore, various requirements such as parallel operation and synchronization of processes included in the internal processing of the control entity are expressed in a description format based on Petri nets. At this time, by introducing diagrams throughout the programming process, we aim to improve the descriptiveness and understandability of processing requirements.

1. Noe in Boo.

A real-time control system is coupled with input groups (various sensor groups)/output groups (actuator groups) and communication paths. In relatively large systems with many inputs and outputs,
The input/output group is divided by function. A system has conventionally been used in which there are multiple modules (tasks) that control each divided input/output group, and the system is described by the interactions between these modules.

In this way, input events from the outside world and internal processing are defined, and functional modules that are independent and continue to exist in the system when activated are called control entities or subsystems in Planet. Furthermore, the control entities communicate with each other by sending and receiving messages.

(Modeling of control entity) The operation of the control entity divided as described above can be expressed by the model shown in FIG. In this figure, the input event set E is a finite set of various sensors and time information related to the control entity, and state transition items such as sensors are input from ei in a stream manner as time passes. The input message set Mi is a set of messages that are input to the control entity in a stream manner. The internal state holding set S is a vector representing the internal state of the control entity. The output element set O is a set of elements that drive various actuators related to the control entity, and the output message set is a set of messages output from the control entity in a stream manner. Output messages become input messages for other control entities. This connection may be via a network. Furthermore, an input event set E, an input message set Mi, and an internal state set S
Based on , there are mappings F and G that define the output requirement set 0 and the output message set MO, and these define the internal processing of the control entity. In other words, FIG. 1 shows that the constantly changing sensor state (E) is monitored, the message (M i ) that arrives from the outside is received, and the internal state (S) is updated while the output requirement (0 ), which represents the operation of a control entity that generates an output message (Mo).

FIG. 2 is an example in which a simple part of the operation of a certain embedded industrial machine is described using planets. Here, the operation of an industrial machine is determined by rconsole J, rconveyOr
J, r assen+bly J, partsman
ager”, [measurement system
It is divided into five control entities named J, and the mutual relationships among these control entities are described from each perspective. i.e. rconsole J,' surrounded by a rectangle
C0nVeyOr J, r assew+bly”,
"partsmanageB, [measureme
ntsystem" represents each control entity, and rbegin J, which is written on the top and bottom sides of the rectangle,
It represents the message terminal that is input/output to a control entity such as rpalleJ. Furthermore, the message terminals are connected by directed branches, and the direction of the message to be updated is defined by the direction of the arrow. The controlling entity is rbegin.”
It is activated when a message arrives at the specially named input terminal, and the control entity's internal processing and message sending/receiving functions begin operating. A message is output every time the control entity performs a sending operation, and FIFO management is performed on directed branches in a pipeline manner for communication.

The processing requirements described in FIG. 2 are as follows.

A start request output from a control entity that monitors the control panel called rconsole J causes the
B, ``Rassetably'', partsman
ager”, [s+asurement system
Four control entities of J are driven. rC0nVey
In the input bullet brought by Or J, r part
The parts supplied by srsaneger J are r asse
mbly” and rmeasureme
ntsystem' via 'C0nVe310
r J carries it out. At the same time, rmeasu
rementsystem J receives the input pallet and outputs the measurement data to the outside of the built-in industrial machine. When ``partsmanager'' detects a shortage of parts, it issues a warning to rconsole J.

In this way, the exchange of control entities can be seen in a detailed diagram from the perspective side, making it easier to understand the written content.

(Sequence description using directed graph) Next, the configuration means for the internal processing of the control entity will be described. In the operational specifications of internal processing, from experience
A fragmentary declaration is often used: ``When you are in the state of , if you do, ◎ becomes ◎, and the mouth changes to the state of mouth.'' This representation means that OO is the internal state a of the control entity before the event input.
(Pre-processing state), ... is the input event, ◎◎ is the activity requirement (response), and the fourth day is the internal state of the processing control entity (post-processing state)
each means. A model expressed by these four things is generally called a stimulus-response model.

The individual contents of this declaration 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, making it complex and difficult to describe problems using traditional sequential procedural languages. This is a major bottleneck when doing so.

In order to express such processing straightforwardly, Planet employs a description method using a directed graph structure based on Petri nets, rather than the conventional one-dimensional processing sequence using character strings. In other words, the message input terminal is the starting end,
A processing sequence is described using a diagram in which input events and activity requirements are expressed as clauses, with the message output terminal as the terminal, and these are connected by directed branches that define the order of execution. The internal state is expressed by where the control is at that moment, or in other words, by markings in a Petri net.

FIG. 3 shows an example of internal processing of a control entity described in planets. An elliptical node with no input directed branch (a node labeled "start" whose name corresponds to the message input terminal name of the control entity described above) represents the beginning of the processing sequence.

A node surrounded by double rectangular nodes (a node written as event t, is the r 5 sensor actually turned on?
Conditional judgment phrases for event detection such as ” are written)
indicates input event detection, and when the entered event occurs, the process ends. - On the other hand, the clause surrounded by double rectangular clauses (a clause with the word action, which actually contains a phrase for a response such as 'turn on 5olenoide') indicates activity requirements. ,
When activated, processing is performed immediately. The directed edges connecting each node express the execution order relationship of processing, and r
A plurality of branches, such as directed branches extending from actionl J and action2 J, indicate that subsequent processing is executed simultaneously, that is, parallel processing is performed. In addition, ``action2'', ``acti
A processing requirement inputted by a plurality of directed edges such as "on5" is driven when all the preceding elements of the processing requirement are completed, that is, synchronization is expressed. In this manner, a processing sequence with a defined execution order terminates at an oval node corresponding to the message output terminal of the control entity.

(Hierarchy of procedures) As shown in Figure 3 above, in Planet,
Each series of processing groups is expressed as a single diagram. Naturally, as the scale of the program increases, the diagram becomes huge, complicated, and difficult to understand. I also want to use general-purpose procedures in common, and I also want to use a recursive calling mechanism. Therefore, in Planet, a set of processes is contained in one diagram, and it is made possible to call it as one processing requirement in the diagram at a higher abstraction level. FIG. 4 shows this relationship. This relationship is hereinafter referred to as procedure hierarchy. The processing of the lower hierarchy is driven when control reaches the processing requirements of the upper hierarchy. That is, control is passed to the rbegin J input terminal in the lower hierarchy diagram, and the lower hierarchy processing sequence begins execution. Then, when the processing in the lower hierarchy progresses and the control reaches the rend J output terminal, all the controls in the lower hierarchy are discarded and control is returned to the upper hierarchy. The returned control continues processing requirements in the upper hierarchy.

In short, on the - screen, the vertical direction means the chronological direction of the processing, and the horizontal spread means the parallelism of the processing. The so-called depth direction of the screen means hierarchy. These relationships are shown in FIG.

(Language Components) Above, we have described the mutual relationship of control entities and the description method of internal processing as a programming format in Planet. Next, we will define each language component for actually writing a program in Planet.

The language components are listed below.

Program frame sub-system block Message input/output terminal event waiting clause Activity processing section conditional branch clause Selective event wait clause Repeat control frame Expressions and data types Each language component is explained below.

It is a diagram (screen) that expresses the internal processing of a program frame control entity or its lower layer procedures. In this program frame, as shown in FIG. 6, a field for entering a name is set at the lower right corner. The name written here becomes the name of the control entity or lower layer procedure. This name is treated as an identifier and is used to specify the destination of a message or to specify a lower-level call destination. The name syntax is shown below.

Name::=Character 1 Name Character 1 Name Number Character: ;= Alphabet character 1 Kana character 1 - Subsystem A subsystem is what a control entity looks like from the outside world. When this processing requirement appears, as shown in Figure 7,
The control entity name is expressed as a figure surrounded by a rectangular frame. The message input/output terminals of the control entity are located on the top and bottom sides of the subsystem and are represented by small rectangular frames with terminal names attached. A terminal name is unique within the same subsystem. If there are multiple terminals with the same name in a program, their generations are interpreted as common. Message sending and receiving operations between control systems over a network are also described in the same way as between control entities within a control system. Note that the shape of the message parameter required at this time is automatically generated by a compiler, which will be described later.

The control entity is activated when a message arrives at the input terminal named rbegin J.

Its internal processing is described by a program net in which constituent elements are defined as nodes and their execution order is defined by arrows. When the internal processing of the control entity progresses and the control reaches the output terminal named [end J, all controls operating in the control entity interrupt processing and are discarded.

Block When the internal processing of a control entity becomes large-scale or complex, procedures are layered and a group of subprocedure programs written as control requirements for a higher-level program is called a block. Blocks are named
A lower hierarchy block is called by entering its name in the processing requirements of the upper hierarchy block.

When control reaches a processing requirement in the upper hierarchy, the lower hierarchy block is called. Recursion and indirect recursion are allowed for calling lower layer blocks. The called lower layer block starts execution from the oval terminal named "rbegin", and the process progresses to rend.
When control reaches the oblong terminal named J, all processes within that block are aborted and discarded. Control is then returned to the higher layer processing requirements and execution of the higher layer block continues.

Arguments can be given to a block call, in which case the name of the block to be called is followed by a list of variable names or values separated by "," enclosed in parentheses. When a variable is used as a block argument, the argument is given by what is called a name call. That is, if the value of an argument given in the above hierarchy is updated in a lower hierarchy, the value of that variable will change when returning to the upper hierarchy.

As an example, FIG. 8 shows a "find factorial of n" block using recursive calls. In this example, [begin J
The obtained value is stored in the argument r[, in the input terminal, and rfa
As a result of calling ctorial J, that value is used. To explain again about the message input/output terminals that appear in lower hierarchy blocks, since the block is expressed as a lower procedure of a control entity, the input/output message terminals that appear in a block are Interpreted as a message terminal.

The syntax of the 'begin terminal' and 'end terminal' is shown below.

begin terminal 22='begin'1'begin' () l°be
gin' (argument list) end terminal:: ='end'1'end'('TRUE')1'
end'(FALSE') argument list:: = type declaration name 1 argument list, name 1 argument list, type declaration name argument list is the type name or the name is ``.

It is made up of characters separated by "." Evaluated from left to right, the type name declares that the named argument is of the specified type. Furthermore, names separated by "," declare that the argument is of the same type as the left argument. Therefore, int a, b, char c,
In the example of int d, float f, g, "a
" and "b" are of int type, [cJ is of char type, rd is of int type, and "f" and 'gJ are of float type.

The syntax for calling the lower hierarchy is shown below.

Lower layer call 222 Name 1 Name (value list) 1 Name 1 Name (value list) Value list::= Value I value list, Value Planet supports separate compilation, and lower levels that are not on the same source file When calling a hierarchical procedure, add "@" at the beginning.

In message transmission/reception operations between input/output terminal control entities, the terminal that is the mouth of the receiver is called the input terminal. On the other hand, the terminal corresponding to the transmission port is called the output terminal. The input/output terminals are shown in FIG. The input terminal and the output terminal have the same oval shape.

The one with an oval input arrow is the output terminal, and the one without is the input terminal. Input and output terminals are named. The rbegin J terminal and the ``rend'' terminal, which were explained in the section about the hierarchy of procedures above, are not treated as input/output terminals.

The message sending operation is performed when the control reaches the output terminal. The message receiving operation is performed when the message reaches the input terminal.

That is, the input terminal serves as a message buffer. When an arrow is connected to an input terminal, when a message is input, the message is read out and the processing after the arrow is driven.

On the other hand, for input terminals without arrows, messages are read from the input terminals by a message successive operation described in a procedure sequence. The message successive operation is performed by writing the input terminal name in the condition judgment phrase.

The input/output terminals correspond to the message terminals of the subsystem that view the control entity from the outside world. That is, as shown in FIG. 8, when control reaches the output terminal (a) and a message sending operation is performed, messages are exchanged by message combination as shown in (C). The message is (
The message reaches the input terminal b) and can be used.

It is also possible to send and receive messages from different control entities in an internal procedure as shown in (d) without describing how messages are combined as shown in (C).

When putting data in a message, write the value "." along with the name of the output terminal as shown in Figure 10 (a).

" (in this case, it is '(1,5,1,234)J).

It is also possible to use variables. ). On the other hand, when connecting messages between subsystems that receive messages, a list specifying the name and type of data is written after the name of the message terminal, as shown in FIG. 2(b). In this example, r (int x,
int y, float Z) J, "(x, y, z)" of the message terminal of the side subsystem is the data list. Furthermore, the same figure (
c) A specified list of data and types to input after the name of the input terminal like '(int a, b, float
t f) Fill in J. In this example, integer type data “1” and “5” and floating point type data r1.234J
These three values are placed in the message and communicated. When this message reaches the input terminal of (C), the input terminal arguments ``a'', ``rb'', and ``rfj'' contain rl and r, respectively.
5. The value of rl, 234J is set. Also, as shown in (d), when outputting a message to a different control entity in the internal procedure of the control entity, directly input the value sequence r (1, 5, 1, 234) to the message terminal of the subsystem. Data can be sent by writing it.

Furthermore, the data in the message on the diagram of FIG. 10(b) showing the message combination can be processed. for example,
If the value order of the message terminal of the message input side subsystem is changed to '(y,
"5""IJ rl, 234J are set respectively. Also, if you convert the value using the formula like [(x+1.7,2*z)J, the obtained value r2J '5J
r2.468" are set respectively.

When sending and receiving messages containing data, the data type order between the message terminal and the input/output terminal must match.

The syntax of input/output terminals and subsystem message terminals is shown below.

Input terminal two names Name 1 name () 1 name (argument list) Output terminal::・Name 1 name () 1 name (value list Subsystem message output terminal::・Name 1 name (variable binding list) Subsystem message input Terminal::・Name 1 Name (value list) Variable binding list::・Type declaration Name 1 Name 1 Variable binding list Type declaration Name 1 variable speed binding list, name variable binding list are evaluated differently from the argument list described above. 0 As an example, the same declaration as mentioned in the argument list, int a, b, char c, int d,
Use float f, g. Similarly, the variable binding list has type names or names separated by ``,''.

Only the names are separated by "5." For example, variables "
b'' and rfJ are items declared elsewhere, such as internal variables and input arguments. Then, when a message is passed to the message terminal, the data in the message will be stored in that variable.

Event Waiting Clause The process of waiting for an input from the outside world is called an event waiting clause.
As shown in FIG. 11, it is described using double rectangular nodes. The process is to "wait until ...". Inside the rectangle, a conditional judgment phrase such as "・ha・ka?" is written. When control reaches the event wait clause, the conditional decision clause is evaluated. The conditional judgment phrase is evaluated repeatedly until the conditional judgment phrase returns true.

There are three types of conditional judgment phrases that can be applied:

(2) Value of judgment result of input sensor state For example, it is a condition judgment such as whether a switch is turned on or whether the value of an input port becomes a specific value.

Processing is interrupted for a specified time based on a conditional judgment as to whether the 0-hour waiting element time has elapsed.

■Input terminal name Based on the conditional judgment "Did a message arrive at that input terminal?" If a message arrives, a message read operation is performed.

Active Processing Section Processing that outputs to the outside world, performs calculations, and assigns values is called an active processing and is described in a single rectangular section as shown in FIG. 12. In the rectangular section, a phrase that performs the process of "turning ◎ into ◎" is written.

Conditional Branching Clause The conditional branching structure of a procedure sequence is described by a conditional branching clause. FIG. 13 shows a description example of a conditional branch clause. As shown in the figure, a conditional branching clause has a shape of stacked rectangles and has multiple output points. A condition judgment clause is written in each rectangle, and the control that has passed through the conditional branch clause is output from the output point where the condition is satisfied among the plurality of output points.

Since the output points are distributed, conditional branching can be realized. Conditional branching clauses are evaluated starting from the top left corner and proceeding downwards if the condition is true, and to the right otherwise.

If the evaluation reaches a point where there is no condition judgment below, processing continues from the corresponding output point onward.

A special phrase "relse" can be entered in the condition judgment phrase of the conditional branch clause. relseJ is ``
If the condition is not met, the evaluation progresses to the right.''The evaluation always returns ``true'' at the end. Therefore, if all conditions are not met, control is output to the output point of r else J.

In the case of the example in Figure 13, "S-...ONJ is evaluated first. If S- is input, then rhphc...OFF"
is evaluated, and if phc is not input, control is output from output point a. If phc is input, ri=
・2'' is evaluated, and if the variable i is 2, the control is output from the output point. If variable i is not 2, r else
Control is output from output point C by J. first s
If w is not input, control is output from output point d by relseJ at the right end.

Selective Event Waiting Clause Some of the requirements for real-time processing include detecting multiple events at the same time, and when one event is detected, continuing the process corresponding to that event and abandoning waiting for other events. There are many cases where the process of doing so is the result. Problems such as waiting for the sensor to detect after energizing the solenoid and issuing a warning if the sensor does not detect it even after 2 times have elapsed. An example of this problem is ``monitoring three switches and performing processing according to the switch that is input first.'' In Planet, this is called selective event waiting, and is described using a selective event waiting clause as shown in FIG.

A selective event-waiting clause is a node in which event-waiting clauses surrounded by double rectangles are lined up horizontally, each waiting for an output point, and has a shape that is similar to a conditional branching clause. Its execution rules are as follows. When the selective event wait clause is activated, all event waits in the horizontal line are driven in parallel, and the one that completes its processing earliest abandons all other processes in the horizontal line and waits for the event. Continue processing after the output point corresponding to the one established. In Figure 14(a), '5ensor =
,=ONJ and rtimer==2000''. In other words, if the sensor receives the input first, it will be extracted from the output point a and normal processing will be performed. Also, if the time doubles first, the output point is turned off, so error recovery processing is performed. Also, Fig. 14(b)
is rswl == ON J, rsw2 == ON
Furthermore, three selective events of rsw3 == ON J are awaited. While scanning three switches, each output point C1d corresponds to the first input switch.
, e, control is taken over.

The operation of discarding other controls at the end of selective event waiting is
It is also effective when calling a lower layer. This is a very powerful feature; a process that detects a stop request while simultaneously executing a series of procedures, and interrupts the running procedure series when a stop request is issued can be described using the wait for selection event clause. . The columns are shown in FIG. In the figure,
It is assumed that the left event wait clause "rcycle" has a lower hierarchy and executes a series of procedures to control the machine. The event wait node ``rstop'' on the right side waits for the stop request message ``rstop'' to be input to this control entity. When the control reaches the select event wait node in the figure, 'cycle, J is activated.

At the same time, processing for detecting a stop request message is also activated. Until a stop request message is input,
The program controls the operation of the machine using the procedure "rcycle". Due to the action of the selective wait for event clause upon arrival of the stop request message, all control running "rcycle" is relinquished and
Execution is interrupted.

Thereafter, a reset operation of the mechanical body is performed after the output point of "waiting for "rstop", and the process ends.

Repeat control frame The repeat structure of the processing sequence is described using repeat frames. Creating loops using arrow connections will create a repeating structure, but this will complicate the program, so it is preferable to use repeating frames. FIG. 16 shows an example of the description. The repeating frame is
Rectangle node indicating control means in the upper left corner and rend J in the lower right corner
It is composed of a rectangular node surrounded by a frame, and a frame with these two rectangles as diagonals.

The repeat control frame operates as follows. The repeat structure begins when control reaches the rectangle node in the upper left corner. Control is distributed according to the control means described in the rectangle node, but if the escape condition is not satisfied and the control is still in the repeating structure, the control is distributed from the rectangle node to the 'and' rectangle node in the lower right corner. Executes a sequence of procedures. When the control reaches the ``r end'' rectangle node, the control is transferred to the upper left corner control means node again. In this way, the procedure series sandwiched between both rectangular nodes is repeatedly executed. When the condition is satisfied and the control means clause escapes from the repetition structure, the procedure sequence after the rend J rectangle clause is executed.

Furthermore, it is also possible to forcibly escape from a repeating structure using a conditional branching clause or a clause that waits for a selective event. The control means includes r 1oop J clause, 'while J clause,
'until' clause and 'for J clause are provided.

■r 1oop J clauser 1oop J clause implements an infinite loop. It unconditionally repeats execution of the control sequence up to the rend J clause. To escape from an infinite loop, use a conditional branch clause or a selective event wait clause.

■「匈hile　J haiku The syntax of the “while J clause is as follows.

while clause::='while' (conditional judgment clause) "
When control reaches the %1hile J clause, the conditional judgment clause enclosed in parentheses is evaluated, and if the result is true, control is assigned to the repeating structure, and if it is false, control is assigned to the "rend" clause.

■runtil J phrase The syntax of the runtilJ clause is as follows.

until1 clause::='until' (conditional judgment clause) r
When control reaches the 'until' clause, the 'runtil' clause is reached.
The procedure sequence leading to the "rend" clause after the J clause is executed, and when control reaches the rend 2 clause, runtil is executed.
” The conditional judgment phrase enclosed in parentheses within the phrase is evaluated.

Control is distributed after the rend J iff if the result is true, and after the 'until J clause if the result is false.

■rfor” phrase The syntax of the "rfor" clause is as follows.

for clause::='for' variable = value 1 tO+
Value l 'for' variable = value 'tO゛value'
The phrase "step 'constant rfor'" is a control means to iterate through additive closed intervals. The above "variables" must be declared. For example, rfor i = x to y 5te
In the for clause of flcJ, the area r (r= (j l X<=
j<y)) is repeated from increasing the variable i by C increments from X until i is within r.

Expressions and data types The basic data types that can be operated on Planet are shown below.

(Basic data) Details of each data type are described below.

■It is a char type 8-bit binary number. 0 to 2 with unsigned data
Takes values up to 55. Used to represent characters and small integers.

■It is an int type 16-bit signed binary number. It takes a value from -32768 to +32767. M in 16 bit data
SB represents the code. Negative numbers are expressed as two's complement numbers. -It is an integer used in boat fishing.

(2) It is a long type 32-bit signed binary number. -2147483
A very large range of integers can be represented from 648 to +2147483647j. Similar to the int type, negative numbers are expressed as two's complement numbers.

■It is a float type floating point number. It consists of a total of 32 bits including the sign bit, exponent part, and mantissa part. The data format is called 5hort real, and is compatible with IE
Conforms to EE standards. FIG. 17 shows the data format.

■Used to operate the sensor/actuator connected to the bit type I10 port. There are three operations for bit type variables: determining whether the bit variable is zero, setting the bit variable to 1, and setting the bit variable to 0. Other than this, for example, it is not possible to perform an OR operation or an AND operation.

■port type Used to perform operations in 8-bit units of the I10 port. For the port type, the physical address is specified by the I10 boat address. When referring to a port type variable,
It is treated as char type data. To set a value in a port type variable, data other than bit type can be used, and the value set at this time is converted to a char type and stored.

Internal variables and I10 variable data of char type, int type, ong type, and float type can be stored on the memory. The language processing element that does this is internal variable declaration. The description of the internal variable declaration is shown below. Furthermore, when accessing I10 port data, that is, bit type and port type data during a procedure, a declaration similar to the internal variable declaration is performed.

bit 5ensor 5olenoid.

ort out ort; In the table above, the variable ri'''j'''kJ is int
type, r ch ” is char type, rcount J is l
ong type and "data" are declared as float types, and respective areas are secured in memory. The bit type and port type data are used to notify the compiler that the I10 data with the declared name is being used without allocating an area in memory.

The syntax of internal variable declaration is shown below.

Internal variable declaration::・Type declaration Name 1 "global' type declaration Name 1 Internal variable declaration 2 Name 1 Internal variable declaration, Type declaration Name 1 Internal variable declaration; Internal variable declaration 1 Internal variable declaration [Positive constant] Type declaration:: ＝'char'￥l 'int'l'
long' l 'float'I'bit' l
'port') Data structure vs. declaration name Describes how to secure storage area for internal variables. The internal procedures of the control entity are hierarchical.

Variables declared in the top-level procedure are allocated in static memory and continue to exist throughout the program execution. On the other hand, when an internal variable is declared in a block declared as a lower layer, the internal variable is dynamically generated on the stack frame when the lower layer is activated. Then, when the lower layer completes the procedure, the secured variable area disappears. By writing the modifier 'global J' in front of the type declaration in the procedure at the lower level, as shown in the above syntax, the statically declared variables at the top level can be accessed.

Lower layer call and input argument The data given when calling the lower layer procedure,
They are called input arguments. As mentioned above, rbegin
This corresponds to the argument list written in "Terminal". Data declared in input arguments can also be accessed in the same way as internal variables. The six data types mentioned above can be given as input arguments. The lower layer calling mechanism is as follows. The address of the variable is passed to the input argument (this implements name calling). When the argument is of char type, int type, long type, or float type, an address on the memory is passed. Also, for bit type/pOrt type, I10 port address, I1
The 0-vote address and bit position are passed respectively. When accessing an input argument, the data value is obtained from the given address and used. When a value that is not a variable name is passed as an argument to a lower layer call, for example, "rl" r3
．． In the case of an immediate value such as 1415J or a calculation result value such as "i+1", the address cannot be defined because it is not a variable. When passing such a value to a lower layer, the processing system first secures a temporary memory area and stores the value. Next, a running code is generated that passes the address of the stored area to the lower layer.

Data in Messages This section describes access to data contained in messages. Since messages are frequently created and destroyed, they perform unique storage area management that is different from stack frames.

From the moment a message is entered, the data contained within it can be accessed in the same way as internal variables.

Data Structures Basic data types such as char type, int type, ont type, and float type arranged in memory constitute more complex data structures called arrays and structures. Since they are arranged in groups in a continuous memory area, they can be applied to various algorithms and it is easy to express various problems. We will discuss arrays and structures below. The data structure is handled in accordance with C.

Array arrays are char type, int type, long type, float
A specified number of contiguous areas are secured and arranged for the type and the data of the structure described immediately below. Planets can also use multidimensional arrays. Array data is declared by enclosing the number of data elements (a positive constant) with "0" immediately after the data name. An example will be explained in which a frequency distribution in increments of 10 is determined for a set in which each element has an attribute value from 0 to 100. At this time, declare rinthist, gras[11) J, and an array representing the histogram. Elements in the array are specified by the number of elements counted from the beginning. The first element of the array is O. 'histgrate [il' specifies the i-th element of the frequency, and the value of i is 1 from 0 to 10.
There is one type. In this way, the data structure is determined and all elements of the array are initialized to 0. Then, when an element with attribute value atr is given, rat in h i S tgrall
Increment the r/IOJth element by 1. If this is done for all the elements of the specified set, the number of elements that take the value 0 skein 9 will increase from 10 to 1 in histgram [0].
The number of elements that take the value 9 is histgram[11000
The number of elements taking 0.100 is obtained in histgram[10]. In addition, in the case of a multidimensional array, rchar b
[10] [5] Declare by arranging the number of elements enclosed by 1 like J. This example declares that char type data is bundled in two dimensions of 10×5.

Structures Structures are used when you want to handle tabular data in a program. Take the current value measured by a certain measuring device. Measurement data may include multiple data such as measurement items if there are multiple measurement points, measurement date and time if measurements are continued, and current values. Even though it is expressed as a "current value", it is composed of multiple items. Declare this matter as a structure as shown in Figure 18,
can be used. A structure has a name that specifies its type. In this case, "CurrentDat
aJ corresponds to this. When handling structure data in a program, declare the name along with the structure when declaring variables and arguments.

Items declared within a structure are called members. Data declared as a structure can be operated on item by item. To specify a specific member in the structure, use "," as shown in FIG. A separately declared structure can be used as a structure member.

They can also be arrayed into members.

An immediate value such as constant 1, 3.1415, or a is called a constant. Constants include character constants, integer constants, and floating point constants.

Operators Various operations can be performed on the basic data described above. It uses the same notation as C operators. Operators include unary operators, binary operators, ternary operators, and assignment operators.

Next, the configuration of a program creation device that creates programs using Planet will be described.

The entire system (hardware) can be composed of, for example, the following parts.

Control unit side microprocessor (editor, compiler) Main memory bag W (capacity: 640 kilobytes or more) Display (analog RGB display) Console (mouse) Target side drive system processor Communication device Storage device Also, main software prepared as a planet environment are listed below.

xed, exe editor xpl, exe parser xp2. exe intermediate code generator xp
3. exe 280 code generator xp3c
c, exe C language template data generator xp4. exe network linker comm
drv, exe HDLC communication driver xnet, e
xe 1 (DLC network configurator xdb, exe debug monitor x io,
exe I 10x 7xhex, exe
The flow of program development using the ROMized utility planet will be explained with reference to FIG. 19.

The planet program is edited with the editor xed.

The edited program information is checked for syntax by the parser xpl. The parser generates intermediate code for each diagram. These intermediate codes generated by the parser xpl are the processors declared by the sorter xp12 (
The required intermediate code is captured for each control entity (control entity) and converted into a large set of intermediate code files. Save this intermediate code file to code generator x
p3 to generate 280 machine codes. Note that when operating on a PC9801 or PC2B6/386, an 8086 machine code generator is not created, so a program that performs a similar operation must be written in C language. Information on communication packets required during execution is output as a C header file, so this is imported and used. In order to generate the data necessary to generate this header file, in the case of PC9801, it is necessary to apply xp3cc.

The Z80 machine code or C header information generated in this way is converted into code that actually operates by adjusting the command fields included in the packets flying over the network by the linker xp4. Furthermore, the linker χp4 was written in Z80 assembler.
, tel" file. In other words, if you need to link planet and assembler, use linker xp4
The linking work is done at the stage of applying.

Here, the files used by Planet Development Environment are listed below.

・, src source file. All graphical information of the program is stored in this file.

It is also possible to create multiple source files and link them.

dtstruc, def It stores the configuration of a data structure.

Required when parsing source files.

. , pl ., is an intermediate code file generated after parsing src. - An intermediate code file is generated for each diagram, and contains the analysis results of all diagrams included in the source file .src.

hardimare, def Stores the topology (shape) of the network, the name and network address of each processor (control entity) on the network, and the name and address of the I10 port and I10 bit used by each processor. It is used to collect intermediate code files, Pl, and generate running code for each processor.

5rcs, tab This is an input file for the sorter xp2, and the names of all the source files to be used are written in this file. This file is an ASCII file and is created by the user using a commercially available As(,II) editor.

◎, p1 This is a file created for each processor by sorter xp2. This file stores all the graphical intermediate codes required by each processor. I1
Information closely related to the hardware such as the address of the 0 port is not included in the intermediate code file.
Sorter xp2 niyo is given to file ◎, p2.

Here, "◎" indicates processor salt.

◎, tr This is a debug information file input to the debugger. The location of source files, the hierarchical structure of the program, etc. are stored.

cpus, tab This is a file that stores a list of processors that appear on the program. This file contains the processor salt, processor type, and its network address. This file is an ASCII file.

◎, cod This is a binary file of the actual running code output by the Z80 code generator xp3.

◎, p3 For programs that require links on the network, network information such as the definition of the packet format and the real address of the reference table for that definition is stored. Furthermore, link information with the assembler for referencing external libraries is also included.

◎, dbx This is a debug information file generated by the code generator. Information such as which address in the actual code corresponds to what is written in the source file is stored.

◎, bin This is a runnable binary file generated by linker xp4. Download from debugger xdb or ROM
This is the final output file that can be used to run the actual machine.

0. cm When the processor type is not z80, the linker xp4
This is a C program header file generated by .

The relationship between the input and output files of each part of the compiler, which is a planet processing system, is listed below.

Input 〱〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〈〉〈〈〈
・,srchardware,d
ef xed hardware, defd
tstruc, def dtstruc
,def・,src xpl・,p
idtstruc, def - or more, pi xp2 cpus, tab
srcs, tab ◎ for each CPU
, p2 per cpu ◎, tr ◎, p2 xp3 ◎, c
od◎, dbx◎, p3 cpus, tab xp4◎
, bin ◎, cod ◎, p3 Next, the operation of the editor and the operation of each processing unit making up the compiler will be explained.

(Editor xed) Editor xed edits the graphic information of the planet program and generates a source file that stores the graphic information. Program information includes a src file that stores planet procedures created by the programmer, and a hardware file that stores hardware input/output boat information.
, def file, and dtstruc, def file that stores information on data structure declarations. These three types of files are edited using the editor xed.

The planet program is created for each screen, and requires editing for each screen.

Therefore, the maximum allowable area length in one screen is set in advance, and storage is managed using a continuous storage area of the maximum length as one unit. This unit storage area is called a memory block.

Additionally, the editor can hold multiple memory blocks in main memory or auxiliary memory in order to display and edit multiple screens at once. Here, the screen of the Planet program has a hierarchical tree structure due to its language specifications.

Therefore, a block tag as shown in FIG. 20 is set to represent block management information.

Editing work is performed using, for example, a mouse and keyboard. This work is also done using a multi-window method. As mentioned above, a planet program is created for each diagram. One sheet displaying a diagram corresponds to one window. In addition to the program diagram, the window also includes hardware address declarations and data structure declarations. It is possible to edit several windows at the same time while displaying these windows one on top of the other. That is, the planet program management information is connected to the window system and has a list structure as shown in FIG. Therefore, planet program screen information can be obtained from mouse events by the following procedure.

■The window system obtains the identifier of the corresponding land from the LV coordinates of the mouse event.

■ Search the display block list for an element that matches this window identifier, and retrieve the block management information rBIock T
Get ag J.

■Obtain screen information from the storage medium based on the contents of the block body in this rBlock Tag.

Here, if there are multiple processors on the network, the planet compiler creates each running code that runs on each processor at once.

For this purpose, the compiler determines what kind of processors exist on the network, what kind of structure each processor is connected to, and what kind of I1 on the processor.
0 port is installed, and information such as what kind of hardware is connected to which boat address is required. The specification of such information is called a hardware declaration. This declaration is absolutely necessary, just like the program procedure. This declaration will be explained using a system with a network structure as shown in FIG. 22 as an example.

First, the declaration of each processor in this declaration will be explained. Processors on a network require names because they are themselves controlling entities. In the illustrated example, the processor "r host" has "rmeasurement" and r
Two processors of assembly J are combined. Furthermore, rs+easurement J has rs
ubm" is connected. In this figure, the number written on the left shoulder represents the network address.

Each processor is declared by specifying the processor salt, processor type, and network shape, respectively. A processor salt is specified by inputting a character string that can be written as a control entity name from the keyboard.

The type of processor is specified, for example, by inputting one of the following keywords. The compiler produces different output for each type of processor.Jupiter' 5TD-Bus SystemJup
Generate a running code that matches the drive system of the iter.

10 IO system Generate a running code that matches the drive system for IO.

Personal computer Runs on a personal computer For the C program to be created, Declared the shape of the communication packet Generate header files. P The program entity is created by the user in C. Program more.

Next, the declaration of network shape will be explained. This declaration is to declare the processors existing in the -hierarchy in a tree-structured network. In the network shown, n+asurement and assen+b
Since ly is coupled, these processors measurement and ass for processor host
assembly is declared. FIG. 23(A) shows an example in which three processors existing in the - hierarchy are declared. In this figure, from the left, the network address, processor type, and processor salt are declared. Furthermore, the network relationship of these processors is shown in terms of their vertical arrangement. In this way, the network-hierarchical statement processor connection relationship is declared. Here, in the illustrated network, the processor subm must also be declared. This processor is +weasureme
It is connected to the lower layer of nt. To declare this, subm is declared for measureresent as shown in FIG. 23(B). The planet compiler detects the processor included in the program based on such network declaration information, and creates running code to be allocated to that processor.

(Compiler) The graphic information of the planet program input by the user is
It is a processing system that converts programs into programs that can be directly executed on control equipment, and it introduces Petri net execution control rules during program analysis, and is based on graph theory's Kano S and BFS.
, DAC, etc. are used to develop the planet program structure obtained from control flow, data flow analysis, and graphics into multiple sequential processes that operate in parallel. For each process generated in this manner, microprocessor code selection and generated code optimization are applied to generate actual running code. Each processing system of the compiler will be explained below.

Parser xpl The parser xpl analyzes the graphic information file .src of the planet program created with the editor xed, and generates the third address code, which is the running code of the virtual machine. The third address code of the program is stored in intermediate code files named .pl. Parser xpl analyzes each program frame. The generated program information for each sheet is combined into one by a simple operation to form a large program.

Sorter xp2 Sorter xp2 links the analysis results for each block output by parser xpl at the intermediate code level.

The linked intermediate code is stored in a file for each processor. By applying this file to the code generator described below, machine code that can actually be run can be obtained for each processor.

The operation of the sorter xp2 will be described as follows.

■First, the hardware created with the editor xed
, find the processor "◎" stored in the def file.

◎ Search the specified input file group for a block that matches the name of the processor, and store the intermediate code of that block in a file named ◎ and p2.

(2) Furthermore, if the processor name and block call a lower layer block, search for that lower layer block and add it to ◎ and p2.

In addition, the blocks of all control entities activated by these blocks are searched in the same way and added to the ◎, p2 file.

■When storing all the necessary blocks◎ and p2 files, the processor◎ searches for the address and name information of the leaked I10 ports and bits, and uses the I10 ports and bits in the block. If so, write those addresses to the p2 file.

■Link global variables accessed by lower hierarchy blocks.

Here, before starting this sorter xp2, it is necessary to create files 5rcs and tab that define the input file list. This file is a commercially available A
It can be edited with a SCII file editor.

205. Enter the names of all source files required by the program in the rcs and tab files.

Sorter xp2 detects the input file by reading this file and performs the operations described above.

Code generator xp3 The code generator xp3 takes as input the intermediate code of the virtual machine output by the sorter xp2, and generates the equivalent z8
0 generates runnable machine code.

The generated machine code depends on the planet drive system described below. The above sorter xp2 outputs ◎,p
The 2 files contain all the information that the processor can run on its own. Based on this information, the generator xp3 generates not only machine code but also link information on the network and link information with other languages.

Linker xp4 The linker xp4 links all the requirements based on the link information on the network generated by the code generator xp3 and the link information with the assembler, and creates machine code that can actually operate on the planet drive system. generate. Also, for a processor written in C, a C header file is created for linking on the network. The linker xp4 operates upon receiving the output of the code generator. First, the consistency of the link information on the network output by the code generator is detected, and the shape of communication packets flying over the network is determined. Next, based on the information for linking the module written in assembler, the module is searched for in the specified library file and running code is added. The running code obtained in this manner is output as an actual running code file. If multiple processors are described in the planet program, the actual running code files for all processors are generated at once.

(Debugger xdb) Whether executable machine code obtained through Planet's compiler operates correctly can be verified using a debug monitor. The debug monitor program can be executed on, for example, a PC9801 or a PC286/386. This debugger has functions such as downloading programs, tracing programs, monitoring I10 ports, and referencing and updating variables. This debugger allows the operation of the target processor to be monitored at the source level. Since debugging is possible at the source level, debugging can be done efficiently. Note that this debugging work can be performed on a multi-landscape using a mouse and keyboard in the same way as when creating a program using an editor.

Monitoring of the target processor is done using the debugger xdb.
The processing system that runs and the target processor are dedicated HDL
It is carried out via a network connected by C communication reform. An inquiry command is issued to the target processor via a communication path, and the state of the target processor is monitored based on the response.

Here, an operation called network configuration is performed in order to reduce the load during execution on the target processor drive system that runs the planet program. This work involves providing in advance various information about the network to the board that controls communication, and thereby allows the communication board and drive system to operate in parallel to achieve functional distribution. In a drive system with this configuration, this information is held in a storage device, such as a RAM for a buffer knob.

Describe debugging operations. First, the network information of the planet drive system is displayed on the screen. In other words, the file hardimare, de edited with the editor xed
Display network information for f. This display screen is called a processor window and is displayed as shown in FIG. In this figure, the number on the left side of each processor is the network address, and the number on the lower left side is the processor identifier. This information is stored in the file hardware,
It is automatically generated by the compiler from the information in def.

Next, specify the target processor to monitor,
Displays the hierarchical information of all procedures included in the running code of that processor. This procedure is a procedure put together by sorter xp2 and linker Xρ4. FIG. 25 shows a hierarchical diagram of the processor ``hosJ.'' The source program in the target block of this hierarchical information is called. The specified source program is searched from the source files. shows the source program of the called block ``ra+ain''. After calling the source program in this way, this program is downloaded to the specified target processor.

Next, breakpoints are set. When a breakpoint is set at a processing requirement, an indication that the breakpoint has been set is displayed in the frame of this processing requirement. After setting the breakpoint, start execution of the target processor.

While the target processor is running, the source program consisting of the graphic information in the created state is continuously displayed, and when control reaches a section where a breakpoint is set, that section is displayed in red, for example. The circle will blink to indicate this, and control will stop at this point.

When tracing a process that has reached a breakpoint and executing control step by step, red circles indicating processing positions are sequentially displayed in the processing requirements that are in operation.

The program after being debugged in this way is EF
It is stored in a storage medium such as ROM.

\Next, the drive system for executing the planet program created as described above will be explained.

FIG. 27 shows the overall configuration of the drive system (kernel). In the figure, arrows indicate the flow of the process. Here, a process refers to a program control activated within the kernel.

In the figure, InInitial Control controls the process to be executed initially (if any) when the kernel starts up.
Send to on. cp/in is a communication port that accepts packets from other processes. The packet itself is also a process.

The Rx packet manager evaluates the received packet and performs the processing expressed in the packet. Process Exe if necessary
Send to ncution.

Process Execution is In1tia
l Control or Rx Packet Man
The processes sent from the agent are executed in order. If a running processor issues a time wait request, the process is delayed to Delay C.

Send to ntrol. Also, if the execution process issues a request for execution by another processor, the request is formatted into the process and Tx
Send to Packet Managea+ent. De
lay contr.

1 accepts the process sent from Process Execution with the waiting time as a parameter. Hold the process for a specified period of time and then run Pr again.
Send to cess Execution. TxP
acket Management sends the accepted process to the conversion processor via CPlout.

(Parallel drive control of processes) While the planet program is being executed, one or more processes exist in the processor. As a method for running multiple processes simultaneously, TSS (Time
Shearing System) is generally adopted. However, with this method, side effects always occur due to multiple processes accessing shared variables. This side effect is considered to be a major bottleneck during program verification and makes debugging difficult, so there is a need for an alternative method. This point will be explained in detail below.

Considering the characteristics of device-embedded software, the operation of the target control device can be considered to be sufficiently slow compared to the processing capacity of the CPU. For example, even the response speed of the photocoupler of the I10 board that controls the machine body is on the order of 10 milliseconds, and with this amount of time, even a Z80 can perform a considerable amount of processing. In view of this, multiple processes running in parallel are executed ``catch-by-catch'' while waiting for some event. Then, when an event occurs, response processing is completed in an instant. In this way, the time required for response processing is generally extremely short compared to the time interval between event occurrences. In consideration of this point, the following principle of parallel drive processing is adopted in this planet drive system.

Consider the case where multiple processes are each waiting for an event. In this case, each process detects the occurrence of an event. If no event has occurred, a system call (SWAP) is made to execute another process. In this way, multiple event waits are sequentially detected, and when an event occurs, the process immediately handles the response.
After that, the sequence moves to the next event waiting process.

That is, Process Execution is I
n1tial C.

ntrol, Rx Packet Manageme
nt or Delay C.

Accumulate processes sent from ntrol.

These processes accumulate by binding to a ring queue, as shown in FIG. Furthermore, a pointer to a process named Rung is set. ProcessExc
The parallel operation mode of execution is as follows.

■Program Co of the process instructed by Rung
Control is passed to the code address indicated by the de address tag.

- The process to which control has been handed runs the given code and returns control to Program Execution.

- Advance one process instructed by RunH.

■Repeat the steps from ■ to ■ above.

The details of the process running code are explained below.

In FIG. 29, after detecting revent l, ac
Examples of the sequential procedure ``execute action 1 and then detect event 2'' and the sequential procedure ``after detecting event 3, execute action 2'' are shown. In this figure, the code UPDATEPC appearing in (b) and (d) is a system call. This will change the running code address to tlPDATE when the process is driven using the above 5WAP.
Performs the function of setting immediately after Pc. The execution of the process is described by following the running code. When the process running in procedure sequence (b) reaches (a), the PCB (Process Column) representing that process is updated by UPDATAPC.
The address (a) is registered in the (ntrol Block). Next, the event (a) is detected, and if this event has not occurred, the execution of the process is interrupted by (a) 5WAP. When the process is executed again, it is executed from the address (a) set by this UPDATAPC. If event 1 has not occurred, execution is interrupted again by 5WAP. However, if this event 1 occurs, the action of (1)
Run the execution code of n1, then perform UPDATEPC (e) for waiting for an event, and wait for an event
Detect t2. Similarly, a procedure for detecting event 3 is performed.

(Process drive system?il) In order to provide sequential CPU time service to processes, it is necessary to use a PCB that corresponds to each process.
is coupled to the ring cue (drive cue) within the drive system as described above. P coupled to the driving queue
CB is executed at that point. System calls are provided for inserting or deleting PCBs in this drive queue.

The system call FORK inserts a new PCB into the drive queue when the planet program is executed to generate a new process and run it in parallel. The starting address of the procedure to be started is set as a parameter in this FORl[.

From the aspect of process execution, if a process
When the ORK system call is reached, the drive system gets a new process and inserts it into the drive queue.

After processing this newly inserted process, the process that issued the FORK continues execution. After FORK completes processing, it generates an identifier for the generated process.

This procedure is shown in FIG. As shown in the figure,
The running code of the process running under Process Exwcution is Process Excec.
By issuing a FORK to the application, other code acquires the process and participates in the parallel drive state. By giving the driven code address as an input parameter to this procedure and calling the FORK procedure, the process identifier is obtained as an output parameter.

The ABORT system call is then issued to abandon a process that has completed executing a series of sequential procedures. When this is issued, the drive system removes the PCB corresponding to that process from the drive queue and discards it. That is, as shown in FIG. 31, when a running process finishes running and abandons process driving, this process issues an ABO to Process Execution.
Issuing an RT will remove this process from the concurrent drive system.

The KILL system call is issued when a running process is desired to be destroyed by another process. The process identifier is required as an input parameter. When a KILL is issued, the drive system removes the PCB corresponding to the specified process from the drive queue and discards it. After this, the process that issued the KILL continues execution. That is, as shown in FIG. 32, the running code of the process in the execution state is Process Execution.
The other process is excluded from the parallel drive system by issuing a KILL request to terminate the other process. KIL
The process identifier returned by procedure FORK is used as an input parameter of the L procedure. That is, a group of related processes running in parallel must have means for recognizing the identifier of the process to be canceled.

The DELAV system call is issued to suspend process operation for a period of time specified by an input parameter. The PCB corresponding to the process that issued this call is removed from the drive queue and reinserted into the drive queue after the specified time.

After being inserted, execution is performed from the next address after issuing DELAY. In this way, the process of waiting for a specified time is realized.

(Process synchronization processing) A planet program having a connection structure as shown in FIG. 33 will be explained as an example. This program describes parallel driving of processes and their synchronization. Two processes are required here. This is because the processing series is divided into two. The synchronization of these processes is achieved by counters as shown in the figure. Here, Rinnualue is the variable. First, the synchronization counter is initialized to 0 (a). Next, “1
Generate code to execute llb (b). After this, the arrow splits into two, so execute the FORK system call so that the processing sequence on the left side is executed in the current process, and the process sequence on the right side is executed in a new process. 20 FORK starts execution from the next address after finishing the process, so the left traveling module m2 is placed at the position (1). Here, synchronization is realized like (ki) and (ri), so you can jump to that code (o). Module m3 that should run in parallel next
Place (force). The code that implements synchronization runs in two processes. The first process reached is mvalu
Increase e to 1. Since mvalue is not 2, the process that reaches it first is discarded. The next process that arrives sets mvalue to 2. As a result, the process is not discarded and runs through module m4.

In this example, it is 2, but the comparison value with mva Iue matches the number of input arrows. The mechanisms (a), (g), and (ri) realize synchronization processing. The process that reaches the last synchronization mechanism will continue processing, and all other processes will be discarded.

(Hierarchical management) Hierarchical management is achieved using a stack. efp, a which represents the stack frame of the current layer to each process.
Add rp and stack pointer sp. Each process has its own frame pointer and offset.
Access internal data. Referring to FIG. 34, the procedure for invoking a lower hierarchy will be described below.

(2) To obtain a storage area for storing output data, reduce the stack pointer SP by the area length (SPI).

■Bush input data (SF3).

■ Bush the current frame pointers (apr and efp) (SF3).

■Bush the return address (SF3).

- Set the current stack pointer value as the new frame pointer. That is, apr is set to its own processor 10, and efp is set to SF3.

■Jump to lower layer code address.

When the lower layer finishes processing and passes control to the higher layer, the procedure is as follows.

■ Set the stack pointer to the frame pointer value (S
F3).

■Pop the return address (SF3).

■Pop the frame pointer (SF3).

■Update the current frame pointer value to the value popped in ■.

Jump to the address popped up with ■■.

Furthermore, the procedure when control is passed to a higher layer is shown below.

(2) To discard the input data area, increase the stack pointer SP by the area length.

■Pop the output data.

The actual running code generated by the planet compiler when calling a lower layer block will be explained below. In the planet program, different calling methods are used depending on the type of processing requirements that appear in the upper layer block. Input arguments, return addresses, and internal variables used in lower hierarchy blocks are secured on the stack and LIFO managed. This makes recursive calls possible.

First, if the active processing section has a lower hierarchy, implement its invocation using the following running code.

GETSTACK push parameter(n)'s point
erpush parameter(n-1)'poi
nterpush parameter(1)'poi
intercall subargument add sp, pushed 5izeABORTST
The stack of the process executing the ACK program is normally set in a general-purpose memory area that is shared by the process and the drive system. A stack is required when calling a lower layer, and in this case, the stack is realized by LIFO, which incorporates the above-mentioned unique storage management mechanism. The one that requests a stack from the storage management mechanism is the GETST mentioned above.
This is an ACK system call. When this system call is made, a unique stack is allocated to the issuing process, allowing that process to call lower layers.

In Planet, a parameter pointer is passed as an argument to a lower layer. This realizes name calling.

Therefore, if an input argument exists, the variable address, I10 port, or bit address is pushed in order from the right of the argument list. Lower layers called in this way access input arguments at positive offsets from the stack frame pointer. If there is an input argument in the lower hierarchy, the address of that argument is bushed when calling the lower hierarchy. Next, suba
When control is returned from the lower layer after calling rgument, the stack pointer is increased by the area length of the input argument that was pressed before the call, and the stack pointer is
The stack pointer value obtained by ACK is restored. Furthermore, it issues ABORTSTACK, which is a system call that returns the stack allocated to the storage management mechanism.

If the event wait clause has a lower hierarchy, it is called as follows.

GETSTACK push parameter(n)'s point
erpush parameter (n-1)'s p
ointerpush parameter(1)'s
pointerUPDATEPC call subbargument Test HL register pair and
SWA is zer.

add sp, pushed 5izeABORTST
The steps up to obtaining the ACK stack and pushing the input argument pointer are the same as in the activity processing section described above, but the rest is different. In other words, if the lower layer is a conditional judgment phrase, the conditional judgment result is.

) The compiler generates running code to return the IL register bear. In the case of an event wait clause, the HL register bear is determined after calling the lower layer, and a need is generated to continue calling the lower layer until this register is no longer 0.

At this time, if the stack is secured each time, the time required to secure the stack cannot be ignored. To do this, issue the UPDATEPC system call after pushing the input arguments onto the stack. It uses an execution control method that prevents the input argument area from being destroyed even when control is passed to another process running in parallel, so it is possible to sandwich lower layers that continue to be called between UPDATEPC and 5WAP. be. If the lower layer returns a non-zero value,
The stack is freed. Also in the case of selective event-waiting clauses,
A running code similar to this will be generated.

Next, the calling mechanism of the conditional branch clause is a simplified version of that of the event wait clause described above, and is as follows.

GETSTACK push parameter(n>”s point
erpush parameter(n-1)'poi
nterpush paran+eter(1)'s
pointercall subargus+ent
add sp, pushed 5izeABORTST
ACK Test HL register pair
jump true address if non-
zer.

That is, since the called lower layer returns the condition judgment result to the register bearer, running code is generated so as to evaluate the value and realize the conditional branch structure.

(Message communication control between processors) Messages that connect multiple processors are processed using a dedicated HDL.
This is done over a C serial communication line. The planet compiler generates finite-length message buffers corresponding to the input/output terminals of control entities in the program. When a process needs to communicate a message, it performs read/evrite operations on the message buffer.

When a message contains data, the data length is fixed and the message buffer is configured as a finite-length ring buffer. , consists of a data pool. If the message does not contain data, it consists only of the number of messages.

First, message communication between control entities will be explained.

As shown in FIG. 35, an operation in which control entity B receives and receives a message output from control entity A will be explained as an example. The planet compiler generates running code to perform a -rite operation on the message buffer output of control entity A for those whose control reaches the output terminal. Also, if an arrow is output from the message terminal of the subsystem, a code is generated to perform a read operation to the message buffer output of control entity A. After the read operation, the message buffer 1npout of control entity B is
Place the code that performs the write operation. On the other hand, in the internal processing of control entity B, message buffer 1n
Generate a running code that performs a read operation on a put.

In this way, the message output by the internal processing of control entity A is used in the internal processing of control entity B.

Here, since the planet program itself is a control entity, message communication between processors is also realized by the same mechanism as the above-mentioned message communication between control entities. In this case, the message buffer rea
d/write operations, and the event detection to perform them, are performed in remote procedure calls to an external processor via a communication path. The read/ivrite operations of the message buffer consisting of the following can be issued by any processor in the network. Such a publishing operation requires various parameters. Below, we will explain these parameters and the function of the procedure call.

Processor Identifier Network parameters are required to perform a remote procedure call. That is, in order to issue a processing request (procedure call) to a specific processor, a destination such as which processor to send the request to is required. This is expressed by the processor identifier. All processors declared in a planet program are assigned a position number on the network. This identifier is the file hardware. It is set incrementally while traversing the network tree structure declared in def in a depth-first manner. This is done automatically by the compiler as described above. On the other hand, at the time of network configuration, information on the network connection shape and processor identifiers is distributed to all processors. Therefore, when the network is in operation, it is possible to specify the destination without being aware of the network shape by simply specifying the processor identifier.

Message Buffer Identifier There may be multiple message buffers in the running code of the processor. A message buffer identifier is required to specify which of these message buffers is to be operated on. This identifier is also automatically generated by the compiler. The processor identifier and message buffer identifier specify which message buffer of which processor is to be operated on.

Remote Procedure Call A message communication function consisting of the following four steps is realized by a remote procedure call.

■ Detecting whether the message buffer is full ■ Message buffer -rite operation ■ Detecting whether the message buffer is empty ■ Message buffer read operation -41
, the message buffer X in the external processor
The following describes the operation of performing the %1rite operation. A request to detect whether buffer X is full is issued to processor X. When the buffer is full, detection requests are continued to be issued to processor X at certain intervals until a report that X is not full is returned. Then, it attaches the data in the message to processor X and issues a -rite request to the buffer. With the above operations, the message will be passed to the processor.

Next, write a read to the message buffer in processor χ.
Describe the operations to be performed. When a reply is returned that the buffer is empty, the buffer is no longer empty and detection requests are continued to be output to the processor at certain intervals.

When the buffer is no longer empty, a buffer read request is issued to the processor.

The processor that receives the read request performs a read operation and sends a reply along with the data attached to the message. With the above operations, messages are passed from the processor.

〔Effect of the invention〕

As explained above, in the program creation device of the present invention, the screen for creating a program is displayed by the screen display means, and on this screen, the program language elements generated by the graphic pattern generation means are selected and the program is executed. Can be created. The programming language elements include directed branches and branching directed branches, and in particular, multiple processing sequences branched by branching directed branches are automatically converted into programs that are processed in parallel by the compiler. It has become so. Therefore, according to the present invention, it is possible to efficiently and easily create programs for parallel driving in networks where a plurality of control means exist.

In addition, if it is possible to display multiple screens for program creation, the program on the lower level of each processing element of the program created on the same screen can be displayed on another screen defined as the lower level of that processing element. can be created on the screen. Therefore, it is possible to efficiently create a large program in a top-down or bottom-up manner.

On the other hand, the debugging means according to the present invention is capable of reproducing and displaying the same screen as that at the time of creation, and debugging can be performed on this screen. Therefore, there is an advantage that the verification position of the program can be intuitively recognized and such debugging work can be easily performed.

[Brief explanation of the drawing]

FIG. 1 is a block diagram showing a model of a control entity in the Planet programming language. FIG. 2 is an explanatory diagram showing an example of describing relationships between control entities using planets. FIG. 3 is an explanatory diagram showing an example of description of internal processing of a control entity by Planet. FIG. 4 is an explanatory diagram showing the hierarchy of procedures by Planet. FIG. 5, like FIG. 4, is an explanatory diagram showing the hierarchy of procedures by planets. FIG. 6 is an explanatory diagram showing the program frame of Planet. FIG. 7 is an explanatory diagram showing a description example of a planet subsystem. FIG. 8 is an explanatory diagram showing an example of a description of a lower layer call by a planet. FIG. 9 is an explanatory diagram showing an example of a description of a message sending/receiving operation by Planet. FIG. 10 is an explanatory diagram showing an example of a description of message transmission and reception including data by Planet. FIG. 11 is an explanatory diagram showing an example of the description of the event wait clause by Planet. FIG. 12 is an explanatory diagram showing an example of the description of the activity processing section by Planet. FIG. 13 is an explanatory diagram showing an example of a description of a conditional branch clause by Planet. FIG. 14 is an explanatory diagram showing the description format of the selection event wait clause by Planet. FIG. 15 is an explanatory diagram showing an example of a planet program that interrupts a procedure. FIG. 16 is an explanatory diagram showing a description example of a repetitive control structure using planets. FIG. 17 is a diagram showing the format of floating point type data. FIG. 18 is an explanatory diagram showing a description example of a data structure in Planet. FIG. 19 is an explanatory diagram showing the flow of program development using Planet. FIG. 20 is an explanatory diagram showing the block management state. FIG. 21 is an explanatory diagram showing a display block list. FIG. 22 is a block diagram for explaining hardware declaration. FIG. 23 is an explanatory diagram for explaining the network declaration procedure. FIG. 24 is a diagram showing the processor window. FIG. 25 is a diagram showing a screen displaying the hierarchical structure of the processors. Figure 26 shows the "*air" screen displayed on the screen in Figure 25.
FIG. 3 is a diagram showing a screen displaying a source program of block B. FIG. FIG. 27 is a block diagram of the overall configuration of the planet drive system (kernel). FIG. 28 is a diagram showing a process ring queue. FIG. 29 is an explanatory diagram showing an example of development of event detection and response processing. FIG. 30 is an explanatory diagram showing the rFORK procedure. FIG. 31 is an explanatory diagram showing the rABORTJ procedure. FIG. 32 is an explanatory diagram showing the rK I LL procedure. FIG. 33 is an explanatory diagram showing an example of synchronizing a plurality of processes. FIG. 34 is an explanatory diagram showing hierarchical management. FIG. 35 is an explanatory diagram showing an example of message communication. [Description of symbols] xed...Editor xpl...Parser xp2...Sorter xp3...Code generator xp4...Linker xdb...Debugger. Besan Figure 6 W! J7 Figure 8 Figure 9 Figure 10 (b) (d) 11th rl!
i Fig. 12 Fig. 13 Ob cd , 114 factor Fig. 15 Fig. 16 Fig. 17 Fig. 18 Mountain (G) D Fig. 21 Fig. 22 Fig. 23 (A) (B) ' 1liJ24 Fig. @ 25 Figure 27 Figure 281 (G) (c) Figure 29 Figure 30 Figure 31 Figure 7JpJ32 &lA φ Figure 34 (c) (b) '6-

Claims (4)

[Claims] (1) A program creation device for creating a program to be processed in parallel by a plurality of control entities on a network, comprising: a hardware information holding means that holds hardware information of a network including the plurality of control entities; and a program creation device. A screen display means for displaying an area on a display screen, a program creation means for creating a program on the display screen, a translation means for translating the created program into machine language, and a program consisting of the translated machine language. and a storage means for storing the program, the program creation means having a graphic pattern generation means for program creation capable of generating a plurality of types of drawing patterns that display the contents of each process processed in chronological order in the program; hardware information input means capable of inputting the hardware information onto the display screen; pattern selection means sequentially selecting the graphic patterns and displaying them on the program display screen; There are multiple types of graphical patterns that indicate the content, directed branches that indicate the chronological flow direction of the processing requirements, and that there are at least two branches, and the processing requirements that follow the chronological order should be processed in parallel. A first branching directed branch shown in FIG. and a branching directed branch, and the translation means converts each of the plurality of processing element sequences subsequent to the first branching directed branch into the first branching directed branch based on the information obtained from the hardware information holding means. It has parallel processing program allocation means for allocating programs to be processed in parallel by each of the plurality of control means, and the pattern selection means selects the graphic pattern indicating the processing requirements and the directed branch or branching directed branch. 1. A program creation device, wherein a parallel processing program to be executed by the plurality of control means is created on the same screen by alternately selecting the following. (2) In claim 1, the screen display means is capable of displaying a plurality of program creation screens, and the lower order of the processing elements displayed by each graphic pattern of the program created on one screen. The program is characterized in that the program can be created on another screen, and has a hierarchy management means that defines a hierarchical relationship between the processing element and the lower program formed on the other screen. Creation device. (3) In claim 1 or 2, the device has debugging means for debugging the created program, and the debugging means is capable of debugging the created program at the time of debugging. What is claimed is: 1. A program creation device comprising: a reproduction display means for reproducing and displaying a graphic pattern; and a display means for displaying a program execution position during debugging on the reproduced program. (4) The program according to claim 3, wherein the display means is capable of simultaneously displaying a plurality of processing parts that are processed in parallel in a part of processing elements that are processed in parallel. Creation device.