JP4366605B2 - Development support apparatus, program, and processing method - Google Patents

Description

The present invention relates to a development support apparatus, a program, and a processing method .

  A programmable controller (PLC) is used as a control device for factory automation (FA). This PLC is composed of a plurality of units. In other words, the PLC controls and outputs to the power supply unit of the power supply source, the CPU unit that controls the entire PLC, the input unit that inputs the signals of the switches and sensors attached to the FA production equipment and equipment, and the actuator. Various units such as an output unit for outputting the signal and a communication unit for connecting to a communication network.

  The control in the CPU unit of the PLC takes in the signal input from the input unit into the I / O memory of the CPU unit (IN refresh) and performs a logical operation based on a user program written in a ladder language registered in advance (calculation execution) The operation execution result is written in the I / O memory, sent to the output unit (OUT refresh), and then the so-called peripheral processing is cyclically repeated.

  The above-described user program is usually a ladder program generated using a development support apparatus, and is downloaded to the CPU unit of the PLC via a communication line. In addition, when a defect occurs in the created ladder program, the user displays the ladder program on the display screen of the development support apparatus, verifies it, finds a defective portion, and performs correction work. Then, the user downloads the modified ladder program to the PLC.

  The debugging of the ladder program involves correcting the ladder program by searching for the input instruction or output instruction related to the output instruction using the operand (contact number or memory number) of the output instruction that performed an unexpected operation as a key. Repeat editing. The contact number is a terminal number indicating the terminal location of the terminal block of the input unit or a terminal number indicating the terminal location of the terminal block of the output unit. The memory number is an address value of the IO data memory in the programmable controller. At this time, it is troublesome for a debug operator to search for an input command or an output command related to an output command that has performed an unexpected operation. For example, when there is a problem with a certain output instruction and there are a plurality of input instructions related to the output instruction, it is necessary to check all of the plurality of input instructions, and the process of finding out is complicated. In addition, if there is a program part that includes an input instruction having the same operand as the above output instruction, after correcting the program related to the output instruction in question, it is necessary to confirm that the program also operates normally. It is very cumbersome to check all the commands to be confirmed without leaking them. The problem becomes more prominent as the ladder program becomes longer.

The present invention easily detects a component of a program including an output instruction that affects other instructions, displays a program including the component, and extracts other components related to the component. It is an object of the present invention to provide a development support apparatus, a program, and a processing method that can be displayed and can easily debug a user program.

  The development support apparatus of the present invention is suitable for editing a user program downloaded to a programmable controller, for example. Specifically, a program storage unit that stores a user program, a component selection unit that receives a component to be extracted among the components of the user program, and a configuration of the user program stored in the program storage unit Outline information that scans elements in order from the top, extracts the constituent elements received by the constituent element selection means, and generates outline information with the extracted constituent elements assigned with unique index numbers in the order of appearance on the user program Generating means, outline information storage means for storing outline information, a program display section for displaying the user program on a display screen, and outline information display for displaying the components stored in the outline information storage means in the order of appearance Are displayed on the outline display section. The ladder program displayed on the components and the program display unit and so as to cooperate with.

  As the display form of the outline information, as shown in the embodiment, it may be arranged in a tree form, a list form, or various other display forms. Further, the user program to be processed can be applied to a program composed of a ladder language, an ST language and other various languages as shown in the embodiment.

  In this way, since only the desired component selected by the user is displayed in the order of appearance on the program in the outline information display section, the desired component on the user program can be viewed by viewing the displayed component. It is possible to recognize the outline of the user program, such as how much is located in the whole. In particular, since the displayed constituent elements are the constituent elements selected by the user, only what the user needs at that time is displayed without any excess or deficiency.

  In addition, a step number indicating a position on the user program is not assigned to a normal comment. However, in the present invention, a unique index number is assigned to every component of the user program including the comment, so that the comment is predetermined. Even if it is set as a component, the outline information display unit and the program display unit can be linked using the index number. That is, when a predetermined component displayed on the outline information display unit is selected, the user program component corresponding to the index number assigned to the selected component is recognized and displayed on the program display unit. be able to. Therefore, it is possible to easily find the components of the target user program.

  Also, when a function is selected by the component selection means, the function block has a function of extracting and displaying an outline of the program inside the function block, and the component of the program inside the extracted function block May be displayed in association with the function block. In the embodiment, the association is realized by indenting one step.

  The outline information may be sorted, and the sorted outline information may be displayed on the outline information display unit. By sorting, it can be grouped into specified items.

  It is preferable to include a component addition unit that additionally registers a component that can be selected by the component selection unit. Thereby, the user can display an arbitrary component in the outline information. In the embodiment, this component addition means is a list of instructions that can be added as shown in FIG. 37B by clicking the “Add” button in FIG. 37A or the function for executing the flowchart shown in FIG. It is realized by displaying.

  Moreover, it is good to provide the component deletion means which deletes the component which can be selected by a component selection means. In this way, it is possible to remove unnecessary components from being displayed as selectable components. In the embodiment, this component element deleting means is realized by a function for executing the flowchart shown in FIG. 39 or by clicking the “delete” button in FIG.

  The development support apparatus of the present invention can also automatically generate and register the outline information described above. Further, an instruction having the same operand as the instruction selected in the user program displayed on the program display unit is extracted, and information on the extracted instruction is displayed on the cross-reference information display unit provided on the display screen. Cross reference information generation means may be provided. In this way, for example, by selecting an output instruction of the user program displayed on the program display section, an input instruction having the same operand as the output instruction is extracted and displayed on the cross reference information display section. be able to. Thereby, the input commands affected by the output command can be displayed as a list.

  When a predetermined command displayed on the cross-reference information display unit is selected, it is preferable to have a function of detecting a user program to which the selected command belongs and displaying the selected command on the program display unit. . In this way, it is possible to display the actual user program corresponding to the instruction displayed on the cross-reference information display section, and it is easy to see how the instruction affects other circuits on the program. I can confirm.

  In addition, information about one or more instructions displayed on the cross-reference information display unit is stored and held, and after the information displayed on the cross-reference information display unit is switched, the recorded and held information is displayed as a cross-reference information display. It is good to be able to display again on the part. This corresponds to the bookmark function in the embodiment. By storing the cross-reference information once displayed in this way, it can be easily returned and displayed again later.

