JP2010122824A - Diagram debugging system of programmable controller, programming apparatus for the system and program for the system - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a diagram debugging system of a programmable controller, which easily debugs a diagram having nodes including branch points of a control program in operation. <P>SOLUTION: A programming apparatus includes: a control program edit processing part 11a for preparing a control program for generating first instruction/first inner variable for specifying connection or non-connection/connection destination of one input side of a node, for the node connecting between symbols and second instruction/second inner variable for specifying connection or non-connection/connection destination of the other output side of the node; and a wire force processing part 11b for commanding to rewrite the first instruction/first inner variable into third instruction/third inner variable respectively, rewrite either the third instruction/third inner variable, and the second instruction/second inner variable into fourth instruction/fourth inner variable respectively, and rewrite either the fourth instruction/fourth inner variable. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to a plant control device for a steel plant, a papermaking plant, a chemical plant, and the like, and more particularly, a programmable controller diagram debugging system using a ladder diagram (LD) language and a function block diagram (FBD) language, and a programming device therefor And the program.

  In general, FA (Factory Automation) field including assembly work such as steel, paper plant and automobile industry, PA (Process Automation) field such as chemical plant, and public system such as water and sewage system, monitoring and control field of industrial system Therefore, a programmable controller (hereinafter referred to as PLC) that uses a control program written in a graphical language is widely used.

  As the PLC diagram language, the global language defined in the international standard IEC61131-3 by the International Electrotechnical Commission is adopted.

  As programming tools using such languages, programming software (such as ladder editors) has become widespread, and diagrams can be created in a form that includes symbols on a personal computer, making it easy to create and edit programs based on diagrams. It is like that.

  Usually, the created program is completed by correcting or changing the program by debugging in order to operate correctly as originally designed. In this debugging, the program is executed with the device connected to the PLC to check whether the device is operating as designed.

  The ladder editor for creating a diagram on a display screen of a personal computer has a mode in which the operation of the diagram can be confirmed by a simulation for forcibly turning on / off the contact in debugging.

  For example, if the ladder editor is installed on a personal computer as an application that runs on a Windows (R) system, a test mode (debug mode) is set, and a dialog box for instructing contact ON / OFF is displayed in this state. And use this operation screen to set the contact ON / OFF.

  However, in debugging by such an operation, as the number of contacts to be turned on increases, the time is increased, and in order to solve the disadvantage that the work efficiency of debugging is remarkably lowered, a dummy circuit is formed by collecting several contacts only during debugging. There is also a method in which the above-described trouble is eliminated by limiting the contacts to be turned on to the minimum necessary.

  However, in such a method, it is necessary to return the dummy circuit to the original circuit after the debugging is completed, and if this is forgotten, there is a possibility of causing a trouble that the program does not operate normally.

