JPH03294924A - State event matrix data forming method and state event matrix data processor - Google Patents

Abstract

PURPOSE:To facilitate the program design by making a subordinate matrix in accordance with the contents in which contents of a processing of a task is complicated. CONSTITUTION:It is a slave matrix 41 that shows the contents of a processing and a transition of contents 311, it is a slave matrix 42 that shows the contents of contents 321, and it is a slave matrix 43 that shows the contents of contents 312. Also, for instance, the contents of a processing and a transition of one contents 5221 of a slave matrix 42 are further entrusted to a sub-slave matrix 622. In such a way, as for the contents of a complicated processing, a subordinate matrix is made and they are described therein, therefore, even if the program becomes larger, its design and analysis can be executed easily.

Description

[Detailed description of the invention] The present invention will be described in the following order.

A. Industrial field of application B1 Overview of the invention C0 Background art [Figures 9 and 10] D1 Problems to be solved by the invention E0 Means for solving the problems F8 Effects G. Examples [First Figures to Figure 8 H0 Effects of the Invention (A, Field of Industrial Application) The present invention has a state that indicates the state of a task in one of the rows and columns, and an event that indicates an input to the task in the other. A method for forming state event matrix data in which task processing/transition is described in the content and used in the software development field, and a state event matrix data processing device that processes the state event matrix data to automatically generate a program in a specific language. It is related to.

(B. Summary of the Invention) The present invention expresses the processing of a task with respect to at least part of the content of the state event matrix in order to express the relationship among inputs, states, and processing in a hierarchical manner using state event matrix data. For complex processing content, such as creating a matrix of children to be processed and then creating a matrix of grandchildren for at least part of the content of the child matrix, a lower matrix is created and recorded in it.
By doing so, it becomes possible to easily express control with complex relationships among inputs, states, and processes/transitions using matrix data.

Then, by appropriately processing the matrix data by a computer, it can be converted into a program capable of operating CPLI, which greatly facilitates the design of the program.

(C, Background Art) [Figures 9 and 10] In a system controlled by a computer, the content executed by the computer can be described on a flowchart, but the relationship between inputs, states, and processes must be described. I can't. Therefore, it is difficult and time-consuming to identify problems or causes of problems in the relationship between inputs, states, and processes of programs executed by the computer. In particular, tasks operating in large-scale and complex real-time control systems must process numerous input events, and the processing changes depending on the current state, and the state itself changes. Therefore, the more complex the real-time system is, the more difficult it is to identify the malfunction and its cause from the flowchart.

Therefore, the relationships among inputs, states, and processes are expressed using a matrix. FIG. 9 shows the format of such matrix data.

In the drawing, a indicates the mode number of the matrix, and bl, b2, ... (in the example shown in Fig. 9, there are only up to b2, but there are usually more numbers) are the mode numbers of the matrix. Each state 1.2, . . . indicates the state of the task taken in the row. c.
l, C2, . . . are each event 1.2, .
It is... d, d, ... are the contents that are the intersections of rows and columns, and here are the transition destination and processing fun.
cl, func2, . . . are written. Note that e indicates a transition destination, and f indicates a process.

The following specifications are expressed by a matrix in this format as shown in FIG. 10.

Specification Micromouse is at the crosswalk. (Micromouse is stopped) Micromouse walks at the crosswalk when the traffic light turns green.

While walking, run when the traffic light turns yellow or red.

While walking, when the traffic light turns red, I bow while running.

When it finishes crossing, it stops there.

As is clear from Figure 10, according to the matrix,
You can see at a glance the types of inputs, states, and processes, you can see at a glance whether there are several test cases, and you can also see at a glance the behavior when an input is in a certain state. Also, according to the matrix, functions are brought to the forefront and processes such as what to set in status flag variables are summarized in a table. Therefore, a flowchart focusing on the processing sequence (PA
It can be said that the advantage of using a matrix is that it is much easier to understand the relationships among inputs, states, and processing than using D).

(D. Problem to be solved by the invention) By the way, system tasks have become so complex that they are difficult to express even with the above-mentioned matrix, and conventional matrices that grasp the relationship between inputs and states in a two-dimensional manner Data cannot handle systems that perform complex control (and it is becoming so. State event matrix data has been used only in the analysis phase, and it is precisely the conventional state event matrix data that has not been utilized in the design phase. This is because matrix data can only grasp the relationship between input, state, and processing in a two-dimensional (non-hierarchical) manner.

Therefore, the present invention provides a method for forming state event matrix data that hierarchically expresses the relationship between complex inputs, states, and processes, and automatically converts the state event matrix data into a program in a specific language that can actually be executed by a CPU. An object of the present invention is to provide a state event matrix data processing device capable of processing data.

(E. Means for Solving Problems) The state event matrix data forming device of the present invention creates a matrix of children expressing the processing of the task for at least part of the content of the state event matrix. For the content of complex processing such as creating a grandchild matrix for at least part of the contest of a matrix, create a lower matrix and write it in it, and the content of the upper matrix entrusted to the lower matrix is written in the lower matrix. The code that specifies the transition destination is written.

The state event matrix data processing device of the present invention stores a parent state event matrix in one area of memory, each child state event matrix in another area of memory, and each grandchild state event matrix in another area. Each matrix with different dimensions, such as an area, is stored in memory, and the hierarchical state event matrix is converted into a program in a specific language by data processing by the CPU based on a program stored in another memory or memory area. It is characterized by being made to do.

(F. Effect) According to the state event matrix data forming method of the present invention, for a contest with complicated processing among the state event matrices, the processing contents are expressed by one matrix, and the processing contents are expressed in the matrix. For the entrusted content, set the matrix as the transition destination and 1. Since we have decided to write it down as follows, it is possible to sequentially hierarchize matrix data as needed, and even if the relationship between input, status, and processing is extremely complex, it can be organized step by step from the outline to the details. I can express it.

Therefore, even if the program becomes large, it can be easily understood, and design and analysis can be performed easily.

According to the state event matrix data processing device of the present invention, the state event matrix data representing the relationship between input states and processing in a hierarchical manner is stored in a memory (for example, R
AM) and converts it into a program in a specific language by the CPU according to a program stored in another memory (for example, ROM), thereby automatically generating a program that can actually operate the CPU. Can be done. That is, state event matrix data is easy to design and analyze system control, but since the instructions are not arranged in an orderly manner, it cannot be used as a program as it is.However, the state event matrix data of the present invention According to the processing device, it is possible to automatically process it and convert it into a program, making it extremely easy to create a program.

(G, Example) [Figures 1 to 8] Hereinafter, the present invention will be explained in detail according to illustrated embodiments.

FIG. 1 is an explanatory diagram showing an example of a method for forming state event matrix data according to the present invention.

In the figure, 1 is the parent state event matrix, and O is given as the mode. This mode is written in mode column 2. In this example, the number of rows,
The number of columns is 2, the first row is event 1, the second row is event 2, the first column is state 1, and the second column is state 2. And 3 is content.

For the content 308 of event 1 and state 1, the content 321 of event 2 and state 1, and the contents 3 and 2 of event 1 and state 2, the expression of the specific processing content is entrusted to the lower child matrix 44□, 43. ing. Content 3 of event 2 and state 2 is not entrusted with expressing the contents of the process. Of course, the first
What is shown in the figure is just an example, and there may be cases where the expression of processing/transition contents for all contents of the parent matrix (mode 0) is entrusted to the child matrix, or expression of processing/transition contents for only one content. There may be cases where the representation of content is left to child matrices.

In the example shown in FIG. 1, child matrix 4.1 shows the processing/transition details of content 3.1. , which is given a mode of 0.1. Content 32
．． The child matrix 42 shows the contents of , and the mode is 0.2. Child matrix 4 indicates the contents of content 3.2, and the mode is 0.3.

The processing and transition of one content 52□ of the child matrix 4□ of mode 0.2 is further entrusted to the grandchild matrix 6□2 (mode 0.2.2). In addition, the processing/transition contents of one content 5311 of the child matrix 4s of mode 0.3 are the grandchild matrix 6 □
(mode 0.3°1).

In this way, this state event matrix data formation method does not represent a real-time control system by one matrix (i.e., one matrix is used as a parent matrix, and at least some of the contents of the parent matrix are represented by one matrix). For the content of , the content of processing/transition is written in the child matrix.Then, if necessary, the content of processing/transition for some or all of the contents of each child matrix is also written in the grandchild matrix.In this example, Although there is only a grandchild matrix, if necessary, it is also possible to form a great-grandchild matrix, a child matrix, and a grandchild matrix for that great-grandchild matrix.Then, the specific content of the processing can be expressed. Content entrusted to a lower matrix is marked with a symbol that specifies the lower matrix.With such hierarchical state event matrix data, even a very complex control system can be expressed, and the control system's This makes analysis easier, but it also allows the control system to be accessed in the form of state-event matrix data.Therefore, the design of the program for the system becomes very difficult. Moreover, it is easy to discover defects in the relationship between input, state, and processing, and it is also easy to find the cause.

Further, the initial value of the state of each matrix is state 1, regardless of whether it is a parent, child, or grandchild. There are two types of state transitions. The first type is a transition that takes place within the matrix and is called a local transition. The second type is transition inside and outside the matrix,
It is called a global transition. In the case of a local transition, the number of the state to be transitioned to is simply written in the column indicating the transition destination. This is the same as the case shown in FIG. If there is no state transition, a - symbol is written in the column indicating the transition destination. This is also the same as the conventional case.

In the case of a global transition, as shown in FIG. 2, the symbol > and / are used to display the content transition destination at the intersection of event 1 and state 1. In this example, O>210.1>2, and the leftmost O indicates the mode O of the matrix in which the transition is made. > is used to separate a mode and a state, and the 2 to the right of > indicates that the transition destination state number is 2. / separates one transition display portion from another transition display portion. The above-mentioned O>2 on the left side of 7/ indicates that the state of the mode 0 matrix is transitioned to state 2. Further, 0.1>2 on the right side of / indicates that the state of the matrix of mode 0.1 is transitioned to state 2.

The number of transitions may be greater than two.

Figure 3 shows the specifications (
It starts with "Micromouse is at a crosswalk." and ends with "When it finishes crossing, it stops on the spot." (see page 7) is expressed as a state event matrix.

In FIG. 3, unique symbols different from those used in FIG. 1 are used for convenience.

This state event matrix consists of a parent state event matrix 21 and a child matrix 22, and is hierarchical. Parent state event matrix 21
The mode is O (described in the mode column 211), and the mode of the child state event matrix 22 is 0.1 (described in the mode column 21). This child state event matrix 22 is a representation of one content of the parent state event matrix 21. The content of the state event matrix 21 whose content has been entrusted to the child state event matrix 22 is expressed by the child state event matrix 22.
A parent-child relationship (hierarchical relationship) is expressed by writing a symbol 21□ indicating the existence of a parent-child relationship (hierarchical relationship). 0 of the modes 0.1 of the child state event matrix 22 indicates that the mode of the parent state event matrix is 0. Further, 1 of the modes 0.1 matches the numerical value in the symbol 212 of the content of the parent matrix 22 to which the expression of the content is entrusted. Therefore, from the symbol 21□, it is known that the child state event matrix 22 exists and which matrix it is.

The state event matrix (that is, the parent state event matrix) 21 for mode O (described in the mode column 21.) includes start (first event column 21.), traffic light information (second event column 214), stop ( Third
Processes and transitions focused only on the three inputs in the event column 21, ) are shown. And mode 0゜1
(described in the mode column 221) state event matrix (i.e. child state event matrix) 22
The details of the traffic light information (the second event column 214 of the parent Tate event matrix 21) are blue (first event column 22□), yellow (second event column 22.), and red (
It shows processing and transitions focused only on the three inputs in the third event column 224).

In other words, the state event matrix of mode O)2
1 shows an overview of the specifications, and state event matrix 22 in mode 0°1 shows details of the specifications.

With such hierarchical state event matrix data, even a very complex control system can be expressed, making it easy to design the control system. It also makes it easier to discover design errors.

FIG. 4 shows a state event matrix data processing device that processes the state event matrix data hierarchically formed by the above method and converts it into a program in a specific language, for example, C language, which can drive the CPU. 5 shows the file arrangement in the external storage device, specifically, the disk device.

In the figure, 11 is the main body of the engineering workstation, 12 is the display, 13 is the keyboard, 1
4 is a mouse, and 1 is an external storage device, specifically a disk device in this example.

State event matrix data is input into the workstation main body 11 by operating the keyboard 13 or mouse 14, which are input devices. Further, the input state event matrix data is displayed on the display 12, stored in the disk device 15, and can be printed out on the printer 16. In particular, when state event matrix data is output from the workstation main body 11 to the disk device 15, it is stored as a file for each mode as shown in FIG. This point will be explained in detail later.

The state event matrix data stored in the disk device 15 can be optionally output to the display 12 and printer 16, and can also be output to the keyboard 1.
3 or by operating the mouse 14, the state event matrix data stored in the disk device 15 can be changed.

Conventionally, a program code coded by a programmer can be automatically coded by the state event matrix processing device shown in FIG. 4, but the procedure for generating the program code will be described below. Note that the program code is generated on the assumption that the real-time monitor has a mail function. FIG. 6 is a flowchart of the generated program code.

FIG. 7 is an event data configuration diagram of the state event matrix data shown in FIG. It is stored in the disk device 15 which is a device. Specifically, traffic-s
ignal event configuration data in area 33, 5top event configuration data in area 34, blue event configuration data in area 35, and yellow event configuration data in area 3.
6, area 37 for red event configuration data.
is stored in

Then, the traffic-signal event (third
The configuration diagram of 214) in Figure 7 is 41 in Figure 7, and the configuration diagram of the 5top event (216 in Figure 3) is 42 in Figure 7.
The configuration diagram of the blue event (22□ in Figure 3) is shown at 43 in Figure 7, the configuration diagram of the yellow event (22s in Figure 3) is shown at 44 in Figure 7, and the red event (22□ in Figure 3) is shown at 44 in Figure 7.
The configuration diagram of 224) in the figure is as shown at 45 in FIG. Note that the 5tart event (213 in FIG. 3) is treated as a non-mail type trigger input event in this example, so an event configuration diagram is not necessary.

State event matrix data processing is performed using the created state event matrix data (state event matrix data 21 in mode O is stored in area 31 of the disk device 15, mode 0.1
The state event matrix data 22 of is stored in area 32 of the disk device 15) and the event configuration data (stored in areas 33 to 37 as described above)
Based on this, proceed with the following processing to generate program code. Note that the generated program code is stored in the area 38 of the disk device 15.

State event matrix mode number (3rd
211.22+) in the figure, a state structure which is a C language variable is formed as follows.

Note that int mo; O is in the mode column 21. The o-i of intmo-1 is generated based on the mode column 22. Generate based on.

Next, event configuration data (41.42.43 in Figure 7)
．． 44.45) and state event matrix data (214.216.22□, 22..224 in Figure 3)
) to generate an input event structure, which is a C language variable, as follows.

