JP2007102384A - Debugging device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a debugging device allowing setting of a step position (a break point) for performing a temporary stop in each instance of a function block, and allowing the setting of the break point inside the function block. <P>SOLUTION: This debugging device continuously executes each step constituting a control program including the function block. A program execution part decides whether the present step during the execution is present in a corresponding step position of the function block specified by break point management information stored in a break point management table or not on the basis of the break point management table during the continuous execution inside the function block, and temporarily stops the program execution when the step is present in the corresponding step position. <P>COPYRIGHT: (C)2007,JPO&INPIT

Description

  The present invention relates to a debugging device for a control program including function blocks.

  In the development of a control program for a programmable controller (hereinafter referred to as “PLC”), various languages according to IEC-61131-3 can be used according to the development target. In the development stage, in order to verify and check the operation of the designed control program, debugging processing using a debugging device is generally performed. This debugging apparatus includes a simulator that executes a control program instead of an actual machine, and a control unit that controls the operation of the simulator.

The control of the operation includes step execution in which the control program is executed step by step (one instruction) each time an execution instruction is input, and scan execution in which the entire control program is executed once or until a stop instruction is received. There is. There is also a control for setting a breakpoint in advance and temporarily stopping the execution of the program when the breakpoint is reached during the scan execution. In such an appropriate way, by executing or stopping the program and checking the state of the memory at that time, whether it is operating normally or if a problem occurs, Identify and correct the problem location. As such a debugging device, there is a device disclosed in Patent Document 1 or the like.
JP 2001-67245 A

  By the way, there is what is called a function block as one of the elements constituting the program defined in IEC-61131-3. One of the purpose of describing this function block is to facilitate design and maintenance by reducing the amount of display program by concealing the program. The function block implementation method is created based on the concept of an instance. Therefore, there is one function block entity, and one or more instances are described in the main control program. When the execution position of the program reaches the position where the function block is described, the above-mentioned subroutine program is executed. Each instruction described in the actual function block is executed in order, and when it is executed up to the last instruction, it returns to the original position and executes the next instruction on the main program.

  It is difficult to set a breakpoint inside this function block. In other words, since the function block implementation method is created with the concept of an instance, even if the same function block is used multiple times in the control program, there is only one function block program entity. When a breakpoint is set at a step in a certain position of a program that constitutes a block, there is a problem that all function block instances are temporarily stopped at the set breakpoint.

  For example, in the case of a program for controlling a robot having a function block, it is assumed that the program is used for two controls of the robot A and the robot B. At this time, robot A wants to pause at a breakpoint set at a certain position, but robot B does not want to pause, but in the above example, function block for controlling robot B During the execution of this program, the program pauses at the set breakpoint and cannot respond to the request.

