JP2000020297A - Controller - Google Patents

Abstract

PROBLEM TO BE SOLVED: To make a user program reproducible at the point of time after one- line editing was performed plural times while additionally changing a user program etc., consisting of modules when the user program is additionally changed. SOLUTION: When a source code 17 stored on a hard disk 7 is executed, a tool 1 reproduces the user program at the point of time after on-line editing was done plural times so as to restore the source code 17 stored on the hard disk 7 on a magnetic disk 6. Further, a run-time core 31 clears remaining variables to 0 when the variables of the source code 61 before the on-line editing are left at the time of the on-line editing of the source code 61 restored on the magnetic disk 6 from the hard disk 7.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a control device for adding or changing a user program or the like in units of modules without stopping external devices.

[0002]

2. Description of the Related Art Conventionally, a control device such as a programmable controller includes a hard check process for operating an external device such as an FA (Factory Automation), a command execution process of a user program including a ladder program, and a control process for an external device. Scan processing is performed in which peripheral processing such as management processing other than is performed as one cycle.

For this reason, in the conventional control device, when a user program or the like is additionally changed without stopping an external device, as shown in FIG. It is supposed to change.

Incidentally, the ladder program for operating the control device has no concept of modularization for each predetermined function, and thus does not have a concept of variables such as C ++ language.

For this reason, the conventional control device has a configuration in which the corresponding address of the memory must be directly specified in order to access the instruction, so that a user program or the like can be added without stopping the external device. When changing, only the peripheral processing can be performed in a short time, and even if only one instruction can be changed,
There has been a problem that a module that has been modularized for each predetermined function cannot be added or changed.

[0006] Therefore, the applicant has filed a Japanese Patent Application No.
In the invention described in Japanese Patent Application No. 9-012726, IEC (Inte
rnationa Electrotechnical Commisson) 1131-3
Use a programming language that can be modularized in accordance with the standards (hereinafter referred to as IEC-compliant programming language)
When a user program or the like is additionally changed, a modularized program is additionally changed.

In the invention described in Japanese Patent Application No. 09-012726, as shown in FIG. 13, the online edit execution unit 34 transmits the IEC 1131 via the communicator 2, the communication I / F and the shared memory 33.
-31 When the information indicating that the online editing has been performed is received from the programming tool 1, the object code for performing online editing which is acquired from the tool 1 and stored is read out from the shared memory 33.

Next, an online edit execution unit 34
Is the object code file name read with reference to the POU address table (PAT) 38,
It is detected whether the currently used code memory is the first CM or the second CM 36.

Subsequently, an online edit execution unit 34
Reads the object code file name stored in the magnetic disk 4, and reads the first CM and the second CM 36.
Rewrites the object code required for the execution processing of the source program and the subroutine to the one not currently used.

Thereafter, the online edit execution unit 34
Rewrites the currently used code memory in the currently used code memory area 382 indicating the currently used code memory in the POU address table (PAT) 38.

Thereafter, the runtime 3 executes the contents of the new code corrected with reference to the POU address table 38 thereafter.

[0012]

However, in the invention described in Japanese Patent Application No. 09-012726 filed earlier,
As described above, based on an instruction from the tool 1, the online edit execution unit 34 stores the currently used code memory area 382 indicating the currently used code memory in the POU address table (PAT) 38. Is rewritten to a code memory that is not
By executing the contents of the new code corrected with reference to the OU address table 38, it is possible to add or change a modularized program when adding or changing a user program or the like. ,
Since the Undo of online editing is only one layer, there is a problem that a program at a certain point in time cannot be reproduced after performing online editing many times.

In view of the above-mentioned problems, the present invention can add or change a modularized program when adding or changing a user program or the like.
It is an object of the present invention to provide a control device capable of reproducing a user program at a certain point in time even after performing a plurality of online edits.

[0014]

