JP2007011507A - Display method of program tree and program generation system - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To clarify correspondence to a structuring-programmed program in a display method of a program tree and a program generation system. <P>SOLUTION: A program element which is a component of a program and includes at least a compile unit is assigned to each node to form a program tree 21, and the formed program tree 21 is displayed on a program tree display part. The processing content of the program element is displayed in a processing content display part. Input work to the program tree display part and the processing content display part is performed by an input means. <P>COPYRIGHT: (C)2007,JPO&INPIT

Description

  The present invention relates to a program tree display method and program generation system, and more particularly to a program tree display method and program generation system in programming using a CAD system.

  Conventionally, in the development of a program, when a computer program is produced using a programming language such as an assembler or C language, means for directly describing text such as a text editor has been used.

  As a text editor-based program production technique, a structured programming technique is widely used. That is, one load module is produced by dividing it into a plurality of compilation units (units for compiling a source program to obtain one output), and then combining the outputs of the respective compilation units into a final load module. Take a method, or create a group of functional units as independent program parts and collect them into large functional units.

  In this structured programming method, small functional unit modules can be produced in a short period of time, and general functional unit modules can be reused. By reusing, each functional unit can be applied to production of another program. It is known that the module of the unit has an advantage that it can be independently inspected, and the structured programming method is an indispensable method as a program production method.

  On the other hand, when the scale of the program reaches a certain level, the text alone is poor in readability, and not only the design of the program but also a great amount of labor is required for inspection, management, maintenance and the like. In order to solve this problem, a method using a graphical program has been proposed. For example, a tree-structured graphical program description method called an HCP (Hierarchical and ComPact description) chart has been proposed (see, for example, Patent Documents 1 and 2). Also, a graphical program description method called a PAD (Problem Analysis Diagram) diagram has been proposed (for example, see Patent Document 10).

  There has also been proposed a method for automatically generating a program in a format that can be executed by an electronic computer or a high-level language from such a graphical program. For example, a method for generating a source program from a sequence of tree structure elements expressed in three sets of formats has been proposed (see, for example, Patent Document 3). A method of automatically generating a program based on a design document has also been proposed (see, for example, Patent Document 4).

In addition, as a program management method, methods of expressing using various formats have been proposed. For example, a format called a link format having a form in which concepts are linked by a link structure has been proposed (see, for example, Patent Document 5). In addition, a format called a network format that uses a network representing a connection between data and a semantic relationship has been proposed (see, for example, Patent Document 6). Further, a format called a tree format has been proposed (see, for example, Patent Documents 7, 8, and 9).
JP-A-2-235144 (FIG. 2) JP-A-1-41931 (FIG. 2) JP-A 63-167931 (FIG. 1) JP-A-2-253443 (FIG. 1) Japanese Unexamined Patent Publication No. 63-233428 (FIG. 4) JP-A-63-61329 (FIG. 4) JP 2003-85012 A (paragraph numbers [0021] to [0029], FIG. 1) JP 2002-66967 A (paragraph numbers [0011] to [0012], FIG. 1) JP 2004-240593 A (paragraph numbers [0026] to [0039], FIG. 5) Japanese Examined Patent Publication No. 6-40302 (FIG. 3)

  However, there are known methods for managing programs that conform to schematic programming methods that can be directly associated with programs created in accordance with structured programming methods, and CAD (Computer Aided Design) systems that use them. It is not done.

  For example, in the invention described in Patent Document 1, the function is divided by a method called modularization to perform hierarchization. However, it is much simpler than a program produced manually using a structured program method. I can't make it.

  In the invention described in the above-mentioned Patent Document 2, as a program hierarchy, a part of the program is written to another file to divide the function. However, in this method, the embedded program can be compiled independently. Since it is impossible to inspect the embedded file alone, it is not possible to enjoy the benefits of the original structured programming. Therefore, it cannot be directly associated with a programming development method based on a so-called structured programming method.

  Further, in the invention described in Patent Document 7, the database management system program is displayed in a tree structure, but the graphical program displayed in the system is only a mutual relationship of procedures that are functional units, and this is an actual program. It is not clear which program component of the program corresponds to.

  In the invention described in Patent Document 8 described above, a program for controlling the operation of the robot is described based on tree structure data management. In this description method, the relationship between the program components and the displayed tree structure data is clearly shown. It has not been.

  Further, in the invention described in Patent Document 9, the project is displayed in a tree shape, but also in this display method, the relationship between the program components and the content displayed in the tree shape is clarified. Absent.

  As described above, the method of structured programming is generally used, but the structured programming can be expressed and managed in a diagrammatic form with a clear correspondence with the program. There has never been a program production CAD system that combines a program production means that combines it with a diagrammatic programming technique and an automatic program code generation means.

  The present invention has been made in view of these points, and an object of the present invention is to provide a program tree display method and a program generation system that clearly express the correspondence with a structured program and express it graphically. To do.

  In the present invention, in order to solve the above problem, in the program tree display method for displaying the program in a tree shape by assigning program elements which are constituent elements of the program to each node of the tree, the compile unit is the program tree. There is provided a method for displaying a program tree, characterized in that the program tree is displayed as a node.

