JP3443184B2 - Programmer for programmable controller - Google Patents

Description

Description: BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program creating apparatus for creating a program for a programmable controller. 2. Description of the Related Art Programmable controllers are used to sequentially control controlled devices.
FIG. 4 is a block diagram showing a configuration of a general programmable controller. The programmable controller 100 shown in FIG.
Includes a CPU (Central Processing Unit) 11, a RAM (Random Access Memory) 12, a ROM (Read Only Memory) 13, an input unit 14, an output unit 15, and a communication interface 16. The input unit 14 is connected to input devices such as switches and sensors, and the output unit 15 is an electromagnetic switch, a relay,
Output devices such as solenoids and motors are connected. ROM
13 stores a system program for controlling the entire operation of the programmable controller 100. The RAM 12 stores a user program storage unit 1
21 and a data storage unit 122. The user program storage unit 121 stores a user program for sequentially controlling a controlled device. The data storage unit 122 stores device information and other various data. Here, the device information includes an input state from the input device to the input unit 14, an output state from the output unit 15 to the output device, and internal relays (input relay, output relay, and auxiliary relay) set on the user program. This is information indicating states of a timer, a counter, a data memory, and the like (hereinafter, referred to as an internal state), and a device is a name indicating an area on a memory provided for storing device information. The CPU 11 controls each part in the programmable controller 100 according to the system program stored in the ROM 13 and executes the user program stored in the user program storage unit 121. FIG. 5 shows a programmable controller 100.
5 is a flowchart showing a basic operation of the embodiment. First, the state of the input device is input to the input unit 14, and the input state is represented by R
Writing to the data storage unit 122 of the AM 12 (Step S
1). This is called input refresh. Next, one scan of the user program stored in the user program storage unit 121 is executed based on each device information of the data storage unit 122 (step S).
2). Here, one scan means to execute one instruction of the main routine. Each device information in the data storage unit 122 is updated by executing the user program. Thereafter, the output state of the data storage unit 122 is read, and the output state is output to an output device via the output unit 15 (step S3). This is called output refresh. The above input refresh (step S
1), the controlled device is sequentially controlled by repeatedly executing one scan of the user program (step S2) and refreshing the output (step S3). In the above-described programmable controller 100, the user program is created, for example, by
This is performed on the program creation device using a ladder diagram as shown in FIG. In FIG. 6, X1, X2, X3, X
4, X5, Y1, and Y2 indicate device numbers. Devices X1, X2, X3, and X5 indicate contacts that turn on during operation, and device X4 indicates contacts that turn off during operation. In part a of this example, the state of the device X1 is input, an AND operation is performed between the state and the state of the device X2, and the result of the operation is output to the device Y1. The ladder diagram is converted into a user program by the program creating device and stored in the user program storage section 121 of the RAM 12. When debugging the user program, the debugging device 200 composed of a personal computer or the like is connected to the communication interface 16 of the programmable controller 100 using a serial line conforming to an interface standard such as RS-232C or RS-422. A ladder diagram is displayed on a CRT display or a liquid crystal display connected to the debug device 200 while executing the user program stored in the user program storage unit 121 one scan at a time. The device information stored in the data storage unit 122 is changed by the operation, and the device information in the data storage unit 122 is appropriately read out to the debug device 200 via the communication interface 16. in this way,
The user performs a debugging operation by changing device information while viewing the ladder diagram. In the above-described method, the debugging device 200 and the programmable controller 10 are compared with each other in comparison with the execution speed of one scan of the user program.
Since the communication speed of data between 0 and 0 is low, data is lost or garbled, and the state of the ladder diagram displayed on the screen may be different from the actual state of the programmable controller 100. For this reason, it is difficult to determine the location to be debugged in the user program based on the ladder diagram, and it is difficult to perform the debugging work unless a skilled technician. Therefore, there has been proposed a software creating apparatus capable of creating and debugging a user program while simulating the programmable controller on a personal computer without connecting to the programmable controller. In this software creating apparatus, a user creates a ladder diagram on a personal computer and creates a time chart in advance by predicting the operation of the programmable controller from the ladder diagram. Then, the operation of the programmable controller is simulated on the personal computer based on the ladder diagram created by the user, and the simulation result is displayed as a time chart. The user compares the previously created time chart with the time chart obtained from the simulation result, and corrects the ladder diagram if they are different. Create a correct ladder diagram by repeating the above operations. In such a software creating apparatus, since a user program can be created and debugged without connecting to a programmable controller, there is no problem of data loss or data corruption due to data communication. However, only the state before and after the execution of one scan of the user program can be checked, and a change in the state during execution cannot be traced. Therefore, it is not easy to create and debug a user program based on a ladder diagram and a time chart unless a skilled technician is used. An object of the present invention is to provide a program creating apparatus capable of easily and accurately creating and debugging a user program. According to the present invention, there is provided a program creating apparatus for a programmable controller, comprising:
When creating a program for a programmable controller that operates in relation to the output state and internal state,
A program created device that functions as over data, create
Program storage means for storing the stored program,
Input state setting means for setting the force state, and input state setting means
Input and output states set by the stage
State storage means for storing unit states, and program storage means
Instruction list that displays the instruction list of the program stored in
List display means and instruction list display means.
Instruction pointer that indicates the instruction to be executed in the instruction list
One step for each instruction by instruction and instruction instruction means
Instruction execution means for executing each instruction;
After the execution of the instruction of the step, the input stored in the state storage means
Status display means for displaying status, output status and internal status
After the execution of the one-step instruction by the instruction execution means,
Input state, output state and internal state stored in the state storage means
State changing means capable of changing the state. In the program creating device for a programmable controller according to the present invention, an instruction list of the program stored in the program storage means is displayed by the instruction list display means. When the user instructs the command instruction means an instruction to be executed in the display instruction list, life
The instruction is executed by the instruction executing means one step at a time for each instruction by the instruction instructing means, and the input state, output state and internal state stored in the state storage means are displayed by the state display means. Therefore, the user can accurately grasp changes in the input state, the output state, and the internal state before and after the execution of the program instruction. Also the user
Indicates the state after the execution of the one-step instruction by the instruction execution means.
Input state, output state or internal stored in the state storage means
The state can be changed by the state changing means. As described above, by executing the program instructions one step at a time while viewing the instruction list and tracing changes in the input state, output state and internal state, the work of creating and debugging the program is facilitated. According to the program creating apparatus,
Since a program creating operation and a debugging operation can be performed without connecting to the programmable controller, data loss or data corruption due to data communication between the program creating device and the programmable controller does not occur. FIG. 1 is a block diagram showing a configuration of a program creating apparatus according to one embodiment of the present invention. The program creation device 1 of FIG. 1 includes a user program creation unit 2, a user program storage unit 3, a device status storage unit 4, a device status change unit 5, a device status display unit 6, a mnemonic display unit 7, and a mnemonic execution unit. 8,
An execution instruction unit 9 and a communication interface 10 are included. The user program creation unit 2 creates a user program according to the ladder diagram created by the user, and stores it in the user program storage unit 3. The device state storage unit 4 stores an input state from an input device, an output state to an output device, and internal states such as an internal relay, a timer, a counter, and a data register. Hereinafter, these input state, output state, and internal state are referred to as device states.
The device status change unit 5 sets or changes the device status stored in the device status storage unit 4 by a user operation. The device status display unit 6 displays the device status stored in the device status storage unit 4. The mnemonic display section 7 converts the user program stored in the user program storage section 3 into a mnemonic list and displays the mnemonic list. The execution instruction unit 9 instructs the mnemonic execution unit 8 to execute one step specified by the user in the mnemonic list displayed by the mnemonic display unit 7. Mnemonic execution unit 8
Executes the mnemonic specified by the execution instructing unit 9 one step at a time. The user program stored in the user program storage unit 3 can be transferred to the user program storage unit 121 of the programmable controller 100 shown in FIG. FIG. 2 is a diagram showing an example of a display screen displayed by the program creating device 1 of FIG. On the screen 20, a mnemonic display window 21 is displayed by the mnemonic display unit 7, and a device status display window 22 and a timing chart display window 23 are displayed by the device status display unit 6. The mnemonic display window 21 displays a mnemonic list of the user program stored in the user program storage unit 3. The device status display window 22 displays the device status stored in the device status storage unit 4, and the timing chart display window 23 displays changes in the device status stored in the device status storage unit 4 in a timing chart. . In the mnemonic display window 21,
The next mnemonic step to be executed specified by the execution instruction unit 9 is displayed in a frame 24. Also, the user
The device state stored in the device state storage unit 4 can be changed by the device state change unit 5 by designating the “value change” field displayed at the bottom of the screen 20 with the cursor 25. Next, the operation of the program creation device 1 of FIG. 1 during debugging will be described with reference to the flowchart of FIG. First, the mnemonic display unit 7 displays the mnemonic list of the user program stored in the user program storage unit 3 on the mnemonic display window 21 (step S11). When the user requests to change the device state (step S12), the device state changing unit 5
Changes the device status stored in the device status storage unit 4 (step S13). Then, the device status display unit 6 displays the changed device status in the device status display window 22, changes the timing chart in the timing chart display window 23 (step S14), and returns to step S12. If it is determined in step S12 that the user does not request a change in the device state, the process proceeds to step S1.
Go to 5. In step S15, when the user requests execution of one step of the mnemonic via the execution instruction unit 9, the mnemonic execution unit 8 executes the execution instruction unit 9 of the user program stored in the user program storage unit 3.
(Step S16). By executing one step of the mnemonic, the device state stored in the device state storage unit 4 is changed. The device status display section 6 displays the changed device information in the device status display window 22 and displays the change in the device status as a timing chart in the timing chart display window 23 (step S17). Further, the mnemonic display unit 7 displays one step of the mnemonic to be executed next in the mnemonic display window 21 in a frame 24 (step S18),
It returns to step S12. As described above, the user executes the mnemonics of the mnemonic list displayed on the mnemonic display window 21 one step at a time, and changes the device state before and after the execution of each step with the device state display window 22 and the timing. Trace can be performed by the chart display window 23. The device state changing unit 5 monitors the change of the device state every time one step of the mnemonic is executed.
Thus, the device state stored in the device state storage unit 4 can be changed, and the user program stored in the user program storage unit 3 can be modified. As described above, since the change in the device state during the execution of one scan of the user program can be accurately and easily grasped while looking at the mnemonic list, the program creation operation and the debug operation are facilitated. As described above, according to the present invention, it is possible to trace the input state, output state, and internal state before and after execution while executing the instructions in the displayed instruction list one step at a time. Therefore, the execution state during one scan of the program can be accurately grasped while looking at the instruction list. Further, since a program creating operation and a debugging operation can be performed without connecting to the programmable controller, data loss and data corruption due to data communication do not occur. Therefore, the creation and debugging of the program can be performed easily and accurately, and the efficiency of the creation and debugging of the program for the programmable controller can be increased.

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram showing a configuration of a program creating device according to one embodiment of the present invention. FIG. 2 is a diagram showing an example of a display screen of the program creation device of FIG. FIG. 3 is a flowchart showing an operation at the time of debugging of the program creating device of FIG. 1; FIG. 4 is a block diagram illustrating a configuration of a programmable controller. FIG. 5 is a flowchart showing a basic operation of the programmable controller. FIG. 6 is a diagram showing an example of a ladder diagram. [Description of Signs] 1 Program creation device 2 User program creation unit 3 User program storage unit 4 Device status storage unit 5 Device status change unit 6 Device status display unit 7 Mnemonic display unit 8 Mnemonic execution unit 9 Execution instruction unit 10 Communication interface 20 Display screen 21 Mnemonic display window 22 Device status display window 23 Timing chart display window

──────────────────────────────────────────────────続 き Continuation of front page (58) Field surveyed (Int.Cl. ⁷ , DB name) G05B 19/04-19/05

Claims (1)

(57) [Claim 1] A program creation device that functions as a simulator when creating a program for a programmable controller that operates in relation to an input state, an output state, and an internal state. Program storage means for storing the created program; input state setting means for setting an input state; state storage means for storing the input state, output state, and internal state set by the input state setting means; An instruction list display unit for displaying an instruction list of a program stored in the program storage unit; an instruction instruction unit for instructing an instruction to be executed in the instruction list displayed by the instruction list display unit; an instruction execution unit for executing instructions by one step for each instruction that by the means, to said instruction execution means 1 after the step of execution of the instruction, said state storage means the stored the input state, a state display means for displaying the output state and internal state, the execution of the instruction of one step by the instruction execution unit, before
The input state, the output state, and the like stored in the state storage means.
A program creating device for a programmable controller , comprising: a state changing means capable of changing an internal state .