According to the present invention, there is provided a source code storage unit for storing a source code of a user program for controlling an external device.
A control device comprising: an object code storage unit that stores an object code of a user program that controls a currently executing external device in a module unit.
Object code forming means for compiling source code stored in the source code storing means to form an object code; source code storing means for storing the source code stored in the source code storing means; When the source code stored in the source code storage means is stored in the source code storage means, and the source code stored in the source code storage means is to be executed, And a source code restoration control means for restoring the source code stored in the source code storage means to the source code storage means.

By providing such a configuration, when it is desired to execute the source code stored in the source code storage means, the source code restoration control means can execute the source code stored in the source code storage means. Is restored in the source code storage means, so that the user program at a certain point in time can be reproduced even after performing the online editing a plurality of times.

Further, according to the present invention, when a source code restored from the source code storage means to the source code storage means is online edited, if a source code variable before online editing remains, Variable 0 clear means for clearing the set variables to 0.

With such a configuration, when the variable 0 clear unit online-edits the source code restored from the source code storage unit to the source code storage unit, the variable of the source code before online editing is changed. When the remaining variables remain, the remaining variables are cleared to 0, so that a malfunction due to the remaining variables can be prevented.

Further, in the present invention, the source code storage means stores a plurality of source codes stored in the source code storage means.

Further, according to the present invention, an object code storage means for storing the object code formed by the object code formation means, and an object code storage means for storing the object code stored in the object code storage means. Object code storage control means for storing the object code stored in the object code storage means in the object code store storage means; and storing the object code stored in the object code store storage means in the object code storage means. Means for restoring the object code.

With such a configuration, the object code store storage control means causes the object code stored in the object code storage means to be stored in the object code store storage means, and the object code restore control means causes the object code store control means to store the object code. Since the object code stored in the storage unit is restored in the object code storage unit, it is not necessary to compile the source code at the time of restoration.

[0021]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of a control device according to the present invention will be described below with reference to the drawings.

FIGS. 1 and 2 are explanatory diagrams of a programming language conforming to the standard 1131-3, and FIG. 4 is a block diagram showing a configuration of an embodiment of a control device according to the present invention.

(1) The control device of this embodiment, for example, a programmable logic controller (hereinafter, referred to as PLC) is an IEC (International Electrotechnical Comm.).
isson) Since a program language conforming to the 1131-3 standard (hereinafter referred to as an IEC-compliant program language) is used as a user program, the IEC-compliant program language will be described before describing the configuration of the control device of this embodiment. I do.

The IEC compliant programming language is POU (Pr
Program called “Future Organization Unit”
It is described in naction and Function Block.

POU and HA Function Blo
As shown in FIG. 1, ck is a module having an internal state having a definition part consisting of an input variable, an output variable, an internal variable, and a code (which can take different outputs when the same input is given). On the other hand, Function is
This module has no internal state.

Here, POU and Function
A location in a data memory (DM) (described later) in which a variable specified in the block declaration section is stored is referred to as a data instance, and stores POU, Function, and object codes for executing Function Block. Code memory (CM)
The part in (described later) is called a code instance.

It is assumed that the function has no data instance.

For example, as shown in FIG. 2, in a source program having three subroutines of an IEC-compliant program, a code instance of the source program is POU1 and its data instance is Pou1_.
Inst1 and the first CALL instruction (CALL PO
The code instance of the subroutine read in U2) is POU2 and its data instance is Po
u2_Inst1 and the next CALL instruction (CA
LL POU3), the code instance of the subroutine read out is POU3, its data instances are Pou3_Inst1 and Pou3_Inst2, and the last CALL instruction (CALL POU3)
Assuming that the subroutine code instance POU4 is read in 4), POU1 is the POU (Prog
ram Organization Unit)
POU2 and POU3 are Function Blo
ck, and POU4 is a Function.

As described above, the IEC-compliant program is a modularized programming language in which a source program and a subroutine have a data instance and a code instance, respectively.

FIG. 3 shows an example of a program described in such an IEC-compliant program language.