Incidentally, event-tyl) e: is 41 + in Figure 7.
, event-paral ; is the same < 41 a
, traffic-signal; are generated based on 214 in FIG. Below, 5top, blue, yellow
Low and red are generated in the same way.

State event matrix (21.22 in Figure 3)
C using the matrix structure tags defined in advance in the state event matrix data processing device.
Initialize the matrix table, which is a language variable.

Note that 3 in [3] above is generated based on 216 in Fig. 3,
2 in [2] is generated based on 217 in Figure 3, (2, 1n
2 of (itial) is generated based on 218 in Fig. 3, 1
ntial is generated based on 219 in Figure 3, (-1, n
-1, non of on) is generated based on 211o in Figure 3, malcnt of (-1, malcnt) is generated based on 2 in Figure 3.
Generated based on 1°.

The following C program code is filled in the part 51 of the C source code of FIG. 6 defined in the state event matrix data processing device.

Note that O in event-type==0 is 413 in Figure 7.
Generated based on, 2 of event = 2; is 2 of Fig. 3
1.1.

Next, fill in the following C program code in the part 52 in FIG.

Then, control processing mo-1ent of the state event matrix data 22 in FIG. 3 is generated in the same way as the above-described processing for filling in the portions 51 and 52 in FIG. 6.

The above C program code is stored as a file in the area 38 of the disk device 15.

Program code is automatically generated by such a procedure.

FIG. 8 is a flowchart showing the steps of software development utilizing the present invention.

First, hierarchical state event matrix data as shown in FIG. 1 is created (edited) [step (a)]. Next, check the syntax and consistency of the created state event matrix data [
step (b)].

Then, it is determined whether there is an error [step (C)]. If the determination result is YES, the process returns to step (a). On the other hand, if the determination result is No, a simulation is performed on the state event matrix [step (a)], and then it is determined whether there is an error or not [step (e)]. If the judgment result is YES, step (a)
). If the judgment result is No, the state event matrix data is written in a specific language, such as C.
Convert to a language program [step (f)].