Program of the present invention causes a computer, of the components of the user program, component selection means for accepting the components to be extracted, by scanning the elements of the user program sequentially from the head in the element selection means Outline information generating means for extracting the received constituent elements and generating outline information in which the extracted constituent elements are assigned unique index numbers in the order of appearance in the user program, and the generated outline information is displayed during the appearance Outline information storage means for storing, means for displaying the user program, and means for displaying the generated outline information in the order of appearance.

The processing method of the present invention is a processing method in a development support apparatus for developing a user program of a programmable controller, and is a configuration for receiving a component to be extracted among components of a user program stored in a program storage means The element selection step, the constituent elements of the user program stored in the program storage means are sequentially scanned from the top, the constituent elements received in the constituent element selection step are extracted, and the extracted constituent elements are displayed on the user program Outline information generation step for generating outline information with unique index numbers in order of appearance, step of displaying the user program on a program display unit of the display device, outline information display unit of the display device in the order of appearance of the outline information Step to display It was to be run.

  In the present invention, it is possible to easily extract predetermined program components such as output commands that affect other commands in the program (user program) and display them on the outline display unit. In addition, since the user can select the component to be displayed, only the information required by the user can be extracted and displayed, which is convenient.

  Further, by providing the cross reference information generating means, other instructions having the same operand as the output instruction can be extracted and displayed. With these, when there are multiple input instructions connected to the problematic output instruction, search for all the multiple input instructions and check for a problem instruction from among many existing instructions, In addition, when a program related to the output instruction in question is corrected, it can be confirmed that the program part including the input instruction having the same operand as the output instruction operates normally, and the user program can be easily debugged. It can be carried out.

  FIG. 1 shows a preferred embodiment of the present invention. The development support apparatus 10 and a PLC (CPU unit) 20 are connected via a predetermined communication line 21. The communication line 21 is realized by, for example, direct cable connection using a serial line such as RS232C. Of course, it is not limited to such a direct connection, and a configuration in which the PLC 20 and the development support apparatus 10 are connected via a network using another communication line may be adopted. The development support apparatus 10 has a function of creating a user program executed by the programmable controller, a function of downloading a user program created via the communication line 21 to the PLC 20, a function of setting various parameters related to the operation of the programmable controller, have.

  The user program is a program written in a ladder language as shown in FIG. The current user program is often written in a ladder language, but may be written in a program language other than the ladder language, as will be described later.

  The development support apparatus 10 realizes the above-described functions by starting software installed in a personal computer in advance. The hardware configuration includes an input device 11 such as a keyboard and a pointing device, a display device 12, a central processing unit 13, and a storage device 14. Although not shown, the storage device 14 includes a nonvolatile storage device and a volatile storage device, and the nonvolatile storage device stores a user program, outline information of the user program, cross-reference information, and the like. Further, a volatile storage device is appropriately used as a work memory when the central processing unit 13 is executed.

  FIG. 3 is a functional block diagram of the development support apparatus 10 of the present invention realized by using the central processing unit 13 and the storage device 14 of FIG. The development support apparatus 10 includes an input processing unit 31 that processes input from the input device 11, a display processing unit 32 that generates display data to be output to the display device 12, a calculation unit 33 that executes each function, a calculation result, and a user program. And the like, and a communication processing unit 35 for processing communication with the PLC. The calculation unit 33 includes a user program editing unit 33a, an outline information generation unit 33b, and a cross reference information generation unit 33c. The storage unit 34 includes a user program storage unit 34a, an outline information storage unit 34b, and a cross reference information storage unit 34c.

  FIG. 4 shows a display screen displayed on the display device 12. As shown in the figure, a program display unit 12a for displaying a user program written in a ladder program or other program language, an outline information display unit 12b for displaying outline information indicating the configuration of the user program, and an operand of a designated instruction Is provided with a cross-reference information display unit 12c for displaying information on an instruction having the same operand. Specifically, as will be described later with reference to FIG. 9, FIG. 10, FIG. 13, FIG. 14, etc., in this embodiment, variable names can be assigned in correspondence with contact numbers and memory numbers corresponding to instruction operands. It is possible to edit programs using variable names. Since program editing using variable names is possible, operands can also be displayed with variable names on the program display unit 12a, outline information display unit 12b, and cross-reference information display unit 12c. Of course, you may display using a contact number or a memory number, without using such a variable name.

  Outline information to be displayed on the outline information display unit 12 b is created by the outline information generation unit 33 b and stored in the outline information storage unit 34 b in the storage unit 34. And the display process part 32 displays the outline information about the user program currently displayed on the program display part 12a on the outline information display part 12b.

  The outline information is information indicating an outline of the configuration of the user program, and predetermined constituent elements used in the user program are extracted in order from the top of the user program. The outline information of the ladder program shown in FIG. 2 is displayed as shown in FIG. 5 as an example. As described above, when the outline information is displayed on the outline information display unit 12b, predetermined components are arranged in the order of appearance from the top of the user program (in this example, a ladder program (hereinafter, the same)), and a plurality of components are arranged. Circuit parts that are a collection of instructions are indented to the right of one column and displayed in a tree shape. By viewing this outline information, the debug operator can recognize in what order and in which position each extracted component is present in the ladder program.

  The components of the ladder program displayed on the outline information display section can be selected instead of being fixed. In this embodiment, an output command, a comment, an end, a function block (FB), an interlock / interlock clear, and a circuit component start and end are selected. As another example, when only the output command is selected, only the output command in the ladder program is extracted, arranged in the order of appearance from the top, and displayed.

  When the outline information generation unit 33b receives the outline information generation command, the outline information generation unit 33b scans the component elements one by one from the top of the ladder program that is the target, and extracts the component elements that are selected in advance as extraction targets, Register sequentially, and generate outline information with a hierarchical structure. FIG. 6 shows a flowchart of the outline generation unit which is one of the premise of the present invention. That is, scanning is performed in order from the top of the program, and if there is a component (Yes in S10), the component is acquired (S11). Here, all the components used in the ladder program are acquired. And it is judged whether the acquired component is an extraction object component (S12). If the component acquired in S11 is not the component to be extracted, the branch determination is No. If it is not the target component, scanning is continued to search for the next component (S20). If there is no next component, the branch determination in S10 is No, and the process ends.

  On the other hand, if the acquired component is the target component, it is further determined whether it is “start or end of circuit component” or “other than circuit component” (S12). If it is not a circuit component, an icon corresponding to each component is acquired (S13) and registered in the tree (S14).

  Assume that the corresponding icons differ for each type of component, and the correspondence between each component and icon is created in advance in a table and registered in the storage device 14. For example, if the extracted component is an output command, a mark like a light bulb is used, and if it is a comment, a mark like a bookmark is used. Thereby, in the process of S13, the type of the acquired command is recognized, and the corresponding icon is acquired by referring to the table. Also, registration in the tree is added one line below the current hierarchy.

  Information to be registered in the tree includes an icon, an index number, a step number, and a variable name. Here, the index number is a number that uniquely exists in the ladder program, and is set in ascending order not only for each command but also for a comment that is not assigned a step number. When the debug operator specifies the index number in the ladder program, it can uniquely specify an arbitrary instruction and comment.

  On the other hand, if the acquired command is the start or end of the circuit component, it is determined whether or not the circuit component is started (S15). If it is started, an icon of the circuit component is acquired (S16), and the tree (S17). This tree registration process is the same as the process of S14. Thereafter, the tree is indented to the right by one column (S18). Then, the process returns to S10 via S20 (proceeds to the next component). As a result, the registration of the tree for the components detected thereafter (the process of S14) is added under the indented tree, and it is at a glance that the component belongs to the circuit component. I understand.