In this example, FIG. 3 (a) shows the definition part of the source program, and FIG. 3 (b) shows the contents of the mnemonically displayed object code of the source program. Shows an outline of a state in which a data instance and a code instance are accessed when a source program is executed.

It should be noted that the detailed contents of this figure are not directly related to the present invention, and therefore detailed description thereof is omitted.

(2) A PLC using such an IEC-compliant program language is, as shown in FIG.
31-3 a programming tool (hereinafter simply referred to as a tool) 1, a communicator 2, a device runtime (hereinafter referred to as a runtime) 3, a magnetic disk 4 storing an object code file 41 described later,
A magnetic disk 5 in which a save code file 51 described later is stored, a magnetic disk 6 in which a source code file 61 is stored, and a source code to be stored (stored) among the source code files 61 stored in the magnetic disk 6 A hard disk 7 for storing a file 71 is provided.

The tool 1 includes an IEC1131-3 editor, a compiler, a degabber, and the like.
The 1131-3 compiler forms an object code file 41 consisting of an object code interpreted and executed by the runtime 3 from the source code file 61 in the magnetic disk 6, and stores the formed object code file 41 on the magnetic disk 4. Is configured.

As shown in FIG. 5, the tool 1 is a source program stored in the magnetic disk 6 or its subroutine program P based on a user's instruction.
OU1 and POU3 are stored on the hard disk 7 and POU1 and POU3 stored on the hard disk 7 are restored on the magnetic disk 6.

The tool 1 has a store POU menu for a user to store and a restore POU menu for a restore on a display unit (not shown).

The object code files stored on the magnetic disk 6 are represented by *. obj, and * is an object code name. For example,
POU2. An object code file “obj” indicates an object code file POU2.

Further, when the tool 1 modifies the object code by online editing, the tool code 1 before the correction stored in the magnetic disk 4 *. obj as *. org, and formed on the magnetic disk 4, and the modified one is renewed *. obj is formed on the magnetic disk 4.

For example, when the object code POU2 is modified by online editing, the unmodified object code file POU2. obj to POU2. org. and formed on the magnetic disk 4, and the POU2.
obj is formed on the magnetic disk 4.

The communicator 2 is middleware that mediates online communication between the tool 1 and the runtime 3.

The runtime 3 includes a runtime core 31, a communication interface (I / F) 32, a shared memory 33, an online edit execution unit 34, a code memory (hereinafter referred to as a first CM) 35, and a code memory (hereinafter referred to as a second CM). , A data memory (hereinafter, referred to as DM) 37, and a POU address conversion table (hereinafter, referred to as PAT) 38.

Here, the run-time core 31 corresponds to FIG.
As shown in (a), in the case of the dedicated PLC, the run-time core 31 performs a scan process at a predetermined cycle time, that is, an out-refresh process for outputting data to an external I / O, The execution timing of the in-refresh processing, instruction execution processing, and peripheral processing that is received is controlled.

On the other hand, the run-time core 31 has a function to execute the PLC function and other application functions in parallel.
In the case of C, for example, (soft PLC + PC), as shown in FIG. 6B, the run-time core 31 performs scan processing, that is, out-refresh processing, in-refresh processing, and instruction execution, as in the case of the dedicated PLC described above. The execution timing of processing and peripheral processing is controlled.

However, in such a PLC, after the runtime core 31 executes (manages) the above-described scanning process, the PLC (Operating System) operates for a time until the cycle time expires.
System) executes another application, and when the cycle time reaches a permissible time, the runtime 31 performs the scanning process again.

In addition, the runtime core executes a first C (described later) as a code instance for each object code of the source program and its subroutine program.
The data instance is formed in the M35 or the second CM 36, and a data instance is formed in the DM 37 described later.

Further, the runtime core includes a PA
Based on T38, the first CM 35 or the second CM 36
The user program is executed using the object code stored in the DM 37 and the data code stored in the DM 37. Furthermore, when the run-time core performs online editing for adding a variable and returns to the source program and subroutine program before online editing, the DM37
The variable value remaining in the data instance is cleared to zero.

