JPH0651973A - Error correction method for sequence program - Google Patents

Abstract

PURPOSE:To easily perform the correction of a sequence program by preserving a program instruction in which an error occurs separately from the sequence program, and correcting it after the sequence program is generated and completed. CONSTITUTION:When the sequence program in sequence memory 12 is corrected, all the contents of program memory 12 are transferred to an editor buffer 13. Also, the contents of the buffer 13 are stored in the program memory 12 at a stage where all the results of programming are completed. When it is decided that the error exists in discrimination, a program instruction of error presence is preserved and stored separately from the sequence program, and a the program instruction preserved and stored when the sequence program is generated or edit is completed is displayed, and a displayed program instruction is set as a correction target. Therefore, since an operator can input the sequence instruction without being conscious of the error, which enables the program to be inputted even by a person who is unfamiliar to a sequence circuit.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a sequence program error correction method for correcting a sequence program error when a sequence program for a programmable controller is created and edited in a programming device.

[0002]

2. Description of the Related Art FIG. 7 shows the relationship between a programmable controller and a programming device. The programming device is connected to the programmable controller via a transmission line, creates a sequence program executed by the programmable controller, and monitors the operating state of the sequence program executed in the programmable controller. FIG. 8 shows a display screen of the programming device during programming. The user repeatedly performs programming by repeatedly adding, inserting, deleting, etc. contacts, coils, etc. of the sequence circuit constituting the sequence program on this display screen. More specifically, when the user inputs a command relating to the program modification from the keyboard, the programming device modifies the program based on this command and displays the modification result.

FIG. 9 shows the flow of program information relating to program modification.

When the user designates an arbitrary portion of the program memory in the programming device and gives an instruction to read the program, the programming device once reads the program designated contents of the program memory into the object buffer, and then the object buffer. Convert to a graphic image file above (this is called decompilation). Thereafter, the programming device uses the graphic image file to display the program contents on the screen.

The contents of the program memory are not stored in graphical form as shown in FIG.
It is stored in machine instruction code form such that the programmable controller can execute the program. These instruction code groups correspond to object files in the field of computers. The above-mentioned graphic image file corresponds to the source file in the computer field. Since the programmable controller has conventionally been characterized by an interpreter system, it is rare to have a source file corresponding to an object program stored in a program memory. Generally, as an intermediate file for creating and editing a program at the time of programming, more specifically, as a file composed of a character code and a control code, it often has a temporary limited range of source files. .

When the program is stored, the program information after being created and edited is transferred to the program memory in the reverse procedure of the above. More specifically, when storage is instructed by the user, the programming device converts the contents of the screen image file on the object buffer into object code (machine instruction code) (this is called compilation). The programming device stores by replacing the converted object code with the original contents of program memory.

As described above, at the time of programming, the user repeatedly performs "read" and "store" instruction operations with respect to the program memory. At the time of compilation, a grammatical check of the program contents is performed, and if the screen image file has incomplete contents (program command error in programming), an error warning is issued. Further, the programming device is configured so that the user cannot correct the error location before the next "reading" of the program content can be performed.

[0008]

However, in general, when a program is edited, the presence or absence of an error in the input sequence command is checked, and the error of the sequence program cannot be entered until the error is eliminated before proceeding to the next editing process. The correction method had the following drawbacks.

(1) When an identification name is given to a component of a sequence circuit that constitutes a sequence program, the identification name cannot be determined unless the entire sequence circuit or the context is taken into consideration. When a program is input on the device, a detailed program including an identification name must be designed.

(2) If the program error is not resolved, the next program editing process will not progress. Therefore, when a beginner in the programming process edits the program, the editing process takes time.

Although it has been practiced to detect a program error collectively after creating the entire sequence program, this method has the following drawbacks.

(1) When an object or source program is to be checked, the operator is in a waiting state while the programming device is detecting an error, and at first glance, the error detection process takes time. Gives the operator the impression of