According to such a program tree display method, a compilation unit is displayed as a node of the program tree.
Further, according to the present invention, in a program generation system for generating a program, a program in which a compile unit is assigned to a node and a program element that is a component of the program is assigned to each node, and the program is configured in a tree shape A program tree display unit for displaying a tree, a processing content display unit for displaying the processing content of each program element, and an input means for performing input operations to the program tree display unit and the processing content display unit A program generation system is provided.

  According to such a program generation system, the program tree display unit displays the program tree including the node of the compilation unit and the node of the program element, the processing content display unit displays the processing content of the program element, and the input unit Thus, data is input to the contents displayed on the program tree display section and the processing content display section.

  According to the program tree display method of the present invention, the program tree can be displayed in association with a program programmed by the method of structured programming, so that the visibility is improved and the reusability and portability of the program are impaired. You can make a program without.

  Further, according to the program generation system of the present invention, since the correspondence with the program programmed by the method of structured programming is clear, the visibility is improved and the reusability of the program, which is an advantage of the structured programming, is achieved. A program can be produced without impairing portability.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
FIG. 1 is a conceptual diagram of the invention applied to this embodiment. As shown in FIG. 1, the CAD system 1 according to the present embodiment includes a terminal device 10, a mouse 11, a keyboard 12, and a monitor 13.

  In the screen display example 20 displayed on the monitor 13, a processing content display window 22 for displaying processing contents corresponding to the program tree 21 and the functional unit of the program is displayed. The program tree 21 displays a project, a compile unit, and a functional unit, which are program elements constituting the program, as nodes in a tree shape. The processing content display window 22 is a window for displaying the processing content of the program.

  The CAD system 1 automatically generates a program such as a C language format from a diagram format, a C language format including the whole from a diagram format and a C language format, or a diagram language format to a machine language format. By providing the means, a program generation system is configured.

  By constructing such a program generation system, a means for displaying the processing contents of the program, a means for inputting an instruction signal from the program and the user, and a means for outputting the program from the input data are added. The program can be produced in such a way that the unit, the compilation unit, and the functional unit can be visually recognized.

  FIG. 2 is a diagram illustrating a hardware configuration example of the terminal device used in the present embodiment. As shown in FIG. 2, the entire terminal device 10 is controlled by a CPU (Central Processing Unit) 101. A random access memory (RAM) 102, a hard disk drive (HDD) 103, a graphics processing device 104, and an input interface 105 are connected to the CPU 101 via a bus 106.

  The RAM 102 temporarily stores at least part of an OS (Operating System) program and application programs to be executed by the CPU 101. The RAM 102 stores various data necessary for processing by the CPU 101. The HDD 103 stores an OS and application programs.

  A monitor 13 is connected to the graphic processing device 104. The graphic processing device 104 displays an image on the screen of the monitor 13 in accordance with a command from the CPU 101. A keyboard 12 and a mouse 11 are connected to the input interface 105. The input interface 105 transmits a signal sent from the keyboard 12 or the mouse 11 to the CPU 101 via the bus 106.

With the hardware configuration as described above, the processing functions of the present embodiment can be realized.
FIG. 3 is a display example of the program tree of the present embodiment. In this figure, the symbol shown in the node 26a indicates a compilation unit. In the present embodiment, the compilation unit is regarded as a module (separable software component). A character 27 a displayed “input control” immediately to the right of the node 26 a is an implementation example in which the name of the compile unit corresponding to the node 26 a is arranged for easy viewing on the program tree 21. Hereinafter, it is assumed that the character on the right side of the compilation unit node of the program tree 21 is the name given to the compilation unit corresponding to the node.

  Further, the symbol shown in the node 28a indicates a functional unit, and the character 29a displayed as "current control" immediately on the right makes it easy to see the name of the functional unit corresponding to the node 28a on the program tree 21. This is a mounting example arranged for this purpose. Hereinafter, it is assumed that a character on the right side of a functional unit node in the program tree 21 is a name given to the functional unit corresponding to the node.

  By the way, the functional unit of current control belongs to the compile unit of input control. Therefore, in order to clarify the dependency, the node 28a representing the functional unit of current control is displayed so as to be subordinate to the node 26a representing the compilation unit of input control. In addition, since the compile unit is considered as a container for inserting a functional unit, there is no processing function that directly belongs to the compile unit, and the processing function always belongs to the functional unit.

  In addition, the functional unit may include a finer functional unit. This is an idea corresponding to the detailed division of the function accompanying the structuring of the program in the idea of the structured programming. The form of functional unit implementation corresponds to a subprogram which is called a function in the C language and sometimes called a subroutine or a procedure in other programming languages. In this case, a smaller functional unit appears in a larger functional unit. On the program tree 21, the situation is shown in a relationship between a node 28a representing a functional unit of current control and a node 28b representing a functional unit of current command calculation. That is, the functional unit of the current command calculation is a partial function belonging to the functional unit of current control, and the node 28b is subordinate to the node 28a in order to improve the visibility of the dependency relationship between the functional units. To display.

  This can occur in the same way in the subordinate functional units. In that case, it is recursively dependent on the upper functional unit to which the node representing the lower partial functional unit belongs. To display. A specific form in this case is shown, for example, in a relationship between a node 28d representing a functional unit of a PWM (Pulse Width Modulation) modulator and a node 28c representing a functional unit of voltage distribution.

  By the way, the compilation unit outputs one file as a result of compilation. More specifically, in a C language format program, the compilation unit is a C language source file whose extension is usually represented by “c”, and by compiling this, the extension usually becomes “o” or “ An object file represented by “obj” is generated.

  This output file may be a binary file that can be directly interpreted and executed by the CPU, but if it is output as a binary file, it is not easy to produce a medium- or large-scale program or to reuse the program. At the end of the process, the absolute position in the memory is not determined, and a relocatable object in which an address is described at a relative position from the top of the module is generated. After producing one or more such relocatable objects as required, information such as a memory map command for a link that matches the memory environment of the execution environment is given. These are combined by a tool called a linker or a linkage editor to form a final executable program.

  The program represented as the program tree 21 has three compilation units. Since the purpose of program creation is to create a final executable program using the linkage editor after compilation. It would be useful to have a concept that represents the units to be combined in the linkage editor. Therefore, a unit corresponding to a load module including one or more compilation units and combining outputs generated from the respective compilation units is defined as a project. The project is represented by a symbol shown as a node 24 on the program tree 21. A character 25 on the right side of the node 24 is a name displayed on the program tree 21 for the name assigned to the project. From the above, it can be said that the program tree 21 is divided into modules that constitute an inverter control project and is represented in a tree shape.

  As described above, according to the CAD system 1, the program tree 21 is displayed in the screen display example 20, and the structure of the program can be easily read. Therefore, the program can be easily produced by structured programming.