If the acquired component (command) is the end of the circuit component, the branch determination in S15 is No, so the process proceeds to S19, the indentation of the tree is canceled (S19), and S20 (next component) Go to step S10. As a result, the constituent elements (commands and the like) detected after this are added to the original tree (the one before the indentation, that is, the hierarchy one level higher).
Thus, by scanning and processing in the order of appearance from the top of the program, the components can be registered in order from the top of the tree in the order in which they appear in the program.

  Next, each process will be described based on a specific example. For example, if the ladder program to be processed is as shown in FIG. 2 (ladder diagram display), the component list is as shown in FIG. In each figure, a circled number is a corresponding target component. As shown in FIG. 7, step numbers are given in ascending order from 0 in the order of appearance from the top of the instruction. Since it is given to the command, it is not given to the comment. Therefore, as described above, index numbers are assigned in ascending order to the program components (commands, comments, etc.) as shown in FIG. In FIG. 2, the 9th to 15th lines are one circuit component (part name is [parts1]).

  When the component list corresponding to the ladder program (FIG. 7) is processed in order from the first command, the first component (Index000000) is an input command, so No in S12. Since the next component of Index000001 is an output command (OUT), the answer is YES in S12, the corresponding icon (light bulb mark) is acquired (S13), the process of S14 is executed, and registered in the tree. As a result, “icon, step number (000001), variable name (b)” is added to the first line as shown in FIG. Since the next component (no step number, Index000002) is a comment, the answer is YES in S12, the corresponding icon (bookmark mark) is acquired (S13), the process of S14 is executed and registered in the tree. Thereby, as shown in FIG. 5, “icon, comment” (not displayed because there is no step number) is added to the second line.

  For example, in Index 00000A, the constituent element is the start of a circuit component. Therefore, by performing the processing from S15 to S17, as shown in FIG. 5, "circuit component name ([parts1]" ) ”Is added. Then, since the tree is indented to the right by one line by executing S18, the comment (“* comment2 *”) of Index00000B that is the next detected target component is added to the eighth line. Is displayed indented under [parts1] on the seventh line. The components detected thereafter are all displayed indented to the right by one line until S19 is executed in PARTS_END of Index 000013 indicating the end of the circuit component and the indentation of the tree is released.

  After the indentation of the tree is released, a function block (“FB1 inst1”) of Index000015 is added to the 13th line in FIG. Then, when the processing of S14 is executed for the END instruction of Index000017 and added to the tree, since there is no component thereafter, the branch determination of S10 becomes No and the processing is terminated.

  The outline information generated as described above is stored in the outline information storage unit 34b. When the outline information displayed in a tree shape on the outline information display unit 12b is viewed, output instructions and comments that affect other instructions are arranged in the order of appearance in the program, and circuit components are displayed in an indented display. Since it is displayed hierarchically, the approximate location of each component in the program can be seen at a glance.

  Next, the linkage between the ladder program displayed on the program display unit 12a and the tree-shaped outline information displayed on the outline information display unit 12b will be described. That is, when an arbitrary component is selected from the tree-like outline information displayed on the outline information display unit 12b, the corresponding component of the ladder program corresponding to the selected component is displayed. Specifically, the interlocking is realized by the function of executing the flowchart shown in FIG.

  That is, the registration information of the cursor position in the outline information display part 12b is acquired (S21). For example, the user operates the input device 11 such as a pointing device to select an arbitrary component in the tree-like list. Then, the selected component is recognized, the outline information storage unit 34b is accessed, and the index number is acquired from the outline information.

  Next, a jump request is made to the display processing unit 32 that displays the ladder screen currently displayed on the program display unit 12a (S22). In other words, the index number is passed. If the index number is acquired, the program jumps to the corresponding position of the ladder program displayed on the program display unit 12a (S23). That is, the user index storage unit 34a is accessed using the acquired index number as a key, and the corresponding component is recognized. If the component is currently displayed on the program display unit 12a, the cursor is moved to the corresponding component. If not displayed on the program display unit 12a, the corresponding component is displayed in the program display unit 12a and the cursor is moved to the component.

  Thus, for example, as shown in FIG. 9, when “step number: 00007, variable name: Complete1” is selected in the tree of the outline information display unit 12b, the corresponding output command is also displayed in the program display unit 12a. The cursor is placed on (variable name: Complete1) (highlighted). In this state, when “step number: 00010, variable name: Complete2” is selected in the tree of the outline information display unit 12b, as shown in FIG. 10, a corresponding output command ( The cursor moves to variable name: Complete2).

  Next, cross reference information displayed on the cross reference information display unit 12c will be described. When a predetermined component in the ladder program displayed on the program display unit 12a is selected, the cross reference information display unit 12c extracts a component having the same operand (variable name) as the component, It displays on the cross reference information display part 12c. This process is performed by the cross-reference information generation unit 33c executing the flowchart shown in FIG. 11 based on the information obtained by the user program editing unit 33a executing the flowchart shown in FIG. In FIG. 11, first, the cursor is moved on the user program screen (the ladder screen in the figure) displayed on the program display unit 12a (S31). It is determined whether or not the cursor position of the moved cursor is the operand part (S32). If it is the operand part, the program name, step number, and operand (variable name) for the component at the cursor position are cross-referenced. It passes to the information generation part 33c (S33).

  As shown in FIG. 12, when predetermined information is acquired from the user program editing unit 33a (S40), it is determined whether or not the operand (variable name) is a global variable (S41). A global variable is a variable that is commonly used by a plurality of PLCs. Whether it is a global variable or not can be determined by the path added before the operand (variable name). For example, the path of the global variable is “project name \ configuration name \ variable name”. Further, in the case of a local variable (task) used only in a specific PLC, “project name \ configuration name \ task name \ variable name”. Thus, since the path differs depending on whether it is a global variable or a local variable, it can be easily determined.

  In the case of a global variable, it is determined whether or not the program specified by the path exists (S42). If it does not exist, the process is terminated, and if it exists, the program is acquired (S43).

  The acquired program is scanned in order from the head instruction to determine whether or not the instruction exists (S44). If an instruction is detected, the instruction is acquired (S45), and it is determined whether or not the operand (variable name) of the instruction matches the operand (variable name) acquired from the ladder editor (S46). . If they match, it is determined whether or not the program is executing a task (S47), and a corresponding icon is acquired depending on whether or not it is executed (S48, S49). Thereafter, the cross reference information for the instruction is registered (S50). Information to be registered here includes at least an operand (variable name), an address, a language, a path, a task execution state, and a step number.

  After this registration, or if the operand (variable name) does not match in the branching determination in processing step S46, the process proceeds to the next instruction (S51). When the last instruction is processed, the branch determination in S44 is No, so that the process jumps to step S52 and the next program is scanned. In this way, when the extraction / registration processing of the instruction having the same operand (variable name) is completed for all the programs, the branch determination in processing step S42 is No, and the series of processing is terminated.

  On the other hand, if it is not a global variable, the branch determination in processing step S41 is No, so it is determined whether or not the program specified by the path exists (S53). To do. If it exists, the processing from processing step S43 to processing step S51 is executed for the program, and an instruction with an operand (variable name) that exists in the program is acquired, and related information (icon , Cross-reference information). If the program has been scanned to the end, the branching determination in process step S44 is No, but in this case, the process ends (S54).

  The cross reference information and the like are stored in a temporary file in the storage device 4 and displayed on a cross reference information display unit as shown in FIG. 13, for example. In FIG. 13, since the output command whose variable name is Complete 1 in the user program screen (ladder screen) displayed on the program display unit 12a is selected, four commands are extracted as input commands having the same variable name, A displayed example is shown.

  From this state, when an arbitrary variable name displayed on the cross-reference information display unit 12c (for example, the variable name on the second line as shown in FIG. 14) is selected, a program including the corresponding variable name (instruction) is selected. It displays on the program display part 12a. At this time, it is possible to make the user easily understand by highlighting the cursor.

  The function for performing such processing executes the flowchart shown in FIG. First, the cursor position on the cross reference information display unit 12c is acquired (S61). This cursor position is a position selected and highlighted in the figure. Then, from the path information of the variable name selected by the cursor, a program to which the variable name belongs is searched (S62), and it is determined whether or not the program is displayed on the program display unit 12a (S63). If the program is not displayed, the program searched in process step S62 is displayed (S64).

  Then, the program jumps to the corresponding program displayed on the program display unit 12a (S65), and jumps to the corresponding command position in the program (S66). The processing in step S66 is the same as the processing in step S23 in FIG. As a result, the corresponding command is displayed on the program display unit 12a, and the cursor is moved and highlighted.

  The information displayed on the cross reference information display unit 12c is generated by the cross reference information generation unit 33c each time corresponding to the selected component (command) in the user program (ladder program) displayed on the program display unit 12a. Generate and display. Therefore, when a component not currently displayed on the cross reference information display unit 12c is selected on the program display unit 12a side, the cross reference information displayed on the cross reference information display unit 12c also changes. Here, the user cannot easily return to the previously displayed information. In the actual debugging process, there is a request to return to the previous display one time or several times before, but conventionally, such a request could not be satisfied.

  Therefore, as shown in FIG. 4, a bookmark button B1, a backward button B2, and a forward button B3 are prepared in the upper part of the cross reference information display unit 13c. The memory device 14 has a function of storing and holding the cross-reference information displayed when the bookmark button B1 is clicked. The cross reference information stored and held in the storage device 14 is numbered in the order in which it is stored. Thus, each time the backward button B1 is selected and executed, the number is referred to and the cross-reference information displayed (stored) immediately before the currently displayed cross-reference information is called from the storage device 14 and displayed. Further, by clicking the forward button B3, the number is referred to, and the cross-reference information displayed (stored) next to the currently displayed cross-reference information is called from the storage device 14 and displayed.

  In this way, the display history of the cross-reference information can be displayed sequentially, and the desired cross-reference information can be easily viewed, making it easy to debug user programs written in ladder languages or other programming languages. It can be carried out.

  In the above-described example, among the components displayed on the outline information display unit 12b, circuit components are indented with respect to the components of the circuit components and displayed so as to be added to the list. It is understood that the constituent elements constitute the same circuit component.

  On the other hand, the function block executes predetermined predetermined processing. As shown in FIG. 2, the function block is described as one block on the ladder program, and what processing is executed internally. I don't know if the program is organized. In normal use such as creation of a user program, it is sufficient to know at least what function the function block has. However, when performing debugging or the like, there is a request to know the components of the function block. Therefore, as with the other components described above, if there is a component selected as an extraction target in the program that constitutes the function block, it is extracted and registered sequentially to generate outline information having a hierarchical structure. . At this time, as in the case of circuit components, the components that make up one function block are managed together, and when displaying outline information, the indentation is performed appropriately and the components that make up the function block at a glance It is made to understand that.