(2) When a person other than the program creator handles the sequence program, the sequence program is a program in the process of creation in which errors are mixed, or
It is difficult to determine whether the program is after error resolution (debug processing).

As described above, the conventional method of correcting a sequence program after detecting an error has advantages and disadvantages, and a more effective error correcting method is desired when creating a program.

Therefore, in view of the above points, an object of the present invention is to provide an error correcting method for a sequence program, in which the program can be easily corrected.

[0016]

In order to achieve such an object, a first aspect of the present invention is to detect the presence or absence of an error in a program command for each input of a program command for creating or editing a sequence program. In the error correction method of a sequence program for making a determination, when an error is obtained in the determination, the program command having the error is stored and stored separately from the sequence program, and the sequence program is created or It is characterized in that the program instructions stored and stored at the end of editing are displayed, and the displayed program instructions are targeted for correction.

In addition to the first aspect of the present invention, the second aspect of the present invention further comprises:
The first position indicating that there is an error at the scheduled position in the sequence program where the program command with the error is described.
It is characterized in that information and second information indicating a storage position of the program instruction with the error are described.

In addition to the first aspect of the present invention, in the third aspect of the present invention, when an error is obtained in the determination, a memory for storing the sequence program until the program instruction with the error is corrected. Is controlled so as to prohibit the transfer of the sequence program to the outside.

[0019]

According to the first aspect of the invention, the program instruction in which an error has occurred is stored separately from the sequence program, and is corrected when the sequence program is created / finished. In the second invention, since the first information and the second information are described at the planned position of the error program instruction on the sequence program, it is easy to read and replace the error program instruction relating to the display and correction of the error program. Becomes
In the third invention, since the unfinished sequence program is not output to the outside, the programmable controller does not malfunction.

[0020]

Embodiments of the present invention will now be described in detail with reference to the drawings.

A circuit configuration of a programming device to which the present invention is applied is shown in FIG.

In FIG. 2, the central processing unit (CP
U) 10 executes program creation / editing processing, programmable controller monitoring processing, and overall apparatus control processing according to various programs stored in the system memory 11.

In this embodiment, the program memory 12 stores a prepared sequence program having no error. The sequence program on the program memory 12 is transferred to the programmable controller. The editor buffer 13 stores a sequence program to be edited (including creation) in the form of a machine instruction code.

When modifying the sequence program of the program memory 12, the entire contents of the program memory 12 are transferred to the editor buffer 13. Further, the contents of the editor buffer 13 are stored in the program memory 12 when all the programming results are completed. In the middle of programming, editor buffer 1
Partial programs on 3 are subject to decompilation and compilation. The object buffer 14 temporarily stores a partial program to be compiled.

The screen image file memory 15 stores a partial screen program (graphic notation) for one screen displayed on the display 16 in the form of an intermediate language such as a character code. The display 16 is a screen image file memory 15
The sequence program stored in is read out at regular intervals and converted into an image pattern for display. The error file memory 17 stores the partial sequence program in which an error has occurred in the form of an intermediate language. The interface (I / O) 18 transfers information signals exchanged between the CPU 10 and the programmable controller. The keyboard 19 is a program command or CP used for programming.
Input an operation instruction to U10.

The correction operation of the sequence program in such a configuration will be described below. As an example, a case where the sequence program stored in the sequence program memory 12 is modified will be described.

The operator inputs a transfer command from the keyboard 19 and instructs the CPU 10 to transfer the sequence program on the sequence program memory 12 to the editor buffer 13. As a result, the sequence program to be edited is loaded on the editor buffer 13. The user can use the editor buffer 13 as shown in FIG.
If you specify the position of the upper partial sequence program c,
The CPU 10 transfers the designated sequence program to the object buffer 14. The CPU 10 decompiles the program information in the object buffer 14 and displays the circuit shown in FIG. 4 in the form of a sequence circuit diagram. At this point, the additional correction circuit AA of FIG.
Is not included in the screen display.