Next, a description will be given of a method for inputting the description of each program element held in correspondence with each program element node and history management.
FIG. 4 is a diagram showing an attribute input window corresponding to a compilation unit of input control. The attribute input window 30 includes input fields 31, 32, 33, and 34. The attribute input window 30 is associated with the node 26a of the input control compilation unit, and can be displayed by selecting the node 26a.

  The input field 31 is an input field for inputting the name of the compilation unit, and the input field 32 is a source program when the compilation unit is compiled into a C language format program and output as a C language format source program. This is an input field for entering a name. The input field 33 is an input field for inputting a description of the compilation unit, and the input field 34 is an input field for inputting an update history of the compilation unit.

  For example, when a program produced using the CAD system 1 according to the present embodiment is converted into C language, an output name is required to execute compilation. Therefore, an input field 32 is provided in the attribute input window 30, and the input information is used as an output destination source program name when the compilation unit is compiled.

  Further, when compiling C language, there is a restriction that only characters complying with C language rules can be used. For example, you cannot use double-byte characters to represent Japanese. For this reason, the name must be given in English or Roman characters, so that the user may not be able to give a name that is easy to understand.

  Therefore, by providing the input field 31 and the input field 32 separately, the name input in the input field 32 can be input according to the C language convention, and the user can input a name that is easy for the user to understand. The name can be displayed on the program tree 21. As described above, since the user-friendly name can be displayed on the program tree 21, the visibility of which compilation unit the node corresponds to is improved. When programming is performed using the CAD system 1 of the present embodiment. Programming becomes easy.

  In addition, by providing the input field 33, it is possible to add an annotation in association with the output of the compilation unit of input control. Therefore, on the program tree 21, it is possible to visually understand which compilation unit the annotation is associated with. Also, by providing the input field 34, it is possible to manage the history in association with the output of the compile unit of input control. Therefore, the version of the compilation unit can be easily managed on the program tree 21.

  In the example of the update history shown in the attribute input window 30, only the version number and the contents of the change are described, but in addition to this, information such as a change date and time, a change operator, etc. may be input. . In addition, although the input field 34 has only three lines displayed, if a large amount of information needs to be entered, a large amount of information may be input by displaying a scroll bar.

  Further, the attribute input window 30 corresponding to the input control compilation unit has been described, but the attribute is also applied to the node 26b of the failure detection compilation unit and the node 26c of the power supply synchronization compilation unit, which are other compilation units of the program tree 21. It is assumed that an attribute input window having the same configuration as that of the input window 30 is associated. And if you want to record the attribute in association with the failure detection compilation unit or the power supply synchronization compilation unit, you want to record by calling the attribute input window from the corresponding node and entering the predetermined item in the predetermined input field Matters can be stored.