Therefore, in order to improve the efficiency of the debugging work of the program by simplifying the operation required for the simulation of forcibly turning on the contacts, ON of the contacts arranged on the connection line between the input and output buses in the diagram. A method of performing a designation process for designating a contact to be turned off by a specified route from the input bus and an ON / OFF process for turning on / off the designated contacts collectively is disclosed. (For example, refer to Patent Document 1).
Japanese Unexamined Patent Publication No. 2000-276212 (first page, FIG. 1)

  However, while debugging a diagram, a method of forcibly setting the value of a variable for an instruction word such as a contact to perform debugging (also called a contact force) is known, but includes a branch point. Since a variable cannot be set at a connection point, there is a problem that debugging after the connection point cannot be performed easily.

  Also, in the method of manufacturing a dummy circuit for debugging etc., there is a possibility that new work may occur because work for restoring the program is necessary and the work may not be performed correctly. There is.

  Furthermore, in the case of a running control program, there is a problem that it takes time and effort to stop the operation, change the diagram (circuit diagram), and start debugging.

  As described above, when debugging a diagram, the circuit to be debugged is separated from other circuits to form a bypass circuit of the circuit including the connection point, or the preset internal variable is switched and applied from the disconnected connection point. In some cases, the connection destination of the diagram is changed in accordance with various debugging purposes, such as presetting a region of a diagram having a plurality of connection points and cutting internal connection lines in the region.

  When debugging by changing the connection destination of such a diagram, replacing the instruction at the connection point of the original control program and inserting a debug program consisting of multiple instructions (number of steps) at that connection point In order to execute a program with the number of steps changed, it is necessary to change the memory area on the controller side, so it is not easy to insert a debug program or restore to the original program There is.

  The present invention has been made to solve the above-described problems. A diagram created in a ladder diagram language or a function block diagram language is displayed on a display screen to create an object control program based on the diagram. In a programmable controller diagram debugging system, when a debugging program consisting of multiple instructions (number of steps) is inserted at the connection point, the debugging program can be easily inserted or restored to the original program. An object of the present invention is to provide a programmable controller diagram debugging system, a programming device thereof, and a program thereof.

  In order to achieve the above object, a programmable controller diagram debugging system according to claim 1 of the present invention creates a diagram created in a ladder diagram language and a function block diagram language on a display screen, and based on the diagram. A diagram debugging system comprising a programmable controller programming device for creating an object control program and the programmable controller for loading and executing the object control program, wherein the diagram is generated and displayed on the display screen. In addition, with respect to the connection point connecting the symbols of the diagram, a first command / first internal variable for designating connection / disconnection / connection destination on one input side of the connection point, and the other of the connection points of A control program editing processing unit for creating the object control program for generating a second command / second internal variable for designating a connection / non-connection on the power side / a connection destination thereof, and the first command / first Of the third instruction / third internal variable, the third instruction / third internal variable, and the second instruction / second internal variable, respectively. And a wire force setting processing unit for instructing to rewrite any of the fourth instruction / fourth internal variable in the instruction / fourth internal variable, the first instruction includes: STORE "instruction, the second instruction is a debugging program stored in a memory area different from the memory area in which the object control program of the controller is stored for a connection point consisting of a" LOAD "instruction. The third “JUMP” instruction step having a first internal address as a third internal variable, a program step comprising a plurality of instruction groups having the start address as a start step, and an operation result of the program A “SORE” instruction step that is stored as a first internal variable, a “JUMP” instruction step in which the step destination of the second instruction of the object control program is an internal variable, and the calculation result as a second internal variable Generating a debug program comprising the second “LOAD” instruction step written as: rewriting the object control program by transmitting the debug program to the controller, and executing the object control program at the connection point Insert a debug program to save the diagram The feature is that the bag can be used.

  To achieve the above object, a programmable controller diagram debugging system according to claim 2 of the present invention creates a diagram created in a ladder diagram language and a function block diagram language on a display screen, and based on the diagram. A diagram debugging system comprising a programmable controller programming device for creating an object control program and the programmable controller for loading and executing the object control program, wherein the diagram is generated and displayed on the display screen. A first instruction / first internal variable for designating connection / non-connection / connection destination on one input side of the connection point with respect to the connection point connecting the symbols of the diagram, and the other of the connection points of A control program editing processing unit for creating the object control program for generating a second command / second internal variable for designating a connection / non-connection on the power side / a connection destination thereof, and the first command / first Of the third instruction / third internal variable, the third instruction / third internal variable, and the second instruction / second internal variable, respectively. And a wire force setting processing unit for instructing to rewrite any of the fourth instruction / fourth internal variable in the instruction / fourth internal variable, the first instruction includes: For the connection point consisting of the “STORE” instruction and the second instruction “LOAD” instruction, the fourth instruction and its internal variables are stored in a memory area different from the memory area in which the object control program is stored. A “JUMP” instruction that uses the top address of the bag program as an internal variable, and a plurality of instructions that start the “LOAD” of the first internal variable at the start address step and the start step as the start address A program consisting of a group, a “STORE” instruction for storing the operation result of the program as the first internal variable, a “LOAD” instruction step for writing as the first internal variable, and a second instruction Generate a debug program consisting of a “JUMP” instruction step to return to the object control program with the step destination of the next instruction as an internal variable, rewrite the object control program by sending the debug program to the controller, During execution of the object control program, The debug program is inserted into the connection point so that the diagram can be debugged.

  In order to achieve the above object, a programmable controller of a programmable controller diagram debugging system according to claim 3 of the present invention creates a diagram created in a ladder diagram language or a function block diagram language on a display screen. A programming device of a diagram debugging system comprising a programming device of a programmable controller for creating an object control program based on a diagram and the programmable controller for loading and executing the object control program, wherein the programming device is the diagram To the connection point connecting the symbols of the diagram displayed on the display screen, the connection / disconnection on one input side of the connection point. / First instruction / first internal variable for specifying a connection destination / connection / non-connection on the other output side of the connection point / second instruction / second internal variable for specifying the connection destination A control program edit processing unit for creating the object control program to be generated; and the third instruction / third internal variable for the first instruction / first internal variable, respectively, and the third instruction / third internal variable. Any one of the internal variables, the second instruction / second internal variable is replaced with a fourth instruction / fourth internal variable, and any of the fourth instruction / fourth internal variable is rewritten. A wire force setting processing unit for instructing that the object control program of the controller has a connection point consisting of a “STORE” instruction and a “LOAD” instruction as the second instruction. Memories that differ from the memory area to be stored The third “JUMP” instruction step having a third internal variable as the start address of the debug program to be stored in the rearea; and a program step comprising a plurality of instruction groups having the start address as a start step; A “SORE” instruction step for storing the calculation result of the program as the first internal variable, a “JUMP” instruction step having the step destination of the second instruction of the object control program as an internal variable, and the calculation result Is generated as a second internal variable, and a debug program comprising the second “LOAD” instruction step is generated, the debug program is transmitted to the controller, the object control program is rewritten, and the object control program is being executed. , Debug to the connection point It is characterized by inserting a program.