The function block is basically the same as the circuit component, and the outline thereof will be described. The process is executed according to the following procedure. First, when the user program is scanned in order from the top and a function block is detected, a function block reentry process is performed according to the following procedure.
(1) Get the function block icon;
(2) Register the function block in the tree / list;
(3) Indentation;
(4) Store the current component group on the stack;
(5) Replace components with function blocks.

The return processing from the function block currently being processed is performed according to the following procedure.
(11) Check on the stack, and if the stack is empty, determine that the process is finished;
(12) Acquire a component group stored on the stack;
(13) Cancel the indentation.

  Further, when there are further function blocks in the function block, indentation is performed to nest from the next of the current function block by the process (3). Then, the processing of (4) and (5) is executed, the component group for the current processing (function block in the function block) is stored in the stack, and the program of the function block is loaded onto the memory. Create an outline the same way. Then, when necessary constituent elements for the function block are extracted, the indentation is canceled (the function block is unnested and registered by being linked to the caller). If all the components have been extracted for the highest-level (parent) function block (the end of the component has been reached), the indentation for the highest-level (parent) function block is canceled and the process returns.

  Next, a specific example will be described. FIG. 16 shows an example of another user program written in a ladder language. In the example shown in FIG. 16, three function blocks [FB1], [FB2], and [FB3] are used. Specific internal programs of these function blocks are as shown in FIGS. 17A, 18A and 18B, respectively. Further, as shown in FIG. 17A, the function block [FB1] further includes another function block [FB11] (see FIG. 17B). As described above, when there are further function blocks in the function block, the above-described reentry process and return process are also performed for the function block existing in the function block.

  In the user program shown in FIG. 16, for example, “MOV” having a step number [00000008] and “TIMX” having a step number [000018] are also described. In the above example, these constituent elements are not constituent elements to be displayed as outline information. For example, when the flowchart shown in FIG. 6 is executed, even if they are described in the user program, Is not extracted. Therefore, it is not displayed on the outline information display part 12b.

  The outline information of the ladder program shown in FIG. 16 is displayed as a list on the outline display unit 12b as an example as shown in FIG. As described above, when the outline information is displayed on the outline information display unit 12b, predetermined constituent elements are arranged in the order of appearance from the top of the ladder program, and the circuit components that are aggregates of a plurality of instructions or the specific details are internally included. Function blocks that contain typical programs and components are indented to the right and displayed in a tree. By viewing this outline information, the debug operator can recognize in what order and in which position each extracted component is present in the ladder program.

  The ladder program component displayed on the outline information display unit 12b may be a fixed component prepared in advance. For example, as shown in FIG. 19, a dialog window for selecting a component to be displayed in the outline information ( The outline display option) may be output to the display device, and the user may select a component to be displayed. This selection is made by checking a check box placed in front of the listed component. In the example shown in FIG. 19, all listed components (output command, comment, end, function block (FB), interlock / interlock clear, start and end of circuit components) are selected.

  When the outline information generation unit 33b receives the outline information generation command, the outline information generation unit 33b scans the components one by one from the top of the ladder program that is the target, and selects the components selected as extraction targets to be displayed in advance (in the check box in FIG. 19). If there is one selected, it is extracted and registered sequentially to generate outline information having a hierarchical structure.

  FIG. 20 shows a flowchart of an outline generation unit that is one of the premise of the present invention that extracts the components in the function block described above and generates outline information. That is, scanning is performed in order from the top of the program, and if there is a component (Yes in S10), the component is acquired (S11). Here, all the components used in the ladder program are acquired. Then, it is determined whether or not the acquired component is a component to be extracted (a component checked in the dialog window shown in FIG. 19) (S12). If the component acquired in process step S11 is not the component to be extracted, the branch determination is No. If it is not the target component, scanning is continued to search for the next component (S20).

  On the other hand, if the acquired component is a target component (Yes in S12 for branch determination), it is determined whether the target component is a function block (S71). If it is not a function block, it is determined whether the component is other than a circuit component (the component in the circuit component is also other than the circuit component), the start of the circuit component, or the end of the circuit component (S78). If it is not a circuit component, an icon corresponding to each component is acquired (S13) and registered in the tree and / or list (S14). That is, although a specific display example will be described later, in the present embodiment, as described above, in addition to the tree display in the tree format described above, the tabular format is used as the outline information display format to be displayed on the outline information display unit 12b. The list display can be done. Therefore, in the registration process of this processing step S14, registration is performed in both the tree and the list. Of course, it is also possible to register only one of the predetermined ones. This also applies to the processing for the tree and list shown below.

  Assume that the corresponding icons differ for each type of component, and the correspondence between each component and icon is created in advance in a table and registered in the storage device 14. For example, if the extracted component is an output command, a mark like a light bulb is used, and if it is a comment, a mark like a bookmark is used. Thereby, in the process of S13, the type of the acquired command is recognized, and the corresponding icon is acquired by referring to the table. Also, the tree / list registration is added one line below the current hierarchy.

  Information registered in the tree includes an icon, an index number, a step number (address), and a variable name (name). Here, the index number is a number that uniquely exists in the ladder program, and is set in ascending order not only for each command but also for a comment that is not assigned a step number. When the debug operator specifies the index number in the ladder program, it can uniquely specify an arbitrary instruction and comment.

  On the other hand, if the acquired instruction is the start of a circuit component, an icon for the circuit component is acquired (S16) and registered in the tree / list (S17). This tree / list registration process is the same as the process of S14. Thereafter, the tree / list is indented to the right by one column (S18). Then, the process returns to S10 via S20 (proceeds to the next component). As a result, the tree / list registration (processing in S14) for the components detected thereafter is added under the indented tree / list, and is a component belonging to the circuit component. You can see at a glance.

  If the acquired component (command) is the end of the circuit component, the process proceeds to S19, the indentation of the tree / list is canceled (S19), and the process proceeds to S20 (proceeds to the next component). Return to S10. As a result, the components (instructions and the like) detected after this are added to the original tree / list (the one before the indentation, that is, one level higher).

  On the other hand, if the target component is a function block, the branch determination in S71 is Yes, so the process jumps to the processing step S72 to execute the process. That is, first, the icon of the corresponding function block is acquired (S72) and registered in the tree / list (S73). This tree / list registration process is the same as the process of S14 and the like. Thereafter, the tree / list is indented to the right by one column (S74). Then, the current component group (program name with path and index number of the FB instance) is stored on the stack (S75). Next, the program (component group) is loaded from the function block instructions into the internal memory (S76). The above process corresponds to the function block reentry processes (1) to (5).

  Thereafter, the process returns to S10 to determine the presence or absence of the component. If there is no component, it is determined whether or not there is a stack (S80). When the process comes from S76 to S80 via S10, since the process of S75 is executed and there is a stack, the branch determination in S80 is Yes. Therefore, the component group stored from the stack is acquired (S82), the indentation of the tree / list is canceled (S82), and the process returns to S10 via S20 (proceeds to the next component). As a result, the components (instructions and the like) detected after this are added to the original tree / list (the one before the indentation, that is, one level higher). In other words, it can be seen at a glance that the components stored in the line from the indentation in S74 to the release of the indentation in S82 constitute one function block. The above processing corresponds to the function block return processing (11) to (13).

  If there is no next component, the branch determination in S10 is No, so it is determined whether there is a stack (S80). If there is no stack (empty), the process is terminated. Thus, by scanning and processing in the order of appearance from the top of the program, the components can be registered in order from the top of the tree in the order in which they appear in the program. In addition, the constituent elements belonging to the circuit parts and the constituent elements belonging to the function block are indented by one line, so that when they are output to the outline information display section 16b, they can be recognized at a glance as constituent elements belonging to them. . The outline information generated in this way is stored in the outline information storage unit 34b as described above.

  The user program shown in FIG. 16 executes the flowchart shown in FIG. 20, whereby the outline information shown in FIG. 21 (tree display) or FIG. 22 (list display) is displayed on the outline information display unit 16b. 21 and 22 show all the components checked in the dialog window shown in FIG. As is apparent from FIGS. 21 and 22, the constituent elements of each function block are displayed indented, so that it can be seen at a glance that they are constituent elements of each function block. Furthermore, since [FB1] has [FB11], [FB11] is included in the components of [FB1] by performing reentry and return in the [FB11] portion. Of course, since the part of [FB11] is further indented, the constituent elements of [FB11] can be seen at a glance.

  Further, in the outline information shown in FIG. 21 (tree display), if there is no nesting, outline information as shown in FIG. 23 is displayed in the outline information display section 12b. Similarly, in the outline information (list display) shown in FIG. 22, if there is no nesting, outline information as shown in FIG. 24 is displayed on the outline information display section 12b.

  Although specific illustration is omitted, when the outline information shown in FIG. 21 (tree display) or FIG. 22 (list display) is displayed on the outline display unit 12b, the program display unit 12a A corresponding part of the corresponding user program (shown in FIG. 16) is displayed, and a part corresponding to the designated component is also displayed on the cross reference information display unit 12c. That is, since only the outline information generation algorithm for the function block is different, the user program (the ladder program in FIG. 16) displayed on the program display unit 12a and the outline information displayed on the outline information display unit 12b. The functions / algorithms described with reference to FIGS. 8 to 15 are used in conjunction with (tree display / list display), and the information displayed on the cross reference information display unit 12c and the components displayed on the respective display units. Since this is the same, the description thereof is omitted. The same applies to the description given below.

  Moreover, although the display example mentioned above is a case where all the components listed in the dialog window shown in FIG. 19 are checked, in this embodiment, arbitrary components can be checked. For example, when only the function block is checked in the dialog window of FIG. 19, the determination of whether or not it is a target component in S12 of FIG. Therefore, only the function block is extracted as the target constituent element, and the process proceeds. As a result, the outline information for the user program shown in FIG. 16 is as shown in FIG. 25A when displayed in a tree, and as shown in FIG. 25B when displayed as a list. 25 (a) and 25 (b) both show a non-nested state, but it is of course possible to display the function block components as in FIGS.

  Further, for example, when only a comment is checked in the dialog window of FIG. 19, the determination of whether or not it is a target component in S12 of FIG. Therefore, only the comment is extracted as the target component, and the process proceeds. As a result, the outline information about the user program shown in FIG. 16 is as shown in FIG. 26A when displayed in a tree form and as shown in FIG. 26B when displayed as a list.

  For example, in the dialog window of FIG. 19, a plurality of components such as output, function block, and comment can be checked. In such a case, the determination of whether or not it is a target component in S12 of FIG. 20 is No except for the above three components. Therefore, only the specified one is extracted as the target component, and the process proceeds. As a result, the outline information for the user program shown in FIG. 16 is as shown in FIG. 27A when displayed as a tree, and as shown in FIG. 27B when displayed as a list. 27 (a) and 27 (b) both show a non-nested state, but it is of course possible to display the function block components as in FIGS.

  In each of the above-described examples, the ladder language is used as the user program. However, the present invention is not limited to this and can be applied to other programming languages. For example, in the case of a program created using the ST language as shown in FIG. 28A, the outline information shown in FIG. 28B can be generated by executing the flowchart shown in FIG. it can.

  FIG. 29 and subsequent figures show a second embodiment of the present invention. In the embodiment described above, the outline information is displayed in the order of appearance of the program in both the tree display and the list display. In the present embodiment, it is possible to sort by a specified item.

  For example, when the outline information displayed as a list is as shown in FIG. 29, sorting is performed using addresses as keys, as shown in FIG. As is clear from the figure, first, in the address column displayed in the list, ascending is performed in ascending order of numerical values, and those with blank addresses are sorted in the order of appearance (index number order) as a reference. That is, regardless of the display state before sorting, the target for sorting is the outline information arranged in the order of appearance (FIG. 22).

  Further, when sorting is performed using the type (type of component) as a key, it is as shown in FIG. Similarly, outline information when sorted by variable name is as shown in FIG. 32, and outline information when sorted by comment is as shown in FIG. As described above, the outline information used as the reference for sorting is shown in FIG. 22 arranged in the order of the index numbers. Therefore, the outline information displayed on the outline information display unit 12b immediately before sorting indicates which item. Regardless of whether or not sorting is performed using the key, the result of sorting by each item is the same. That is, for example, when sorting is performed using addresses as keys, the display form is always as shown in FIG. 30, regardless of whether the immediately preceding display form is, for example, FIG. 31, FIG. 32, or FIG. Of course, the sort target may be outline information displayed immediately before.

  In addition, since the specific internal processing for performing such sorting with respect to the display form of the outline information of the list display, for example, the same function as the function of the spreadsheet software (application program) can be used. A description using a specific flowchart or the like for performing the processing will be omitted.

  In the above-described example, the sort process based on the list display is performed. However, for example, by implementing the function of executing the flowchart shown in FIG. 34, the sort process is also performed on the outline information of the tree display. Can do. First, as a selection screen (input screen) for sorting processing, for example, a screen as shown in FIG. 35 is output and displayed. In this selection screen, a check is made on a check box “validate type display” provided in the information, so that sorting using items as keys is performed. If the check box is not checked, the flowchart shown in FIG. 20 is executed, and outline information arranged in the order of appearance (index number order) is generated. Also in this example, the component is displayed in a list together with the check box, and the checked component is the target component to be displayed as outline information. In the figure, all the components are selected.

  FIG. 34 basically assumes the flowchart shown in FIG. Corresponding processing steps are given the same step number. As is apparent from a comparison between FIG. 34 and FIG. 20, in the present embodiment, the type is first acquired (S90). That is, among the components displayed as a list on the selection screen shown in FIG. 35, the components whose check box is checked are acquired.

  Next, the type of the component acquired in S90 is registered in the tree (S91). That is, in FIG. 35, since all the components are checked, all the components are registered in the tree. Thereby, “output”, “component (circuit component)” (library), “comment”, “function block”, “interlock”, and “end” shown in FIG. 36 are registered in the list together with corresponding icons.

  Thereafter, the processing after S10 is executed. When a target component is detected, a corresponding icon is acquired, and when it is registered in the tree, additional registration is sequentially performed under the same component. As a result, as shown in FIG. 36, tree-shaped outline information in a state (sorted state) grouped by type (component) is generated. Note that the sort processing in the list display is also possible by executing the processing of FIG.

  FIG. 37 and subsequent figures show a third embodiment of the present invention. As is apparent from FIG. 37, in this embodiment, the user can add display items to be displayed on the outline information display unit 12b. In other words, in each of the above-described embodiments, the component to be displayed can be selected, but the selection range is limited to a preset range. On the other hand, in the present embodiment, as shown in FIG. 37A, the “add” button and the “delete” button of the component are prepared in the dialog window of the outline display option, and FIG. An instruction list window that can be added is prepared as shown in FIG.

  In FIG. 37A, when the “add” button is clicked, an instruction list window shown in FIG. 37B is displayed. The user checks the check box of the component to be added using the instruction list window and clicks the “OK” button. Accordingly, the display target components stored in the storage device 14 (initially “comments”, “function blocks”, “outputs”, “libraries” (circuit parts), “ Only "Interlock" and "End") are registered), and the component checked in the instruction list is added. In the example of FIG. 37 (b), since “MOV” and “TIMX” are checked and added, the outline display options displayed thereafter are displayed in six basic display components as shown in FIG. 37 (c). , “MOV” and “TIMX” are added to display eight components. Note that when the added component is first displayed, the check box may be checked, or the initial state may be blank. In the outline display option dialog window shown in FIG. 37 (c), a basic display component and a check box of “MOV” are checked by a subsequent user operation, and “TIMX” is added to the outline display option. By unchecking the check box, the current processing is not displayed as outline information.

  The function for performing the registration process can be performed by executing the flowchart shown in FIG. That is, it is determined whether there is a component to be added (S101). This can be determined based on whether or not there is a checked component in the check box when the “OK” button is clicked in the instruction list window displayed by clicking the “Add” button of the outline display option. .

  If there is a component to be added, the component to be added is extracted (S102), and the extracted component is recorded in the target component stored in the recording device 14 (S103). As a result, when displaying the dialog window of the outline display option, since the target component stored in the recording device 14 is read and displayed, the process of S103 is executed and the additional target component is added. The added target component is also displayed in the list (see FIG. 37 (c)).

  On the other hand, the present embodiment also has a function of deleting a component once added. That is, as shown in FIG. 37C, when there is an added component, if there is something to delete, click the “Delete” button with the check box of the component to be deleted checked. Then, the checked component is deleted. However, in the present embodiment, deletion of the six basic display components is prohibited. Thus, for example, in the outline display option shown in FIG. 37 (c), when the “Delete” button is clicked with all check boxes checked, “MOV” and “TIMX” other than the basic display components are deleted. Then, the state shown in FIG.

  The function for performing such deletion processing can be performed by executing the flowchart shown in FIG. That is, it is determined whether or not there is a selection of deletion (S104). In other words, when the “delete” button is clicked in a state where the check box of at least one component is checked, this branch determination is Yes, and otherwise, the process ends.

  If there is a selection, it is determined whether or not the component can be deleted (S105). That is, when a component other than the six basic display components is selected, the component can be deleted, and this branch determination is Yes. If deletion is possible, the deletion target component selected by the check box is extracted, and the selected component is deleted from the target components stored in the recording device 14 (S106, S107). By repeatedly executing the above processing, components other than the basic display components can be deleted even after being registered once. Of course, even if it is not deleted, in the normal outline information generation process, it is not displayed in the outline information if the check box is not checked, so the same effect can be exhibited, but an unnecessarily many configurations It can be expected to eliminate the effect that the element is displayed in the outline display option.

  As described above, by adding / deleting new components or checking necessary components, outline information is extracted and extracted only from the components that the user wants to see at that time. Can do. As an example, when the “OK” button is clicked in the state shown in FIG. 37 (c), outline information is generated by seven constituent elements in which “MOV” is added to the six basic display constituent elements. Therefore, the outline information display section 12b displays outline information in the form of a tree display as shown in FIG. 40 or a list display as shown in FIG.

