JP2001209409A - Plc simulator device and recording medium on which program for simulation is recorded - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a PLC simulator device capable of carrying out a simulation of an interrupt task without being connected to an actual machine, and also capable of changing an executable condition of a task and a standby state and shortening a cycle time by the simulation, and to provide a recording medium on which a program to simulate is recorded. SOLUTION: From the task management part 31 of the debugger 30, an interrupt task activation is instructed to the main process part 21 of the ladder execution engine 20, the main process part 21 receives a factor of a interrupt. As the factor of the interrupt occurs the main process part 21 analyzes it, then execution is moved to relevant interrupt task.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a PL for simulating a PLC program composed of tasks.
The C simulator device and a recording medium on which a program for simulation is recorded are described in detail in PL
The present invention relates to a PLC simulator device capable of simulating an interrupt task among tasks constituting a C program, and a recording medium on which a program for simulating is recorded.

[0002]

2. Description of the Related Art Conventionally, when debugging a program of a PLC (Programmable Logic Controller), for example, the program is simulated by executing the program virtually one instruction at a time on a personal computer to debug the program.

[0003] Conventionally, a PLC program has one program.
Although it has been configured as one continuous program, in recent years, a system in which one continuous program is divided into a plurality of programs called tasks to configure a PLC program has become widespread.

FIG. 6 is an explanatory diagram of a case where a program is composed of tasks. Conventionally, as shown in FIG. 1A, a PLC program (user program) is composed of one continuous program. In a program using tasks, a conventional continuous program is divided into a plurality of tasks (tasks 1 and 2 in FIG.
The program is divided into 2 and 3). The program assigned to each task is one program having an END instruction at the end as in the conventional case.

[0005] A feature of a task is that its execution and non-execution (called "waiting") can be arbitrarily controlled by a "task control instruction" from another task. FIG.
In (b), task 1 and task 3 are in an execution state, and task 2 is not executed (standby).

Therefore, several program parts can be incorporated as tasks (program modularization), and only certain programs (tasks) can be executed (program changeover) in accordance with the type and process.

Further, only necessary programs can be executed when necessary, which contributes to improvement in performance (cycle time).

Further, since the program can be modularized, debugging can be performed for each task.

Note that a task once executed is also executed in the next cycle and thereafter. Also, the task that has been put on standby remains on standby even after the next cycle unless it is returned to execution from another task.

The difference between the case of executing a conventional program and the case of executing a task will be schematically described with reference to FIG. 7. Conventionally, as shown in FIG. 7 (a), a scroll 50 is read from the beginning. The task is an image in which the card is read individually, as shown in FIG.

As described above, in the case of a task, the respective cards can instruct execution and standby, and the cards on standby are skipped. Instructions for execution and standby are given by task control instructions. In the case of FIG. 7B, the task 2 is made executable (activated) by the task control instruction from the task 1, and
Task 3 is on standby (inactivated).

[0012]

The tasks include a cycle execution task and an interrupt task.

The cycle execution task is one per cycle.
If the state of the task is “executable”, the task is executed.

Further, the interrupt task is a task that is interrupted and executed during execution of the cycle execution task when an interrupt factor occurs. There are the following four types of interrupt tasks. (1) Power interruption interrupt task: Executed when power is turned off (2) Periodic interruption task: Executed at fixed time intervals (3) I / O interrupt task: Executed at contact rising of interrupt input unit (4) External interrupt task: External Execute when requested by a high-performance unit

Here, when trying to simulate a program constituted by such tasks for debugging, there are the following problems.

(1) The cycle execution task can be simulated so that debugging can be performed. However, since the interrupt task is not connected to a real machine, simulation cannot be performed.
I cannot debug.

Therefore, conventionally, after constructing a PLC system,
This has been done by attaching a debugging device for generating an interrupt factor and manually operating the device.

However, at this time, if a problem occurs, it is necessary to verify the already completed program again, and there is a problem that post-processing is troublesome.
In addition, there is a problem that a separate debugging device is required, which increases the cost.

(2) Conventionally, the change of the internal state of a task, that is, the change of the executable state and the standby state, is performed through a programming console connected to the PLC or an application on a personal computer after actually constructing the PLC system. Or through execution of a task control instruction from another task as described above.