To achieve the above object, a programming device for a programmable controller diagram debugging system according to claim 4 of the present invention creates a diagram created in a ladder diagram language or a function block diagram language on a display screen. A programming device of a diagram debugging system comprising a programming device of a programmable controller for creating an object control program based on a diagram and the programmable controller for loading and executing the object control program, wherein the programming device is the diagram To the connection point connecting the symbols of the diagram displayed on the display screen, the connection / disconnection on one input side of the connection point. / First instruction / first internal variable for specifying a connection destination / connection / non-connection on the other output side of the connection point / second instruction / second internal variable for specifying the connection destination A control program edit processing unit for creating the object control program to be generated; and the third instruction / third internal variable for the first instruction / first internal variable, respectively, and the third instruction / third internal variable. Any one of the internal variables, the second instruction / second internal variable is replaced with a fourth instruction / fourth internal variable, and any of the fourth instruction / fourth internal variable is rewritten. A wire force setting processing unit for instructing the connection, and the first instruction is a “STORE” instruction, and the second instruction is a “LOAD” instruction. A variable is a memory that stores the object control program. A “JUMP” instruction that uses a start address of a debug program stored in a memory area different from the rear as an internal variable, an instruction step that “LOADs” the first internal variable in the step of the start address, and the start address A program composed of a plurality of instruction groups starting from the above, a “STORE” instruction for storing the operation result of the program as the first internal variable, and a “LOAD” instruction step for writing as the first internal variable;
Further, a debug program including a “JUMP” instruction step for returning to the object control program, in which the step destination of the instruction next to the second instruction is an internal variable, is generated, and the debug program is transmitted to the controller. The object control program is rewritten, and the debug program is inserted into the connection point during execution of the object control program.