The operator uses the keyboard 19 to specify the cursor on the correction position on the display screen, and in the case of FIG. 4, instructs the insertion of a contact command. The CPU 10 inserts the input program command into the screen image file memory 15 and temporarily stores it in the object buffer 14. As a result, the program command inserted on the screen image file is imaged by the display 16 together with other program commands, and is visually displayed as in the circuit AA in FIG.

Next, the CPU 10 activates the control procedure shown in FIG. 5 and compiles the program information in the object buffer 14 (step S1). In this compilation, as in the conventional case, the CPU 10 determines the presence or absence of a program error by grammatical analysis of the program instruction to be compiled (step S2). When the circuit identification name is not input as in the circuit AA in FIG. 4, an error determination is obtained, so the CPU 10 stops the compilation process, and the execution procedure of the CPU 10 proceeds to step S4.
Here, the CPU 10 stores in the editor buffer 13
Originally, the error information is registered at the position where the program instruction of the added circuit is inserted, and the program instruction (intermediate language form) in which the error has occurred is cumulatively stored in the error file memory 17 in the next step (step S
5).

The editor buffer 13 is composed of 1 step instruction = 3 bytes, the first byte is the instruction part,
The second and third bytes are assigned to the address part representing the identification name. Therefore, in this embodiment, a pseudo program instruction using FF (hexadecimal number) as the first information of the present invention is inserted into the sequence program on the editor buffer 13 in the instruction portion of the first byte. This indicates that an error circuit exists at this insertion position. Also,
At the second and third bytes of this pseudo instruction, the storage address (second information of the present invention, referred to as a pointer) on the error file memory 17 of the intermediate language program instruction determined to be an error is stored by the CPU 10. Enter.

On the other hand, when the result of determination that there is no error is obtained in step S2, the CPU 10 sends the compiled program instruction (machine code form) to the editor buffer 1.
3 (step S3).

In the above procedure, the insertion of the program instruction is explained as an example of editing, but in addition, deletion of
It goes without saying that the CPU 10 inserts a pseudo-instruction indicating an error occurrence at the program description stop position on the editor buffer 13 where an error has occurred in relation to replacement, movement or the like.

In this way, when there is an error in the program command input for editing, the error command is stored in the error file memory 17, and the error command in the sequence program in the editor buffer 13 is edited. A pseudo instruction indicating the existence of the error instruction and the storage location of the error instruction on the error file memory 17 is inserted at the expected position.

Therefore, unlike the conventional case, the editing process of the operator is not interrupted every time an error occurs, and the editing process of the program can be smoothly continued. When the operator makes a key input from the keyboard 19 to finish the program editing, the CPU 10 activates the control procedure of FIG. 6, searches the sequence program in the editor buffer 13, and detects a pseudo instruction indicating the presence of an error (step S10
0 → S101 → S102). Then, the CPU 10 reads the error sequence command from the address on the error file memory 17 indicated by the pointer in the detection pseudo command and writes it in the screen image file memory 15 to display the error sequence command on the display unit 16. (Steps S103 → S104).

When the CPU 10 receives the edit command from the keyboard 19, it compiles the sequence command (intermediate language form) on the screen image file memory 15. If no error occurred during compilation, CPU
Reference numeral 10 replaces the pseudo instruction on the editor buffer 13 with the sequence instruction after compilation (steps S105 to S105).
S107). If an error occurs during this compilation, the execution procedure of the CPU 10 is step S106 → S105.
Therefore, the execution procedure cannot escape from the loop processing of steps S105 to S106 unless the error of the sequence instruction is resolved. Therefore, the control procedure of FIG. 6 has a program configuration in which the sequence instruction in which an error has occurred cannot be mixed in the sequence program in the editor buffer 13.

Thereafter, the CPU 10 uses the editor buffer 1
Every time a pseudo-instruction is detected from the above sequence program 3, system processing relating to correction of an error instruction is performed. Since the correction of the error command is completed when the search is completed, the CPU 10 accepts an output command related to the sequence program in the editor buffer 13, for example, writing to the sequence program memory 12 or the like.
The output process of the sequence program from the buffer 13 is executed (steps S100 → S110 → S111).