Therefore, the debugging work for changing the internal state of the task is performed in a process after the system is constructed, and the post-processing when a problem occurs is also troublesome.

(3) Even when a program is composed of tasks, the cycle time must be reduced as much as possible. However, there is no special configuration for that, and there is a problem that it is difficult to reduce the cycle time. Was.

Therefore, according to the present invention, a simulation of an interrupt task can be performed without connecting to a real machine, and a task executable state and an internal state of standby can be changed and a cycle time can be reduced by a simulation.
It is an object to provide a C simulator device and a recording medium on which a program for performing a simulation is recorded.

[0023]

According to the present invention, in a PLC simulator for simulating the execution of an instruction of a PLC program comprising a cycle execution task and an interrupt task, an interrupt factor for activating a specific interrupt task is generated. It is characterized by comprising interrupt factor generating means and interrupt task executing means for executing the interrupt task specified by the interrupt factor generating means.

Here, simulating the execution of the instruction of the PLC program means that the PLC program is virtually executed by a personal computer or the like in order to check whether or not the control program for controlling the operation of the controlled device operates on the PLC as designed. To do. Therefore, the PLC simulator device refers to a personal computer or the like used in such a manner. Note that P
The LC simulator device can be configured by a PLC, a combination of a PLC and a display device, or the like.

Here, P simulated in the present invention
The LC program is composed of a cycle execution task and an interrupt task.

The cycle execution task is one per cycle.
If the state of the task is “executable”, the task is executed.

The interrupt task is a task that is executed by interruption even when a cycle execution task is executed when an interrupt factor occurs. There are the following four types of interrupt tasks. (1) Power interruption interrupt task: Executed when power is turned off (2) Periodic interruption task: Executed at fixed time intervals (3) I / O interrupt task: Executed at contact rising of interrupt input unit (4) External interrupt task: External Execute when requested by a high-performance unit

Here, when a program composed of such tasks is to be simulated for debugging, the cycle execution task can be simulated, so that debugging can be performed. Since the device is not connected to the actual device, simulation cannot be performed and debugging cannot be performed.

Therefore, in the present invention, an interrupt factor for activating a specific interrupt task is generated by the interrupt factor generating means, and the task specified by the interrupt factor generating means is executed by the task executing means.

To generate an interrupt factor for activating a specific interrupt task means that power is actually cut off in a power interruption task, a certain time comes in a periodic interrupt task,
In the O interrupt task, the contact of the interrupt input unit rises, and in the external interrupt task, a request is issued from an external high-performance unit or the like. In the embodiment, the task type display section 32-2 on the message window 32 shown in FIG. This is an interrupt task start instruction of the task management unit 31 based on the designation of any interrupt task among the displayed tasks and the subsequent click of the “start” button in a pop-up screen (not shown).

The execution of the interruption task designated by the interruption factor generation means by the task execution means is defined as steps 110 to 1 in the flowchart of FIG.
This is the 16th interrupt task execution process.

As described above, according to the present invention, an interrupt task can be executed on a simulation, and debugging can be performed before a PLC system is constructed.

Therefore, it is not necessary to verify the already completed program again after the construction of the PLC system.
Debugging efficiency is improved. Further, a debugging device is not required, and debugging can be performed at low cost.

Further, according to the present invention, the execution state of another task can be controlled by a task start instruction and a task wait instruction.
PL that simulates instruction execution of LC program
The C simulator apparatus is characterized in that it has an internal state changing means that can change the internal state of the task between a standby state and an executable state.

Here, controlling the execution state of another task by a task start instruction and a task wait instruction means that, in a program using a task, for example, as shown in FIG. To make task 2 executable (activated) and wait for task 3 (inactive)
Means that

As described above, in a program using a task, the execution state in the task cannot be changed unless a task control instruction is issued from another task.

Therefore, in the present invention, an internal state changing means is provided so that the internal state of a task can be changed between a standby state and an executable state.

In the embodiment, the internal state changing means is the one shown in FIG.
This is the process.

Therefore, it is not necessary to verify the already completed program again after the construction of the PLC system, and the debugging efficiency is improved.

