JP4811678B2 - PLC simulator apparatus, simulation program, and recording medium on which the program is recorded - Google Patents

Description

  The present invention relates to a PLC simulator device for simulating instruction execution of a PLC program that can control the execution state of another task by a task start instruction and a task standby instruction, and instruction execution of a PLC program executed in units of tasks, and for simulation The present invention relates to a program and a recording medium on which the program is recorded.

  Conventionally, when a PLC (programmable logic controller) program is debugged, the program is simulated by, for example, virtually executing the program on a personal computer one instruction at a time, thereby debugging the program.

  Conventionally, a PLC program has been configured as a single continuous program. However, in recent years, a method of dividing a single continuous program into a plurality of programs called tasks to form a PLC program has become widespread.

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

  A feature of a task is that its execution and non-execution (referred to as “waiting”) can be arbitrarily controlled by “task control instructions” from other tasks. In FIG. 6B, task 1 and task 3 are in an execution state, and task 2 is not executed (waiting).

  Accordingly, some program parts are incorporated as tasks (program modularization), and only a certain program (task) can be executed (program changeover) according to the type or process.

  In addition, when necessary, only necessary programs can be executed, which contributes to improved performance (cycle time).

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

  Note that a task once executed is executed after the next cycle. In addition, a task that has been placed 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 the conventional program and the case of executing the task will be described schematically with reference to FIG. 7. Conventionally, as shown in FIG. 7A, an image of reading the scroll 50 from the beginning. On the other hand, the task is an image of reading cards individually as shown in FIG.

  As described above, in the case of a task, each card can instruct execution and waiting for each other, and the card that has been placed on standby is skipped. Execution and standby instructions 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 the task 3 is put on standby (inactivated).

  By the way, the task includes a cycle execution task and an interrupt task.

  The cycle execution task is a task that is executed once in one cycle if the state of the task is “executable state”.

An interrupt task is a task that is interrupted and executed even when a cycle execution task is executed when an interrupt factor occurs. There are four types of interrupt tasks:
(1) Power interruption interrupt task: Executed when the power is turned off (2) Scheduled interrupt task: Executed at a fixed time interval (3) I / O interrupt task: Executed at the rising edge of the interrupt input unit contact (4) External interrupt task: External Executed when requested by a high-function unit

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

(1) Since the cycle execution task can be simulated, it can be debugged. However, since the interrupt task is not connected to the actual machine, it cannot be simulated and cannot be debugged.

  Therefore, conventionally, after a PLC system is constructed, a debugging device for generating an interrupt factor is attached, and the device is manually operated.

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

(2) Conventionally, the change of the internal state of the task, that is, the change of the executable state and the standby is actually made through the programming console connected to the PLC or the application on the personal computer after the construction of the PLC system or the above-mentioned It can only be changed through the execution of task control instructions from other tasks such as

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

(3) Even when a program is configured by tasks, the cycle time must be shortened as much as possible. However, there is no special configuration for that purpose, and there is a problem that it is difficult to shorten the cycle time.

  It is an object of the present invention to provide a PLC simulator device capable of changing a task executable state and a standby internal state and shortening a cycle time by simulation, a program for simulation, and a recording medium on which the program is recorded. To do.