Next, an attribute input window corresponding to a functional unit will be described.
FIG. 5 is a diagram showing an attribute input window corresponding to a function unit of current control. The attribute input window 40 includes input fields 41, 42, 43, 44, and 45. The attribute input window 40 is associated with the node 28a of the current control compilation unit, and can be displayed by selecting the node 28a.

  The input field 41 is an input field for inputting a name of a functional unit, and the input field 42 is an input field for inputting a function name when converted into C language as an output name. The reason why the input field 41 and the input field 42 are provided separately is the same as the reason why the input field 31 and the input field 32 are provided separately when compiling a source program output in the C language format according to the C language rules. This is to prevent the adverse effect that only the names that are difficult to understand for the user can be given due to restrictions on the characters that can be used.

  The input field 43 is an input field for inputting a subprogram argument corresponding to the current control function unit, and the input field 44 is used to input a return value of the subprogram corresponding to the current control function unit. The input field 45 is an input field for inputting a description of the functional unit. By providing the input field 45, it is possible to attach a function description in association with the current control function unit. Therefore, on the program tree 21, it is possible to visually understand which functional unit the functional description is associated with.

  Although the attribute input window 40 corresponding to the current control functional unit has been described, the attribute input window having the same configuration as the attribute input window 40 is associated with the functional unit other than the current control functional unit of the program tree 21. It is assumed that the attribute can be input from the corresponding attribute input window.

Next, the attribute input window corresponding to the project will be described.
FIG. 6 is a diagram showing an attribute input window corresponding to a project. The attribute input window 50 is associated with the project node 24 and can be displayed by selecting the node 24. The attribute input window 50 includes an input field 51 for inputting a project name. In addition, an input field 53 for inputting information for a link is provided. Information for linking is required when linking projects. In other words, this information is required when combining the output of compilation units included in the project. Note that the information for link specifically indicates a link command. The link command input in the input field 53 is executed like a post-processing command that is executed when the compilation of the program of each compilation unit is completed.

  In addition, if the link command input in the input field 53 is regarded as a post-processing command, it is also useful to be able to describe a more general post-processing command, although it is not necessarily link information. In particular, when compiling each compile unit not in the object format but in the C language format or the like, it is not possible to link with the linkage editor without compiling using a cross compiler or the like thereafter. In such a case, it is necessary to describe the command including the compilation by the cross compiler in the link command. In this way, link commands are understood in a broad sense.

  Further, an input field 52 for inputting a description is provided. However, the contents entered in the input field 52 are not comments as described in a compiled program, which will be described later, like the input field 33 in FIG. 4 and the input field 45 in FIG. This is because the project unit is a unit that exceeds the compilation unit, and therefore, the project information is not referred to at the time of each compilation. As can be seen from the above, the project does not reflect structured programming, but assists the visual representation of the concepts such as compilation units that reflect structured programming on the program tree 21. As an effective concept.