In addition, there is a request to set breakpoints at different positions for robot A and robot B, but if breakpoints are set at two positions, robot A and robot B will each be controlled. Since it pauses at the position of two breakpoints, it cannot respond to such a request.
It is an object of the present invention to provide a debugging apparatus that can set a practical breakpoint in a function block.

  In order to achieve the above object, a debugging device according to the present invention is a debugging device for a control program including a function block, the program executing means for continuously executing the steps constituting the control block, and the control program Storage means for storing breakpoint management information associating program identification information for specifying the function block described in the above and step position information to be temporarily stopped in the program in the function block, and the program execution means, the function block Based on the breakpoint management information stored in the storage means during continuous execution, the step currently being executed is the corresponding step of the function block identified by the breakpoint management information stored in the storage means. It is equal to the position and configuration and means to suspend program execution when applicable. The program identification information may include function block instance identification information. Of course, other information may be further added, or information other than the instance identification information (information that can identify the corresponding instance) may be used. In the embodiment, the breakpoint management information corresponds to a breakpoint management table.

  In this way, even if there are a plurality of instances of the same function block in the control program, each instance can be specified, so that a step position for temporary suspension can be defined for each instance. Therefore, even the same function block can be continuously executed without being paused in an instance of a certain function block, and can be paused in another instance. In addition, since the position to be paused can be set uniquely for each instance, workability is improved.

  The storage means stores breakpoint management information in which program identification information for specifying a step and step position information of the step are associated with each other for a step existing outside the function block. The means for suspending the execution of the program may be applicable to a step existing outside the function block if applicable. Such a configuration is preferable because breakpoints can be managed with the same system configuration regardless of whether the function block is inside or outside.

  In the present invention, since a step position (break point) for temporary stop can be set for each instance of each function block, a practical break point can also be set in the function block.

  FIG. 1 shows an embodiment of a debugging apparatus according to the present invention. The debugging device is configured by installing an application program in a computer such as a personal computer. Accordingly, as shown in FIG. 1, the hardware configuration includes an input device 1 such as a keyboard and a pointing device, a display device 2, and a device main body (CPU main body) 3. The apparatus body 3 includes an operation unit 11, a program control unit 12, a program execution unit 13, a control program storage area 14, a program control information area 15, a program execution work area 16, an I / O area 17, It has. The operation unit 11, the program control unit 12, and the program execution unit 13 are realized by application programs executed by the CPU. The control program storage area 14, the program control information area 15, the program execution work area 16, and the I / O area 17 are realized by various storage means such as a RAM and a hard disk.

  The operation unit 11 outputs an operation screen for performing control program debugging to the display device 2, receives an input from the input device 1, and passes the received input to the program control unit 12. FIG. 2 shows an example of the operation screen. In this operation screen layout, various execution operation buttons B1, B2, B3, B4, B5, B6,... For giving a control program execution command are arranged at the top of the screen, and the program configuration is displayed on the left side. A project tree display area R1 is arranged, and a program display area R2 for displaying a control program to be debugged is arranged on the right side. In the program display area R2, a rectangular cursor C1 indicating a step (command) currently being executed is displayed. As will be described later, the cursor C1 is also used to specify a step position for setting a breakpoint. The execution operation buttons B1, B2, and B3 are operation buttons used when performing step execution. The one-scan execution operation button B4 gives a command for continuously executing the control program only once (one scan) from the beginning to the end. The continuous execution operation button B5 gives a continuous execution command for repeatedly executing the control program. The execution stop button B6 gives an instruction to stop the execution of the program being continuously executed by pressing (clicking) the continuous execution operation button B5.

  The program control unit 12 determines an execution step based on the execution command received from the operation unit 11, requests the program execution unit 13 to execute the determined execution step, or sets a break command received from the operation unit 11. Then, a breakpoint management table for managing breakpoints is created and stored in the program control information area 15.

  The program execution unit 13 executes or stops the control program according to a request from the program control unit 12 and program control information set by the program control unit 12 (breakpoint management table in the present embodiment). .

  The control program storage area 14 is a storage area for storing a PLC control program, and is set in a predetermined area of the memory. The program execution unit 13 reads and executes the control program stored in the control program storage area 14.

  The program control information area 15 is a storage area for storing program control information such as a breakpoint management table created by the program control unit 12, and is set in a predetermined area of the memory.

  The program execution work area 16 corresponds to the internal memory of the PLC, and is a storage area serving as a work memory used when the program execution unit 13 executes the control program, and is set in a predetermined area of the RAM. The I / O area 17 is a storage area corresponding to the I / O memory of the PLC, and is set in a predetermined area of the RAM.

  In the present embodiment, the control program executed by the program execution unit 13 is a program written in a ladder language including function blocks as displayed in the program display area R2 of FIG. In the case of the control program shown in FIG. 2, the program (FB_A) created by the function is used as instances Robot_1 and Robot_2 in the program StationNo1 and Robot_3 and Robot_4 in the program StationNo2, and controls each facility.

  FIG. 3A shows a part of the function block (FB_A) program. As shown in FIG. 3B, when a rectangular box corresponding to a function block is described in the control program, each instruction of the control program shown in FIG. The program in the function block shown in FIG. 3A is executed to the end, and then the next instruction of the function block shown in FIG. 3B is executed.

  In FIG. 3B, the control of Robot_1 and Robot_2 is performed by the function block (FB_A). Robot_1 and Robot_2, which are instances of the same function block (FB_A), have their respective work areas set in the program execution work area 16 (see FIG. 3C), and are individually controlled by giving input data individually. Controls the robot. Since the work areas are set in this way, even if the same function block program is executed, the I / O data and the like are different, and control according to each control target can be performed.

  As shown in FIG. 4, the function block (FB-B) can be described in the program constituting the function block (FB_A). Thus, the function block can describe a multi-layered structure.

  In the present embodiment, the program control unit 12 has three functions of “step over”, “step in”, and “step out” as functions at the time of step execution. These three functions are all used in execution related to the function block.

  As shown in FIG. 5A, in the step over, when the cursor C1 indicating the instruction to be executed (current step position) is at the head of the function block, the function block is continuously executed and the next step is executed. (Refer to FIG. 5B). In other words, the command for executing step over can be said to be a command for executing a function block as one step. As a result, the process of stepping each instruction in the function block can be omitted, and debugging work can be performed efficiently. This is an effective function when function block debugging is unnecessary.

  Step-in moves to the first step in the function block when the cursor C1 indicating the instruction to be executed (current step position) is at the head of the function block (see FIG. 5C). That is, the command for executing step-in can be said to be a command that stops at the first step in the function block. This makes it possible to execute the program in the function block step by step. This function is useful when you want to verify a program in a function block.

  In step-out, once step-in is executed and the function block is entered, and if step by step is executed one instruction at a time, the remaining steps in the function block are continuously executed, and the function block calling side after the function block is executed Move to the step. The command for executing this step-out can be said to be a command that continuously executes the remaining steps in the function block and stops at the next step of the function block that has called the function block. If the inside of the function block is step-executed and verified halfway, and verification of subsequent instructions is unnecessary, the step-by-step operation after that can be omitted.

  By providing two functions of step over and step in in this way, when the user comes to the beginning of a function block, does the user enter the inside of the function block and perform verification while executing the step (step in)? Without entering into the function block, it is possible to selectively execute whether the function block is executed continuously and shift to the next step (step over), and an appropriate process according to the situation can be efficiently performed.

  Furthermore, by providing a step-out, step execution is performed up to the necessary part inside the function block, and after that, the step execution command is executed one step at every step in the function block by executing it continuously. Since the operation of inputting a command can be omitted, the workability is further improved.

  In the present embodiment, the three functions described above and normal step execution are executed by the three execution operation buttons B1, B2, and B3. That is, B1 is a step-in button. If this step-in button B1 is pressed at the beginning of the function, the process moves to the first step in the function block. That is, the above-described step-in function is executed. When this step-in button B1 is pressed at a position other than the top of the function block, that is, within a normal command or inside the function block, one step is executed.

  B2 is a step over button. When the step over button B2 is pressed at the beginning of the function block, the function block is continuously executed. That is, the above-described step over function is executed. When this step over button B2 is pressed at a position other than the top of the function block, that is, within a normal command or inside the function block, one step is executed.

  B3 is a step-out button. When the step-out button B3 is pressed in any case in the beginning of the function block or in the middle of the function block, the rest of the function block is continuously executed. When this step-out button B3 is pressed at the position of the normal command outside the function block, one step is executed.

  That is, at the position of a normal command outside the function block, all of the three buttons B1, B2, and B3 mean commands that are executed in one step. Of course, in the present embodiment, the three buttons B1, B2, and B3 can be used to input three functions and four types of normal one-step execution commands. However, the present invention is not limited to this. A button for inputting instructions for one-step execution may be further provided, or it may be realized by two buttons by using both step over and step out. . In the latter case, step over is executed when the shared button is pressed at the beginning of the function block, and step out is executed when the shared button is pressed inside the function block. do it.

  FIG. 6 is a flowchart showing the above-described three functions and the function of the program control unit 12 that performs one-step execution. The program control unit 12 determines an execution step (stop step) based on the execution command (pressing B1, B2, and B3) received from the operation unit 11, and determines a predetermined step of the control program based on the determined content. The execution request is given.

  This flowchart operates in the one-step execution mode. That is, in the operation screen shown in FIG. 2, the one-step execution mode is a case where continuous execution is not performed in response to pressing of the one-scan execution operation button B4 or the continuous execution operation button B5.

  In the one-step execution mode, it waits for any one of step-in button B1, step-over button B2, and step-out button B3 to be pressed (command input). When the step over button B2 is pressed, it is determined whether or not the next step is a function block (S11). Specifically, the determination is made based on whether or not the cursor C1 is at the head position of the function block as shown in FIG. When the next step is a function block (S11 is Yes), the inside of the function block is continuously executed, and the stop position is set so as to stop at the next step of the function block (S12). Based on this, the program execution unit 13 continuously executes the function block. The cursor C1 moves to the next step of the function block that is the stop position.

  If the step-in button B1 is pressed while waiting for command input, it is determined whether or not the next step is a function block (S13). If the next step is a function block (S13 is Yes), a stop position is set so that the next step stops at the first step in the function block (S14). In response to this, the program execution unit 13 jumps to the first step in the function block. The operation unit 11 displays the function block program in the program display area R2 and positions the cursor C1 at the first step of the displayed function block.

  If the step-out button B3 is pressed while waiting for command input, it is determined whether or not the function block is being executed (S15). This can be determined based on whether or not the cursor C1 is positioned at a step (regardless of whether it is the head or not) constituting the function block program. If the inside of the function block is being executed (S15 is Yes), a stop position to stop at the next step of the function block that called the function block is set (S16). Based on this, the program execution unit 13 continuously executes the steps in the function block after the current step. The cursor C1 moves to the next step of the function block that is the stop position.

  Regardless of which command is input, if the judgment result of each branch judgment S11, S13, S15 is No, one step is executed (S17). That is, the program execution unit 13 executes the current step where the cursor C1 is placed and stops at the next step.

  Next, continuous execution will be described. When the program execution unit 13 acquires that the one-scan execution operation button B4 has been pressed from the operation unit 11 via the program control unit 12, the program execution unit 13 continuously executes the control program from the beginning to the end (one scan) and stops. To do. When the program execution unit 13 acquires that the continuous execution operation button B5 has been pressed from the operation unit 11 via the program control unit 12, the program execution unit 13 repeatedly executes the control program. Further, when the program execution unit 13 recognizes that the execution stop button B6 has been pressed while the control program is being repeatedly executed, the program execution unit 13 stops the program execution at the top step position of the control program. Actually, when the program is executed to the end of the control program and the execution target step is returned to the top of the control program, it is determined whether or not the execution stop button B6 is pressed, and the execution stop button B6 is pressed. If not, the control program is continuously executed from the beginning to the end, and the execution position is returned to the beginning of the control program. If the execution stop button B6 is pressed when the execution target step is returned to the top of the control program, the execution of the program is stopped. As described above, the execution stop button B6 functions effectively when the continuous execution button B5 is pressed and the control program is repeatedly executed. Therefore, the execution stop button B6 is normally an inactive button as shown in FIG. The execution stop button B6 becomes active on the condition that the continuous execution button B5 is pressed.

  If a breakpoint is set and registered in the program control information area 15, the program execution unit 13 determines whether or not the next execution position has become the step position set by the breakpoint during the above-described continuous execution. If it is not a breakpoint, the step is executed. If the breakpoint is at the step position, execution of the program is paused. In the present embodiment, the breakpoint information stored in the program control information area 15 is as follows.

  FIG. 7 shows an example of the data structure of the breakpoint management table stored in the program control information area 15. This breakpoint management table is a table in which program identification information, a POU name, and a breakpoint position (program step position) are associated with each other. As is apparent from the project tree displayed in the project tree display area R1 of FIG. 2, the same function block (FB_A) is two for task_000 (Robot_1 and Robot_2) and two for task_001 (Robot_3 and Robot_4). Are used in a total of four places.

  Simply setting a breakpoint at the step position of the function block (FB_A) program itself breaks and stops at the same step position in all four instances. However, actually, for example, in Robot_1 and Robot_4, there is a request to break and stop, but in Robot_2 and Robot_3, it is desired to continuously execute without break. Furthermore, there is also a request for stopping at different step positions in Robot_1 and Robot_4 to be broken. This is because even if the same function block is used, the controlled object is different, so the presence or absence of a break and the breakpoint to be stopped differ for each controlled object (for example, the sixth step of Robot_1). And 10th step of Robot_4).

  Therefore, in this embodiment, the task No. The target instance is uniquely identified by the program identification information including the instance identification information. Further, by managing the program identification information and the step position of the program, each breakpoint setting position is identified for a specific function block instance.

  The program execution unit 13 determines whether or not the current step position is a step that should be broken and stopped based on the information stored in the breakpoint management table during continuous execution of the control program. Then, the step is executed as it is, and in the case of a breakpoint, the process is stopped. Whether or not it is a breakpoint is determined as a breakpoint on condition that the program identification, the POU name, and the step position match. In other words, if any one of the program identification, the POU name, and the step position is different, it is determined that it is not a breakpoint, and the step is executed.

  In the case of the breakpoint management table shown in FIG. 7, the function block (FB_A) whose program identification information is “task_000 \ StationNo1 \ Robot_1” stores the condition that a break occurs in the sixth step, and “task_001 ¥ StationNo2 The function block (FB_A) of “¥ Robot — 4” stores the condition that a break occurs at the 10th step. Therefore, the function block (FB_A) stops at the sixth step of Robot — 1 of Station No. 1 but does not stop at the 10th step. Conversely, Robot_4 of Station No. 2 stops due to a break at the 10th step, but does not stop at the 6th step. Furthermore, during the continuous execution of Robot No. 2 of Station No. 1 and Robot No. 3 of Station No. 2, the program is continuously executed to the end without being broken (it is not stopped at the sixth step or the tenth step).

  The breakpoint management table registration process is performed by the program control unit 12 executing the flowchart shown in FIG. First, it waits for a breakpoint to be selected (input) via the operation unit 11 (S21). Specifically, as shown in FIG. 9, a breakpoint setting instruction is accepted for the instruction specified by the cursor C1 among the instructions (steps) in the program displayed in the program display area R2. That is, the user operates the input device 1 and moves the cursor C1 to an instruction (step) to be set as a breakpoint in the displayed program. In this state, the input device 1 is operated to give an instruction to register the instruction pointed by the cursor C1 as a breakpoint. For example, various instructions can be used for such instructions, such as displaying a predetermined registration button on the setting screen and clicking the registration button.

  Next, it is determined whether or not the instruction (step) designated as the breakpoint is in the function block (S22). In the case of the function block, the task number is displayed in the program identification information column. The instance identification information is registered (S23), the POU name is registered in the POU name column (S24), and the step position (number) is registered in the position column (S24). The program identification information, the POU name, and the step position are given via the operation unit 11. Since the program displayed in the program display area R2 is known in the debug device side as to which program in the project tree display area R1, the cursor C1 is placed on an arbitrary instruction (step) of the program. When placed, the operation unit 11 can recognize the program identification information and the POU name for the program, and the operation unit 11 can also recognize the step position designated by the cursor C1. Therefore, the program control unit 12 can acquire information necessary for registration in the breakpoint management table via the operation unit 11. For example, breakpoints for Robot_1 and Robot_4 shown in FIG. 7 are registered by executing such processing.

  On the other hand, when the selected breakpoint is outside the function block, the task number is displayed in the program identification information column. (S26), the POU name is registered in the POU name column (S27), and the step position (number) is registered in the position column (S28). For example, a breakpoint for StationNo3_Robot5 shown in FIG. 7 is registered by executing such processing.

  When executing the control program, the program execution unit 13 executes and stops the program while referring to the breakpoint management table created by the registration process described above. Specifically, the program execution unit 13 executes the flowchart shown in FIG.

  First, it is determined whether or not step execution is performed (S30). In the operation screen shown in FIG. 2, step execution is performed when continuous execution is not performed in response to pressing of one scan execution operation button B4 or continuous execution operation button B5. In the case of step execution, processing for setting a stop position is performed (S31). In this stop position setting process, when one step is executed, the stop position is set to the next step to be executed after one step is executed. In the case of step over execution, the stop position is set to the next step of the function block (similar to S16 in FIG. 6).

  When the one-scan execution operation button B4 or the continuous execution operation button B5 is pressed, since it is continuous execution, the branch determination in processing step S30 is No, and the stop position is not set because it does not go through S31.

  Then, the program execution unit 13 executes the step at the current execution position (S32). Next, the program execution unit 13 calculates the next step to be executed (S33). That is, although the steps are basically executed in the order of step numbers, there is a jump instruction or the like, which is not necessarily the next step number, so the next step to be executed is determined in this processing step.

  When the next step to be executed is determined, the program execution unit 13 determines whether or not the determined step is the step at the head of the scan (the head of the control program) (S34). If it is not the top (No in the branching determination in processing step S34), it is determined whether or not the next execution position (step) determined in S33 matches the step position / POU name registered in the breakpoint management table. Judgment is made (S35). If they match (Yes in the branch determination in processing step S35), it is determined whether or not they match the program identification number (information) (S36). If they match (Yes in the branch determination of processing step S36), it is determined that the next step that is currently being executed is a breakpoint, and the program execution is stopped (S39). In addition, if any of the branch determinations in the processing step S35 and the processing step S36 is No, the next step is not a breakpoint, and the process jumps to the processing step S37. In process step S37, it is determined whether or not the next step to be executed at present is the step stop position set in S31 (S37). In the case of the step stop position (Yes in the branch determination in process step S37), the program execution is stopped (S39). When the position is not the step stop position (No in the branch determination in process step S37), the process step S32 is executed.

  On the other hand, if the step determined in process step S33 is the head of the control program, the branch determination in process step S34 is Yes, so it is determined whether a stop command is being accepted (S37). Specifically, it is determined whether or not the execution stop button B6 is pressed (being accepted). If no stop command has been received, the process jumps to step S35.

  According to this flowchart, in the case of one-step execution, if one step is executed in processing step S32, the next is the step stop position, so that it becomes Yes in processing step S37 and the program execution is stopped. That is, only one step is executed and stopped. In the case of step over execution, the process proceeds from the process steps S32 to S35 in order, and if the break point does not come, the process step S35 is NoNo, and as long as the step in the function block remains, the process step S37 is NoNo. Therefore, it returns to processing step S32 and repeats it. If there is no breakpoint, repeat steps S32 to S37 as described above to process all the steps in the function block, and then come to the step stop position set in S31. To do. In other words, all remaining steps in the function block are executed and then stopped. If there is a breakpoint, whether it is one-step execution or step-over execution, the processing steps S35 and S36 result in Yes, and the program execution stops at the breakpoint position (S39).

  When the one-scan execution operation button B4 or the continuous execution operation button B5 is pressed and executed, if it is not the head of the scan, the process proceeds from step S32 to S35 in order, and unless a breakpoint comes, No in process step S35. Since the stop position is not set, the process step S37 is No, and the process returns to the process step S32 to repeat it. If there is a breakpoint, the processing steps S35 and S36 result in Yes, and the program execution stops at the breakpoint position (S39). That is, in the case of continuous execution, the above-described S32 to S37 are repeatedly executed as long as there is no breakpoint and the execution stop button B6 is not pressed. When the execution stop button B6 is pressed during continuous execution and a stop command is received, when the scan head position is reached, Yes is made in S34, Yes is made in S38, and program execution is stopped.

  In the case of one scan execution, if it is not the head of the scan, the process proceeds in order from process steps S32 to S35, and unless a breakpoint comes, the process step S35 becomes NoNo, the process step S37 becomes NoNo, and the process returns to process step S32. This flow is repeated as long as the program in one scan remains. If there is a breakpoint, program execution stops at the breakpoint position in the processing steps S35 and S36 (S39). Even if there are no break points, after all the program steps in one scan have been processed and then returned to the beginning of the scan, the result is Yes in S34, Yes in ST38, and program execution is stopped (S39). Supplementally, when the one-scan execution operation button B4 is pressed, the operation is performed by automatically issuing a stop command regardless of the operation of the execution stop button B6. Instead of automatically issuing a stop command when the one-scan execution operation button B4 is pressed, two determinations are made in processing step ST38: “Do you accept stop command?” And “Is it executed one scan?” May be. The two determination processes may be separately divided into serial flow processes.

  In the flowchart of FIG. 10, it is possible to modify the one scan execution to be handled as the step execution in the processing step S30. In that case, Yes in processing step S30, and in step S31, the stop position is set in the scan head step. In this modification, in the case of one scan execution, if the scan head position is reached, Yes in S34, but No in ST38, after ST35 and ST36, in step ST37, the step stop position set in ST31 Yes, and the program execution is stopped (S39).

  Next, a case where the inside of the function block of Robot_4 is continuously executed will be described as an example. In this case, it is assumed that the steps are sequentially executed and the next step becomes the sixth step. Then, the POU name is FB_A and the step position is sixth, which matches the information registered in the breakpoint management table, so that the branch determination in processing step S35 is Yes. However, since the program identification information is different, the branch determination in processing step S36 is No, and the sixth step is executed.

  Then, it is assumed that the process further proceeds and the next step becomes the tenth step. Then, the POU name is FB_A, the step position is 10th, and the information matches the information registered in the breakpoint management table, so the branch determination in processing step S35 is Yes. Furthermore, since the program identification information also matches, the branch determination in process step S36 is also Yes, so that program execution stops at that step position.

  On the other hand, when the function blocks of Robot_2 and Robot_3 are continuously executed by step over, the branch determination of processing step S35 is Yes in both the sixth and tenth steps, but the program identification information does not match. The branch determination in process step S36 is No, and the process is executed without a break until the last step. As described above, in this embodiment, a breakpoint can be set at a unique position for each instance of each function block.

  Of course, according to the present invention, a breakpoint set for a normal instruction (step) outside the function block can be suspended based on the break process in the same procedure.

  In the above description, the case where B4 and B5 are pressed to perform continuous execution has been described. However, the present invention can also be applied to the case where function blocks are continuously executed due to step over or step out.