Further, the present invention provides a program for simulating instruction execution of a PLC program executed on a task basis.
In the LC simulator apparatus, one instruction processing time measuring means for measuring the processing time of each instruction in a task during execution or non-execution, and the processing time measured by the one instruction processing time measuring means is integrated to 1 It is characterized by having one-task processing time measuring means for measuring the processing time of a task, and one-task processing time storing means for storing the processing time measured by the one-task processing time measuring means.

That is, according to the present invention, in the simulation, (1) one instruction processing time measuring means measures execution time or non-execution time of each instruction constituting one task, and (2) one instruction processing time. When the execution of the task is completed, the processing time of each instruction is integrated by the one-task processing time measuring means, and the processing time of the one task is measured. (3) When the processing of one task is completed, the processing time of the one task is stored in the one-task processing time storage means. The processing time is stored.

For this reason, the execution time of each task can be known. For example, when one cycle time of a program is long, the execution time of each task constituting the program is verified to contribute to shortening of one cycle time. It has effects such as being able to do.

The present invention also provides a method for activating a specific interrupt task on a recording medium in which a program for simulating the instruction execution of a PLC program comprising a cycle execution task and an interrupt task by a PLC simulator device is recorded. And an interrupt task executing means for executing the interrupt task specified by the interrupt factor generating means.

Here, the recording medium on which the program for the simulation is recorded is constituted by, for example, a floppy disk.

When the program recorded on the recording medium is read and executed by a PLC simulator device composed of a personal computer or the like, an interrupt task can be executed on a simulation.

[0046]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, embodiments of a PLC simulator device according to the present invention and a recording medium on which a program for simulation is recorded will be described in detail with reference to the accompanying drawings.

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

In FIG. 1, a PLC simulator 1
0 is composed of personal computers, etc., and composed of tasks P
It supports program debugging by simulating the instruction execution of an LC program, and is composed of a ladder execution engine 20 and a debugger 30.

The ladder execution engine 20 executes a PLC program in accordance with an instruction from the debugger 30. The ladder execution engine 20 includes a main processing unit 21 and a ladder execution processing unit 2.
2. Peripheral processing unit 23.

Here, the main processing unit 21 includes a debugger 30
In response to an instruction from the CPU, the program executes, stops, switches tasks, changes the internal state of the task, and integrates the execution time of the program. The ladder execution processing unit 22
And the peripheral processing unit 23.

The ladder execution processing unit 22 includes the main processing unit 2
The program is executed one instruction at a time in accordance with a command from one.

The peripheral processing unit 23 includes a ladder execution processing unit 22
Is not executed, communication processing with a communication device (for example, a PLC) or an application (not shown) is performed in accordance with a command from the main processing unit 21.

The debugger 30 instructs the ladder execution engine 20 to execute the program one instruction at a time for debugging. In this embodiment, the debugger 30 particularly instructs the ladder execution engine 20 to start an interrupt task, It is configured to be able to issue an instruction to change the internal state, manage the execution time of a task, etc., and has a task management unit 31 and a message window 32.

Here, the task management section 31 manages the tasks constituting the PLC program, as will be described in detail later.

The message window 32 is the debugger 30
It supports the debugging of programs performed by.

In the present embodiment, the simulation of the PLC program is performed on a task basis. At this time, the execution of the interrupt task on the simulation and the change of the internal state of the task on the simulation, which have not been conventionally possible, are performed. Then, the execution time of each task on the simulation is calculated.

Therefore, in the present embodiment, a message screen as shown in FIG. 2 is displayed in the message window 32 of the debugger 30, and the operator performs various operations using a mouse or the like on this screen to execute the above operation. Perform processing.

The recording medium on which the program for simulation described in the claims is recorded is a recording medium on which a program for performing the above processing is recorded, and is recorded on a floppy disk or the like.

In FIG. 2, the message window 32 includes a task display switching section 32-1, a task type display section 32-2, a task number. Display section 32-3, task setting display section 32-4, [close] button 32-5, main menu display section 32-6, monitor button 32-7, task activation interval display section 32-8, task state display section 32 −
9, a task execution count display section 32-10, and a task execution time display section 32-11.

Here, the task display switching unit 32-1 switches the display of the task by clicking this portion with a mouse.

The task type display section 32-2 displays the type of the task, and displays the type of the interrupt task or the cycle execution task.

Task No. The display unit 32-3 displays a task number.

