JPH11242509A - Programmable logic controller - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce the time and troubles for program compilation at the time of debug-testing a control program. SOLUTION: The instruction part 14 of a programmable logic controller 1 executes the object code of a control program, which is stored in an object code storage part 16 at a mode except for a debug test mode. When an instruction for switching a system to the debug test mode is given, the object code only on a rang to be executed is read based on execution/non-execution flags stored in a rang management table 13 and it is executed. A rang execution designation part 15 executes the prescribed range from a program generator and sets the execution/non-execution flags of the pertinent rang in the rang management table 13 as an instructed way when an instruction for not executing it is received.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a programmable logic controller for executing a control program for controlling a device to be controlled such as a sensor or an actuator.

[0002]

2. Description of the Related Art Conventionally, a programmable logic controller controls a device to be controlled such as a sensor or an actuator by executing a control program including a ladder program. , The control program is FA (Factory A)
Before the release to the system, an online debug test is performed to check whether the system operates normally.

As an on-line debug test,
One of the methods commonly used in the past is NOP
There is a method using instructions.

According to this method, a ladder program having an instruction (circuit) to be embedded for debugging / testing is created in advance, and an instruction (circuit) not to be executed when executing an online debug test of the ladder program is executed. By inserting a NOP instruction by online editing before the instruction, the instruction is not executed.

The online debug test of a ladder program using the NOP instruction has an advantage that a program check can be performed without changing the step number.

[0006]

However, in the above-described method of executing the online debug test of the ladder program using the NOP instruction, it is necessary to insert the NOP instruction by online edit each time. There was a problem that it required.

SUMMARY OF THE INVENTION In view of the above problems, an object of the present invention is to provide a programmable logic controller which does not require time and effort for program editing when performing a control program online debugging test.

[0008]

SUMMARY OF THE INVENTION In order to achieve the above object, an invention according to claim 1 is a programmable logic controller for executing a control program formed by a rung having a group of instructions as one unit. A rung execution / non-execution flag storage unit having an execution / non-execution flag indicating whether or not to execute the rung, and an execution / non-execution flag stored in the rung execution / non-execution flag storage unit. And a flag correcting means for correcting the flag in response to the request.

According to a second aspect of the present invention, in the first aspect of the present invention, the rung execution / non-execution flag storage means stores a rung start address for each rung and starts execution of the rung. When executing, the instruction is executed from the instruction specified by the rung start address.

In the present invention, a rung for forming a control program is executed based on an execution / non-execution flag indicating whether or not to execute a rung. Therefore, when a debug test is performed, a rung not to be executed is designated in advance. If so, it is not necessary to compile all of the ladder programs again to form the object code again.

[0011]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The configuration of a programmable logic controller according to the present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram showing a configuration of an embodiment of a programmable logic controller according to the present invention.

The programmable logic controller 1 of this embodiment executes a predetermined rung (described later) in a debug test so as to skip (skip) the rung. The source program storage unit 11 and the compile unit 12 , A rung management table 13, an instruction execution unit 14, a rung execution designation unit 15, and an object code storage unit 16.

In describing each component of the programmable logic controller 1 of this embodiment, FIG.
The rung will be described using a control program including a ladder program as shown in FIG. 3 and a mnemonic notation program as shown in FIG. 3 as an example.

In the ladder program as shown in FIG. 2, a rung is a circuit formed between a plurality of contacts connected to the left bus 1H and outputs or instructions connected to the right bus 2H. In a mnemonic notation program as shown in FIG. 3, LD (Loaded instruction)
To a RETURN instruction.

Incidentally, rung 1 shown in FIG. 2 is a circuit A formed by contacts 1a and 1b connected to left bus 1H and output 1c connected to right bus 2H, and rung 2 is a left bus. Contact 2a and contact 2 connected to 1H
b, and a circuit B formed by an instruction to connect to the right bus 2H.