As described above, in the present embodiment, when the operator edits the program, the sequence command in which the error has occurred is automatically saved in another file and displayed at the end of the program edit. Also, unless the error sequence instruction is corrected correctly, the editor buffer 13
Since the above sequence program cannot be externally output, the sequence program in which a program error has occurred is not transferred to the programmable controller or the like.

In addition to this embodiment, the following example can be carried out.

1) This embodiment deals with the program editing process as an example, but the same applies to the creation of a new program.
In this case, it is assumed that a blank blank edit target sequence program exists in the editor buffer 13 at the start of creating a new program.

2) In this embodiment, a sequence program including an error is not stored in the editor buffer 13,
Also, the system is configured not to output externally,
When it is desired to temporarily store the sequence program in the process of being created on a floppy disk or the like, the following process may be performed.

That is, at the end of the program creation, the operator determines whether or not to store the program in the floppy disk.
If there is this instruction, the CPU 10 does not execute the control procedure of FIG. 6 and stores the sequence program on the editor buffer 13 and the error instruction of the error file memory 17 in the floppy disk as a set of data. To do. When transferring the above data from the floppy disk to the editor buffer 13, the CPU 10 confirms the presence or absence of pseudo instructions, and the error instruction
Re-register in the memory 17. At this time, if the error command (circuit) is automatically displayed, the operator knows that the sequence program to be edited has an error.

3) When displaying the error sequence instruction, it is preferable to display not only the circuit figure (decompilation result) but also the error content.

4) In the present embodiment, no error detection is displayed when a program error is detected, but a display indicating that an error has occurred is provided for warning purposes, for example, a lighting display is given to a program command in which an error has occurred. Of course, you can do that.

[0044]

As described above, according to the present invention, the operator can input a sequence command without worrying about an error, so that, for example, a person who does not understand the sequence circuit such as a key puncher. It is also possible to adopt a program creating method in which a person who understands the sequence program corrects the error after inputting the sequence program. Further, since the program command in which the error has occurred does not coexist with the sequence program to be created / edited, the safety for the entire system is maintained.

[Brief description of drawings]

FIG. 1 is an explanatory diagram showing the contents of sequence program related data according to an embodiment of the present invention.

FIG. 2 is a block diagram showing a circuit configuration of an embodiment of the present invention.

FIG. 3 is an explanatory diagram showing an editing order of a sequence program.

FIG. 4 is an explanatory diagram showing a display example of a sequence program.

5 is a flowchart showing a control procedure executed by the CPU 10 of FIG.

FIG. 6 is a flowchart showing a control procedure executed by the CPU 10 of FIG.

FIG. 7 is a perspective view showing an appearance of a conventional system.

FIG. 8 is an explanatory diagram showing a display example of a sequence program.

FIG. 9 is an explanatory diagram showing a conventional editing procedure.

[Explanation of symbols]

 10 CPU 12 Program memory 13 Editor buffer 17 Error file memory

Claims (3)

[Claims] 1. An error correction method for a sequence program, which determines whether or not there is an error in the program instruction for each input of a program instruction that is a target for creating or editing a sequence program, wherein an error is obtained in the determination. If the error occurs, the program command with the error is stored and stored separately from the sequence program, and the stored and stored program command is displayed at the end of the creation or editing of the sequence program. A method for correcting an error in a sequence program, characterized in that a program instruction is a target for correction. 2. When an error is obtained in the determination, further, the first information indicating the error and the error are present at the scheduled position on the sequence program of the program command with the error. 2. The error correcting method for a sequence program according to claim 1, wherein the second information indicating the storage location of the program instruction is described. 3. When it is determined that there is an error in the determination, it is prohibited to transfer the sequence program from the memory storing the sequence program to the outside until the program command with the error is corrected. The method for correcting a sequence program according to claim 1, wherein the method is modified so that the sequence program is controlled.