In order to achieve the above object, the present invention manages a task constituting a PLC program in a PLC simulator device that simulates instruction execution of a PLC program that can control the execution state of another task by a task start instruction and a task standby instruction. A task management unit that performs the above, a main processing unit that executes the PLC program in accordance with an instruction from the task management unit, and an internal state change unit that can mutually change the internal state of the task into a standby state and an executable state, When the instruction is a task activation instruction, the internal state changing means sets the internal state of the task specified by the main processing unit to an executable state, and the internal state changing means determines that the instruction is a task waiting instruction. In this case, the internal state of the task specified by the main processing unit is set to the standby state. To.
The present invention relates to a PLC simulator device for simulating instruction execution of a PLC program capable of controlling the execution state of another task by a task start instruction and a task standby instruction, and instruction execution of a PLC program executed in units of tasks. A task management unit that manages the tasks that constitute the task, a main processing unit that executes a PLC program in response to an instruction from the task management unit, and an internal state change that can mutually change the internal state of the task to a standby state and an executable state Means for determining whether or not an execution condition is satisfied for each instruction, and when the execution condition is satisfied by the execution condition determination means, the execution processing time of one instruction is read and the execution is performed When the condition is not satisfied, the one instruction processing time acquisition means for reading the non-execution processing time and the one instruction processing time One task processing time calculation means for calculating the processing time of one task by accumulating the processing time read by the acquisition means, and one task processing time storage means for storing the processing time calculated by the one task processing time calculation means And when the instruction is a task activation instruction, the internal state change means sets the internal state of the task specified by the main processing unit to an executable state, and the internal state change means When the instruction is a task standby instruction, the internal state of the task designated by the main processing unit is set to the standby state.
The present invention is a recording medium on which a program for simulating instruction execution of a PLC program capable of controlling the execution state of another task by a task start instruction and a task standby instruction is recorded, and the recording medium includes a computer, a PLC program, and the like. A task management means for managing the tasks constituting the program, a main processing means for executing a PLC program in accordance with an instruction from the task management means, and, if the instruction is a task activation instruction, designated by the main processing means A program for causing an internal state of a task to be an executable state and functioning as an internal state changing unit that sets the internal state of the task specified by the main processing unit to a standby state when the instruction is a task standby command. It is a recorded computer-readable recording medium
The present invention is a program for simulating instruction execution of a PLC program that can control the execution state of another task by a task start instruction and a task standby instruction, and the program manages a computer and a task that constitutes the PLC program. Task management means to perform, main processing means for executing a PLC program according to an instruction from the task management means, and when the instruction is a task activation instruction, the internal state of the task specified by the main processing means can be executed When the instruction is a task standby instruction, the program is a program for causing the internal state of the task designated by the main processing means to function as an internal state changing unit.

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

  Here, the PLC program to be simulated in the present invention includes a cycle execution task and an interrupt task.

  The cycle execution task is a task that is executed once in one cycle if the state of the task is “executable state”.

An interrupt task is a task that is interrupted and executed even when a cycle execution task is executed when an interrupt factor occurs. There are four types of interrupt tasks:
(1) Power interruption interrupt task: Executed when the power is turned off (2) Scheduled interrupt task: Executed at a fixed time interval (3) I / O interrupt task: Executed at the rising edge of the interrupt input unit contact (4) External interrupt task: External Executed when requested by a high-function unit

  Here, when a program composed of such tasks is to be simulated for debugging, the cycle execution task can be simulated and can be debugged, but the interrupt task started from an external real machine is the simulation, the device Since it is not connected to the actual machine, simulation cannot be performed and debugging cannot be performed.

  Therefore, in the present invention, an interrupt factor for starting a specific interrupt task may be generated by the interrupt factor generating unit, and the interrupt task specified by the interrupt factor generating unit may be executed by the task executing unit.

  In order to generate an interrupt factor for starting a specific interrupt task, the power interruption is actually performed in the power interruption interrupt task, the fixed time comes in the periodic interruption task, the contact input unit rises in the I / O interruption task, The external interrupt task is a request from an external high-functional unit or the like, but in the embodiment, any interrupt among the tasks displayed in 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 a task and the click of a “start” button in a subsequent pop-up screen (not shown).

  In addition, the execution of the interrupt task specified by the interrupt factor generation means in the task execution means is the interrupt task execution processing in steps 110 to 116 in the flowchart of FIG.

  Thus, according to the present invention, the interrupt task can be executed on the simulation, and debugging can be performed before the PLC system is constructed.

  Therefore, it is not necessary to re-verify a program that has already been completed after the PLC system is constructed, and debugging efficiency is improved. Further, a debugging device is not required, and debugging can be performed at a low cost.

  In the present invention, the execution state of another task is controlled by a task start instruction and a task standby instruction. In a program using a task, for example, as shown in FIG. The task 2 is in an executable state (activated) and the task 3 is in a standby state (inactivated).

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

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

  In the embodiment, the internal state changing means is the process of FIG.

  Accordingly, similarly, it is not necessary to re-verify a program that has already been completed after the PLC system is constructed, and debugging efficiency is improved.

  Here, the recording medium on which the program for simulation is recorded is composed of, 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, the interrupt task can be executed on the simulation.

  The present invention has the following effects.