Communication interface (I /
F) 32 constitutes a communication interface between the communicators 2.

The shared memory 33 stores, via the communication interface (I / F) 32, information (hereinafter referred to as edit execution information) indicating that the online edit received from the communicator 2 and the name of the object code that has been edited online. What to store.

The shared memory 33 stores the tool 1 via the communication interface (I / F) 32.
Output information indicating that the Undo process has been executed (hereinafter, U
ndo execution information).

Here, executing the Undo processing means returning to the state before the execution of online editing.

When the online edit execution section 34 detects that the edit execution information has been written to the shared memory 33, the online edit execution section 34 reads the object code name to be online edited from the shared memory 33.

The online edit execution unit 34
When the online-edited object code name is read from the shared memory 33, which of the first CM 35 and the second CM 36 is the object code read with reference to the PAT 38? Is detected.

Further, the online edit execution section 34
Detects the used one of the first CM 35 and the second CM 36 with reference to the PAT 38, the object file of the object code name *. obj is read from the magnetic disk 4, and the code memory not currently used, for example, the second CM if the currently used code memory is the first CM 35.
The object code of the CM 36 is rewritten.

Furthermore, as described above, the online edit execution unit 34 rewrites the object code specified in the shared memory 33 into a code memory that is not currently used, as described above. (To be described later) is rewritten to the previously rewritten code memory.

For example, if the object code to be edited online is POU2, and this code POU2 is rewritten to the second CM 36, the code corresponding to "POU2" in the code name area 381 of the PAT 38 (see FIG. 9) is used. The contents of the code memory area are changed from the first CM 35 to the second CM 36 (C in FIG. 9).
M2).

The first CM 35 stores a source program and an object code of a subroutine. When the power of the PLC is turned off, all the stored contents are erased.

Here, the object code is stored in the runtime core 31 or the online edit execution unit 34.
Is an object code file read from the magnetic disk 4.

For example, in the example shown in FIGS.
The first CM 35 includes POU1, POU2, and POU of the source program and the subroutine program described above.
3, an object code such as POU4.

The second CM 36 is, similarly to the first CM 135, POU1, POU2, POU3, POU of the above-mentioned source program and subroutine program.
4 for storing object codes such as PL
When the power of C is turned off, all the stored data are erased.

The first CM 35 and the second CM 35
The area indicated by “*” in 6 is a margin area for online editing, and is reserved by the compiler. Then, if the corrected object code exceeds “*” by online editing, the compiler checks and generates an error.

In the DM 37, when the tool 1 compiles the source program, a data instance is formed via the runtime core 31.

For example, when the above-mentioned source program in FIG. 2 is compiled, as shown in FIG. 7C, a data instance storing a global variable, the above-described Pou1_Inst1, Pou2_Inst1, and Pou
Data instance locations such as 3_Inst1 and Pou3_Inst2 are formed.

The area indicated by "*" in each data instance is a margin area, and if it exceeds this, the compiler checks and generates an error.

The DM 37 stores the source code file 71 stored in the hard disk 7 as shown in FIG.
When the online editing is executed, the variable of the source code file previously online-edited is 0.

When the power supply of the PLC is turned off, the DM 37 deletes the non-essential items stored in the work storage area. Is not erased.

As shown in FIG. 8, when the runtime core 31 executes the scanning process, the PAT 38 stores a code instance name area 381 having information on a code instance name in which an object code is stored, and a code instance described above. It is composed of a used code memory area 382 having a used code memory.
When the power of the LC is turned off, all the stored data are erased.

Incidentally, assuming that the code instance executed by the runtime core 31 is POU2, the code memory used is that of POU2 stored in the second CM 36 (CM2 in the figure).

The save code file 5 formed on the magnetic disk 5 stores the code instance name in the code instance name area 381 read out from the PAT 38 by the runtime core 31 before the PLC turns off the power, and the corresponding use instance. This is a file having information including the used code memory in the code memory area 382.