The task setting display section 32-4 displays the setting state of the task. In the case of an interrupt task, the type of the interrupt, that is, a "periodic" interrupt task, an "external" interrupt task, or an "I / O""The type of interrupt task or the like is displayed. Note that the cycle execution task does not have a type, so that only “cycle” is displayed.

The [Close] button 32-5 is for terminating the current screen.

The main menu display section 32-6 displays a main menu such as "task" or "help".

The monitor button 32-7 is a switch for monitoring the status of the task.

The task start interval display section 32-8 displays the start interval of the periodic interrupt task.

The task state display section 32-9 displays the current state of the cycle execution task. The cycle execution task has an unexecuted state (INI) and an executable state (RE).
ADY), execution state (RUN), standby state (WAIT)
Since the four states are changed, any one of the states is displayed.

The task execution count display section 32-10 displays the number of executions of the task so far.

The task execution time display section 32-11 displays the execution time of the task.

FIG. 3 is a flowchart showing a processing procedure when an interrupt task is executed on a simulation.

In this process, first, the task management unit 31 of the debugger 30 instructs the main processing unit 21 of the ladder execution engine 20 to start an interrupt task (step 100). This is done by clicking on any of the interrupt tasks among the tasks displayed in the task type display section 32-2 on the message window 32 shown in FIG. A pop-up screen (not shown) appears, and the user clicks the “start” button in the pop-up screen.

As a result, the main processing section 21 receives the interrupt factor (step 102). Note that the interrupt factors are actually power-off in the power interruption task, arrival of a fixed time in the periodic interruption task, contact rise of the interrupt input unit in the I / O interruption task, and external high-performance units in the external interruption task. In the simulation, any one of the tasks displayed in the task type display unit 32-2 on the message window 32 is specified as an interrupt task, and a This is an interrupt task start instruction of the task management unit 31 based on the click of the “start” button.

When the interrupt factor is received in this way, the main processing unit 21 stores the reception of the interrupt factor. This storage is determined later in step 108.

Next, the main processing unit 21 requests the ladder execution processing unit 22 to execute one instruction (step 10).
4). Thus, the ladder execution processing unit 22 executes one instruction (Step 106).

Next, at step 108, it is checked whether or not an interrupt factor has occurred. Here, step 1
Since the main processing unit 21 has received the interrupt factor in 02, it is determined that the interrupt factor has occurred (YES in step 108). Therefore, proceed to step 110,
The main processing unit 21 analyzes the cause of the interrupt and shifts the execution to the corresponding interrupt task. The corresponding interrupt task is the interrupt task received in step 102.

Next, the main processing unit 21 requests the ladder execution processing unit 22 to execute one instruction of the corresponding interrupt task (step 112). Ladder execution processing unit 2
2 executes one instruction (step 114).

Next, it is checked whether or not the program is the last program of the interrupt task, that is, whether or not the program is an END instruction (step 116).
If NO at step 16, the process returns to step 112 to execute one more instruction.
Then, the process returns to step 108 to check again whether an interrupt factor has occurred.

If an interrupt factor has occurred (YES in step 108), the process returns to step 110 to execute the corresponding interrupt task. In this case, the occurrence of the interrupt factor occurs when the interrupt task is further activated during the execution of the interrupt task.

If no interrupt factor has occurred (NO in step 108), it is checked whether or not the program (PLC program) is at the end (step 118). If it is not the end of the program (step 118). N
O), proceed to step 104 to execute one more instruction. In the last case of the program (step 118)
YES), the main processing unit 21 instructs the peripheral processing unit 23 to perform the peripheral processing (step 120).
Then, the process of step 104 is performed again.

The above is the processing procedure when the interrupt task is executed on the simulation.

In the above description, as a method of generating an interrupt factor, one of the tasks displayed in the task type display section 32-2 on the message window 32 shown in FIG. Although the operation is performed by clicking or the like, it is also possible to connect an actual device to generate an interrupt factor due to a change in input of a specific I / O.

If it is determined in step 108 that an interrupt factor has occurred, the interrupt task of step 110 and subsequent steps is executed. If another interrupt factor occurs during the execution of the interrupt task, the process is repeated. Step 11
The execution of the interrupt task of 0 or less is performed. In this case, a newly generated interrupt cause is suspended, and the suspended interrupt task is executed when the currently executed interrupt task ends. That is, if the interruption task is suspended, it is determined in step 108 that an interruption factor has occurred.