The rung 1 shown in FIG. 3 is an LD instruction having a step number “0000” and a step number “000”.
1 "AND instruction, step number" 0002 "OUT
RETURN of instruction and step number "0003"
The rung 2 is formed from an LD instruction having a step number “0004”, an OR instruction having a step number “0005”, an OR instruction having a step number “0006”, and a RETURN instruction having a step number “0007”. ing.

The address addresses shown in FIG. 3 are the address addresses indicating the storage locations of the object codes for the instructions in each step.

Incidentally, the address of the object code of the contact LD instruction whose step number indicating the start of rung 1 is “0000” is “$ 0000”, and the rung 2
The address of the object code of the LD instruction whose start number is “0004” is “$ 0004”, and the step number indicating the start of rung 3 is “000”.
The address of the object code of the contact LD instruction of “8” is “$ 0008”, and the address of the object code of the END instruction with a step number of “0021” indicating the start of rung 4 is “$ 0021”.

Next, each component of the programmable logic controller 1 of this embodiment will be described.

The source program storage unit 11 includes a sensor,
A source program described in the mnemonic notation program or the ladder program for controlling a device to be controlled such as an actuator is stored.

The compiling section 12 reads the source program stored in the source program storage section 11 (see arrow 1h in the figure), compiles the source program to form an object code, and converts the formed object code into an object code. While being stored in the storage unit 16 (see arrow 2h in the figure), the start address of the object code of each rung is stored in the rung management table 13 (see arrow 8h in the figure).

The rung management table 13 includes a rung number area 131 for storing a number specifying a rung, a rung start address area 132 for storing a start address of each rung, and whether or not the rung is executed by the instruction execution unit 14. Is formed from an execution / non-execution flag area 133 for storing a flag for designating.

Incidentally, the rung 1 indicated by A has a rung start address of “$ 0000” and is a rung to be executed, and the rung 2 indicated by B has “$ 0004” as a rung start address. Is a rung that does not run.

The instruction execution unit 14 executes all the object codes of the control program stored in the object code storage unit 16 except in the debug / test mode (see arrow 7h in the figure). In this case, the RETURN instruction is ignored.

When the instruction execution unit 14 is instructed to switch to the debug / test mode, the instruction execution unit 14 performs an operation based on the execution / non-execution flag stored in the rung management table 13 (see arrow 6h in the figure). The object code is read only for the rung to be executed (arrow 7h in the figure).
See) and do this.

The mode switching in the instruction execution unit 14 is based on a mode switching instruction 5h.

The rung execution specifying unit 15 executes a predetermined rung according to an instruction from the debug tester (see the arrow 3h in the figure) or receives an instruction to disable the rung. The execution / non-execution flag of the corresponding rung is set according to the instruction.

The object code storage section 16 stores the object code of the control program formed by the compiling section 12.

Next, the operation of the programmable logic controller of this embodiment will be described with reference to FIG.

As shown in FIG. 5A, the programmable logic controller of this embodiment performs an OUT refresh process for refreshing I / O information (step 1).
10), an IN refresh process (step 120), a program execution process for executing a control program (step 130), and peripheral processes unrelated to the execution of the control program, for example, a process for outputting the number of processed components, are defined as one cycle. Repeat the process.

Here, step 13 which characterizes the present invention is described.
0 program execution processing will be described.

When receiving an instruction to switch to the debug / test mode, the instruction execution unit 14 determines whether the run / non-execution flag of rung 1 stored in the rung management table 13 is “1”. (Step 131).

The instruction execution unit 14 executes the rung management table 1
If the run / run flag of rung 1 stored in No. 3 is determined to be “1” (step 131;
Y), the rung start address stored in the rung management table 13 is read, and then the object code of rung 1 is sequentially stored in the object code storage unit 16 from the object code stored at the previously read rung start address. Is executed, and all object codes of rung 1 are executed (step 13).
2) The process proceeds to step 133, and if it is determined that the execution / non-execution flag is not “1” (step 13)
1; N), the process proceeds to step 133 without executing rung 1.

When proceeding to step 133, the instruction execution unit 14 determines whether or not the run / non-execution flag of rung 2 stored in the rung management table 13 is "1" (step 133).