(3) Next, the operation of the online editing process of the control device of this embodiment is described in the subroutine program object code file POU2. An example in which obj is edited online will be described.

The user edits and compiles the corresponding subroutine program with the tool 1.

Next, the tool 1 already has the magnetic disk 4
Of the object code file POU already stored is
2. obj to POU2. org. and formed on the magnetic disk 4, and the object code file of the object code formed this time is renewed as POU2.org. obj is formed on the magnetic disk 4.

Thereafter, the tool 1 stores, via the communicator 2 and the communicator I / F 32 of the runtime 3, edit execution information indicating that there is an online edit in the shared memory 33, and the object code name POU 2 that has been edited online. I do.

When the online edit execution section 34 detects that the edit execution information is stored in the shared memory 33, the online edit execution section 34 reads the object code name P from the shared memory 33.
Read OU2.

Next, the online edit execution unit 34
Detects that the object code name POU2 read with reference to the PAT 38 is the second CM 36 as the currently used code memory (FIG. 7).
reference).

Subsequently, the online edit execution unit 34
Are the object files POU2. obj, and reads the object code POU2 in the first code memory CM35 that is not currently used into the read object file POU.
2. obj.

Next, the online edit execution section 34
Is the P in the used code memory area 382 in the PAT 38.
CM2 corresponding to OU2 is rewritten to CM1.

With the above, the object code file POU2. The online editing process of the obj ends.

If such processing is performed during peripheral processing, in the next scanning processing, the runtime 3
Will be executed thereafter.

(4) Subsequently, when the PLC of this embodiment executes online editing and finishes starting the control device and then restarts, the operation for restarting the runtime in the state after the online editing is performed. explain.

The reason why such a processing operation is required is that when the power supply of the control device is turned off, the memory code (CM)
1) The contents of 25, the memory code (CM2) 26, and the contents of the PAT are all erased and cannot be restarted.

First, when the power of the PLC is turned on, the run-time core 31 reads out the contents of the PAT 38 stored before the power was turned off from the save code file formed on the magnetic disk 5.

Next, the runtime core 31 uses the object instance name read from the save code file 5 as the basis for the object code file *. obj is read from the magnetic disk 4 and the read object code file *. obj is stored in the previously read code memory, and then stored in the non-stored code memory in the object code file *. org is read from the magnetic disk 4 and stored.

Thereafter, the runtime core 31 executes PAT3
In the code instance name area 381 and the used code memory area 382, the code instance name and the used code memory included in the save code file 5 are registered.

In this way, the runtime core 31
When the above-described processing is completed for all the items stored in the save code file 5, the state returns to the state before the power supply of the PLC is turned off.
The first CM 35, the second CM 36 and P
The AT 38 can be used to restart.

(5) Then, the online edit U
The operation of the ndo process will be described.

When the user selects an object code to be undone on the editor of the tool 1 based on a menu displayed on the CRT among the object codes subjected to online editing, the tool 1 is stored on the magnetic disk 4. *. obj, *. After changing to obk,
*. org *. obj.

The tool 1 has *. Obk file is *. org, and *. Delete the obk file.

Therefore, before the change, *. obj was *. org, *. or
g. obj.

When the tool 1 changes the file name of the object code file stored on the magnetic disk 4, the communicator 2 and the communication I / O
The Undo execution information is stored in the shared memory 33 via F32.

When the runtime core 31 detects the Undo execution information stored in the shared memory 33, the PAT
The code memory stored in the used code memory area 382, for example, CM1 (first CM35) is replaced with CM2
(2nd CM36) and CM2 (2nd CM36)
Change to M1 (first CM 35).

By doing so, the PL of this embodiment is
In C, the object code of the undoed object code is executed from the next scan.

(6) The tool 1 transfers the source code file 71 stored in the hard disk 7 to the magnetic disk 6
When the online editing for adding variables to the restored source code file 61 is performed, the runtime core 31 clears the remaining variables of the DM 37 to zero.