This completes the creation of the program.

(H, Effect of the Invention) As is clear from the above description, according to the method for forming state event matrix data of the present invention, for content whose processing is complicated in the state event matrix, the content of the processing is transferred to the lower level. For content that is expressed by a matrix and whose processing content is entrusted to a lower-level matrix, that matrix is designated as the transition destination, so matrix data can be layered sequentially as necessary, and input, Even if the relationships between states and processes are extremely complex, they can be organized and expressed step by step from the outline to the details. Therefore, even if the program becomes huge, it becomes easier to understand it, and it becomes not only easier to analyze but also easier to design.

According to the state event matrix data processing device of the present invention, state event matrix data representing the relationships among inputs, states, and processes in a hierarchical manner is stored in a memory, and the state event matrix data is processed according to a program stored in another memory.
Since the PU converts it into a specific language program,
State event matrix data that cannot be used to control the CPU as it is is automatically converted into a program in a specific language.
That is, it can be generated in a form that allows the CPU to operate. Therefore, creating a program becomes extremely easy.

[Brief explanation of the drawing]

FIG. 1 is an explanatory diagram of one embodiment of the method for forming state event matrix data of the present invention, FIG. 2 is an explanatory diagram of global transition, FIG. 3 is an explanatory diagram of a specific example of state event matrix data, and FIG. and FIG. 5 show one embodiment of the state event matrix data processing device of the present invention, FIG. 4 is a schematic configuration diagram of the device, FIG. 5 is a diagram showing an example of file arrangement in an external storage device, and FIG. 6 is a flowchart of the generated C code, FIG. 7 is an event data configuration diagram, and FIG. 8 is a flowchart showing an example of the program creation process using the present invention.
9 and 10 are for explaining the background technology, FIG. 9 is an explanatory diagram of conventional state event matrix data, and FIG. 10 is an explanatory diagram of a specific example of conventional state event matrix data. be. Explanation of symbols 1.21...Parent matrix, 3...
Content, 4.22...Child matrix, 5...
Content, 6...Grandchild matrix, 15...Memory (external storage device). Figure 3 Generated C source code flowchart Figure 6 Implementation Figure 8 Figure 10

Claims (2)

[Claims] (1) A state event matrix that forms state event matrix data in which one of the rows and columns has a state that indicates the state of the task, and the other has an event that indicates the input to the task, and the content describes the processing of the task. In the data formation method, for at least some content, create a child matrix that represents the processing of the task, write a symbol specifying the child matrix in the content, and change the child matrix as necessary. A grandchild matrix expressing the task processing is created for some or all of the contents, and a symbol specifying the grandchild matrix is written in the content. State event matrix data formation method characterized by creating a matrix (2) In a part of the memory, one of the rows and columns has a state that indicates the state of the task, and the other has an event that indicates the input of the task, and becomes a parent whose content describes the processing of the task. storing state event matrix data; storing child state event matrix data expressing task processing for at least part of the content of the parent state event matrix data in another area of the storage unit; The grandchild state event matrix data representing the processing of the task of at least a part of the content of the child state event matrix data is stored in another area of the memory, and the data is stored in another area of the memory or another memory. A state event matrix data processing device, characterized in that the state event matrix data is converted into a program in a predetermined language by processing the state event matrix data by a CPU based on a program stored in advance in a CPU.