Next, a function for storing and managing information input from each attribute input window will be described.
FIG. 7 is a diagram illustrating a data configuration example of the storage unit. As shown in FIG. 7, the storage unit 60 includes file storage units 61a, 61b, and 61c. The file storage units 61a, 61b, and 61c correspond to three compilation units set in the program tree 21. Here, the file storage unit 61a corresponds to a compilation unit for input control, the file storage unit 61b corresponds to a compilation unit for failure detection, and the file storage unit 61c corresponds to a compilation unit for power supply synchronization. Suppose you are.

  In addition, the names 62a, 62b, and 62c of the file storage units 61a, 61b, and 61c are the same as the names 27a, 27b, and 27c of the respective compilation units displayed on the program tree 21. Then, when searching for a compilation unit on the HDD 103, it is only necessary to search for the same name as that on the program tree 21, so that convenience is enhanced. In addition, by associating a physical file storage unit with a node of a compile unit, an entity can be given to a compile unit that does not describe processing contents directly, and identification as data is facilitated.

  The three file storage units 61a, 61b, and 61c provided in the storage unit 60 are, for example, a folder (Windows) manufactured by Microsoft (registered trademark), a UNIX (registered trademark), or MS-DOS manufactured by Microsoft Corporation. (Registered trademark) refers to what is called a directory.

  Various attributes input in the attribute input window 30 are associated with each compilation unit, and these pieces of input information are stored in the file storage units 61a, 61b, and 61c of the storage unit 60 provided in the HDD 103. The An example of the data structure of the file storage unit 61a at that time is shown in FIG.

  FIG. 8 is a diagram illustrating an example of the data structure of the file storage unit. In FIG. 8, among the file storage units 61a, 61b, and 61c corresponding to the three compilation units shown in FIG. 7, the data about the file storage unit 61a of the input control compilation unit shown at the top. An example structure is shown.

  As shown in FIG. 8, the file storage unit 61a stores an attribute file 64, a hierarchy information file 65, a processing content file 66, and a processing content information file 67. The attribute file 64 records attributes of a compilation unit of input control input from a predetermined input field of the attribute input window 30. As is clear from the program tree 21, the hierarchical information file 65 stores information on the hierarchical structure because functional units are input in a hierarchical manner in the compilation unit.

  Although not shown, these pieces of information may be stored in the same file. In order to describe a hierarchical structure, when a markup description language such as XML (eXtensible Markup Language) is used, a generally distributed mechanism such as DOM (Document Object Model) can be used. Therefore, it is convenient.

  By the way, each functional unit has a processing content, but the processing content is collectively recorded in the processing content file 66 together with the processing content of all the functional units in the same compilation unit. Further, the attribute information of each functional unit in the compilation unit is collectively recorded in the processing content information file 67.

  As described above, since the attribute information, hierarchy information, and processing contents constituting the compilation unit are all stored in one file corresponding to the compilation unit as the file entity, the file storage unit 61a is moved and copied in accordance with the contents. Portability is improved. Also, since it can be reused as a module, once a compilation unit has been tested, it can be reused without modification, improving reusability and improving program quality. can do.

  FIG. 9 is a diagram illustrating an example of the data structure of the file storage unit. As shown in FIG. 9, the file storage unit 61d includes an attribute file 64, a hierarchy information file 65, a current control file 66a, a current command calculation file 66b, a current regulator file 66c, a voltage distribution file 66d, and a PWM modulator file 66e. It has.

  Similarly to the file storage unit 61a shown in FIG. 8, the file storage unit 61d stores a file for storing input control compilation units and functional unit attribute information included in the compilation units. However, the file storage unit 61d does not have the processing content file 66 and the processing content information file 67.

  The file storage unit 61d is provided with a file for recording processing contents corresponding to each node representing a functional unit. That is, a file in which processing contents corresponding to each functional unit included in the compilation unit of input control corresponding to the file storage unit 61d is provided in the file storage unit 61d. As shown in FIG. 9, an attribute file 64 for storing attributes of compilation units, a hierarchical information file 65 for storing information on the hierarchical structure of functional units included in the compilation units, and a current control file 66a corresponding to the functional units of current control. The current command calculation file 66b corresponding to the functional unit of current command calculation, the current regulator file 66c corresponding to the functional unit of the current regulator, the voltage distribution file 66d corresponding to the functional unit of voltage distribution, and the function of the PWM modulator A PWM modulator file 66e corresponding to the unit is provided.

  In the file storage unit 61d, the attribute information of each functional unit is stored together in a file describing the processing content, so the file corresponding to the processing content information file 67 shown in the file storage unit 61a is the file storage unit 61d. Not. Further, a file corresponding to the processing content information file 67 may be provided as necessary.

  As described above, in the file storage unit 61a, information of all functional units in the compilation unit is stored in one file. However, in the file storage unit 61d, by providing a file corresponding to each functional unit. , It is saved separately for each functional unit. By doing so, it is expected that the size of the files 66a to 66e corresponding to the functional unit will be reduced. Therefore, the CAD system 1 is provided which can be processed without load even on a computer with low processing capability. It becomes possible.

  By the way, the various information input from the attribute input windows 30, 40, 50 is not only when the program is produced on the CAD system 1, but also when viewing the program after being compiled into a high-level language format such as C language. Is also used.

  10 and 11 are diagrams showing program sources when compiling input control compilation units. The program source 70 shown in FIG. 10 and FIG. 11 is originally one program source, but will be described in two drawings for convenience.

  As shown in FIG. 10, various pieces of information on the compilation unit of input control input from the attribute input window 30 are inserted as comments after the header. In addition, various pieces of information on the current control functional unit input from the attribute input window 40 are inserted as comments immediately before int CurrentControl (int lin, int Vdc); which is a function corresponding to the current control functional unit. As shown in FIG. 11, various information input from the attribute input window is also inserted as a comment immediately before a function corresponding to a functional unit other than current control.