When the runtime core 31 receives an instruction from the tool 1 to execute online editing for adding a variable, the data instance for storing the global variables of the source program and the subroutine program before online editing formed in the DM 37, Pou1_Inst1, Pou2_Inst1, Po described above
Data instances such as u3_Inst1 and Pou3_Inst2 (see A in FIG. 10A) are
As shown in FIG. 10B, a variable is added (see B in FIG. 10B).

Thereafter, when the runtime core 31 receives an instruction from the tool 1 to execute online editing of the source code file 71 previously stored in the hard disk 7, the source code file 71 instructed by the tool 1 Is formed (see (c) in FIG. 10).

In this data instance, variable values remain (see B in FIG. 10D).

[0096] The runtime core 31
When the data instance for the source code file 71 stored in the data instance is formed, the remaining variables in this data instance are cleared to 0 (FIG. 10).
(See C in (d)).

In the PLC of this embodiment, when the source code 71 stored in the hard disk 7 is to be executed, the tool 1 restores the source code 71 stored in the hard disk 7 to the magnetic disk 6. Even after a plurality of online edits, the user program at a certain point in time can be reproduced.

In the PLC of this embodiment, when the runtime core 31 online-edits the source code 61 restored from the hard disk 7 to the magnetic disk 6, the variables of the source code 61 before online editing remain. At this time, since the remaining variables are cleared to 0, malfunction due to the remaining variables can be prevented.

In the PLC according to the present embodiment, the object code formed in advance by the online edit execution unit 34 being changed and corrected during the peripheral processing is converted into the corresponding object code in the first CM 35 or the second CM 36 based on the PAT 38. Is changed, it is possible to eliminate the influence on the runtime processing executed by the runtime core 31.

In the PLC of this embodiment, a programming language conforming to the 1131-3 standard is used as a programming language to be used, and each of the source program and the subroutine has a data instance and a code instance. The system can be configured.

In the PLC of this embodiment, the object codes of the source program and the subroutine program are separately stored as code instances in the first CM 35 and the second CM 36, and the runtime core 31 is stored in the PAT 38. Since the code memory is executed based on the indirect designation method, it is not necessary to maintain the object code to be read out by using the CALL instruction.

For example, as shown in FIG. 2, since the object code POU2 executed by the CALL instruction is read out by the indirect designation method as described above, even if the object code POU2 is edited online and corrected, There is no need to change the code POU1 of the program.

In the PLC of this embodiment, since the magnetic disk 5 has the PAT save file 51, it is used with the code instance name written in the PAT save file 51 when the power is turned off and restarted. Based on the code memory, the first CM 35 and the second CM 23
6 and the PAT 38 can be returned to the state before the power was turned off.

Therefore, in the PLC of this embodiment, after the power is turned off, it can be easily restarted even when the power is turned on.

In the PLC of this embodiment, when online editing is performed, the tool 1 has the object code file *. obj as *. org, and revisit the modified *. obj, and the runtime core 31 uses the code memory area 38 of the PAT 38.
Since both CM1 and CM2 stored in No. 2 are rewritten oppositely, Undo processing can be performed in online editing.

In the PLC of this embodiment, the number of source codes stored in the magnetic disk 6 is one. However, as shown in FIG. You may make it memorize | store.

In this case, since the hard disk 7 stores a plurality of source codes stored on the magnetic disk 6, it is possible to have a plurality of source codes to be restored.

Further, in the PLC of this embodiment, the object code stored on the magnetic disk 4 is not stored on the hard disk 7, but the tool 1 is stored on the magnetic disk 4 in other cases. The object code stored in the hard disk 7 may be stored in the hard disk 7, and the tool 1 may restore the object code stored in the hard disk 7 to the magnetic disk 4.

By doing so, it is possible to save the trouble of compiling the source code at the time of restoration.

[0110]