A program of a programmable controller diagram programming apparatus according to claim 5 of the present invention creates a diagram created in a ladder diagram language or a function block diagram language on a display screen, and creates an object control program based on the diagram. A program of a diagram debugging system comprising a programming device of a programmable controller and the programmable controller for loading and executing the object control program, wherein the programming device generates the diagram and displays it on the display screen A first instruction / first internal for designating connection / disconnection / connection destination of one input side of the connection point with respect to the connection point connecting the symbols in the diagram A control program editing function for creating the control program for generating a variable and a second instruction / second internal variable for designating a connection / disconnection / connection destination on the other output side of the connection point; 1 instruction / first internal variable as a third instruction / third internal variable, respectively, any of the third instruction / third internal variable, and the second instruction / second internal variable. A wire force setting processing function for instructing to rewrite any of the fourth instruction / fourth internal variable to a fourth instruction / fourth internal variable, respectively, and the first instruction Is the start address of the debug program to be stored in a memory area different from the memory area in which the object control program of the controller is stored, for the connection point consisting of the “STORE” instruction and the second instruction being the “LOAD” instruction. Said third "JUMP" instruction step of the internal variable of 3,
Furthermore, a program step comprising a plurality of instruction groups starting from the head address, a “SORE” instruction step for storing the calculation result of the program as the first internal variable, and a second step of the object control program A debug program comprising a “JUMP” instruction step having an internal variable as a step destination of the instruction and a second “LOAD” instruction step for writing the operation result as a second internal variable. .

  A program of a programmable controller diagram programming apparatus according to claim 6 of the present invention creates a diagram created in a ladder diagram language or a function block diagram language on a display screen, and creates an object control program based on the diagram. A program of a diagram debugging system comprising a programming device of a programmable controller and the programmable controller for loading and executing the object control program, wherein the programming device generates the diagram and displays it on the display screen A first instruction / first internal for designating connection / disconnection / connection destination of one input side of the connection point with respect to the connection point connecting the symbols in the diagram A control program editing function for creating the control program for generating a variable and a second instruction / second internal variable for designating a connection / disconnection / connection destination on the other output side of the connection point; 1 instruction / first internal variable as a third instruction / third internal variable, respectively, any of the third instruction / third internal variable, and the second instruction / second internal variable. A wire force setting processing function for instructing to rewrite any of the fourth instruction / fourth internal variable to a fourth instruction / fourth internal variable, respectively, and the first instruction Is connected to a connection point consisting of a "STORE" instruction and the second instruction is a "LOAD" instruction. The fourth instruction and its internal variables are stored in a memory area different from the memory area in which the object control program is stored. Debug program to be memorized The “JUMP” instruction having a start address as an internal variable, and the step of the start address include an instruction step of “LOAD” the first internal variable, and a plurality of instruction groups having the start address as a start step. A program, a “STRORE” instruction for storing the operation result of the program as the first internal variable, a “LOAD” instruction step for writing as the first internal variable, and an instruction next to the second instruction It is a debug program comprising a “JUMP” instruction step for returning to the object control program, wherein the step destination is an internal variable.

  According to the present invention, a programmable controller diagram debugging system for creating an object control program based on a diagram created on a display screen by creating a diagram created in a ladder diagram language or a function block diagram language. A debug system for a programmable controller diagram that can easily insert a debug program or restore the original program when a debug program composed of a plurality of instructions (number of steps) is inserted at a connection point; and The programming device and the program can be provided.

  This will be described below with reference to the drawings.

  A first embodiment according to the present invention will be described below with reference to FIGS. FIG. 1 is a block diagram showing a configuration of a PLC diagram debugging system.

  The programming device 1 is used by downloading an object control program based on a diagram created by the programming device 1 to a programmable controller (hereinafter referred to as PLC) 2 that controls a control target.

  Here, the diagram refers to a circuit diagram created using a ladder diagram language (LD) and a function diagram language (FBD) defined in the international standard IEC61131-3 by the International Electrotechnical Commission.

  The configuration of the programming device 1 is to create a diagram and connect / disconnect / connect each of the connection points connecting the symbols of the diagram to one input side and the other output side of the connection point. An instruction / internal variable for designating a destination is generated, an object control program based on a diagram is created, an arithmetic processing unit 11 for downloading the created object control program to the controller 2, a source control program 12a1 for creating a diagram, and debugging A source file unit 12a for storing the program 12a2, a storage unit 12 for storing the object control program file unit 12b of the source file, a display unit 13 for displaying a diagram and an operation screen such as a dialog box, a diagram and an object Input unit 14 for various input operations to create a control program, and a communication interface 15. for sending an object control program to PLC2.

  The PLC 2 includes a communication interface 25 that receives the object control program transmitted from the programming device 1, a memory unit 22 that stores the received object control program, an arithmetic processing unit 21 that executes the object control program, and an arithmetic processing unit. And an input / output unit 23 that processes input / output signals to / from the controlled object in accordance with 21 commands.

  Further, the memory unit 22 stores the object control program in a data memory and a code memory. Then, the memory area of the object control program and the memory area of the debug program assumed in advance are set as a capacity that can be stored.

  The arithmetic processing unit 21 includes a program load server unit for storing the object control program transmitted via the communication interface 15 separately in a data memory and a code memory, a program execution processing unit for executing the object control program, Is provided.

  Next, the configuration of each part of the programming device 1 will be described. The programming device 1 can be configured by, for example, a personal computer, and the arithmetic processing unit 11 includes a CPU unit including a CPU and a main memory (not shown), and is based on a source control program and a diagram for creating a diagram. A control program editing processing unit 11a including a program compiler for generating an object control program, and a program load client unit for downloading the created object control program to the controller 2, and a wire force for performing connection point setting processing according to the present invention And a setting processing unit 11b.

  The storage unit 12 includes a hard disk drive device and the like. The source file unit 12a including the created source control program 12a1, the diagram symbol 12a2, and the debugging source debug program 12a3, and an object file storing the object control program The unit 12b is stored.

  Specifically, the program compiler 11a1 of the control program editing processing unit 11a extracts a program from the generated source file unit, generates a diagram, and further connects the symbols of the diagram displayed on the display screen. A first command / first internal variable for designating a connection / non-connection / connection destination on one input side of the connection point, and a connection / non-connection / on / off / on the other output side of the connection point An object control program for generating a second instruction / second internal variable for designating the connection destination is created.

  Then, the program load client unit 11a2 of the control program editing processing unit 11a downloads the generated object control program to the controller 2 via the communication interface 15.

  Then, the wire force setting processing unit 11b converts the first instruction / first internal variable into the third instruction / third internal variable, and any of the third instruction / third internal variable, In addition, the second instruction / second internal variable is instructed to be replaced with a fourth instruction / fourth internal variable, respectively, and any of the fourth instruction / fourth internal variable is rewritten.

  That is, the arithmetic processing unit 11 instructs the created diagram and the modified diagram to connect / disconnect the connection point including the branch point of the diagram on the input side and the output side, and the connection destination. A function for setting the value of the variable, a function for cutting between any connection points, and a function for setting the value of the internal variable from the connection point to the downstream side of the power flow.

  Here, the internal variable means a variable that is not displayed on the screen of the display unit 13, and the displayed variable is simply called a variable.

  Further, the wire force setting processing unit 11b is changed by rewriting only the third command / third internal variable and the fourth command / fourth internal variable in response to the command of the controller 2 in operation. Commands the PLC 2 to execute debugging on the diagram.

  Next, the processing operation of the connection point of the programming device 1 configured as described above will be described with reference to FIGS.

  FIG. 2 is an example of a diagram created by the programming device 1. For example, A is a variable A of a contact and its symbol is indicated by “||”. Similarly, the variable B is a variable of the coil and its symbol is indicated by “()”. The numerical value shown at the bottom of each symbol indicates a step number in an object control program described later.

  Further, the connection point between the symbol of the contact of the variable A and the coil of the variable B indicates an internal variable not displayed on the operation screen by (t1). The internal variable (t1) at this connection point is a connection point between the contact point of the variable A and the coil of the variable B, and is also connected to the connection between the internal variable (t2) at the connection point in the downward direction of the diagram. This is a branching point.

  Next, FIG. 3 shows the source control program of the diagram shown in FIG. 2. The left column shows the step number, the instruction word corresponding to each step is shown in the next column, and the variable name is shown in the right view. As shown in FIG. 3, each of the variables (t0) to (t9) corresponding to the connection points of the diagram is defined by “LOAD” and “STORE” in the assembler language. Given after a two-step instruction.

  The variable setting of this connection point can be generated in the process of creating the diagram, or after creating the diagram, you can specify the connection point with the cursor and click this cursor position to set it. A connection point may be specified and defined as “LOAD” and “STORE” collectively.

  Usually, the connection point is a connection point where the input / output terminals are connected as in the case of a symbol. According to the present invention, for example, the connection between the internal variable (t4) and the internal variable (t5) Like the connection line between t5) and the internal variable (t6), it is possible to set the connection point by regarding both ends of a simple connection having no symbol between the connection points as symbols.

  FIG. 3 illustrates a case where the internal variables (t0) to (t9) of these connection points are set as connection points that are not displayed on the diagram.

  Next, the operation of the wire force setting process in the case where the connection points of the diagram in which the connection points are set as described above is cut will be described with reference to FIGS.

  As shown in FIG. 4, for example, a portion indicated by a cross mark in the connection is cut, and the internal variable (t5) and the internal variable (t6) are separated, and the function block “Fun” and the coil F are included. A case where the downstream circuit is to be debugged will be described.

  As shown in FIG. 5, in the program, the “STORE” instruction shown in step 19 is changed to a “NOP” instruction (no processing) in the program so that the power flow input side is disconnected.

  Next, with reference to FIG.6 and FIG.7, the operation | movement which sets the value of the internal line number of the cutting | disconnection between connection points and the connection point downstream of a cut point is demonstrated. FIG. 6 is an operation flow diagram thereof, and FIG. 7 shows an example of a dialog box D13 for operating the wire force setting displayed on the display unit 13.

  First, a diagram created in advance is displayed, and the cursor is moved to the connection cut point, for example, the connection between the internal variable (t5) and the internal variable (t6) (s1). Then, the screen is clicked at that position to display the dialog box D13 (s2).

  Next, the icon “x” in the dialog box D13a is clicked. Then, “NOP” is written in the source control program on the main memory of the arithmetic processing unit 11, and an x mark as shown in FIG. 4 is displayed on the display screen (s3).

  Further, an “ON” or “OFF” icon D13a is clicked here. Then, the internal variable rewritten in step 20, for example, the value of (tX) is written to the main memory of the arithmetic processing unit 11 as the value of the connection point in the downstream direction of the cut portion.

  Next, when the “write (W)” icon D13d is clicked, rewriting of the object control program of the PLC 2 is instructed. (S5).

  In this way, the connection of the diagram that has been changed and the internal variable of the connection point that becomes the base point of the downstream power flow that has been disconnected are set, and the debugging of the circuit in the downstream direction of the diagram can be controlled. The program can be changed and implemented.

  The cutting location and the value of the internal variable can be canceled and reset by clicking the “Release (R)” icon D13b.

  Further, the values of the internal variables set in the diagram as a plurality of cut points can be changed by clicking the “Release All (A)” icon D13c and then clicking the “Write (w)” icon D12d. By rewriting only the information, it is possible to reliably return to the state before debugging.

  When the object control program of the changed part is not downloaded, the “Save File (s)” icon D13e can be clicked and written to the storage unit 12.

  By doing this, for the connection point of the diagram to be changed, the connection / disconnection command and the connection destination (internal variable) in the case of connection can be rewritten to the object control program of the running controller. Even in a diagram having a branching point, it is possible to easily debug a circuit to be debugged by separating it from other circuits.

  Further, it is possible to easily restore the program state before the change in a batch.

  Next, with reference to FIG. 8 and FIG. 9, a case will be described in which a debug program composed of a plurality of instructions (number of steps) is inserted at the connection point (t7).

  The wire force setting processing unit 11 described above has the function of cutting the connection and setting the internal variable of the connection point. However, in the present embodiment, a pattern signal or the like is further generated from the connection point (t7) to connect the connection point. A case where a debug program having a function of simulating the subsequent circuits is inserted will be described.

  FIG. 8 shows a contact made up of variables C1 to C5, a coil made up of variables C6 and C7, a function block diagram (hereinafter referred to as FBD) “AND (logical sum)”, FBD “+ (adder)”, FBD. A diagram composed of "-(subtractor)" and FBD "> (comparator)" is shown.

  Further, the output of one FBD “+ (adder)” at the connection point t7 is disconnected, and the SG “(signal generation circuit) is connected to the input terminal of the FBD“> (comparator) ”behind the other connection point t7. ) "Shows a diagram for debugging to apply the signal generated.

  FIG. 9A shows a source control program before change created based on this diagram, and FIG. 9B shows a source control program after change.

  The changed source control program uses the “SUMP” command in one step 31 of the connection point as the “JUMP” command and its internal variable (50) as the destination step number. And