Next, a screen display example in the CAD system 1 of the present embodiment will be described.
FIG. 12 is a diagram illustrating a screen display example of the CAD system according to the present embodiment. In the screen display example 20, a program tree 21 and a processing content display window 22 are displayed. The processing content display window 22 is a screen display example when the processing content of the current control function unit is displayed.

  As described above, the compilation unit is only an outer frame in which a functional unit having a program processing function is placed. That is, information for performing program production work such as input work, program reference work, and the like is information in functional units. Therefore, the processing content corresponding to the functional unit is displayed in the processing content display window 22 for displaying the processing content.

  In the CAD system 1, when the processing content for each functional unit is displayed in the processing content display window 22, compulsory separation is performed on the display inside the functional unit and outside the functional unit. Then, since it is possible to work without worrying about things other than the processing content displayed in the processing content display window 22, it becomes possible to perform programming by a technique more suitable for structured programming.

  In the graphical program, in addition to the case where all the programs are represented in a diagram, a portion described in the C language may be included directly by assigning a part or the whole of the C language program to the diagram. Further, the program displayed in the processing content display window is not necessarily a graphical program, and may be a program described in a text format.

  FIG. 13 is a diagram illustrating a screen display example when a plurality of processing content display windows are displayed in the CAD system. In the screen display example 20a, a program tree 21 and processing content display windows 22, 22a, and 22b are displayed. The processing content display window 22a is a window for displaying the processing content of the functional unit of voltage distribution, and the processing content display window 22b is a window for displaying the processing content of the functional unit of the PWM modulator.

  Since the program tree 21 includes a plurality of functional units, if a plurality of processing content display windows can be opened at a time, the processing content of other functional units can be compared. In addition, the flow of processing contents can be followed while comparing with the processing contents of other functional units. For example, the processing contents of the parent hierarchy and the processing contents of the child hierarchy can be viewed at the same time, and convenience is improved.

  FIG. 14 is a diagram illustrating a screen display example of the CAD system when the sub program block is displayed in the processing content display window. In the screen display example 20b, a program tree 21 and a processing content display window 22a are displayed. The functional units of the program tree 21 form a hierarchical structure. It can be said that the lower functional unit is a subprogram of the upper functional unit. Therefore, when the processing content of the functional unit corresponding to the upper functional unit is displayed in the processing content display window, the subprogram corresponding to the lower functional unit is displayed as the processing content. An example of the screen display is a processing content display window 22a.

  The processing content display window 22a displays the processing content of voltage distribution functional units. As shown in the program tree 21, the functional unit of voltage distribution includes the functional unit of the PWM modulator as a subprogram. The functional unit block 23 displayed in the processing content display window 22a represents this subprogram.

  Since the subprogram has one function in the upper program, it is represented by one block. The functional unit block 23 has two connection points on the left side and one connection point on the right side. If the left connection point is regarded as an input signal and the right connection point is regarded as an output signal, this subprogram Represents a sub-program having two inputs and one output. Thus, visibility is improved when the subprograms included in the functional unit are displayed as functional unit blocks.

  FIG. 15 is a diagram illustrating a screen display example of the CAD system when the processing content display window is displayed from the functional unit block. In the screen display example 20c, a program tree 21 and processing content display windows 22a and 22c are displayed. A processing content display window 22c is associated with the functional unit block 23 of the graphical program displayed in the processing content display window 22a. When the functional unit block 23 is selected, the processing content display window 22c is opened. The processing content display window 22c displays the processing content of the subprogram corresponding to the functional unit block 23. In the CAD system 1 capable of displaying processing contents corresponding to a plurality of functional units, the processing contents display window can be opened not only from the program tree 21 but also from the graphical program displayed in the processing contents display window. And convenient.

  FIG. 16 is a diagram illustrating a screen display example of the CAD system when the names of functional units corresponding to the functional unit blocks are displayed. In the screen display example 20d, a program tree 21 and a processing content display window 22d are displayed. In the functional unit block 23a displayed in the processing content display window 22d, a functional unit name 23b corresponding to the functional unit block 23a is displayed.

  As shown in FIG. 15 above, it is convenient to select the functional unit block so that the processing content corresponding to the functional unit block can be seen. However, if the content can be understood without performing such an operation, as shown in FIG. Furthermore, convenience is improved. Therefore, by displaying the name on the program tree 21 corresponding to the corresponding functional unit in the functional unit block 23a corresponding to the functional unit in the schematic program, it is easy to understand the processing contents on the program tree 21. As with, it is easy to understand in the graphical program.

  FIG. 17 is a display example of the capture window. An import window 80 shown in FIG. 17 is an example when a window opened when a screen associated with the node 24 of the inverter control project is opened is shown. For example, this is displayed when using a function for importing a compilation unit produced in another project into the own project. In the CAD system 1, since the compilation unit is implemented in the form of a file storage unit, the compilation unit already produced by copying the file storage unit of the compilation unit desired to be imported into the file storage unit of the own project by copying or the like. Can be easily incorporated.

  The node 24 is associated with two windows, an attribute input window 50 and a capture window 80. To open each window, for example, in a window system using a mouse, the node 24 is pointed with the mouse cursor, and a plurality of menus are opened by clicking the mouse button, and a desired window is opened from the menu. An operation that opens a screen by selecting it.

  The compilation unit stores a file on the HDD 103 in a form including all information of the compilation unit on the HDD 103 by a file storage unit corresponding to each node representing the compilation unit. Further, since the file storage unit has the same name as the name assigned to the corresponding node on the program tree 21, in the import window 80, the path of the file storage unit of the compile unit to be captured is input in the input field 81. Enter in to import.

Next, the changes in the project when importing will be described in detail.
FIG. 18 is a diagram showing a project before importing in a tree shape, and FIG. 19 is a diagram showing a project produced separately from the project to be imported in a tree shape.

  When it is desired to import and use a program in the project shown in the program tree 21b from the project shown in the program tree 21a, the node 24a of the inverter control project shown in FIG. 18 is selected and the import window 80 is opened. When a power supply synchronization compile unit in the program tree 21b is designated and taken in, the power supply synchronization compile unit is taken into the project shown as the program tree 21a. As a result, the project shown in the program tree 21 can be produced.

  FIG. 20 shows a display example of the program tree when the display is omitted. The program tree 21c displays the project shown as the program tree 21 while displaying the functional units immediately below the compilation unit but omitting the display of the functional units below it. The symbol 90 is a symbol indicating that the display of the functional unit belonging to the lower right of the functional unit is omitted. By displaying in this way, only the functional units immediately below the node of the compilation unit are displayed.

  By doing this, suppose that the functional unit directly below the compilation unit is a public function outside the compilation unit, and the functional unit that is not is a private program outside the compilation unit as a subprogram of the functional unit immediately above it. Since the program tree 21c enumerates what public functions are implemented in each compilation unit, it is very useful when reusing each compilation unit. Further, it is possible to visually and clearly confirm that the functional unit whose display is omitted in the program tree 21c is a functional unit that can be used only within each compilation unit. Further, when a functional unit that can be used only within such a compile unit is manufactured, it can be simplified because it can be manufactured based on the limitation that it is used only within that range. Therefore, since the number of manufacturing steps and the number of inspection steps can be reduced, the burden on the manufacturing can be reduced, and the deterioration of quality due to the complexity of specifications can be avoided.