(1) In the present invention, in a PLC simulator device for simulating instruction execution of a PLC program that can control the execution state of another task by a task activation instruction and a task standby instruction, the internal state of the task is changed into a standby state and an executable state. Since the internal state changing means that can be changed to is provided, the internal state of the task can be changed on the simulation.

  Accordingly, similarly, it is not necessary to re-verify a program that has already been completed after the PLC system is constructed, and debugging efficiency is improved.

(2) Further, in the present invention, in a PLC simulator device that simulates instruction execution of a PLC program executed in units of tasks, one instruction processing for measuring a processing time at the time of execution or non-execution of each instruction in a task A time measuring means, a one-task processing time measuring means for measuring the processing time of one task by integrating the processing times measured by the one-command processing time measuring means, and a process measured by the one-task processing time measuring means 1 task processing time storage means for storing time, so that the execution time for each task can be known. For example, when one cycle time of a program is long, each task constituting the program is The execution time can be verified and it can contribute to shortening of one cycle time.

  The best mode for carrying out the present invention will be described below in detail with reference to the accompanying drawings.

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

  In FIG. 1, a PLC simulator device 10 is composed of a personal computer or the like, and supports program debugging by simulating instruction execution of a PLC program composed of tasks. The PLC simulator device 10 is composed of a ladder execution engine 20 and a debugger 30. Yes.

  Here, the ladder execution engine 20 executes a PLC program in response to a command from the debugger 30 and includes a main processing unit 21, a ladder execution processing unit 22, and a peripheral processing unit 23.

  Here, the main processing unit 21 executes program execution, stop, task switching, task internal state change, program execution time integration processing, and the like according to instructions from the debugger 30. Also, the ladder execution processing unit 22 and the peripheral processing unit 23 are managed.

  The ladder execution processing unit 22 executes the program one instruction at a time according to a command from the main processing unit 21.

  When the ladder execution processing unit 22 is not executed, the peripheral processing unit 23 performs communication processing with a communication device (for example, PLC) or an application (not shown) according to 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, in particular, the ladder execution engine 20 instructs the ladder execution engine 20 to start an interrupt task and the internal state of the task. It is configured to be able to perform change instructions, task execution time management, and the like, and includes a task management unit 31 and a message window 32.

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

  The message window 32 supports debugging of the program performed by the debugger 30.

  By the way, in the present embodiment, the PLC program is simulated in units of tasks. At that time, execution of an interrupt task on the simulation, which has not been possible in the past, change of the internal state of the task on the simulation, The execution time of each task at 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 the above-described processing by performing various operations using a mouse or the like on this screen. .

  The recording medium on which a program for simulation referred to 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 unit 32-1, a task type display unit 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 status display section 32 -9, a task execution number display section 32-10, and a task execution time display section 32-11 are provided.

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

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

  Task No. The display unit 32-3 displays the 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 interrupt, that is, a “scheduled” interrupt task, an “external” interrupt task, or an “I / O” interrupt task Or the like type is displayed. Since the cycle execution task has no type, only “cycle” is displayed.

  The [Close] button 32-5 is used to end 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 state of the task.

  The task activation interval display section 32-8 displays the activation interval of the scheduled interrupt task.

  The task state display unit 32-9 displays the current state of the cycle execution task. The cycle execution task includes an unexecuted state (INI), an executable state (READY), an execution state (RUN), and a standby state ( Since the four states of WAIT) are transitioned, which state is displayed.

  The task execution number display section 32-10 displays the number of times the task has been executed 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 the 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 any interrupt task 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) is displayed for the user, and is further performed by clicking the “Start” button in the pop-up screen.

  As a result, the main processing unit 21 receives an interrupt factor (step 102). Note that the interrupt factor is actually a power interruption in a power interruption interrupt task, a fixed time has arrived in a scheduled interrupt task, a contact rise of an interrupt input unit in an I / O interrupt task, an external high-functional unit in an external interrupt task, etc. In the simulation, as described above, one of interrupt tasks among the tasks displayed in the task type display section 32-2 on the message window 32 is specified and a pop-up screen following this is specified. This is an interrupt task activation instruction of the task management unit 31 based on the click of the “activation” button.

  Thus, when receiving the interrupt factor, the main processing unit 21 stores the reception of the interrupt factor, and 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 104). As a result, the ladder execution processing unit 22 executes one instruction (step 106).

  Next, in step 108, it is checked whether or not an interrupt factor has occurred. Here, since the main processing unit 21 has received the interrupt factor in step 102, it is determined that the interrupt factor has occurred (YES in step 108). Accordingly, the process proceeds to step 110, where the main processing unit 21 analyzes the interrupt factor and shifts the execution to the corresponding interrupt task. The corresponding interrupt task is the interrupt task received in step 102.

  Next, an execution request for one instruction of the corresponding interrupt task is sent from the main processing unit 21 to the ladder execution processing unit 22 (step 112). The ladder execution processing unit 22 executes one instruction (step 114).

  Next, it is checked whether or not it is the last program of the interrupt task, that is, whether or not it is an END instruction (step 116). If it is not the end of the program (NO in step 116), the process returns to step 112 to execute one more instruction. However, if it is the last of the program (YES in step 116), the process returns to step 108 and it is checked whether an interrupt factor has occurred again.

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

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

  The above is the processing procedure for executing the interrupt task on the simulation.

  In the above description, as an interrupt factor generation method, one of the interrupt tasks displayed in the task type display section 32-2 on the message window 32 shown in FIG. However, it is also possible to connect an actual machine and generate an interrupt factor by changing the input of a specific I / O.

  If it is determined in step 108 that an interrupt factor has occurred, the interrupt task in step 110 and subsequent steps is executed. If an interrupt factor further occurs during execution of the interrupt task, step 110 and subsequent steps are performed again. The interrupt task is executed, but the newly generated interrupt factor is suspended, and the suspended interrupt task is executed when the currently executing interrupt task is completed. That is, if there is an interrupt task pending, it is determined in step 108 that an interrupt factor has occurred.

  As described above, in the process of FIG. 3, a specific interrupted task is clicked out of the tasks displayed in the task type display section 32-2 on the message window 32 shown in FIG. Since the interrupt factor is generated and the interrupt task is simulated, the program can be debugged by the simulation before the PLC system is constructed, and all the tasks including the interrupt task are surely debugged before the PLC system is constructed. There is an effect that it can be performed.

  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 this task internal state change process, first, the task management unit 31 of the debugger 30 issues a task internal state change instruction (step 130). Next, it is checked whether or not this change instruction is a change instruction from the standby state to the executable state (step 132). If the change instruction is from the standby state to the executable state (YES in step 132), ladder execution is performed. The main processing unit 21 of the engine 20 sets the internal state of the designated task to an executable state (step 134).

  If the change instruction is not an instruction to change from the standby state to the executable state (NO in step 132), it is next checked whether or not this change instruction is an instruction to change from the executable state to the standby state (step 136) In the case of an instruction to change from the executable state to the standby state (YES in step 136), the main processing unit 21 of the ladder execution engine 20 sets the internal state of the designated task to the standby state (step 138).

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

  Thus, 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, it is possible to perform a debugging operation for changing the internal state of the task before the system construction, and it is possible to prevent the occurrence of a problem in advance.

  Next, a processing procedure in the case of calculating the execution time of each task on the simulation will be described based on the flowchart of FIG.

  In this process, when task execution is started (step 150), a mnemonic (code) of one instruction is read (step 152), and it is determined whether or not an execution condition is satisfied (step 154). It is checked whether or not a predetermined input condition is satisfied for one instruction. If the execution condition is not satisfied (NO in step 154), the non-execution processing time is read (step 156). Proceed to

  On the other hand, if the execution condition is satisfied (YES in step 154), mnemonic processing, that is, one instruction is executed (step 158), and the execution processing time of one instruction is read (step 160). Then, although integration is performed for the processing time up to the previous time (step 162), the integration is not performed for the first instruction execution.

  Next, it is checked whether or not the execution of one task is completed (step 164). If the execution of one task is not completed (NO in step 164), the process returns to step 152 and continues to execute one task. When the execution of one task is completed (YES in step 164), the process proceeds to step 166, the processing time of the one task is stored, the number of tasks is incremented by 1 (step 168), and whether or not it is the last task. Are examined (step 170).

  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. If it is the last task (YES in step 170), the total execution time of the task (program Is stored (step 172), the total number of tasks executed is stored (step 174), and the task execution is terminated (step 176).

Thus, in this embodiment, in simulation,
(1) Store the processing time at the time of execution or non-execution for each instruction constituting one task,
(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 all tasks have been executed, the total task execution time and the total number of tasks that make up the program are stored.

  For this reason, the execution time for each task is known, and when the cycle time of a program is long, for example, the execution time of each task constituting the program can be verified to contribute to shortening of the one cycle time. There are effects such as.

It is a block diagram which shows schematic structure of one Embodiment of the PLC simulator apparatus concerning this invention. The figure which shows the content of the PLC program performed with the PLC simulator apparatus shown in FIG. The figure which shows the example of a display in the message window of a debugger when the program shown in FIG. 2 is performed. The flowchart which shows the process sequence of embodiment shown in FIG. The flowchart which similarly shows the process sequence of embodiment shown in FIG. In the case of configuring a program with tasks, (a) shows a case where a PLC program (user program) is constituted by one continuous program, (b) shows a program (a) having a plurality of tasks (in the figure, It is explanatory drawing in the case of dividing | segmenting into a task 1,2,3) and comprising a program. It is a figure which illustrates typically the difference between the case where a conventional program is executed, and the case where a task is executed, (a) is an explanatory view when executing a conventional program, and (b) is an explanatory view when executing a task. .

Explanation of symbols

DESCRIPTION OF SYMBOLS 10 PLC simulator apparatus 20 Ladder execution engine 21 Main processing part 22 Ladder execution processing part 23 Peripheral processing part 30 Debugger 31 Task management part 32 Message window 32-1 Task display switching part 32-2 Task type display part 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 Part 32-11 Task execution time display part

Claims (4)

In a PLC simulator device that simulates instruction execution of a PLC program that can control the execution state of another task by a task start instruction and a task standby instruction,
A task management unit for managing the tasks constituting the PLC program;
A main processing unit that executes a PLC program according to a command from the task management unit;
An internal state changing means capable of mutually changing the internal state of the task into a standby state and an executable state;
When the instruction is a task activation instruction, the internal state changing means sets the internal state of the task specified by the main processing unit to an executable state,
The PLC simulator device characterized in that the internal state changing means sets the internal state of the task designated by the main processing unit to a standby state when the command is a task standby command. In a PLC simulator device for simulating instruction execution of a PLC program that can control the execution state of another task by a task start instruction and a task standby instruction, and instruction execution of a PLC program executed in units of tasks,
A task management unit for managing the tasks constituting the PLC program;
A main processing unit that executes a PLC program according to a command from the task management unit;
An internal state change means that can mutually change the internal state of the task to a standby state and an executable state;
Execution condition determining means for determining whether or not the execution condition is satisfied for each instruction;
If the execution condition is satisfied by the execution condition determining means, the execution processing time of one instruction is read; if the execution condition is not satisfied, the one instruction processing time acquisition means for reading the non-execution processing time;
1 task processing time calculation means for calculating the processing time of one task by adding the processing times read by the one command processing time acquisition means;
One-task processing time storage means for storing the processing time calculated by the one-task processing time calculation means,
When the instruction is a task activation instruction, the internal state changing means sets the internal state of the task specified by the main processing unit to an executable state,
The PLC simulator device characterized in that the internal state changing means sets the internal state of the task designated by the main processing unit to a standby state when the command is a task standby command. A recording medium on which a program for simulating instruction execution of a PLC program capable of controlling the execution state of another task by a task start instruction and a task standby instruction is recorded,
The recording medium includes a computer, a task management unit that manages tasks constituting a PLC program, a main processing unit that executes a PLC program according to a command from the task management unit, and the command is a task activation command. Is an internal state in which the internal state of the task specified by the main processing means is made executable and, when the instruction is a task standby instruction, the internal state of the task specified by the main processing means is in a standby state. A computer-readable recording medium on which a program for functioning as a changing means is recorded. A program that simulates instruction execution of a PLC program that can control the execution state of another task by a task start instruction and a task wait instruction,
The program includes: a task management unit that manages a task that constitutes a PLC program; a main processing unit that executes a PLC program according to a command from the task management unit; and when the command is a task activation command The internal state of the task designated by the main processing means is made executable, and if the instruction is a task standby instruction, the internal state change to make the internal state of the task designated by the main processing means standby Program to function as a means.

Images