It is a hardware block diagram showing an embodiment of the present invention. It is a figure which shows an example of the ladder program displayed on a program display part. It is a functional block diagram which shows one embodiment of this invention. It is a figure which shows an example of a display screen. It is a figure which shows the outline information with respect to the ladder program shown in FIG. 2 displayed on an outline information display part. It is a flowchart which shows the function of an outline information generation part. FIG. 3 is a diagram showing a list of programs shown in FIG. 2. It is a figure which shows an example of the jump function to the user program (ladder program etc.) displayed on a program display part from the list displayed on the outline information display part. It is a display example of the display screen explaining an effect. It is a display example of the display screen explaining an effect. It is a flowchart explaining the function of a program editor (ladder editor etc.). It is a flowchart which shows the function of a cross reference information generation part. It is a display example of the display screen explaining an effect. It is a display example of the display screen explaining an effect. It is a figure which shows an example of the jump function to the ladder program displayed on the program display part from the instruction | indication displayed on the cross reference information display part. It is a figure which shows an example of the ladder program displayed on a program display part. It is a figure which shows the internal structure of the function block used for the user program of FIG. It is a figure which shows the internal structure of the function block used for the user program of FIG. It is a figure which shows an example of the dialog window of an outline display option. It is a flowchart which shows the function of an outline information generation part. It is a figure which shows the outline information (tree display) with respect to the ladder program shown in FIG. 16 displayed on an outline information display part. It is a figure which shows the outline information (list display) with respect to the ladder program shown in FIG. 16 displayed on an outline information display part. It is a figure which shows the outline information (tree display) with respect to the ladder program shown in FIG. 16 displayed on an outline information display part. It is a figure which shows the outline information (list display) with respect to the ladder program shown in FIG. 16 displayed on an outline information display part. It is a figure which shows the outline information with respect to the ladder program shown in FIG. 16 displayed on the outline information display part at the time of selecting the component to display. It is a figure which shows the outline information with respect to the ladder program shown in FIG. 16 displayed on the outline information display part at the time of selecting the component to display. It is a figure which shows the outline information with respect to the ladder program shown in FIG. 16 displayed on the outline information display part at the time of selecting the component to display. (A) is a figure which shows an example of the program by ST language displayed on a program display part, (b) is a figure which shows the outline information displayed on the outline information display part with respect to the program. It is a figure explaining the 2nd Embodiment of this invention, and is a figure which shows the outline information (list display) displayed on the outline display part of a basic state. It is a figure explaining the 2nd Embodiment of this invention, and is a figure which shows the outline information (list display) displayed on the outline display part after a sort. It is a figure explaining the 2nd Embodiment of this invention, and is a figure which shows the outline information (list display) displayed on the outline display part after a sort. It is a figure explaining the 2nd Embodiment of this invention, and is a figure which shows the outline information (list display) displayed on the outline display part after a sort. It is a figure explaining the 2nd Embodiment of this invention, and is a figure which shows the outline information (list display) displayed on the outline display part after a sort. It is a flowchart explaining the sort function used as the principal part of 2nd Embodiment of this starting committee. It is a figure which shows an example of the selection screen which selects whether sort is performed. It is a figure which shows an example of the sorted outline information. It is a figure which shows an example of the input screen explaining the 3rd Embodiment of this invention. It is a figure which shows the flowchart for implement | achieving the function to add a component. It is a figure which shows the flowchart for implement | achieving the function to delete the component added by the user. It is a figure which shows the outline information (tree display) with respect to the ladder program shown in FIG. 16 displayed on an outline information display part. It is a figure which shows the outline information (list display) with respect to the ladder program shown in FIG. 16 displayed on an outline information display part.