Then, a debug program composed of a plurality of instructions of Step 50 to Step 50 _{+ i−2} stored in a different area from the object control program is inserted, and the result is stored as an internal variable (t7) in Step 50 _{+ i−1.} STORE "instruction.

In step 50 _{+ i} , instead of the “LOAD” instruction in step 32 which is the other connection point of the source control program before the change, a “JUMP” instruction with its internal variable set to 32 is used, and the debug program is changed to the original program before the change. Return to step 32 of the source control program.

  Therefore, not only the conventional on / off signal debugging, but also a signal having a degree of freedom can be applied, so that accurate debugging is possible.

  In this way, the “JUMP” instruction is inserted into one of the connection points, the debug program stored in a different memory area from the control program before the change is executed, and the “JUMP” instruction is inserted into the other before the change. Debugging of programmable controller diagrams that can be easily inserted and restored to the original program by changing only one step of the control program before the change by returning to the connection point of the control program A system, a programming device thereof, and a program thereof can be provided.

  Next, with reference to FIG.10 and FIG.11, the debugging system of the PLC diagram of Example 2 of this invention is demonstrated. The same parts of the second embodiment as those of the PLC debugging system of the first embodiment shown in FIG.

  The difference between the second embodiment and the first embodiment is that the wire force setting processing unit 11 of the first embodiment disconnects one connection destination of the connection points, inserts a new debug program, and outputs the debug program. Is connected to the other connection point, but in the third embodiment, one connection destination of the connection point is connected to the input end of a new debug program, and the connection to the other connection destination is disconnected and inserted. The difference is that the output of the debug program is connected to the other connection point.

  This will be described with reference to the diagram of FIG. FIG. 10 shows a contact made up of variables C1 to C5, a coil made up of variables C6 and C7, a function block diagram (hereinafter referred to as FBD) “AND (logical sum)”, FBD “+ (adder)”, FBD. The output of one FBD “+ (adder)” at the connection point t7 of the diagram composed of “− (subtractor)” and FBD “> (comparator)” is input to the CFun (correction function generator). Is connected to the input terminal of the FBD “> (comparator)” behind the other connection point t7, and the output terminal of the CFun (correction function generating circuit) is connected to the FBD “> (comparator). ) "Shows the modified diagram connected to the input.

  FIG. 11A shows a source control program before change created based on this diagram, and FIG. 11B shows a source control program after change.

  The “LOAD” instruction at one of the connection points of the changed source control program is set as the “JUMP” instruction and its internal variable (50).

