JP2906382B2 - Trace method of user program in programmable controller - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a user program in a programmable controller (hereinafter, referred to as a PC) which stores a command execution locus of a user program in a memory in a time-series manner so that a user can refer to the locus by a peripheral tool. Regarding the trace method.

[0002]

2. Description of the Related Art In a conventional PC, a tracing function of a user program, that is, a function of storing the execution locus (position) of the user program in a time-series manner is a known technique. It was performed every time a program instruction was executed.

That is, conventionally, when a user program is executed, first, as shown in FIG. 1, an address of an instruction of a user program to be executed next is read from a program counter (ST100), and a trace execution is executed for each instruction. It is determined whether or not there is a setting (ST110). If the setting for trace execution is present, data sampling processing, that is, the value of the program counter currently being executed or the object code of the instruction being executed is sequentially stored in the trace memory. Is stored (ST120), and thereafter, an instruction is read from the user program based on the address (ST120).
150), a process based on the instruction was executed (ST
180).

[0004]

By the way, in most cases, the user uses the above-mentioned trace function on a PC when debugging a user program.
Even when the trace function is used, it is required that the execution processing speed of the user program does not change as compared with the case where the function is not used.

However, in the conventional tracing method, as shown in FIG. 10, for each instruction of the user program, whether or not to execute tracing and an actual data sampling process are added, so that the number of instructions in the program is reduced. As the number of instructions increases, a time other than the processing time of the instruction itself is required, so that the overhead time increases, and there is a problem that a processing delay that is greater than the original instruction processing speed occurs.

Also, regarding the capacity of a memory (trace memory) for storing the traced data, since all executed instructions are sampled as data, there is a possibility that the capacity may be insufficient, and it is difficult to trace for a long time. There was a problem that is.

SUMMARY OF THE INVENTION The present invention has been made in view of the above problems, and it is possible to trace the execution locus of a user program at a processing speed close to real time and to trace a user program of a PC which can be traced with a limited memory capacity. The aim is to provide a scheme.

[0008]

SUMMARY OF THE INVENTION In order to solve the above-mentioned problems, the present invention provides a method in which a user executes a command execution locus of a user program in a memory in a time-series manner and displays the locus on a display device. In a tracing method of a user program in a programmable controller to be referred to, an identification instruction in which an identification number for identifying the instruction itself is set as an operand is stored at an arbitrary position in the user program, and The identification number of the identification instruction is stored in a memory only when the identification instruction is executed during execution, and the user can refer to the identification number stored in the memory with a peripheral tool. I do.

[0009]

According to the above arrangement, an identification instruction in which an identification number for identifying the instruction itself is set as an operand is set at an arbitrary position in the user program, and the identification instruction is executed during execution of the user program. Only when executed, the identification number of the identification instruction is stored in the memory. The user can refer to the identification number stored in the memory by a peripheral tool by a method such as displaying the identification number on a display device.

[0010] For this reason, it is no longer necessary to determine whether or not to execute the trace and to actually perform the data sampling process, which is conventionally required for each instruction of the user program.
The instruction execution locus of the user program can be traced at a processing speed close to real time, and the memory capacity for the trace can be reduced.

[0011]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of a trace method for a user program in a PC according to the present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram showing an internal configuration of a PC to which a user program tracing method according to the present embodiment is applied. This PC is a microprocessor (hereinafter, referred to as a microprocessor) which performs various processes such as control of the entire PC and tracing. MPU)
1, a system program memory 2, and a working memory 3 for temporarily storing data processed by the MPU 1.
A trace memory 4 for storing trace data (sampling data) processed by the MPU 1; a user program memory 5 for storing a program arbitrarily programmed by a user; a keyboard 6;
A display device 7 such as a T, an I / O memory 8 for storing data input by the keyboard 5, data executed by a user program, data output to the display device 7, etc., and peripheral devices are connected. Interface 9 and an internal bus 10 for connecting these.

The above system program memory 2
The MPU 1 is programmed so that the MPU 1 executes control of the entire PC and various processes, and performs a trace process in a process as shown in FIG. 7 only when an identification instruction described later is executed during execution of a user program. System programs are stored.

Further, in this embodiment, the format as shown in FIG.
ARK ", a plurality of identification instructions M1 each having a 4-bit identification number for identifying the instruction itself as an operand thereof, and those identification instructions M1 being written in a ladder language as shown in FIG. 3, for example. The data is stored immediately after an arbitrary position in the program 11, particularly immediately after branch execution under conditions such as the jump instruction M2. As a result, the user program 11 becomes as shown in FIG.
The identification command M1 is stored at an arbitrary position such as before or after step 2. Note that the identification number as an operand may be a simple serial number or a number indicating the storage position of the identification instruction M1 itself in the user program.
Further, the input range and the like are set depending on the implementation.

Next, the processing of the tracing method of the user program of this embodiment will be described with reference to the flowcharts shown in FIGS.

FIG. 5 shows P including execution of a user program.
In the flowchart showing the entire process of C, first, the PC performs a predetermined initial process by turning on the power (ST10).

Next, common processing such as initial processing of peripheral devices (tools) connected to the PC is performed (ST20), and it is determined whether a user program can be executed (ST3).
0).

If the user program is executable (ST3
0 “Yes”), it is determined whether or not the execution is the first execution (ST40).
s "), an initial process for executing the user program such as clearing of the I / O memory 8 is performed (ST50). If it is not the first execution (ST40" No "), the user program is executed as it is (ST60). , The I / O memory 8 is refreshed (ST70).