As described above, in the process of FIG. 3, the task type display section 32 is displayed on the message window 32 shown in FIG.
A specific interrupt factor is generated by, for example, clicking a mouse on any of the interrupted tasks among the tasks displayed in -2, and the interrupt task is simulated. This makes it possible to debug a program and to surely debug all tasks including an interrupt task before constructing a PLC system.

Next, a procedure for changing the internal state of a task from an executable state to a standby state or from a standby state to an executable state by simulation will be described with reference to the flowchart of FIG.

In the internal state change processing of the task, first, the task management section 31 of the debugger 30 issues an instruction to change the internal state of the task (step 130). Next, it is checked whether or not the change instruction is a change instruction from the standby state to the executable state (step 132). If the change instruction is an instruction to change from the standby state to the executable state (YE in step 132).
S), the main processing unit 21 of the ladder execution engine 20 sets the internal state of the specified task to an executable state (step 134).

If the change instruction is not the change instruction from the standby state to the executable state (N in step 132)
O) Next, it is checked whether or not the change instruction is an instruction to change from the executable state to the standby state (step 136). If the change instruction is an instruction to change from the executable state to the standby state (YES in step 136). Then, the main processing unit 21 of the ladder execution engine 20 sets the internal state of the specified task to a standby state (step 138).

If the change instruction is not an instruction to change from the executable state to the standby state (N in step 136)
O), the process ends.

As described above, in this embodiment, the internal state of a task can be changed from an executable state to a standby state or from a standby state to an executable state by simulation.

Therefore, the debugging operation for changing the internal state of the task can be performed before the system is constructed, and it is possible to prevent problems from occurring in advance.

Next, the processing procedure for calculating the execution time of each task on a simulation will be described with reference to the flowchart of FIG.

In this process, when execution of a task is started (step 150), a mnemonic (code) of one instruction is read (step 152), and it is determined whether or not execution conditions are satisfied (step 154). . This is 1
It is checked whether a predetermined input condition is satisfied for the instruction. If the execution condition is not satisfied (step 1).
NO in step 54), the non-execution processing time is read (step 15).
6) Go to step 162.