Then, a debug program composed of a plurality of instructions of Step 50 to Step 50 _{+ j-3} stored in a memory area different from that of the source control program before the change is inserted, and the result is an internal variable (t7) in Step 50 _{+ j-2.} As a “STORE” instruction.

Then, in step 50 _{+ j−1} , the “LOAD” instruction is read to read the internal variable (t7) of the source control program before the change, and “JUMP” is returned to step 32 in the object control program before the change in step 50 _{+ j.} Write and execute the changed object control program as an instruction.

  Therefore, debugging can be performed by accurately correcting signals between diagrams.

  Thus, the control program before the change is inserted by inserting the “JUMP” instruction at one of the connection points, executing the debug program in a different memory area, and inserting the “JUMP” instruction to return to the other connection point. A debugging system for a programmable controller diagram that can easily insert a debugging program at a connection point of the diagram or restore the program before the change by changing only one step of the program, and a programming apparatus and program thereof I can do it.

  The present invention is not limited to the above-described embodiment, and the “JUMP” instruction for changing only one step of the connection point before the change is inserted and the circuit of the diagram is changed or changed. Any point may be used as long as it connects the input end of the program composed of a plurality of instructions to the point and returns the output end of the inserted program to the other connection point before the change. Various programs can be modified and inserted as long as they are not.

The block diagram of the debug system of the programmable controller of this invention. 2 is an example diagram of the present invention. The example of a setting of the internal variable of the connection point of this invention. The example of a setting of the cutting | disconnection between the connection points of this invention. The example of a setting of the internal variable at the time of the cutting | disconnection between the connection points of this invention. The flowchart of the setting operation of the internal variable at the time of the cutting | disconnection between the connection points of this invention. The example of the dialog box of the wire force setting between the connection points of this invention. The example of the diagram of Example 1 of this invention. The example of the debug program of the diagram of Example 1 of this invention. The example of the diagram of Example 2 of this invention. The example of the debug program of the diagram of Example 2 of this invention.

Explanation of symbols

1 Programming device 2 Programmable controller (PLC)
11 arithmetic processing unit 11a control program editing processing unit 11a1 program compiler 11a2 program load client unit 11b wire force setting processing unit 12 storage unit 12a source file unit 12a1 source control program 12a2 source debug program 12b object control program file unit 13 display unit 14 input Unit 14a keyboard 14b mouse 15 communication interface 21 arithmetic processing unit 22 memory unit 23 input / output unit 25 communication interface