1 is a block diagram showing a preferred embodiment of the present invention. It is a figure which shows an example of an operation screen. It is a figure explaining a function block. It is a figure explaining a function block. It is a conceptual diagram explaining step over, step in, and step out. It is a flowchart which shows the function of a program control part. It is a figure which shows an example of the data structure of a breakpoint management table. It is a flowchart explaining the registration function of a breakpoint which a program control part has. It is a figure explaining the effect | action of a breakpoint registration. It is a flowchart explaining the break processing function which a program execution part has.

Explanation of symbols

DESCRIPTION OF SYMBOLS 11 Operation part 12 Program control part 13 Program execution part 14 Control program storage area 15 Program control information area 16 Program execution work area 17 I / O area

Claims (3)

A debugging device for a control program including a function block,
Program execution means for continuously executing the steps constituting the control block;
Storage means for storing breakpoint management information in which program identification information for specifying a function block described in the control program and step position information for temporarily stopping the program in the function block are associated with each other;
Based on the breakpoint management information stored in the storage means during continuous execution of the function block by the program execution means, the step currently being executed is identified by the breakpoint management information stored in the storage means Means for determining whether or not the corresponding step position of the function block to be executed, and, if applicable, temporarily stopping program execution;
A debugging device comprising:   The debugging apparatus according to claim 1, wherein the program identification information includes function block instance identification information. For the step existing outside the function block, the storage means stores breakpoint management information that associates the program identification information that identifies the step with the step position information of the step,
2. The debugging apparatus according to claim 1, wherein the means for temporarily stopping the program temporarily stops program execution when a step existing outside the function block is applicable.

Images