Next, the change of the program source when only the functional unit immediately below the compilation unit is set as the public function will be described using the program source compiled specifically in the C language format.
FIG. 21 is a diagram showing a project header file in the case where only the functional unit immediately under the compilation unit is a public function. In the header file 71, since the functional unit immediately below the compilation unit in the project can be referred from outside the compilation unit, an external reference declaration of a function corresponding to the functional unit is described. As can be seen from the fact that the node 28a and the node 28e are connected immediately below the node 26a of the program tree 21, there are a functional unit for current control and a functional unit for DC voltage control immediately below the compilation unit for input control. . Of the functional units included in the compile unit for input control, only the functional unit for current control and the functional unit for DC voltage control can be referred to from the outside. Therefore, the header file 71 is an int that is a function declaration of a function corresponding to the current control functional unit so that the current control functional unit and the DC voltage control functional unit can be read from the outside of the inverter control project. CurrentControl (int lin, int Vdc); and int DCVoltageController (int Vdc), which is a function declaration of a function corresponding to a functional unit of DC voltage control.

  FIG. 22 is a diagram showing the beginning of the program source of the project when only the functional unit immediately below the compilation unit is set as the public function. As shown in FIG. 22, an external reference declaration is described in the beginning portion of the program source 70 shown in FIG. 10 so as to refer to the header file 71.

  FIG. 23 is a diagram illustrating a program tree in which a functional unit that refers to a functional unit from outside the compilation unit is added. As shown in FIG. 23, a main compile unit node 26d is added to the program tree 21d under the node 24 of the inverter control project. The main compilation unit includes the interrupt main functional unit, and the interrupt main functional unit node 28f is displayed so as to be subordinate to the node 26d.

For example, a state when the functional unit of the interrupt main calls a functional unit included in another compile unit will be described using a program source.
FIG. 24 is a diagram showing a program source of a main compilation unit. As shown in FIG. 24, the program source 72 represents a state in which the interrupt main function unit calls the current control function unit and the DC voltage control function unit included in the input control compilation unit.

  In the above-described embodiment, there are portions that have been described for only some of the nodes, but naturally, by performing the processing described in the above-described embodiments for other nodes that have not been described, The same effect can be obtained.

It is a conceptual diagram of the invention applied to this Embodiment. It is a figure which shows the hardware structural example of the terminal device used for this Embodiment. It is an example of a display of the program tree of this Embodiment. It is a figure which shows the attribute input window corresponding to the compilation unit of input control. It is a figure which shows the attribute input window corresponding to the functional unit of electric current control. It is a figure which shows the attribute input window corresponding to a project. It is a figure which shows the data structural example of a memory | storage part. It is a figure which shows the example of a data structure of a file storage part. It is a figure which shows the example of a data structure of a file storage part. It is a figure which shows the program source when the compilation unit of input control is compiled. It is a figure which shows the program source when the compilation unit of input control is compiled. It is a figure which shows the example of a screen display of the CAD system of this Embodiment. It is a figure which shows the example of a screen display when a plurality of process content display windows are displayed with a CAD system. It is a figure which shows the example of a screen display of a CAD system when displaying a subprogram block in a process content display window. It is a figure which shows the example of a screen display of a CAD system when displaying a processing content display window from a functional unit block. It is a figure which shows the example of a screen display of a CAD system at the time of displaying the name of the functional unit corresponding to a functional unit block. It is a display example of an import window. It is the figure which showed the project before taking in in the shape of a tree. It is the figure which showed the project produced separately from the project which performs import in the shape of a tree. It is a display example of a program tree when omitted. It is the figure which showed the header file of the project at the time of setting only the functional unit immediately under a compilation unit as an open function. It is the figure which showed the beginning of the program source of the project when only the functional unit immediately under the compilation unit is a public function. It is a figure which shows the program tree which added the functional unit which refers a functional unit from the exterior of a compilation unit. It is a figure which shows the program source of the main compilation unit.

Explanation of symbols

1 CAD system 10 Terminal device 11 Mouse 12 Keyboard 13 Monitor 20 Screen display example 21 Program tree 22 Processing content display window

Claims (43)