When it is determined whether or not the user program can be executed (ST30), if the user program cannot be executed (ST30 "No"), the I / O memory 8 is refreshed without executing the user program. (ST7
0). As described above, the various processes (ST20 to ST70) from the common process to the refresh of the I / O memory 8 are repeated after the power-on initial process, and the PC executes the user program.

The instruction execution process (ST60) of the user program is performed for each instruction as shown in FIG. 6. First, a control unit (not shown) in the MPU 1 controls a program counter (not shown). , The address of the next instruction to be executed is read (ST200). If the address is that of the identification instruction "MARK", or the transfer instruction "M
Even in the case of ordinary instructions such as "OV" and a jump instruction "JMP", the instruction corresponding to the address is read from the user program memory 4 as it is without determining whether or not to execute the trace or performing actual data sampling processing. (ST210).

Then, the instruction is analyzed (ST220),
End instruction “END” indicating the end of the instruction (see FIG. 4)
Is determined (ST230), and if it is a termination command (ST230 "Yes"), the user program is terminated, while if it is not a termination command (ST230).
"No"), and executes processing based on the contents of each instruction (ST).
240), and updates the value of the program counter (ST2).
50), and return to reading the program counter (ST200) to execute the next instruction.

At this time, only when the identification command is executed (S
T240), the trace processing according to the present embodiment as shown in FIG. 7 is executed. That is, as shown in the figure, it is first determined whether or not there is a setting for trace execution (ST30).
0), if there is a setting for trace execution (ST300)
“Yes”), the identification instruction, that is, the operand of the identification instruction corresponding to the address stored in the program counter is stored in the trace memory 4 and the trace processing is executed (S
If the data storage area in the trace memory 4 is exhausted (T320 “Yes”), the setting of tracing is cleared and the tracing process is ended (T3).
30), as shown in FIG. 6, the value of the program counter is updated for the execution of the next instruction (ST250), and the process returns to reading of the program counter (ST200).

In this manner, the processing from reading to updating of the program counter shown in FIG.
T250), and the trace processing (ST30) shown in FIG.
0-330) is repeated until all instructions of the user program have been executed.

Therefore, if the instructions in the user program are sequentially executed as described above, the identification instructions stored in the user program are also executed sequentially, and the trace memory 4 shown in FIG. "0005", "0000", "0001", "0002",
.. And the identification numbers, which are the operands of the identification instructions, are sequentially stored in chronological order, while the display device 7 stores the identification instructions stored in chronological order on the trace memory 4 as shown in FIG. The operand is displayed together with the instruction “MARK”.

Therefore, according to the present embodiment, the user sets the above-described identification command at an arbitrary position in the user program, and is the operand of the identification command displayed on the display device 7 after the execution of the user program. By observing the identification number, the instruction execution trajectory of the user program can be detected, so that the judgment processing for tracing and the actual data sampling processing required for each instruction of the user program become unnecessary. Thus, the trace of the execution locus of the user program can be traced in a form closer to the actual processing speed as compared with the conventional method, and the capacity of the trace memory 4 can be reduced.

In FIG. 8, the sampling start point is a pointer indicating the start position of the data sampling on the trace memory 4, and the sampling current pointer indicates the storage position of the last sampling data on the trace memory 4. It is a pointer.

[0027]

As described above, according to the present invention, an identification instruction in which an identification number for identifying the instruction itself is provided as an operand is set at an arbitrary position in the user program, and during execution of the user program, Only when the above-mentioned identification instruction is executed, the identification number of the identification instruction is stored in the memory, and the identification number is displayed on a display device. Until now, it is no longer necessary to determine whether or not trace execution is required for each instruction of the user program, and to perform actual data sampling processing, and trace the instruction execution locus of the user program at a processing speed close to real time. Thus, the memory capacity for tracing can be reduced.

As a result, the overhead time due to the processing time required for trace sampling can be minimized, so that the number of work steps as debugging means for a user program can be greatly reduced.

Further, since the number and position of using this instruction can be selected at the level required by the user, only the minimum necessary trace sampling can be performed, and the required use of the trace memory is required. By suppressing the amount, the tracing process can be continued for a long time.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a schematic configuration of a PC according to the present invention.

FIG. 2 is an explanatory diagram illustrating an example of an identification instruction having a trace function according to the embodiment;

FIG. 3 is an explanatory diagram showing an example of a user program.

FIG. 4 is an explanatory diagram showing an example of a user program in which an identification command according to the embodiment is stored.

FIG. 5 is a flowchart showing the overall processing of the PC.

FIG. 6 is a flowchart illustrating a trace execution process according to the embodiment;

FIG. 7 is a flowchart illustrating processing for executing an identification command according to the embodiment;

FIG. 8 is a memory map showing a state of a trace memory in which an identification instruction is stored according to the embodiment.

FIG. 9 is an explanatory diagram illustrating an example of a case where a trace result according to the present embodiment is displayed on a display device.

FIG. 10 is a flowchart showing a conventional trace execution process.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Microprocessor 2 System program memory 3 Working memory 4 Trace memory 5 User program memory 6 Keyboard 7 Display device 8 I / O memory 9 Interface 10 Internal bus

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

Claims (1)

(57) [Claims] 1. A tracing method of a user program in a programmable controller, wherein a user's instruction execution locus is stored in a memory in a time-series manner and displayed on a display device so that a user can refer to the peripheral tool by a user. Storing an identification instruction in which an identification number for identifying the instruction itself is set as an operand at an arbitrary position in the user program, and identifying the identification instruction only when the identification instruction is executed during execution of the user program. A trace method for a user program in a programmable controller, wherein the identification number of an instruction is stored in a memory, and a user can refer to the identification number stored in the memory with a peripheral tool.