As described above, according to the present invention, when it is desired to execute the source code stored in the source code store storage means, the source code restoration control means sets the source code stored in the source code store storage means. Is restored in the source code storage means, so that the user program at a certain point in time can be reproduced even after performing the online editing a plurality of times.

In particular, when the variable 0 clearing means online-edits the source code restored from the source code storing means to the source code storing means,
When the variables of the source code before online editing remain, the remaining variables are cleared to 0, so that malfunction due to the remaining variables can be prevented.

Further, since the source code storage means stores a plurality of source codes stored in the source code storage means, it can have a plurality of source codes to be restored.

Further, the object code store storage control means causes the object code stored in the object code storage means to be stored in the object code store storage means, and the object code restore control means is stored in the object code store storage means. Since the object code is restored in the object code storage means, it is possible to save the time and effort of compiling the source code at the time of restoration.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram of a programming language conforming to the IEC1131-3 standard.

FIG. 2 is an explanatory diagram of a programming language conforming to the IEC1131-3 standard.

FIG. 3 is an example diagram of a program described in a programming language conforming to the IEC1131-3 standard.

FIG. 4 is a block diagram showing a configuration of an embodiment of a control device according to the present invention.

FIG. 5 is an explanatory diagram illustrating contents stored and restored by a source code.

FIG. 6 is an explanatory diagram of a function of a runtime core in FIG. 4;

FIG. 7 is a block diagram showing a configuration of a first code memory, a second code memory, and a data memory in FIG. 4;

FIG. 8 is an explanatory diagram for explaining DM in a state where remaining variables are cleared to 0;

FIG. 9 is a block diagram showing a configuration of a POU address table in FIG. 4;

FIG. 10 is an explanatory diagram illustrating an operation in which a runtime core clears variables remaining in a DM to 0.

FIG. 11 is an explanatory diagram illustrating contents stored and restored by a source code when a plurality of source codes stored on a magnetic disk are stored.

FIG. 12 is an explanatory diagram of program correction of a conventional program controller.

FIG. 13 is a block diagram showing a configuration of an embodiment of a conventional control device.

[Explanation of symbols]

 Reference Signs List 1 IEC1131-3 programming tool 2 Communicator 3 Runtime 31 Runtime core 32 Communication I / F 33 Shared memory 34 Online edit execution unit 35, 36 CM 37 DM 38 PAT 4 Magnetic disk 41 Object code file 5 Magnetic disk 51 Evacuation code file 6 Magnetic disk 61 Source code file 7 Hard disk 71 Source code file

Claims (3)

[Claims] A source code storage means for storing a source code of a user program for controlling an external device, and an object code storage means for storing, in module units, an object code of a user program for controlling a currently executed external device. A control device comprising: compiling source code stored in the source code storage means to form an object code; and storing and storing the source code stored in the source code storage means. Source code storage means; source code storage control means for storing the source code stored in the source code storage means in the source code storage means; source code stored in the source code storage means Real If you want to, the control apparatus characterized by comprising a source code restoration control means for restoring the source code stored in the source code store storing means to the source code storage means. 2. A source code storage means for storing a source code of a user program for controlling an external device, and an object code storage means for storing, in units of modules, an object code of a user program for controlling a currently executed external device. A control device comprising: compiling source code stored in the source code storage means to form an object code; and storing and storing the source code stored in the source code storage means. Source code storage means; source code storage control means for storing the source code stored in the source code storage means in the source code storage means; source code stored in the source code storage means Real If desired, the source code storage control means causes the source code stored in the source code storage means to be restored in the source code storage means, and the source code is restored from the source code store storage means to the source code storage means. And a variable zero clearing means for clearing the remaining variables to zero when variables of the source code before online editing remain after online editing of the source code. 3. An object code storage means for storing the object code formed by the object code formation means, an object code storage means for storing and storing the object code stored in the object code storage means, Object code store storage control means for storing the object code stored in the code storage means in the object code store storage means; and restoring the object code stored in the object code store storage means in the object code storage means 3. The control device according to claim 1, further comprising an object code restoration control unit.