In a program tree display method for displaying the program in a tree shape by assigning program elements which are constituent elements of the program to each node of the tree,
A program tree display method, comprising: displaying a compilation unit as a node of the program tree.   2. The program tree display method according to claim 1, wherein a compile name that is a name for distinguishing from other nodes is displayed near a node corresponding to the compile unit.   2. The program tree display method according to claim 1, wherein functional units included in the compilation unit are displayed as nodes of the program tree.   4. The program tree display method according to claim 3, wherein a function name that is a name representing a function of the functional unit is displayed near a node corresponding to the functional unit.   4. The program according to claim 3, wherein a node of a first functional unit which is a functional unit immediately below the compilation unit is displayed subordinate to a node of the compilation unit including the first functional unit. How to display the tree.   6. The program tree display according to claim 5, wherein a node of a second functional unit, which is a subprogram included in the first functional unit, is displayed depending on the node of the first functional unit. Method.   4. The program tree display method according to claim 3, wherein when the subprogram included in the upper functional unit is a lower functional unit, the node of the lower functional unit is displayed subordinate to the node of the upper functional unit. .   6. The program tree display method according to claim 5, wherein a functional unit lower than the first functional unit is omitted and displayed.   2. The program tree display method according to claim 1, wherein a project including one or more compilation units is displayed as a node of the program tree.   10. The program tree display method according to claim 9, wherein a project name which is a name of the project is displayed near a node corresponding to the project. In a program generation system for generating a program,
A program tree display unit that assigns a compilation unit to a node and assigns a program element that is a component of the program to each node, and displays a program tree in which the program is configured in a tree shape;
A processing content display unit for displaying the processing content of each program element;
Input means for performing input operations to the program tree display unit and the processing content display unit;
A program generation system comprising:   12. The program generation system according to claim 11, wherein a file storage unit for storing a file is provided in association with the node of the compilation unit.   13. The program generation system according to claim 12, wherein the file holds a compilation name that is a name for distinguishing a node corresponding to the compilation unit from other nodes.   14. The program generation system according to claim 13, wherein the file holds the compile name as the name of the file storage unit.   14. The program generation system according to claim 13, wherein the program tree display unit displays the compile name in the vicinity of a node corresponding to the compile unit.   13. The program generation system according to claim 12, wherein the file holds, as an attribute, a compile description that is a content description of a program corresponding to the compile unit.   13. The program generation system according to claim 12, wherein the file holds a compile update history that is an update history of a program corresponding to the compilation unit as an attribute.   12. The program generation system according to claim 11, wherein the program tree display unit displays functional units included in the compilation unit as nodes of the program tree.   The program tree display unit displays a node of a first functional unit, which is a functional unit immediately below the compilation unit, subordinated to a node of the compilation unit including the first functional unit. The program generation system according to claim 18.   The said program tree display part displays the node of the 2nd functional unit which is a subprogram contained in the said 1st functional unit subordinated to the node of the said 1st functional unit, It is characterized by the above-mentioned. The program generation system described.   21. The program tree display unit, when a sub-program included in a higher functional unit is a lower functional unit, displays the lower functional unit node subordinate to the higher functional unit node. The program generation system described.   The program generation system according to claim 19, wherein the program tree display unit displays the functional unit lower than the first functional unit.   12. The program generation system according to claim 11, wherein a project including one or more compilation units is displayed as a node of the program tree.   24. The program generation system according to claim 23, wherein the project holds information necessary for linking the program.   24. The program generation system according to claim 23, wherein the project has a function of fetching a compilation unit belonging to another project.   The program generation system according to claim 23, wherein the project holds a project name which is a name representing the project.   24. The program generation system according to claim 23, wherein the program tree display unit displays a project name near a node of the project.   12. The program generation system according to claim 11, further comprising data conversion means for converting data input from the input means into a high-level language format or a format that can be directly executed by an electronic computer.   13. The program generation system according to claim 12, wherein the file holds a compile output destination name which is an output destination name output by compiling the compilation unit.   13. The program generation system according to claim 12, wherein the file holds a function output name which is a name when the function unit is compiled and output.   When the subprogram included in the functional unit has an argument or a return value, the file holds code generation information that is information necessary for code generation such as a name, a type, and a delivery order of the subprogram. The program generation system according to claim 12.   13. The program generation system according to claim 12, wherein the file retains a description relating to the description of contents of functional units as an attribute.   13. The program generation system according to claim 12, wherein the file holds a function name representing a function of a function unit.   The program generation system according to claim 33, wherein the program tree display unit displays the function name in the vicinity of a node corresponding to the function unit.   12. The program generation system according to claim 11, wherein the processing content display unit displays a processing content display window for displaying processing content corresponding to each functional unit.   36. The program generation system according to claim 35, wherein the processing content display unit is capable of displaying a plurality of processing content display windows.   12. The program generation system according to claim 11, wherein the processing content display unit represents the subprogram included in the functional unit in the processing content display window by a graphic symbol.   38. The program generation according to claim 37, wherein the processing content display unit displays the processing content display window for displaying the processing content of the subprogram corresponding to the graphic symbol when the graphic symbol is selected. system.   38. The program generation system according to claim 37, wherein the processing content display unit displays a function name of the subprogram represented as the graphic symbol for the graphic symbol.   13. The program generation system according to claim 12, wherein the file holds a hierarchical structure formed so as to be subordinate to a node corresponding to an element of a program including itself.   13. The program generation system according to claim 12, wherein the file storage unit stores a processing content file in which processing contents of all functional units in the compilation unit are recorded in one file.   13. The program generation system according to claim 12, wherein the file storage unit stores a function processing content file in which processing content of a functional unit is recorded for each functional unit. The function output name, the code generation information, the description related to the description of the contents of the function unit, and the function name are stored in any one of the process content file, the function process content file, and the attribute file provided in the file storage unit. The program generation system according to claim 12.

Images