On the other hand, if the execution condition is satisfied (step 1
(YES in 54), mnemonic processing, that is, one instruction is executed (step 158), and the execution processing time of one instruction is read (step 160). Then, it is added to the processing time up to the previous time (step 162), but is not added in the case of the first instruction execution.

Next, it is checked whether or not the execution of one task has been completed (step 164). If the execution of one task has not been completed (NO in step 164), step 152 is executed.
Then, the execution of one task is continued, but when the execution of one task is completed (YES in step 164), the process proceeds to step 166, where the processing time of the one task is stored, and the number of tasks is incremented by one ( (Step 168) It is checked whether the task is the last one (Step 17).
0).

Here, if it is not the last task (NO in step 170), the process returns to step 152 and the execution of one task is continued, but if it is the last task (YES in step 170), the total execution of the tasks is performed. The time (total execution time of the program) is stored (step 172), the total number of executed tasks is stored (step 174), and the execution of the task is terminated (step 176).

As described above, in the present embodiment, in the simulation, (1) the execution time or non-execution processing time of each instruction constituting one task is stored, and (2)
When the execution of one task is completed, the processing time of each instruction is accumulated and the processing time of the one task is stored. (3) When the execution of all tasks is completed, the total execution time of the task and the program are configured. The total number of tasks is now stored.

For this reason, the execution time of each task can be known. For example, when one cycle time of a program is long, the execution time of each task constituting the program is verified to contribute to shortening of one cycle time. It has effects such as being able to do.

[0098]

As described above, the present invention has the following effects.

(1) In a PLC simulator apparatus for simulating the execution of an instruction of a PLC program composed of a cycle execution task and an interrupt task, an interrupt factor generating means for generating an interrupt factor for activating a specific interrupt task; Since an interrupt task executing means for executing an interrupt task specified by the interrupt factor generating means is provided, the interrupt task can be executed on a simulation, and debugging can be performed before a PLC system is constructed.

Therefore, it is not necessary to verify the already completed program again after the construction of the PLC system.
Debugging efficiency is improved. Further, a debugging device is not required, and debugging can be performed at low cost.

(2) PLC capable of controlling the execution state of another task by a task start instruction and a task wait instruction
In a PLC simulator apparatus for simulating the execution of a program instruction, an internal state changing means for changing the internal state of a task between a standby state and an executable state is provided, so that the internal state of the task can be changed on simulation. .

Accordingly, the verification of the already completed program after the construction of the PLC system is not required again, and the debugging efficiency is improved.

(3) The PL executed on a task basis
PLC for simulating C program instruction execution
In the simulator device, one instruction processing time measuring means for measuring the processing time of each instruction in a task during execution or non-execution, and one task by integrating the processing times measured by the one instruction processing time measuring means. And a one-task processing time storage means for storing the processing time measured by the one-task processing time measurement means. When the time or the like is known, for example, when one cycle time of the program is long, the execution time of each task constituting the program is verified, which can contribute to shortening of one cycle time.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a schematic configuration of an embodiment of a PLC simulator device according to the present invention.

FIG. 2 is a view showing the contents of a PLC program executed by the PLC simulator device 50 shown in FIG. 1;

FIG. 3 is an exemplary view showing a display example in a message window 32 of the debugger 30 when the program shown in FIG. 2 is executed.

FIG. 4 is a flowchart showing a processing procedure of the embodiment shown in FIG. 1;

FIG. 5 is a flowchart showing a processing procedure of the embodiment shown in FIG. 1;

6A and 6B are explanatory diagrams of a case where a program is composed of tasks, in which FIG. 6A shows a case where a PLC program (user program) is composed of one continuous program, and FIG. 6B shows a case where a program of FIG. FIG. 3 is an explanatory diagram of a case where a program is divided into tasks 1, 2, and 3.

7A and 7B are diagrams schematically illustrating a difference between a case where a conventional program is executed and a case where a task is executed. FIG. 7A illustrates a case where a conventional program is executed, and FIG. 7B illustrates a case where a task is executed. FIG.

[Description of Signs] 10 PLC simulator apparatus 20 Ladder execution engine 21 Main processing section 22 Ladder execution processing section 23 Peripheral processing section 30 Debugger 31 Task management section 32 Message window 32-1 Task display switching section 32-2 Task type display section 32 -3 Task No. Display section 32-4 Task setting display section 32-5 [Close] button 32-6 Main menu display section 32-7 Monitor button 32-8 Task activation interval display section 32-9 Task status display section 32-10 Task execution count display Section 32-11 Task execution time display section

 ──────────────────────────────────────────────────続 き Continued on the front page F term (reference) 5H220 BB09 BB12 CX03 DD04 HH01 JJ19 JJ26 JJ42 JJ53 KK08 LL01 LL06 5H223 CC03 CC08 DD03 EE19 FF05 FF08 9A001 DD13 HH32 LL05

Claims (4)

[Claims] 1. A PLC simulator for simulating the execution of an instruction of a PLC program comprising a cycle execution task and an interrupt task, wherein: an interrupt factor generating means for generating an interrupt factor for activating a specific interrupt task; An interrupt task executing means for executing an interrupt task specified by the factor generating means. 2. A PLC simulator for simulating the execution of an instruction of a PLC program capable of controlling the execution state of another task by a task start instruction and a task standby instruction, wherein the internal state of the task is mutually changed to a standby state and an executable state. P having an internal state changing means capable of
LC simulator device. 3. A PLC simulator for simulating the execution of an instruction of a PLC program executed in a task unit, comprising: one instruction processing time measuring means for measuring a processing time of each instruction in a task during execution or non-execution; A one-task processing time measuring means for integrating the processing time measured by the one-command processing time measuring means to measure the processing time of one task; and storing the processing time measured by the one-task processing time measuring means. A PLC simulator device comprising: one task processing time storage means. 4. A recording medium on which a program for simulating an instruction execution of a PLC program composed of a cycle execution task and an interrupt task by a PLC simulator device is recorded, wherein an interrupt factor for activating a specific interrupt task is determined. A recording medium in which a program for simulation is recorded, comprising: an interrupt factor generating means for generating; and an interrupt task executing means for executing an interrupt task specified by the interrupt factor generating means.