Explanation of symbols

DESCRIPTION OF SYMBOLS 10 Development support apparatus 11 Input apparatus 12 Display apparatus 12a User program display part 12b Outline information display part 12c Cross reference information display part 13 Central processing unit 14 Memory | storage device 15 Communication I / F
20 PLC
21 communication line 31 input processing unit 32 display processing unit 33 arithmetic unit 33a user program editing unit 33b outline information generation unit 33c cross reference information generation unit 34 storage unit 34a ladder program storage unit 34b outline information storage unit 34c cross reference information storage unit 35 Communication processing unit

Claims (7)

A development support apparatus for developing a user program for a programmable controller,
Program storage means for storing a user program;
Among the constituent elements of the user program, the constituent element selecting means for receiving the constituent element to be extracted;
The constituent elements of the user program stored in the program storage means are scanned in order from the top, the constituent elements received by the constituent element selection means are extracted, and the extracted constituent elements are unique in the order of appearance on the user program. Outline information generating means for generating outline information with an index number;
Outline information storage means for storing the outline information;
A development support apparatus comprising: a program display unit that displays a user program; and a display device that includes an outline information display unit that displays the outline information in the order of appearance. When a function is selected by the component selection means,
It also has the function to extract the components of the program inside the function block and display the outline.
2. The development support apparatus according to claim 1, wherein the constituent elements of the program inside the extracted function block are displayed so as to be distinguishable from constituent elements other than the function block.   The development support apparatus according to claim 1, further comprising a function of sorting the outline information and displaying the sorted outline information on the outline information display unit.   The development support apparatus according to any one of claims 1 to 3, further comprising a component addition unit that additionally registers a component that can be selected by the component selection unit.   The development support apparatus according to any one of claims 1 to 4, further comprising: a component deletion unit that deletes a component that can be selected by the component selection unit. Computer
Among the constituent elements of the user program, the constituent element selection means for receiving the constituent elements to be extracted,
Outline information in which the constituent elements of the user program are scanned in order from the top, the constituent elements received by the constituent element selection means are extracted, and the extracted constituent elements are assigned unique index numbers in the order of appearance in the user program Outline information generation means for generating
Outline information storage means for storing the generated outline information during the appearance ;
Means for displaying the user program;
Means for displaying the generated outline information in the order of appearance;
Program to function as. A processing method in a development support apparatus for developing a user program of a programmable controller,
Among the constituent elements of the user program stored in the program storage means, the constituent element selection step for receiving the constituent element to be extracted,
The constituent elements of the user program stored in the program storage means are scanned in order from the top, and the constituent elements received in the constituent element selection step are extracted. An outline information generation step for generating outline information with an index number;
Displaying the user program on a program display unit of a display device;
Displaying the outline information in the order of appearance in the outline information display section of the display device;
Processing method to execute.

Images