Claims (6)

A programming device of a programmable controller that creates a diagram created in a ladder diagram language or a function block diagram language on a display screen and creates an object control program based on the diagram, and the programmable that loads and executes the object control program A diagram debugging system consisting of a controller,
A first instruction for generating the diagram and designating connection / disconnection / connection destination on one input side of the connection point with respect to the connection point connecting the symbols of the diagram displayed on the display screen Control for creating the object control program for generating the first internal variable and the second instruction / second internal variable for specifying the connection / disconnection / the connection destination on the other output side of the connection point A program editing processing unit;
The first instruction / first internal variable is changed to a third instruction / third internal variable, the third instruction / third internal variable is changed to the second instruction / second internal variable, respectively. In a programming device comprising: a wire force setting processing unit that instructs to rewrite any one of the fourth instruction / fourth internal variable to a fourth instruction / fourth internal variable, respectively, of the two internal variables;
The debugging in which the first instruction is stored in a memory area different from the memory area in which the object control program of the controller is stored for the connection point including the “STORE” instruction and the second instruction including the “LOAD” instruction. The third “JUMP” instruction step with the top address of the program as a third internal variable;
Furthermore, a program step comprising a plurality of instruction groups starting from the head address,
A “SORE” instruction step for storing the calculation result of the program as the first internal variable;
A “JUMP” instruction step in which the step destination of the second instruction of the object control program is an internal variable;
And generating a debug program comprising the second “LOAD” instruction step for writing the operation result as a second internal variable.
The debug program is transmitted to the controller to rewrite the object control program, and the debug program is inserted into the connection point during execution of the object control program so that the diagram can be debugged. And a programmable controller diagram debug system. A programming device of a programmable controller that creates a diagram created in a ladder diagram language or a function block diagram language on a display screen and creates an object control program based on the diagram, and the programmable that loads and executes the object control program A diagram debugging system consisting of a controller,
A first instruction for generating the diagram and designating connection / disconnection / connection destination on one input side of the connection point with respect to the connection point connecting the symbols of the diagram displayed on the display screen Control for creating the object control program for generating the first internal variable and the second instruction / second internal variable for specifying the connection destination / non-connection on the other output side of the connection point / the connection destination A program editing processing unit;
The first instruction / first internal variable is changed to a third instruction / third internal variable, the third instruction / third internal variable is changed to the second instruction / second internal variable, respectively. In a programming device comprising: a wire force setting processing unit that instructs to rewrite any one of the fourth instruction / fourth internal variable to a fourth instruction / fourth internal variable, respectively, of the two internal variables;
The first instruction is a “STORE” instruction, the second instruction is a connection point consisting of a “LOAD” instruction, and the fourth instruction and its internal variable are a memory area in which the object control program is stored. A "JUMP" instruction having an internal variable as the start address of the debug program stored in a different memory area,
In the step of the head address, an instruction step of “LOAD” the first internal variable;
A program consisting of a plurality of instruction groups starting from the head address;
A “SORE” instruction for storing the operation result of the program as the first internal variable; and a “LOAD” instruction step for writing as the first internal variable;
Further, a debug program comprising a “JUMP” instruction step for returning to the object control program, wherein the step destination of the instruction next to the second instruction is an internal variable is generated,
The debug program is transmitted to the controller to rewrite the object control program, and the debug program is inserted into the connection point during execution of the object control program so that the diagram can be debugged. And a programmable controller diagram debug system. A programming device of a programmable controller that creates a diagram created in a ladder diagram language or a function block diagram language on a display screen and creates an object control program based on the diagram, and the programmable that loads and executes the object control program A diagram debugging system programming device comprising a controller,
The programming device generates the diagram and designates connection / disconnection / connection destination on one input side of the connection point with respect to a connection point connecting the symbols of the diagram displayed on the display screen. The object control for generating a first command / first internal variable to be generated and a second command / second internal variable for designating a connection / disconnection / connection destination on the other output side of the connection point A control program editing processing unit for creating a program;
The first instruction / first internal variable is changed to a third instruction / third internal variable, the third instruction / third internal variable is changed to the second instruction / second internal variable, respectively. A wire force setting processing unit for instructing to rewrite any one of the fourth instruction / fourth internal variable into a fourth instruction / fourth internal variable, respectively, of the two internal variables,
The debugging in which the first instruction is stored in a memory area different from the memory area in which the object control program of the controller is stored for the connection point including the “STORE” instruction and the second instruction including the “LOAD” instruction. The third “JUMP” instruction step with the top address of the program as a third internal variable;
Furthermore, a program step comprising a plurality of instruction groups starting from the head address,
A “SORE” instruction step for storing the calculation result of the program as the first internal variable;
A “JUMP” instruction step in which the step destination of the second instruction of the object control program is an internal variable;
And generating a debug program comprising the second “LOAD” instruction step for writing the operation result as a second internal variable.
Debugging a diagram of a programmable controller, wherein the debug program is transmitted to the controller to rewrite the object control program, and the debug program is inserted at the connection point during execution of the object control program System programming device. A programming device of a programmable controller that creates a diagram created in a ladder diagram language or a function block diagram language on a display screen and creates an object control program based on the diagram, and the programmable that loads and executes the object control program A diagram debugging system programming device comprising a controller,
The programming device generates the diagram and designates connection / disconnection / connection destination on one input side of the connection point with respect to a connection point connecting the symbols of the diagram displayed on the display screen. The object control for generating a first command / first internal variable to be generated and a second command / second internal variable for designating a connection / disconnection / connection destination on the other output side of the connection point A control program editing processing unit for creating a program;
The first instruction / first internal variable is changed to a third instruction / third internal variable, the third instruction / third internal variable is changed to the second instruction / second internal variable, respectively. A wire force setting processing unit for instructing to rewrite any one of the fourth instruction / fourth internal variable into a fourth instruction / fourth internal variable, respectively, of the two internal variables,
The first instruction is a “STORE” instruction, the second instruction is a connection point consisting of a “LOAD” instruction, and the fourth instruction and its internal variable are a memory area in which the object control program is stored. A "JUMP" instruction having an internal variable as the start address of the debug program stored in a different memory area,
In the step of the head address, an instruction step of “LOAD” the first internal variable;
A program consisting of a plurality of instruction groups starting from the head address;
A “SORE” instruction for storing the operation result of the program as the first internal variable; and a “LOAD” instruction step for writing as the first internal variable;
Further, a debug program comprising a “JUMP” instruction step for returning to the object control program, wherein the step destination of the instruction next to the second instruction is an internal variable is generated,
Debugging a diagram of a programmable controller, wherein the debug program is transmitted to the controller to rewrite the object control program, and the debug program is inserted at the connection point during execution of the object control program System programming device. A programming device of a programmable controller that creates a diagram created in a ladder diagram language or a function block diagram language on a display screen and creates an object control program based on the diagram, and the programmable that loads and executes the object control program A diagram debugging system program comprising a controller,
The programming device generates the diagram and designates connection / disconnection / connection destination on one input side of the connection point with respect to a connection point connecting the symbols of the diagram displayed on the display screen. The control program for generating a first command / first internal variable to be executed and a second command / second internal variable for designating a connection / disconnection / connection destination on the other output side of the connection point A control program editing function to be created;
The first instruction / first internal variable is changed to a third instruction / third internal variable, the third instruction / third internal variable is changed to the second instruction / second internal variable, respectively. A wire force setting processing function for instructing to rewrite any one of the fourth instruction / fourth internal variable to a fourth instruction / fourth internal variable, respectively,
The debugging in which the first instruction is stored in a memory area different from the memory area in which the object control program of the controller is stored for the connection point including the “STORE” instruction and the second instruction including the “LOAD” instruction. The third “JUMP” instruction step with the top address of the program as a third internal variable;
Furthermore, a program step comprising a plurality of instruction groups starting from the head address,
A “SORE” instruction step for storing the calculation result of the program as the first internal variable;
A “JUMP” instruction step in which the step destination of the second instruction of the object control program is an internal variable;
A program for a debug system of a diagram of a programmable controller, further comprising a debug program comprising the second “LOAD” instruction step for writing the operation result as a second internal variable. A programming device of a programmable controller that creates a diagram created in a ladder diagram language or a function block diagram language on a display screen and creates an object control program based on the diagram, and the programmable that loads and executes the object control program A diagram debugging system program comprising a controller,
The programming device generates the diagram and designates connection / disconnection / connection destination on one input side of the connection point with respect to a connection point connecting the symbols of the diagram displayed on the display screen. The control program for generating a first command / first internal variable to be executed and a second command / second internal variable for designating a connection / disconnection / connection destination on the other output side of the connection point Control program editing function to be created,
The first instruction / first internal variable is changed to a third instruction / third internal variable, the third instruction / third internal variable is changed to the second instruction / second internal variable, respectively. A wire force setting processing function for instructing to rewrite any one of the fourth instruction / fourth internal variable to a fourth instruction / fourth internal variable, respectively,
The first instruction is a “STORE” instruction, the second instruction is a connection point consisting of a “LOAD” instruction, and the fourth instruction and its internal variable are a memory area in which the object control program is stored. A "JUMP" instruction having an internal variable as the start address of the debug program stored in a different memory area,
In the step of the head address, an instruction step of “LOAD” the first internal variable;
A program consisting of a plurality of instruction groups starting from the head address;
A “SORE” instruction for storing the operation result of the program as the first internal variable; and a “LOAD” instruction step for writing as the first internal variable;
Debugging a diagram of a programmable controller, further comprising a “JUMP” instruction step for returning to the object control program, wherein the step destination of the instruction next to the second instruction is an internal variable System program.

Images