The instruction execution unit 14 executes the rung management table 1
When it is determined that the run / non-execution flag of rung 2 stored in No. 3 is “1” (step 133;
Y), the rung start address stored in the rung management table 13 is read, and then the object code of rung 2 is sequentially stored in the object code storage unit 16 from the object code stored at the previously read rung start address. Is executed, and all object codes of rung 2 are executed (step 13
4) The process proceeds to step 135, and if it is determined that the execution / non-execution flag is not “1” (step 13)
3; N), proceed to step 135 without executing rung 2.

When proceeding to step 135, the instruction execution unit 14 determines whether the run / non-execution flag of rung 3 stored in the rung management table 13 is "1" (step 135).

The instruction execution unit 14 executes the rung management table 1
When the run / non-execution flag of rung 3 stored in run 3 is determined to be “1” (step 135;
Y), the rung start address stored in the rung management table 13 is read, and then the object code of the rung 3 is sequentially stored in the object code storage unit 16 from the object code stored at the previously read rung start address. Is executed, and all object codes of rung 3 are executed (step 13).
6) The process proceeds to step 137. On the other hand, if it is determined that the execution / non-execution flag is not “1” (step 13)
3; N), proceed to step 137 without executing rung 3;

At step 137, the instruction execution unit 14 determines whether the run / non-execution flag of rung 4 stored in the rung management table 13 is "1" (step 137).

The instruction execution unit 14 executes the rung management table 1
When the execution / non-execution flag of the rung 4 stored in No. 3 is determined to be “1” (step 137;
Y), the rung start address stored in the rung management table 13 is read out, and then the object code of the rung 4 is sequentially stored in the object code storage unit 16 from the object code stored at the previously read rung start address. Is executed, and all object codes of rung 4 are executed (step 13
8) The program execution process is terminated. On the other hand, if it is determined that the execution / non-execution flag is not "1" (step 133; N), the program execution process is terminated without executing rung 4.

Since rung 4 is an END instruction,
The execution / non-execution flag is "1", and is always executed.

In the programmable logic controller 1 of this embodiment, the instruction execution unit 14 is described in the object code stored in the object code storage unit 16 based on the execution / non-execution flag stored in the rung management table 13. Run the rung of the control program.

For this reason, when performing a debug test, the rung management table 13 for rungs that are not executed
If the execution / non-execution flag is set to a non-execution flag in advance, it is possible to execute a debug test without having to compile all of the ladder program and re-create the object code, thereby reducing the time required for program editing. And trouble can be eliminated.

[0044]

As described above, according to the present invention, the rung for forming the control program is executed based on the execution / non-execution flag indicating whether or not the rung is to be executed. If no rung is specified, it is not necessary to compile all the ladder programs again to form the object code again, so that the time and labor for editing the program can be eliminated.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of an embodiment of a programmable logic controller according to the present invention.

FIG. 2 is a ladder program as a control program executed by the programmable logic controller of the embodiment.

FIG. 3 is a mnemonic notation program in which the ladder program of FIG. 2 is mnemonically written.

FIG. 4 is a block diagram showing a configuration of a rung management table in FIG. 1;

FIG. 5 is a flowchart showing the operation of the programmable logic controller of the embodiment.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Programmable logic controller 11 Source program storage part 12 Compilation part 13 Rung management table 14 Instruction execution part 15 Lang execution designation part 16 Object code storage part

Claims (2)

[Claims] 1. A programmable logic controller for executing a control program formed by a rung having a group of instructions as one unit, the rung having a run / non-execution flag indicating whether to execute the rung. A programmable logic controller comprising: a non-execution flag storage unit; and a flag correction unit that corrects the execution / non-execution flag stored in the rung execution / non-execution flag storage unit as necessary. 2. The rung execution / non-execution flag storage means stores a rung start address for each rung. When execution of the rung is started, an instruction specified by the rung start address is executed. 2. The programmable logic controller according to claim 1, wherein said controller is executed.